阅读量:0
1. 前言
动态代理在Java中有着广泛的应用，比如 Spring AOP、RPC 远程调用、Java 注解对象获取、日志、用户鉴权、全局性异常处理、性能监控，甚至事务处理等。
下面我将着重的介绍两个常用的动态代理：JDK原生动态代理 和 CGLIB 动态代理。
2. 代理模式
当我们谈及 Java 的 动态代理 或者是 静态代理 ，我们都很容易谈及到设计模式中的—— 代理模式。
在这里我想要提出几个问题，什么是代理模式？代理模式的构成是怎想的？如何实现代理模式？代理模式在实际开发中的左右是什么？Java的动态代理与设计代理模式有什么关系？如何实现Java的动态代理？
下面我们将围绕着抛出的这几个问题来展开这篇博文。
代理模式的定义：
代理模式是给某一个对象提供一个代理，并由代理对象来控制对真实对象的访问，起到对代理对象已有功能的增强。 代理模式是一种结构型设计模式。 代理模式一般会存在三个角色：
1、抽象主题角色（Subject）
抽象主题角色指的是 `真实对象` 与 `代理对象` 的公共的法所抽象出来的一个接口或者是抽象类。 在 Java 编程成，我们就可以认为是一个 `接口` 或者是 `抽象类` 。 2、真实主题角色（RealSubject）
真实主题角色指的是被代理对象。 3、代理主题角色（ProxySubject）
代理主题角色指的是代理对象。 代理模式的结构比较简单，其核心是代理类，为了让客户端能够一致性地对待真实对象和代理对象，在代理模式中引入了抽象层。
如果根据字节码的创建时机来分类，可以分为静态代理和动态代理：
静态代理
所谓 `静态` 也就是在 `程序运行前` 就已经存在代理类的字节码文件，代理类和真实主题角色的关系在运行前就确定了。 动态代理
而 `动态` 代理的源码是在 `程序运行期间` 由 JVM 根据反射等机制动态的生成，所以在运行前并不存在代理类的字节码文件。 3. 静态代理
在介绍 动态代理 之前，我们介绍一下 静态代理 。由上可推到出，无论动态代理还是静态代理，都是代理模式的一种实践。下面我们将实现一套基础的 静态代理代码 。
代理模式分为 3 个组成部分：抽象主题对象、真实主题对象、代理主题对象。 定义抽象主题接口（上面我们已经介绍了抽象主题对象就是接口或抽象类）。此案例中我们使用接口。
// 定义接口 interface Subject { void request(); } 定义真实主题类
// 定义被代理类 class RealSubject implements Subject { @Override public void request() { System.out.println("Do invoke request(), now."); } } 定义抽象主题类
// 定义代理类 class ProxySubject implements Subject { private Subject realSubject; public ProxySubject(Subject realSubject) { this.realSubject = realSubject; } @Override public void request() { before(); realSubject.request(); after(); } private void before() { System.out.println("准备开始执行方法..."); } private void after() { System.out.println("方法方法执行结束..."); } } 定义客户端，查看执行效果
public class Client{ public static void main(String[] args) { Subject realSubject = new RealSubject(); Subject proxySubject = new ProxySubject(realSubject); proxySubject.request(); } } 输出结果：
准备开始执行方法... Do invoke request(), now. 方法方法执行结束... 这样，我们就完成了一个静态代理的编写。从上面的代码我们不难发现 静态代理 存在一个问题，代理主题类与真实主题类之间的 耦合程度太高 ，当真实主题类中增加、删除、修改方法后，那么代理主题类中的也必须增加、删除、修改相应的方法，提高了代码的维护成本。另一个问题就是当代理对象代理多个 Subject 的实现类时，多个实现类中必然出在不同的方法，由于代理对象要实现与目标对象一致的接口（其实是包含关系），必然需要编写众多的方法，极其容易造成臃肿且难以维护的代码。
相比与于静态代理，动态代理则不存在上述的诸多问题，下面我们进入 JDK 的动态代理。
4. 动态代理
从 静态代理 章节中为我们可知，静态代理存在着诸多的问题，最主要的问题是静态代理类需要对被代理类做手动的方法映射。造成这个问题的原因是代理对象是通过硬编码得到的，是在程序编译前就已经存在的，所以顺着这个思路，我们不难得到一个方向，如何代理对象不是通过硬编码提前写好的，而是在程序运行中动态生产的，且生成的代理对象可以对被代理类的方法做自动的映射，那么问题不就解决了吗？是的，这也就是动态代理的大致解决方案。
4.1 JDK原生动态代理
JDK原生动态代理的组成分为三个部分： 抽象主题角色 、 真实主题角色 、 增强主题橘色 。
抽象主题角色和代理模式的抽象主题角色是一样的，都是抽象出来的接口或类，对于JDK原生动态代理而言，抽象主题角色就是接口。
真实主题角色和代理模式的真实主题角色一样，都是被代理类。
增强主题角色在JDK原生代理中值的是实现了 InvocationHandler 接口的类，其目的是对真实主题角色的方法的增强。 InvocationHandler 接口中只有一个方法 invoke 方法，所有的动态代理对象中的映射方法在执行时都是调用的 InvocationHandler 接口中的 invoke 方法，在调用 invoke 方法时，动态代理对象会将 被代理对象的方法 和 动态代理对象映射的方法的参数 传递给 InvocationHandler 的 invoke 方法， invoke 方法的实现是由程序员编写的，这样程序员就可以在 被代理对象的方法 执行 前后 进行增强。
下面我们来实现一下JDK原生动态代理
1、定义抽象主题角色接口 UserService
public interface UserService { public void select(); public void update(); } 2、定义真实主题角色类 UserServiceImpl
public class UserServiceImpl implements UserService{ @Override public void select() { System.out.println("执行UserService.select()方法"); } @Override public void update() { System.out.println("执行UserService.update()方法"); } } 3、定义增加主题角色类 LogHandler
public class LogHandler implements InvocationHandler { // 用于存储真实的被代理对象 Object target; public LogHandler(Object target) { this.target = target; } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { // 真实方法执行前的增强 before(method.getName()); // 真实方法执行 Object result = method.invoke(target, args); after(method.getName()); // 真实方法执行后的增强 return result; } private void before(String methodName) { System.out.printf("[%s] 准备开始执行%s方法%n", new Date(), methodName); } private void after(String methodName) { System.out.printf("[%s] %s方法方法执行结束%n", new Date(), methodName); } } 4、编写客户端（其中有生产JDK原生动态代理的核心代码）
public class Client { public static void main(String[] args) { // 实例化被代理对象 UserService targetInstance = new UserServiceImpl(); // 获取被代理对象的类加载器，用作生成代理对象的必要参数 ClassLoader classLoader = targetInstance.getClass().getClassLoader(); // 获取被代理对象的实现接口，用作生成代理对象的必要参数 // 方法映射就是基于这个参数实现的 Class<?>[] interfaces = targetInstance.getClass().getInterfaces(); // 获取被代理对象的增强主题类，用作生成代理对象的必要参数 LogHandler logHandler = new LogHandler(targetInstance); // 生成代理对象的核心代码！！！！ UserService proxyInstance = (UserService)Proxy.newProxyInstance(classLoader, interfaces, logHandler); // 使用代理对象执行方法 proxyInstance.select(); System.out.println(); proxyInstance.update(); } } 执行结果：
[Tue Feb 20 17:58:14 CST 2024] 准备开始执行select方法 执行UserService.select()方法 [Tue Feb 20 17:58:14 CST 2024] select方法方法执行结束 [Tue Feb 20 17:58:14 CST 2024] 准备开始执行update方法 执行UserService.update()方法 [Tue Feb 20 17:58:14 CST 2024] update方法方法执行结束 我相信你一定和我一样好奇，生产的动态代理对象到底是什么样子的。 下面我将提供一个工具类，将代理对象生成出来，让大家一睹它的芳容。
代理工具类 ProxyUtils
public class ProxyUtils { /** * 将根据类信息动态生成的二进制字节码保存到硬盘中，默认的是clazz目录下 * @param clazz 需要生成动态代理类的类 * @param proxyName 为动态生成的代理类的名称 */ public static void generateClassFile(Class clazz, String proxyName) { // 根据类信息和提供的代理类名称，生成字节码 byte[] classFile = ProxyGenerator.generateProxyClass(proxyName, clazz.getInterfaces()); String paths = clazz.getResource(".").getPath(); System.out.printf("代理对象%s生成位置：%s.class%n",proxyName, paths + proxyName); FileOutputStream out = null; try { //保留到硬盘中 out = new FileOutputStream(paths + proxyName + ".class"); out.write(classFile); out.flush(); } catch (Exception e) { e.printStackTrace(); } finally { try { if (out != null) out.close(); } catch (IOException e) { e.printStackTrace(); } } } } 生成代理对象
public class Client { public static void main(String[] args) { // 实例化被代理对象 UserService targetInstance = new UserServiceImpl(); // 生成代理类（我只是想看一下代理类到底长什么样而已） ProxyUtils.generateClassFile( targetInstance.getClass(), "UserServiceImplProxy" + System.currentTimeMillis() ); } } 执行结果
代理对象UserServiceImplProxy1708423094323生成位置：/E:/project/z_other/demo/target/classes/com/example/proxy/jdkProxy/UserServiceImplProxy1708423094323.class JDK原生的动态代理执行过程如下图所示：
下面就是生成的代理对象，注解有说明哦。
我们可以发现这个对象继承了 Proxy 类和实现了 抽象主题角色类（UserService） 。继承了 Proxy 类就意味着该类可以访问 proxy 中的成员属性，例如 InvocationHandler 接口。实现了 UserService 就以为这其可以完成对 UserServiceImpl 类的接口映射。
public final class UserServiceImplProxy1708423094323 extends Proxy implements UserService { // 这 5 个变量就是用来存储被代理对象的方法的 private static Method m1; private static Method m2; private static Method m4; private static Method m0; private static Method m3; public UserServiceImplProxy1708423094323(InvocationHandler var1) throws { super(var1); } // 从被代理对象映射出来的方法 public final void select() throws { try { // 核心执行代码（调用） // 调用 InvocationHandler 的 invoke 方法 // 将被代理对象的方法和参数传递给 invoke 方法 super.h.invoke(this, m4, (Object[])null); } catch (RuntimeException | Error var2) { throw var2; } catch (Throwable var3) { throw new UndeclaredThrowableException(var3); } } // 从被代理对象映射出来的方法 public final void update() throws { try { super.h.invoke(this, m3, (Object[])null); } catch (RuntimeException | Error var2) { throw var2; } catch (Throwable var3) { throw new UndeclaredThrowableException(var3); } } // 从被代理对象映射出来的方法 public final boolean equals(Object var1) throws { try { return (Boolean)super.h.invoke(this, m1, new Object[]{var1}); } catch (RuntimeException | Error var3) { throw var3; } catch (Throwable var4) { throw new UndeclaredThrowableException(var4); } } // 从被代理对象映射出来的方法 public final String toString() throws { try { return (String)super.h.invoke(this, m2, (Object[])null); } catch (RuntimeException | Error var2) { throw var2; } catch (Throwable var3) { throw new UndeclaredThrowableException(var3); } } // 从被代理对象映射出来的方法 public final int hashCode() throws { try { return (Integer)super.h.invoke(this, m0, (Object[])null); } catch (RuntimeException | Error var2) { throw var2; } catch (Throwable var3) { throw new UndeclaredThrowableException(var3); } } static { // 这就是代理对象获取被代理对象真实方法的过程 try { m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object")); m2 = Class.forName("java.lang.Object").getMethod("toString"); m4 = Class.forName("com.example.proxy.jdkProxy.UserService").getMethod("select"); m0 = Class.forName("java.lang.Object").getMethod("hashCode"); m3 = Class.forName("com.example.proxy.jdkProxy.UserService").getMethod("update"); } catch (NoSuchMethodException var2) { throw new NoSuchMethodError(var2.getMessage()); } catch (ClassNotFoundException var3) { throw new NoClassDefFoundError(var3.getMessage()); } } } 4.2 CGLIB动态代理
在上面的 4.1 JDK原生动态代理 模块中，我们知道动态代理的实现是基于接口实现的。本章我们将介绍 CGLIB动态代理 ，CGLIB 实现动态代理的方式与 JDK 代理略有区别，CGLIB 是基于继承实现的动态代理，CGLIB 会生成一个动态代理子类，这个子类需要重写被代理对象的所有非 finanl 方法，在子类中采用方法拦截的技术拦截所有的父类方法调用，顺势织入横切逻辑。
在介绍基于 CGLIB 实现动态代理之前，我想先说一下实现动态代理需要实现的几个模块：
首先，我们需要一个被代理对象（普通类，不要求需要实现什么接口）；
其次，我们需要编写一个增强类（我们需要代理的目的就是为了实现对原本方法的增强），所有的增强逻辑都基于它来实现，增强类需要实现 CGLIB 的 MethodInterceptor接口，并重写其中唯一一个方法 intercept，后面操作就可 JDK 的动态代理类似了，基于intercept 方法区执行被代理类的方法，并在方法执行前后完成对被代理方法的增强；
最后，我们需要基于 CGLIB 的对象生成目标对象的被代理对象。
下面是基于 CGLIB 实现动态代理的案例：
编写一个被代理对象 UserService ：
public class UserService { public void select() { System.out.println("执行UserService.select()方法"); } public void update() { System.out.println("执行UserService.update()方法"); } } 编写对被代理对象的增强类 LogInterceptor ：
public class LogInterceptor implements MethodInterceptor { /** * * @param o 表示要增强的对象（被代理对象） * @param method 表示被拦截的方法 * @param objects 表示参数列表 * @param methodProxy 表示对连接方法的代理,invokeSuper方法表示对被代理对象方法的调用 */ @Override public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable { // 前置增强 before(method.getName()); // 调用被实际方法 Object result = methodProxy.invokeSuper(o, objects); // 后置增强 after(method.getName()); // 返回实际对象的结果 return result; } private void before(String methodName) { System.out.printf("[%s] 准备开始执行%s方法%n", new Date(), methodName); } private void after(String methodName) { System.out.printf("[%s] %s方法方法执行结束%n", new Date(), methodName); } } 生成代理对象并执行代理方法：
public class Client { public static void main(String[] args) { // Enhancer 为 CGLIB 代理增强类 Enhancer enhancer = new Enhancer(); // 设置被代理类（父类），以便 CGLIB 去生成该类的子类 enhancer.setSuperclass(UserService.class); // 你可以认为是设置增强方法 enhancer.setCallback(new LogInterceptor()); // 生成代理对象 UserService proxy = (UserService) enhancer.create(); // 执行代理方法 proxy.select(); System.out.println(); proxy.update(); } } 输出结果：
[Thu Feb 22 17:46:18 CST 2024] 准备开始执行select方法 执行UserService.select()方法 [Thu Feb 22 17:46:18 CST 2024] select方法方法执行结束 [Thu Feb 22 17:46:18 CST 2024] 准备开始执行update方法 执行UserService.update()方法 [Thu Feb 22 17:46:18 CST 2024] update方法方法执行结束 现在有这么一个需求，对于同一个代理对象中的不同方法，我想实现不同的增强逻辑，应该如何优雅的实现。
CGLIB 中支持对一个类设置多个不同的增强类，但是多个增强类无法增强同一个方法，这也就意味着我们需要为代理独享编写过滤器。有上面的介绍我们可得：想要实现对同一个类的不同方法实现差异性增强，我们需要多写一个代理过滤器，以便可以为不同的方法分配不同的增强方案。
我的大概实现方案如下：
1） 通过在方法上 引用 不同的自定义 注解 去，去 区分 不同方法的 增强 方案。
2） 编写多个增强类（实现类MethodInterceptor接口的类）去实现不同的增强逻辑。下面我会编写一个 日志增强 和 参数校验增强。
3）基于 CGLIB 语法生成多重增强代理类。
编写参数检查注解 CheckProxy 和日志注解 LogProxy：
@Documented @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.METHOD) public @interface CheckProxy { } @Documented @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.METHOD) public @interface LogProxy { } 编写被代理对象 UserService，并其方法上打上不同的注解：
public class UserService { @CheckProxy public void select() { System.out.println("执行UserService.select()方法"); } @LogProxy public void update() { System.out.println("执行UserService.update()方法"); } } 编写日志增强类 LogInterceptor 和参数检查增强类 CheckInterceptor ：
public class LogInterceptor implements MethodInterceptor { @Override public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable { before(method.getName()); Object result = methodProxy.invokeSuper(o, objects); after(method.getName()); return result; } private void before(String methodName) { System.out.printf("[%s] 准备开始执行%s方法%n", new Date(), methodName); } private void after(String methodName) { System.out.printf("[%s] %s方法方法执行结束%n", new Date(), methodName); } } public class CheckInterceptor implements MethodInterceptor { @Override public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable { check(objects); return methodProxy.invokeSuper(o, objects); } private void check(Object[] objects) { boolean b = Arrays.stream(objects).allMatch(Objects::nonNull); System.out.printf("[%s] 正在进行参数检查%n", new Date()); if (b) { System.out.printf("[%s] 参数检查通过%n", new Date()); } else { throw new RuntimeException("存在非法参数"); } } } 编写代理增强过滤器 InterceptorFilter：
这个地方我要介绍一下大家的疑惑点，我们可以看到 accept 方法的返回值是 int 且我分别返回了 0，1, 2 。accept 返回的是 增强类数组的索引 ，之所以会有增强类数组的存在，是因为我们在生成代理对象之前，需要向 Enhancer 中注入 增强类数组。代理方法在被执行前后被哪一个增强类所增强，是由 我们编写并实现了 CallbackFilter 接口的 InterceptorFilter 类所分配的，即 accept方法 的返回值
public class InterceptorFilter implements CallbackFilter { @Override public int accept(Method method) { if (method.isAnnotationPresent(LogProxy.class)) { return 0; } else if (method.isAnnotationPresent(CheckProxy.class)) { return 1; } return 2; } } 生成代理对象：
public class Client { public static void main(String[] args) { Enhancer enhancer = new Enhancer(); enhancer.setSuperclass(UserService.class); // 设置增强类数组 enhancer.setCallbacks(new Callback[]{new LogInterceptor(), new CheckInterceptor(), NoOp.INSTANCE}); // 设置增强类过滤器 enhancer.setCallbackFilter(new InterceptorFilter()); UserService proxy = (UserService) enhancer.create(); proxy.select(); System.out.println(); proxy.update(); } } 执行结果：
[Thu Feb 22 18:42:21 CST 2024] 正在进行参数检查 [Thu Feb 22 18:42:21 CST 2024] 参数检查通过 执行UserService.select()方法 [Thu Feb 22 18:42:22 CST 2024] 准备开始执行update方法 执行UserService.update()方法 [Thu Feb 22 18:42:22 CST 2024] update方法方法执行结束 这样我们就实现了对被代理对象的不同方法的差异性增强。
5. 总结
太累了，总结就择机再说吧。上面介绍的很详细了。
