【Java】万字解读Java的动态代理（JDK原生动态代理、CGLIB动态代理）

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. 总结

太累了，总结就择机再说吧。上面介绍的很详细了。