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

07-19 1339阅读

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

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

VPS购买请点击我

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

1. 前言

2. 代理模式

3. 静态代理

4. 动态代理

4.1 JDK原生动态代理

4.2 CGLIB动态代理

5. 总结

相关阅读

易语言程序怎么防破解?

iis6怎么升级到7?

dede手机模版怎么加载?

十一选五怎么买必赚钱?

目录[+]