【Java】试问：你小汁就是我的代理类吗？（动态代理）

文章目录

【Java】试问：你小汁就是我的代理类吗？（动态代理）
- 代理模式
- - 啥是代理模式？
  - 代理模式是嘎哈的？
  - - 1. 日志记录
    - 2. 权限检查
    - 3. 事务管理
    - 4. 远程方法调用
    - 5. 性能监控
- 静态代理
- - 静态代理的实现
  - 示例代码
  - 分析
  - 静态代理的优缺点
  - - 优点
    - 缺点
  - 静态代理小结
- 动态代理
- - 动态代理的主要特性和优势
  - 动态代理的核心组件
  - - `Proxy` 类
    - `InvocationHandler` 接口
  - 动态代理的实现步骤
  - - 定义接口和实现类
    - 创建代理类`ProxyBurgerKing`
    - 创建代理对象
  - 代码调用顺序分析
  - 动态代理的优缺点
  - - 优点
    - 缺点
- JDK动态代理与CGLIB动态代理
- - JDK动态代理
  - - 实现方式
    - 优缺点
  - CGLIB动态代理
  - - 实现方式
    - 优缺点
  - 区别总结
- 结语

在现代软件开发中，代理模式是一种广泛使用的设计模式，它允许对象在不修改其源码的情况下拦截和控制方法调用。动态代理（Dynamic Proxy）是代理模式的一种实现，它在运行时动态地生成代理类，这使得它非常灵活和强大。本文将深入探讨动态代理的概念、原理及其在 Java 编程中的应用。

代理模式

啥是代理模式？

在开发中，当我们如上图，将要访问目标类时，并不选择直接访问目标类，而是先选择调用其代理类，通过代理类再调用目标类来实现调用。

简而言之，我们可以通过代理机制，将直接调用转换成间接调用。

代理模式是嘎哈的？

代理模式是一种设计模式，通过代理对象（Proxy）控制对实际对象（Real Subject）的访问。代理对象可以在不修改实际对象代码的情况下，为实际对象的功能添加额外的处理逻辑，如预处理、后处理、安全性控制、日志记录等。

那我们为什么需要这样的代理模式呢？

这样做最大的好处，实际上是我们可以在代理类调用目标类的之前和之后，去添加一些预处理或者后处理的内容，来扩展一些不属于目标类的功能，例如：

1. 日志记录

通过代理模式，可以在方法调用前后记录日志信息，便于调试和监控。例如，在调用服务方法前后记录方法名称、参数和执行时间等。

2. 权限检查

在方法调用前进行权限检查，确保调用者具有执行该方法的权限。这样可以在不修改目标对象代码的情况下，添加权限控制功能。

3. 事务管理

在业务方法调用前后管理事务。在方法调用前开启事务，在方法调用后根据执行结果提交或回滚事务。

4. 远程方法调用

拦截方法调用，实现远程方法调用的逻辑。例如，在分布式系统中，可以通过动态代理实现远程服务调用。

5. 性能监控

统计方法调用的时间和频率，分析系统性能瓶颈。通过动态代理，可以在方法调用前后记录时间戳，并计算方法执行时间。

在代理模式的实现方式上，也会有静态和动态之分，现在我们一一对其进行介绍。

静态代理：由程序员在代码中显式地创建代理类，代理类和目标类实现相同的接口。在编译期确定代理类和目标类的关系，适用于简单的场景，但代码冗余较多，扩展性差。
动态代理：通过反射机制在运行时动态生成代理类，不需要显式地创建代理类。动态代理更加灵活，适用于复杂的场景。

静态代理

静态代理是一种在编译期间就确定的代理方式，通常通过预先定义的类来实现。在静态代理中，代理类在编译阶段就已经生成，并且所有的代理逻辑都是在代码中手动实现的。换句话说，开发者需要在编写代码时明确地创建和编写代理类，这些代理类需要实现与目标类相同的接口，并在接口方法中调用目标类的相应方法。

静态代理的实现

定义接口：首先，定义一个接口，该接口声明了目标对象和代理对象需要实现的方法。

实现目标类：创建目标类并实现上述接口，包含具体的业务逻辑。

创建代理类：编写代理类，同样实现接口，并持有目标类的引用。在代理类的方法中，调用目标类的方法，并可以在调用前后添加额外的逻辑处理。

示例代码

// 1. 定义接口
public interface Service {
    void performOperation();
}

// 2. 目标类
public class RealService implements Service {
    @Override
    public void performOperation() {
        System.out.println("Performing operation in RealService.");
    }
}

// 3. 代理类
public class ServiceProxy implements Service {
    private RealService realService;

    public ServiceProxy(RealService realService) {
        this.realService = realService;
    }

    @Override
    public void performOperation() {
        System.out.println("Proxy: Before performing operation.");
        realService.performOperation();
        System.out.println("Proxy: After performing operation.");
    }
}

// 4. 使用代理类
public class Main {
    public static void main(String[] args) {
        RealService realService = new RealService();
        Service service = new ServiceProxy(realService);
        service.performOperation();
    }
}

分析

接口（Service）：定义了一个方法performOperation。
目标类（RealService）：实现了Service接口并具体实现了performOperation方法。
代理类（ServiceProxy）：实现了Service接口，并在performOperation方法中，控制对RealService对象的访问，增加了额外的逻辑（如日志记录）。
Main类：通过代理类ServiceProxy来访问RealService的performOperation方法。

通过上述代码，代理类ServiceProxy控制了对实际服务对象RealService的访问，可以在调用前后增加额外的逻辑，从而实现对真实对象的控制。

静态代理的优缺点

优点

控制访问：可以在不修改目标对象的情况下，控制对目标对象的访问。
增加功能：在目标对象的方法执行前后增加额外的功能，如日志记录、权限检查等。

缺点

代码冗余：每个代理类都需要实现与目标对象相同的接口和方法，导致代码冗余。
扩展性差：每增加一个新方法，都需要修改代理类和目标类，维护成本高。
类数量过多：如果需要为多个类提供代理，会导致大量的代理类，增加系统复杂度。

静态代理小结

由于代理类是手动编写的，并且在编译期就确定下来，所以这种方式被称为静态代理。静态代理的特点是代码结构清晰明确，容易理解和调试，但缺点是代码冗余较多，如果接口中增加新的方法，则目标类和所有的代理类都需要相应地修改，导致维护成本较高。此外，静态代理不如动态代理灵活，因为它无法在运行时动态生成代理类，只能在编译时确定。

动态代理

动态代理是一种在运行时动态创建代理对象的技术，它能够拦截对目标对象方法的调用，并在此基础上添加额外的功能。与静态代理不同，动态代理不需要在编译期就确定代理类，而是在程序运行时通过反射机制生成代理类。这种方式使得动态代理具有更高的灵活性和扩展性。

动态代理的主要特性和优势

运行时创建代理对象：动态代理不需要预先定义代理类，而是在运行时根据需要动态生成代理对象。这意味着可以根据不同的运行时条件生成不同的代理逻辑，极大地提高了代码的灵活性和动态适应能力。
方法调用拦截：动态代理能够拦截对目标对象方法的调用，并在调用前后执行自定义的处理逻辑。这样，可以在不修改目标对象源码的情况下，增强其功能。例如，可以在方法调用前进行参数验证，在方法调用后记录日志信息，或者在方法调用前后进行性能监控。
无需修改目标对象源码：动态代理的一个显著优势是可以在不修改目标对象源码的情况下，为其添加新的功能和逻辑。这样，可以保持目标对象的代码简洁和独立，同时又能灵活地扩展其功能。

动态代理的核心组件

在 Java 中，动态代理主要通过 java.lang.reflect 包中的两个核心类来实现：

Proxy 类：用于动态生成代理类。
InvocationHandler 接口：定义了处理代理实例方法调用的接口。

`Proxy` 类

Proxy 类提供了一个静态方法 newProxyInstance，用于创建动态代理实例。该方法签名如下：

public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)

loader：指定代理类的类加载器。
interfaces：指定代理类实现的接口。
h：指定调用处理器，实现了 InvocationHandler 接口。

`InvocationHandler` 接口

InvocationHandler 接口只有一个方法 invoke，它在代理对象调用方法时被调用。该方法签名如下：

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable;

proxy：代理实例。
method：被调用的方法对象。
args：方法调用的参数。

动态代理的实现步骤

为了更好地理解动态代理，我们以一个简单的例子来说明如何使用动态代理。

定义接口和实现类

首先，我们定义一个接口 InterfaceBurger 及其实现类 Burger：

public interface InterfaceBurger {
    String  cookBurger(String name);
    String cookShake(String name);
}

public class Burger implements InterfaceBurger{

    private String name;

    public Burger() {
        this.name = name;
    }

    public Burger(String name) {
        this.name = name;
    }

    public String  cookBurger(String name){
        System.out.println(this.name + " 开始制作美味的 " + name);
        return "感谢大家对蟹堡王的支持！";
    }

    public String cookShake(String name){
        System.out.println(this.name + " 开始制作可口的 " + name);
        return "感谢大家对蟹堡王的支持！";
    }
}

创建代理类`ProxyBurgerKing`

接下来，我们实现 InvocationHandler 接口，用于在汉堡制作开始前准备材料：

public class ProxyBurgerKing {
    public static InterfaceBurger createProxy(Burger burger){
        /*
            newProxyInstance(ClassLoader loader,
                Class<?>[] interfaces,
                InvocationHandler h)
         */
        // 参数1：用于指定一个类加载器
        // 参数2：指定生成的代理长什么样子，也就是有哪些方法
        // 参数3：指定生成的代理对象要干什么事情

        InterfaceBurger burgerProxy
                = (InterfaceBurger) Proxy.newProxyInstance(ProxyBurgerKing.class.getClassLoader(),
                new Class[]{InterfaceBurger.class},
                new InvocationHandler() {
                    @Override // 回调方法
                    public Object invoke(Object o, Method method, Object[] objects) throws Throwable {
                        // 代理对象要做的事情，会在这里以代码形式呈现
                        if(method.getName().equals("cookBurger")){
                            System.out.println("准备美味的芝士、面包胚、牛肉饼！");
                        }else if(method.getName().equals("cookShake")){
                            System.out.println("准备美味的奶昔、海草！");
                        }
                        return method.invoke(burger,objects);
                    }
                });

        return burgerProxy;
    }
}

创建代理对象

最后，我们使用 ProxyBurgerKing 类创建动态代理对象：

public class Main {
    public static void main(String[] args) {
        Burger burger = new Burger("海绵宝宝");
        InterfaceBurger burgerProxy = ProxyBurgerKing.createProxy(burger);

        String s = burgerProxy.cookBurger("双层芝士汉堡！");
        System.out.println(s);

        String s1 = burgerProxy.cookShake("海草奶昔！！");
        System.out.println(s1);
    }
}

运行以上代码，输出如下：

准备美味的芝士、面包胚、牛肉饼！
海绵宝宝 开始制作美味的 双层芝士汉堡！
感谢大家对蟹堡王的支持！
准备美味的奶昔、海草！
海绵宝宝 开始制作可口的 海草奶昔！！
感谢大家对蟹堡王的支持！

从输出结果可以看出，代理对象在调用目标对象方法前后执行了汉堡的准备操作。

代码调用顺序分析

创建目标对象：

Burger burger = new Burger("海绵宝宝");

创建代理对象：

InterfaceBurger burgerProxy = ProxyBurgerKing.createProxy(burger);

Proxy.newProxyInstance 方法被调用。
传递三个参数：类加载器、接口数组和 InvocationHandler 实现。
代理类动态生成，实现 InterfaceBurger 接口，调用方法时会触发 InvocationHandler 的 invoke 方法。

调用 cookBurger 方法：

String s = burgerProxy.cookBurger("双层芝士汉堡！");

调用 burgerProxy 的 cookBurger 方法。

触发 InvocationHandler 的 invoke 方法。

检查方法名称：

if (method.getName().equals("cookBurger")) {
    System.out.println("准备美味的芝士、面包胚、牛肉饼！");
}

打印准备信息。

调用目标对象的 cookBurger 方法：

return method.invoke(burger, args);

打印制作汉堡的信息并返回结果。

输出结果：

System.out.println(s);

打印 “感谢大家对蟹堡王的支持！”。

调用 cookShake 方法：

String s1 = burgerProxy.cookShake("海草奶昔！！");

调用 burgerProxy 的 cookShake 方法。

触发 InvocationHandler 的 invoke 方法。

检查方法名称：

if (method.getName().equals("cookShake")) {
    System.out.println("准备美味的奶昔、海草！");
}

打印准备信息。

调用目标对象的 cookShake 方法：

return method.invoke(burger, args);

打印制作奶昔的信息并返回结果。

输出结果：

System.out.println(s1);

打印 “感谢大家对蟹堡王的支持！”。

动态代理的优缺点

优点

灵活性高：动态代理可以在运行时为对象添加额外的功能，而无需修改目标对象的源码。
解耦性强：通过代理对象和调用处理器，业务逻辑和横切关注点（如日志、权限、事务等）得到了很好的解耦。
代码复用：动态代理可以将通用的功能封装在调用处理器中，实现代码的复用。

缺点

性能开销：由于动态代理在方法调用时会进行反射操作，因此会带来一定的性能开销。
调试困难：由于动态代理生成的类在源码中不可见，调试时可能比较困难。

JDK动态代理与CGLIB动态代理

JDK动态代理和CGLIB动态代理是Java中两种常见的动态代理实现方式。它们在代理对象的生成方式、使用场景以及性能等方面存在明显的区别。：

JDK动态代理

JDK动态代理是基于Java的反射机制，使用java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口实现的动态代理。它只能代理实现了接口的类。

实现方式

接口要求：JDK动态代理要求目标类必须实现一个或多个接口。
代理类生成：代理类在运行时由Proxy类动态生成。通过Proxy.newProxyInstance方法创建代理对象。

优缺点

优点：
- 简单易用：只需要定义接口和实现InvocationHandler接口即可。
- 无需依赖第三方库：JDK自带的类库即可实现。
缺点：
- 只能代理接口：目标类必须实现接口，无法代理没有实现接口的类。
- 性能较低：由于使用反射机制，性能比CGLIB稍差。

CGLIB动态代理

CGLIB（Code Generation Library）动态代理是基于ASM字节码操作框架实现的。它通过生成目标类的子类来创建代理对象，因此可以代理没有实现接口的类。

实现方式

无需接口：CGLIB动态代理可以代理任何类，包括没有实现接口的类。
代理类生成：代理类在运行时通过CGLIB库动态生成，生成的代理类是目标类的子类。

优缺点

优点：
- 可以代理没有实现接口的类：更灵活。
- 性能较高：由于直接操作字节码，性能优于JDK动态代理。
缺点：
- 依赖第三方库：需要引入CGLIB库。
- 无法代理final类和方法：因为CGLIB是通过生成子类实现代理的。

区别总结

接口要求：
- JDK动态代理：要求目标类实现接口。
- CGLIB动态代理：无需目标类实现接口，可以代理任意类。
代理类生成方式：
- JDK动态代理：通过Java反射机制生成代理类。
- CGLIB动态代理：通过生成目标类的子类来创建代理类。
性能：
- JDK动态代理：由于使用反射机制，性能相对较低。
- CGLIB动态代理：通过直接操作字节码，性能较高。
适用范围：
- JDK动态代理：适用于目标类有接口的场景。
- CGLIB动态代理：适用于目标类没有接口或希望代理类的所有方法的场景。
依赖性：
- JDK动态代理：无需额外依赖，使用JDK自带的类库。
- CGLIB动态代理：需要引入CGLIB库。
限制：
- JDK动态代理：无法代理没有实现接口的类。
- CGLIB动态代理：无法代理final类和final方法，因为CGLIB通过继承生成代理类，而final修饰符会阻止继承。

这两种动态代理方式各有优缺点，选择哪种方式取决于具体的应用场景和需求。在实际开发中，可以根据目标类是否实现了接口、性能要求以及是否允许引入第三方库等因素来决定使用哪种动态代理。

结语

动态代理是Java中比较难的部分，记本篇笔记以敦促自己力学笃行，登山不能以艰险而止，学习也不能畏难而不前。在此篇之后，笔者还将介绍Java反射（其实应该先发反射再发动态代理，但笔者实在太懒了）。

本篇博客参考：

【黑马磊哥】Java动态代理深入剖析，真正搞懂Java核心设计模式：代理设计模式_哔哩哔哩_bilibili

【java常问面试题】JDK动态代理为什么只能代理有接口的类？_哔哩哔哩_bilibili

Java面试必知必会.Java基础.05.动态代理(JDK/CGLIB)_哔哩哔哩_bilibili

字节二面：动态代理是如何实现的？JDK动态代理和CGLIB动态代理有什么区别？_哔哩哔哩_bilibili