javassist 入门以及dubbo中的使用案例

阿里云国内75折 回扣 微信号：monov8
阿里云国际，腾讯云国际，低至75折。AWS 93折 免费开户实名账号 代冲值 优惠多多 微信号：monov8 飞机：@monov6

javassite 入门

概述

学习javassite 不得不提的javaagent 技术字节码插桩 如果不太了解的可以参考 Javaagent入门这一篇文章 自己有一个简单的大致了解

Javassist是一个开源的分析、编辑和创建Java字节码的类库。其主要的优点在于简单而且快速。直接使用java编码的形式而不需要了解虚拟机指令就能动态改变类的结构或者动态生成

Javassist 应用场景:
监控、动态代理
dubbo、myBatis、Spring 都有不同程度的应用。

javaagen 是操作字节码对jvm了解的要求非常高因此就有了对字节码操作的代码库比如asm和javassite这样的框架。

原理

在这里插入图片描述
在这里插入图片描述

简单的demo

pom依赖

<dependency>
            <groupId>org.javassist</groupId>
            <artifactId>javassist</artifactId>
            <version>3.29.2-GA</version>
        </dependency>

我们修改下面的字节码内容

public class UserService {
    public void saveUser(){
        System.out.println("保存用户");
    }
}

开始修改

@Test
    public void test1() throws NotFoundException, CannotCompileException {
        ClassPool classPool = ClassPool.getDefault();
        CtClass ctClass = classPool.get("com.wfg.javassite.UserService");
        CtMethod saveUser = ctClass.getDeclaredMethod("saveUser");
        saveUser.insertAfter("System.out.println(System.currentTimeMillis());");
        //把修改后的类装入jvm
        ctClass.toClass();
        new UserService().saveUser();
    }

在这里插入图片描述

记录方法执行的时间

 @Test
    public void test2() throws NotFoundException, CannotCompileException {
        ClassPool classPool = ClassPool.getDefault();
        CtClass ctClass = classPool.get("com.wfg.javassite.UserService");
        CtMethod saveUser = ctClass.getDeclaredMethod("saveUser");
        saveUser.insertBefore("long start = System.currentTimeMillis();");
        saveUser.insertAfter("long end = System.currentTimeMillis();" +
                "System.out.println(end - start);");
        //把修改后的类装入jvm
        ctClass.toClass();
        new UserService().saveUser();
    }

在这里插入图片描述
从错误信息中可以看出来试 没有start 变量导致的
ps javassite的语法插入语句默认 使用{} 括号括着因此start 和 end 不在同一个代码块中

因此我们需要把整体的插入使用一个代理的方法
saveUser(){
saveUser$agent();
}
这样的方式处理

public void test2() throws NotFoundException, CannotCompileException {
        ClassPool classPool = ClassPool.getDefault();
        CtClass ctClass = classPool.get("com.wfg.javassite.UserService");
        CtMethod saveUser = ctClass.getDeclaredMethod("saveUser");
        //这种写法不符合语法存在代码
//        saveUser.insertBefore("long start = System.currentTimeMillis();");
//        saveUser.insertAfter("long end = System.currentTimeMillis();" +
//                "System.out.println(end - start);");
        CtMethod newMethod = CtNewMethod.copy(saveUser, ctClass, null);
        newMethod.setName(saveUser.getName()+"$agent");
        ctClass.addMethod(newMethod);
        saveUser.setBody("{long start = System.currentTimeMillis();\n" +
                "        saveUser$agent();\n" +
                "        long end = System.currentTimeMillis();\n" +
                "        System.out.println(end-start);}");

        //把修改后的类装入jvm
        ctClass.toClass();
        new UserService().saveUser();
    }

带参数和返回值

 @Test
    public void test3() throws Exception {
        ClassPool classPool = ClassPool.getDefault();
        CtClass ctClass = classPool.get("com.wfg.javassite.UserService");
        CtMethod save = ctClass.getDeclaredMethod("save");
        CtMethod newMethod = CtNewMethod.copy(save, ctClass, null);
        newMethod.setName(save.getName()+"$agent");
        ctClass.addMethod(newMethod);
        save.setBody("{long start = System.currentTimeMillis();\n" +
                "        save$agent($$);\n" +
                "        long end = System.currentTimeMillis();\n" +
                "        System.out.println(end-start);" +
                "        return $3 ;" +
                "}");
        //把修改后的类装入jvm
        ctClass.toClass();
        User user = new UserService().save("张三", 12, new User());
        System.out.println(user.toString());
    }

javassite 占位符

符号

描述

$0, $1, $2, ...  

$0表示this其他的表示实际的参数

$args

参数数组. 相当于new Object[]{$1,$2,....}其中的基本类型会被转为包装类型

$$


所有的参数如m($$)相当于m($1,$2...)如果m无参数则m($$)相当于m()

$cflow(...)

表示一个指定的递归调用的深度

$r

用于类型装换表示返回值的类型.

$w

将基础类型转换为一个包装类型.如Integer a=($w)5表示将5转换为Integer。如果不是基本类型则什么都不做。

$_

返回值如果方法为void则返回值为null; 值在方法返回前获得

如果希望发生异常是有返回值默认值如nul需要将insertAfter方法的第二个参数asFinally设置为true

$sig

方法参数的类型数组数组的顺序为参数的顺序

$type

返回类型的class 如返回Integer则$type相当于java.lang.Integer.class 注意其与$r的区别

$class

方法所在的类的class

dubbo中的使用

代理工厂 JavassistProxyFactory

org.apache.dubbo.rpc.proxy.javassist.JavassistProxyFactory
这个是dubbo代理工厂的其中之一

 @Override
    @SuppressWarnings("unchecked")
    public <T> T getProxy(Invoker<T> invoker, Class<?>[] interfaces) {
        try {
        	//创建代理类 并且实例化
            return (T) Proxy.getProxy(interfaces).newInstance(new InvokerInvocationHandler(invoker));
        } catch (Throwable fromJavassist) {
            // try fall back to JDK proxy factory
            //如果失败使用jdk代理兜底
            try {
                T proxy = jdkProxyFactory.getProxy(invoker, interfaces);
                logger.error(PROXY_FAILED, "", "", "Failed to generate proxy by Javassist failed. Fallback to use JDK proxy success. " +
                    "Interfaces: " + Arrays.toString(interfaces), fromJavassist);
                return proxy;
            } catch (Throwable fromJdk) {
                logger.error(PROXY_FAILED, "", "", "Failed to generate proxy by Javassist failed. Fallback to use JDK proxy is also failed. " +
                    "Interfaces: " + Arrays.toString(interfaces) + " Javassist Error.", fromJavassist);
                logger.error(PROXY_FAILED, "", "", "Failed to generate proxy by Javassist failed. Fallback to use JDK proxy is also failed. " +
                    "Interfaces: " + Arrays.toString(interfaces) + " JDK Error.", fromJdk);
                throw fromJavassist;
            }
        }
    }

(T) Proxy.getProxy(interfaces).newInstance(new InvokerInvocationHandler(invoker));

代理类 org.apache.dubbo.common.bytecode.Proxy

这个类是参数判断和缓存功能

public static Proxy getProxy(Class<?>... ics) {}

 private static Class<?> buildProxyClass(ClassLoader cl, Class<?>[] ics, ProtectionDomain domain) {
        ClassGenerator ccp = null;
        try {
            // 类的创建工具类
            ccp = ClassGenerator.newInstance(cl);
            //保存方法描述
            Set<String> worked = new HashSet<>();
            List<Method> methods = new ArrayList<>();

            //判断不是 public 包名是否相同 作为基准
            String pkg = ics[0].getPackage().getName();
            Class<?> neighbor = ics[0];

            for (Class<?> ic : ics) {
                String npkg = ic.getPackage().getName();
                if (!Modifier.isPublic(ic.getModifiers())) { //判断不是 public 并且包名不同
                    if (!pkg.equals(npkg)) {
                        throw new IllegalArgumentException("non-public interfaces from different packages");
                    }
                }

                ccp.addInterface(ic);

                for (Method method : ic.getMethods()) {
                    //* int do(int arg1) => "do(I)I"
                    // * void do(String arg1,boolean arg2) => "do(Ljava/lang/String;Z)V"
                    String desc = ReflectUtils.getDesc(method);
                    if (worked.contains(desc) || Modifier.isStatic(method.getModifiers())) {
                        continue;
                    }
                    worked.add(desc);

                    int ix = methods.size();
                    Class<?> rt = method.getReturnType();
                    Class<?>[] pts = method.getParameterTypes();

                    StringBuilder code = new StringBuilder("Object[] args = new Object[").append(pts.length).append("];");
                    for (int j = 0; j < pts.length; j++) {
                        code.append(" args[").append(j).append("] = ($w)$").append(j + 1).append(';');
                    }
                    code.append(" Object ret = handler.invoke(this, methods[").append(ix).append("], args);");
                    if (!Void.TYPE.equals(rt)) {
                        code.append(" return ").append(asArgument(rt, "ret")).append(';');
                    }

                    methods.add(method);
                    ccp.addMethod(method.getName(), method.getModifiers(), rt, pts, method.getExceptionTypes(), code.toString());
                }
            }

            // create ProxyInstance class.
            String pcn = neighbor.getName() + "DubboProxy" + PROXY_CLASS_COUNTER.getAndIncrement();
            ccp.setClassName(pcn);
            ccp.addField("public static java.lang.reflect.Method[] methods;");
            ccp.addField("private " + InvocationHandler.class.getName() + " handler;");
            ccp.addConstructor(Modifier.PUBLIC, new Class<?>[]{InvocationHandler.class}, new Class<?>[0], "handler=$1;");
            ccp.addDefaultConstructor();
            Class<?> clazz = ccp.toClass(neighbor, cl, domain);
            clazz.getField("methods").set(null, methods.toArray(new Method[0]));
            return clazz;
        } catch (RuntimeException e) {
            throw e;
        } catch (Exception e) {
            throw new RuntimeException(e.getMessage(), e);
        } finally {
            // release ClassGenerator
            if (ccp != null) {
                ccp.release();
            }
        }
    }

这个方法是创建代理实例

  1. 注入public static java.lang.reflect.Method[] methods; 存放被代理对象的方法
  2. 注入InvocationHandler handler 属性
  3. 注入沟通方法 一个是无参数一个是 InvocationHandler handler参数的
  4. 增强每一个方法存放到methods中

org.apache.dubbo.rpc.proxy.InvokerInvocationHandler

通过上面的分析我们知道代理类真正的是 InvokerInvocationHandler 的invoke方法

创建类的工具类 ClassGenerator

package com.wfg.javassite.mydubbo;

import javassist.*;
import org.apache.commons.lang3.ArrayUtils;
import org.apache.commons.lang3.StringUtils;

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.security.ProtectionDomain;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicLong;

/**
 * @author wufagang
 * @description
 * @date 2023年06月10日 12:56
 */
public class ClassGenerator {

    private static final AtomicLong CLASS_NAME_COUNTER = new AtomicLong(0);
    private static final String SIMPLE_NAME_TAG = "<init>";
    private static final Map<ClassLoader, ClassPool> POOL_MAP = new ConcurrentHashMap<>(); //ClassLoader - ClassPool
    private ClassPool mPool;
    private CtClass mCtc;
    private String mClassName;
    private String mSuperClass;
    private Set<String> mInterfaces;
    private List<String> mFields;
    private List<String> mConstructors;
    private List<String> mMethods;
    private ClassLoader mClassLoader;
    private Map<String, Method> mCopyMethods; // <method desc,method instance>
    private Map<String, Constructor<?>> mCopyConstructors; // <constructor desc,constructor instance>
    private boolean mDefaultConstructor = false;

    private ClassGenerator() {
    }

    private ClassGenerator(ClassLoader classLoader, ClassPool pool) {
        mClassLoader = classLoader;
        mPool = pool;
    }

    public static ClassGenerator newInstance() {
        return new ClassGenerator(Thread.currentThread().getContextClassLoader(), getClassPool(Thread.currentThread().getContextClassLoader()));
    }

    public static ClassGenerator newInstance(ClassLoader loader) {
        return new ClassGenerator(loader, getClassPool(loader));
    }

    public static boolean isDynamicClass(Class<?> cl) {
        return ClassGenerator.DC.class.isAssignableFrom(cl);
    }

    public static ClassPool getClassPool(ClassLoader loader) {
        if (loader == null) {
            return ClassPool.getDefault();
        }

        ClassPool pool = POOL_MAP.get(loader);
        if (pool == null) {
            pool = new ClassPool(true);
            pool.insertClassPath(new LoaderClassPath(loader));
            POOL_MAP.put(loader, pool);
        }
        return pool;
    }

    private static String modifier(int mod) {
        StringBuilder modifier = new StringBuilder();
        if (Modifier.isPublic(mod)) {
            modifier.append("public");
        } else if (Modifier.isProtected(mod)) {
            modifier.append("protected");
        } else if (Modifier.isPrivate(mod)) {
            modifier.append("private");
        }

        if (Modifier.isStatic(mod)) {
            modifier.append(" static");
        }
        if (Modifier.isVolatile(mod)) {
            modifier.append(" volatile");
        }

        return modifier.toString();
    }

    public String getClassName() {
        return mClassName;
    }

    public ClassGenerator setClassName(String name) {
        mClassName = name;
        return this;
    }

    public ClassGenerator addInterface(String cn) {
        if (mInterfaces == null) {
            mInterfaces = new HashSet<>();
        }
        mInterfaces.add(cn);
        return this;
    }

    public ClassGenerator addInterface(Class<?> cl) {
        return addInterface(cl.getName());
    }

    public ClassGenerator setSuperClass(String cn) {
        mSuperClass = cn;
        return this;
    }

    public ClassGenerator setSuperClass(Class<?> cl) {
        mSuperClass = cl.getName();
        return this;
    }

    // 写好对字符串属性 private Object aa;
    public ClassGenerator addField(String code) {
        if (mFields == null) {
            mFields = new ArrayList<>();
        }
        mFields.add(code);
        return this;
    }
    //没有赋值
    public ClassGenerator addField(String name, int mod, Class<?> type) {
        return addField(name, mod, type, null);
    }
    // 处理完整的 带有赋值的属性
    public ClassGenerator addField(String name, int mod, Class<?> type, String def) {
        StringBuilder sb = new StringBuilder();
        sb.append(modifier(mod)).append(' ').append(ReflectUtils.getName(type)).append(' ');
        sb.append(name);
        if (StringUtils.isNotEmpty(def)) {
            sb.append('=');
            sb.append(def);
        }
        sb.append(';');
        return addField(sb.toString());
    }

    //完整的方法体
    public ClassGenerator addMethod(String code) {
        if (mMethods == null) {
            mMethods = new ArrayList<>();
        }
        mMethods.add(code);
        return this;
    }

    public ClassGenerator addMethod(String name, int mod, Class<?> rt, Class<?>[] pts, String body) {
        return addMethod(name, mod, rt, pts, null, body);
    }
    /**
     *
     * @author wufagang
     * @date 2023/6/10 13:22
     * @param name
     * @param mod
     * @param rt 返回值
     * @param pts 参数
     * @param ets 异常类型
     * @param body 方法体
     * @return com.wfg.javassite.mydubbo.ClassGenerator
     */
    public ClassGenerator addMethod(String name, int mod, Class<?> rt, Class<?>[] pts, Class<?>[] ets,
                                    String body) {
        StringBuilder sb = new StringBuilder();
        sb.append(modifier(mod)).append(' ').append(ReflectUtils.getName(rt)).append(' ').append(name);
        sb.append('(');
        if (ArrayUtils.isNotEmpty(pts)) {
            for (int i = 0; i < pts.length; i++) {
                if (i > 0) {
                    sb.append(',');
                }
                sb.append(ReflectUtils.getName(pts[i]));
                sb.append(" arg").append(i);
            }
        }
        sb.append(')');
        if (ArrayUtils.isNotEmpty(ets)) {
            sb.append(" throws ");
            for (int i = 0; i < ets.length; i++) {
                if (i > 0) {
                    sb.append(',');
                }
                sb.append(ReflectUtils.getName(ets[i]));
            }
        }
        sb.append('{').append(body).append('}');
        return addMethod(sb.toString());
    }

    public ClassGenerator addMethod(Method m) {
        addMethod(m.getName(), m);
        return this;
    }

    public ClassGenerator addMethod(String name, Method m) {
        String desc = name + ReflectUtils.getDescWithoutMethodName(m);
        addMethod(':' + desc);
        if (mCopyMethods == null) {
            mCopyMethods = new ConcurrentHashMap<>(8);
        }
        mCopyMethods.put(desc, m);
        return this;
    }

    public ClassGenerator addConstructor(String code) {
        if (mConstructors == null) {
            mConstructors = new LinkedList<>();
        }
        mConstructors.add(code);
        return this;
    }

    public ClassGenerator addConstructor(int mod, Class<?>[] pts, String body) {
        return addConstructor(mod, pts, null, body);
    }

    public ClassGenerator addConstructor(int mod, Class<?>[] pts, Class<?>[] ets, String body) {
        StringBuilder sb = new StringBuilder();
        sb.append(modifier(mod)).append(' ').append(SIMPLE_NAME_TAG);
        sb.append('(');
        for (int i = 0; i < pts.length; i++) {
            if (i > 0) {
                sb.append(',');
            }
            sb.append(ReflectUtils.getName(pts[i]));
            sb.append(" arg").append(i);
        }
        sb.append(')');
        if (ArrayUtils.isNotEmpty(ets)) {
            sb.append(" throws ");
            for (int i = 0; i < ets.length; i++) {
                if (i > 0) {
                    sb.append(',');
                }
                sb.append(ReflectUtils.getName(ets[i]));
            }
        }
        sb.append('{').append(body).append('}');
        return addConstructor(sb.toString());
    }

    public ClassGenerator addConstructor(Constructor<?> c) {
        String desc = ReflectUtils.getDesc(c);
        addConstructor(":" + desc);
        if (mCopyConstructors == null) {
            mCopyConstructors = new ConcurrentHashMap<>(4);
        }
        mCopyConstructors.put(desc, c);
        return this;
    }

    public ClassGenerator addDefaultConstructor() {
        mDefaultConstructor = true;
        return this;
    }

    public ClassPool getClassPool() {
        return mPool;
    }

    /**
     * @param neighbor    A class belonging to the same package that this
     *                    class belongs to.  It is used to load the class.
     */
    public Class<?> toClass(Class<?> neighbor) {
        return toClass(neighbor,
                mClassLoader,
                getClass().getProtectionDomain());
    }

    public Class<?> toClass(Class<?> neighborClass, ClassLoader loader, ProtectionDomain pd) {
        if (mCtc != null) {
            mCtc.detach();
        }
        long id = CLASS_NAME_COUNTER.getAndIncrement();
        try {
            CtClass ctcs = mSuperClass == null ? null : mPool.get(mSuperClass);
            if (mClassName == null) {
                mClassName = (mSuperClass == null || javassist.Modifier.isPublic(ctcs.getModifiers())
                        ? ClassGenerator.class.getName() : mSuperClass + "$sc") + id;
            }
            mCtc = mPool.makeClass(mClassName);
            if (mSuperClass != null) {
                mCtc.setSuperclass(ctcs);
            }
            mCtc.addInterface(mPool.get(DC.class.getName())); // add dynamic class tag.
            if (mInterfaces != null) {
                for (String cl : mInterfaces) {
                    mCtc.addInterface(mPool.get(cl));
                }
            }
            if (mFields != null) {
                for (String code : mFields) {
                    mCtc.addField(CtField.make(code, mCtc));
                }
            }
            if (mMethods != null) {
                for (String code : mMethods) {
                    if (code.charAt(0) == ':') {
                        mCtc.addMethod(CtNewMethod.copy(getCtMethod(mCopyMethods.get(code.substring(1))),
                                code.substring(1, code.indexOf('(')), mCtc, null));
                    } else {
                        mCtc.addMethod(CtNewMethod.make(code, mCtc));
                    }
                }
            }
            if (mDefaultConstructor) {
                mCtc.addConstructor(CtNewConstructor.defaultConstructor(mCtc));
            }
            if (mConstructors != null) {
                for (String code : mConstructors) {
                    if (code.charAt(0) == ':') {
                        mCtc.addConstructor(CtNewConstructor
                                .copy(getCtConstructor(mCopyConstructors.get(code.substring(1))), mCtc, null));
                    } else {
                        String[] sn = mCtc.getSimpleName().split("\\$+"); // inner class name include $.
                        mCtc.addConstructor(
                                CtNewConstructor.make(code.replaceFirst(SIMPLE_NAME_TAG, sn[sn.length - 1]), mCtc));
                    }
                }
            }

            try {
                return mPool.toClass(mCtc, neighborClass, loader, pd);
            } catch (Throwable t) {
                if (!(t instanceof CannotCompileException)) {
                    return mPool.toClass(mCtc, loader, pd);
                }
                throw t;
            }
        } catch (RuntimeException e) {
            throw e;
        } catch (NotFoundException | CannotCompileException e) {
            throw new RuntimeException(e.getMessage(), e);
        }
    }

    public void release() {
        if (mCtc != null) {
            mCtc.detach();
        }
        if (mInterfaces != null) {
            mInterfaces.clear();
        }
        if (mFields != null) {
            mFields.clear();
        }
        if (mMethods != null) {
            mMethods.clear();
        }
        if (mConstructors != null) {
            mConstructors.clear();
        }
        if (mCopyMethods != null) {
            mCopyMethods.clear();
        }
        if (mCopyConstructors != null) {
            mCopyConstructors.clear();
        }
    }

    private CtClass getCtClass(Class<?> c) throws NotFoundException {
        return mPool.get(c.getName());
    }

    private CtMethod getCtMethod(Method m) throws NotFoundException {
        return getCtClass(m.getDeclaringClass())
                .getMethod(m.getName(), ReflectUtils.getDescWithoutMethodName(m));
    }

    private CtConstructor getCtConstructor(Constructor<?> c) throws NotFoundException {
        return getCtClass(c.getDeclaringClass()).getConstructor(ReflectUtils.getDesc(c));
    }

    public static interface DC {

    } // dynamic class tag interface.
}
阿里云国内75折 回扣 微信号：monov8
阿里云国际，腾讯云国际，低至75折。AWS 93折 免费开户实名账号 代冲值 优惠多多 微信号：monov8 飞机：@monov6
标签: Java
返回列表

上一篇：uc-osⅡ入门——创建工程模板

下一篇：联想拯救者独显和混显怎么切换「联想拯救者2023值得买吗」

“javassist 入门以及dubbo中的使用案例” 的相关文章

JavaScript 中URL 查询字符串(query string)的序列与反序列化1年前 (2023-02-02)
有了这份Java面试中的葵花宝典，让你面试起飞！！！1年前 (2023-02-02)
JavaWeb酒店管理系统_java web酒店管理系统1年前 (2023-02-02)
Java学习（85）Java集合——Set概述、案例：在集合中插入字符串1年前 (2023-02-02)
Java基础之 String类 源码分析1年前 (2023-02-02)
java 编程 之【评分系统】可以计算平均成绩和最烂评委1年前 (2023-02-02)
JavaScript高级 ES6类1年前 (2023-02-02)
记录每日LeetCode 2293.极大极小游戏 Java实现1年前 (2023-02-02)
【java】idea常用的快捷键和快捷代码！1年前 (2023-02-02)
09、秒懂 Java CompletableFuture ( 下 )1年前 (2023-02-02)

阿里云国际版