在看dubbo源码和mybatis源码的时候发现代理用的是javassist， 简单研究下。可以动态的修改一个类，也可以动态的创建类，也可以实现代理(可以基于继承和接口两种)。
pom如下;
<dependency>
<groupId>org.javassist</groupId>
<artifactId>javassist</artifactId>
<version>3.28.0-GA</version>
</dependency>
1. 基本用法
1. 实现动态的创建类和增加字段和方法
package org.example.javassit; import javassist.*; import java.io.IOException; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.net.URISyntaxException; public class Test2 { public static void main(String[] args) throws Exception { test2(); } // 动态的添加字段信息 private static void test2() throws Exception { //创建类，这是一个单例对象 ClassPool cp = ClassPool.getDefault(); //我们需要构建的类 CtClass ctClass = cp.get("cn.qz.Person"); //创建字段，指定了字段类型、字段名称、字段所属的类 CtField field = new CtField(cp.get("java.lang.Integer"), "age", ctClass); //指定该字段使用private修饰 field.setModifiers(Modifier.PRIVATE); //设置age字段的getter/setter方法 ctClass.addMethod(CtNewMethod.setter("getAge", field)); ctClass.addMethod(CtNewMethod.getter("setAge", field)); //当前工程的target目录 final String targetClassPath = Thread.currentThread().getContextClassLoader().getResource("").toURI().getPath(); //生成.class文件 ctClass.writeFile(targetClassPath); } // 创建类信息 private static void test1() throws CannotCompileException, NotFoundException, URISyntaxException, IOException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException { //创建类，这是一个单例对象 ClassPool pool = ClassPool.getDefault(); //我们需要构建的类 CtClass ctClass = pool.makeClass("cn.qz.Person"); //新增字段 CtField field$name = new CtField(pool.get("java.lang.String"), "name", ctClass); //设置访问级别 field$name.setModifiers(Modifier.PRIVATE); //也可以给个初始值 ctClass.addField(field$name, CtField.Initializer.constant("qz-default")); //生成get/set方法 ctClass.addMethod(CtNewMethod.setter("setName", field$name)); ctClass.addMethod(CtNewMethod.getter("getName", field$name)); //新增构造函数 //无参构造函数 CtConstructor cons$noParams = new CtConstructor(new CtClass[]{}, ctClass); cons$noParams.setBody("{name = "qz";}"); ctClass.addConstructor(cons$noParams); //有参构造函数 CtConstructor cons$oneParams = new CtConstructor(new CtClass[]{pool.get("java.lang.String")}, ctClass); // $0=this $1,$2,$3... 代表方法参数 cons$oneParams.setBody("{$0.name = $1;}"); ctClass.addConstructor(cons$oneParams); // 创建一个名为 print 的方法，无参数，无返回值，输出name值 CtMethod ctMethod = new CtMethod(CtClass.voidType, "print", new CtClass[]{}, ctClass); ctMethod.setModifiers(Modifier.PUBLIC); ctMethod.setBody("{System.out.println(name);}"); ctClass.addMethod(ctMethod); //当前工程的target目录 final String targetClassPath = Thread.currentThread().getContextClassLoader().getResource("").toURI().getPath(); //生成.class文件 ctClass.writeFile(targetClassPath); // 获取Class 对象的两种方式 // 1. 直接转 Class aClass = ctClass.toClass(); // 2. 调用类加载获取 class 信息 // Class<?> aClass = ClassLoader.getSystemClassLoader().loadClass("cn.qz.Person"); Object o = aClass.newInstance(); Method method = o.getClass().getMethod("print"); method.invoke(o); } }
2. 通过创建代理类实现增强：
(1) 接口：
package org.example.javassit.proxy; public interface IHelloService { String sayHello(String name); }
(2) 代理接口
package org.example.javassit.proxy; public interface IProxy { void setProxy(Object t); }
(3) 测试类：
package org.example.javassit.proxy; import javassist.*; import java.util.Arrays; /** * @author 乔利强 * @date 2021/8/31 10:45 * @description */ public class ProxyTest { public static void main(String[] args) throws Exception { //创建类，这是一个单例对象 ClassPool pool = ClassPool.getDefault(); pool.appendClassPath(Thread.currentThread().getContextClassLoader().getResource("").toURI().getPath()); //我们需要构建的类 CtClass ctClass = pool.makeClass("org.example.javassit.proxy.HelloServiceJavassistProxy"); //这个类实现了哪些接口 ctClass.setInterfaces(new CtClass[]{ pool.getCtClass("org.example.javassit.proxy.IHelloService"), pool.getCtClass("org.example.javassit.proxy.IProxy")}); //新增字段 CtField field$name = new CtField(pool.get("org.example.javassit.proxy.IHelloService"), "helloService", ctClass); //设置访问级别 field$name.setModifiers(Modifier.PRIVATE); ctClass.addField(field$name); //新增构造函数 //无参构造函数 CtConstructor cons$noParams = new CtConstructor(new CtClass[]{}, ctClass); cons$noParams.setBody("{}"); ctClass.addConstructor(cons$noParams); //重写sayHello方方法，可以通过构造字符串的形式 CtMethod m = CtNewMethod.make(buildSayHello(), ctClass); ctClass.addMethod(m); // 创建一个名为 setProxy 的方法 CtMethod ctMethod = new CtMethod(CtClass.voidType, "setProxy", new CtClass[]{pool.getCtClass("java.lang.Object")}, ctClass); ctMethod.setModifiers(Modifier.PUBLIC); // // $0=this $1,$2,$3... 代表方法参数 ctMethod.setBody("{$0.helloService = $1;}"); ctClass.addMethod(ctMethod); // 写到本地 ctClass.writeFile(Thread.currentThread().getContextClassLoader().getResource("").toURI().getPath()); //获取实例对象 final Object instance = ctClass.toClass().newInstance(); System.out.println(Arrays.toString(instance.getClass().getDeclaredMethods())); //设置目标方法 if (instance instanceof IProxy) { IProxy proxy = (IProxy) instance; proxy.setProxy(new IHelloService() { @Override public String sayHello(String name) { System.out.println("目标接口实现：name=" + name); return "name：" + name; } }); } if (instance instanceof IHelloService) { IHelloService service = (IHelloService) instance; service.sayHello("qz"); } } private static String buildSayHello() { String methodString = " public String sayHello(String name) { " + " System.out.println("静态代理前 .."); " + " helloService.sayHello(name); " + " System.out.println("静态代理后 .."); " + " return name; " + " }"; return methodString; } }
结果：
[public java.lang.String org.example.javassit.proxy.HelloServiceJavassistProxy.sayHello(java.lang.String), public void org.example.javassit.proxy.HelloServiceJavassistProxy.setProxy(java.lang.Object)] 静态代理前 .. 目标接口实现：name=qz 静态代理后 ..
(4) 查看生成的类：
// // Source code recreated from a .class file by IntelliJ IDEA // (powered by FernFlower decompiler) // package org.example.javassit.proxy; public class HelloServiceJavassistProxy implements IHelloService, IProxy { private IHelloService helloService; public HelloServiceJavassistProxy() { } public String sayHello(String var1) { System.out.println("静态代理前 .."); this.helloService.sayHello(var1); System.out.println("静态代理后 .."); return var1; } public void setProxy(Object var1) { this.helloService = (IHelloService)var1; } }
2. 实现代理
1. 基于继承实现
1. 需要增强的类：
package org.example.javassit.proxy2; public class UserDao { public void saveUser() { System.out.println("saveUser ======-"); } }
2. ProxyFactory 实现增强(基于继承实现增强)
package org.example.javassit.proxy2; import javassist.util.proxy.MethodFilter; import javassist.util.proxy.MethodHandler; import javassist.util.proxy.ProxyFactory; import java.lang.reflect.Method; public class ProxyTest { public static void main(String[] args) throws Exception { ProxyFactory factory = new ProxyFactory(); // 设置写出的目录会导出到具体的目录 // factory.writeDirectory = "D:/proxy"; // 指定父类，ProxyFactory会动态生成继承该父类的子类 factory.setSuperclass(UserDao.class); // 设定接口，接口可以继承多个，所以用数组 // factory.setInterfaces(new Class[]{}); //设置过滤器，判断哪些方法调用需要被拦截 factory.setFilter(new MethodFilter() { @Override public boolean isHandled(Method method) { if (method.getName().equals("saveUser")) { return true; } return false; } }); //设置拦截处理 factory.setHandler(new MethodHandler() { @Override public Object invoke(Object self, Method thisMethod, Method proceed, Object[] args) throws Throwable { System.out.println("前置处理"); Object result = proceed.invoke(self, args); System.out.println("执行结果:" + result); System.out.println("后置处理"); return result; } }); // 创建 UserDao 代理类，并创建代理对象 Class<?> c = factory.createClass(); UserDao javassistTest = (UserDao) c.newInstance(); // saveUser方法，会被拦截 javassistTest.saveUser(); System.out.println(javassistTest.toString()); } }
结果：
前置处理 saveUser ======- 执行结果:null 后置处理 org.example.javassit.proxy2.UserDao_$$_jvst840_0@1593948d
3. 反编译查看类
// // Source code recreated from a .class file by IntelliJ IDEA // (powered by FernFlower decompiler) // package org.example.javassit.proxy2; import java.io.ObjectStreamException; import java.lang.reflect.Method; import javassist.util.proxy.MethodHandler; import javassist.util.proxy.ProxyObject; import javassist.util.proxy.RuntimeSupport; public class UserDao_$$_jvst840_0 extends UserDao implements ProxyObject { public static MethodHandler default_interceptor; private MethodHandler handler; public static byte[] _filter_signature; public static final long serialVersionUID; private static Method[] _methods_; public UserDao_$$_jvst840_0() { this.handler = default_interceptor; if (default_interceptor == null) { this.handler = RuntimeSupport.default_interceptor; } super(); } public final void _d7saveUser() { super.saveUser(); } public final void saveUser() { Method[] var1 = _methods_; this.handler.invoke(this, var1[14], var1[15], new Object[0]); } static { Method[] var0 = new Method[24]; Class var1 = Class.forName("org.example.javassit.proxy2.UserDao_$$_jvst840_0"); RuntimeSupport.find2Methods(var1, "saveUser", "_d7saveUser", 14, "()V", var0); _methods_ = var0; serialVersionUID = -1L; } public void setHandler(MethodHandler var1) { this.handler = var1; } public MethodHandler getHandler() { return this.handler; } Object writeReplace() throws ObjectStreamException { return RuntimeSupport.makeSerializedProxy(this); } }
2. 基于接口
(1) UserDao 接口
package org.example.javassit.proxy2; public interface UserDao { void saveUser(); }
(2) 测试类：
package org.example.javassit.proxy2; import javassist.util.proxy.MethodFilter; import javassist.util.proxy.MethodHandler; import javassist.util.proxy.ProxyFactory; import java.lang.reflect.Method; import java.util.Arrays; public class ProxyTest { public static void main(String[] args) throws Exception { ProxyFactory factory = new ProxyFactory(); // 设置写出的目录会导出到具体的目录 factory.writeDirectory = "D:/proxy"; // 设定接口，接口可以继承多个，所以用数组 factory.setInterfaces(new Class[]{UserDao.class}); //设置过滤器，判断哪些方法调用需要被拦截 factory.setFilter(new MethodFilter() { @Override public boolean isHandled(Method method) { if (method.getName().equals("saveUser")) { return true; } return false; } }); //设置拦截处理 factory.setHandler(new MethodHandler() { @Override public Object invoke(Object self, Method thisMethod, Method proceed, Object[] args) throws Throwable { System.out.println("前置处理"); System.out.println("self: " + self + " thisMethod: " + thisMethod + " proceed: " + proceed + " args: " + Arrays.toString(args)); System.out.println("后置处理"); return ""; } }); // 创建 UserDao 代理类，并创建代理对象 Class<?> c = factory.createClass(); UserDao javassistTest = (UserDao) c.newInstance(); // saveUser方法，会被拦截 javassistTest.saveUser(); System.out.println(javassistTest.toString()); } }
(3) 结果;
前置处理 self: org.example.javassit.proxy2.UserDao_$$_jvst840_0@1b604f19 thisMethod: public abstract void org.example.javassit.proxy2.UserDao.saveUser() proceed: null args: [] 后置处理 org.example.javassit.proxy2.UserDao_$$_jvst840_0@1b604f19
(4) 反编译查看类
// // Source code recreated from a .class file by IntelliJ IDEA // (powered by FernFlower decompiler) // package org.example.javassit.proxy2; import java.io.ObjectStreamException; import java.lang.reflect.Method; import javassist.util.proxy.MethodHandler; import javassist.util.proxy.ProxyObject; import javassist.util.proxy.RuntimeSupport; public class UserDao_$$_jvst840_0 implements UserDao, ProxyObject { public static MethodHandler default_interceptor; private MethodHandler handler; public static byte[] _filter_signature; public static final long serialVersionUID; private static Method[] _methods_; public UserDao_$$_jvst840_0() { this.handler = default_interceptor; if (default_interceptor == null) { this.handler = RuntimeSupport.default_interceptor; } super(); } public final void saveUser() { Method[] var1 = _methods_; this.handler.invoke(this, var1[14], var1[15], new Object[0]); } static { Method[] var0 = new Method[24]; Class var1 = Class.forName("org.example.javassit.proxy2.UserDao_$$_jvst840_0"); RuntimeSupport.find2Methods(var1, "saveUser", (String)null, 14, "()V", var0); _methods_ = var0; serialVersionUID = -1L; } public void setHandler(MethodHandler var1) { this.handler = var1; } public MethodHandler getHandler() { return this.handler; } Object writeReplace() throws ObjectStreamException { return RuntimeSupport.makeSerializedProxy(this); } }