Java 代理模式的基本概念、使用场景、应用示例和实现方法

快来打我* 2023-10-12 11:29 12阅读 0赞

代理模式是一种常见的设计模式，在 Java 开发中被广泛应用。它允许我们通过添加一个代理对象来控制对另一个对象的访问，从而提供了一种间接访问实际对象的方法。本文将详细介绍 Java 代理模式的基本概念、使用场景、应用示例和实现方法等相关内容。

### 1. 概述 ###

代理模式是一种结构型设计模式，它允许我们通过添加一个代理对象来控制对另一个对象的访问。代理对象和实际对象具有相同的接口，使得客户端在不知情的情况下可以使用代理对象进行操作。代理对象在与客户端进行交互时，可以控制对实际对象的访问，以实现一些额外的功能，例如访问计数、延迟加载、权限控制等。

在 Java 中，代理模式主要有两种实现方式：静态代理和动态代理。静态代理需要手动编写代理类，通常需要针对每个实际对象编写一个代理类，在系统中管理多个代理类比较麻烦。而动态代理则可以在运行时动态生成代理类，使得客户端代码更加简洁和易于维护。本文将分别介绍这两种代理模式的实现方法和使用场景。

### 2. 静态代理 ###

静态代理是最基本的代理模式，它需要手动编写代理类。在 Java 中，可以通过实现或继承相同的接口或父类，使得代理对象拥有与实际对象相同的方法和属性。代理对象在调用实际对象的方法时，可以在方法前或方法后添加一些额外的操作，以实现特定的功能。

#### 2.1 实现方式 ####

假设我们需要实现一个简单的计算器程序，我们首先需要定义一个计算器接口：

public interface Calculator {
        
        int add(int a, int b);
        int sub(int a, int b);
        int mul(int a, int b);
        int div(int a, int b);
    }

然后，我们可以实现一个实际的计算器类：

public class RealCalculator implements Calculator {
        
        @Override
        public int add(int a, int b) {
        
            return a + b;
        }
    
        @Override
        public int sub(int a, int b) {
        
            return a - b;
        }
    
        @Override
        public int mul(int a, int b) {
        
            return a * b;
        }
    
        @Override
        public int div(int a, int b) {
        
            if (b == 0) {
        
                throw new IllegalArgumentException("除数不能为零");
            }
            return a / b;
        }
    }

接下来，我们可以编写一个代理类来控制对计算器对象的访问：

public class CalculatorProxy implements Calculator {
        
        private final Calculator calculator;
        
        public CalculatorProxy(Calculator calculator) {
        
            this.calculator = calculator;
        }
    
        @Override
        public int add(int a, int b) {
        
            System.out.println("执行加法操作");
            return calculator.add(a, b);
        }
    
        @Override
        public int sub(int a, int b) {
        
            System.out.println("执行减法操作");
            return calculator.sub(a, b);
        }
    
        @Override
        public int mul(int a, int b) {
        
            System.out.println("执行乘法操作");
            return calculator.mul(a, b);
        }
    
        @Override
        public int div(int a, int b) {
        
            System.out.println("执行除法操作");
            return calculator.div(a, b);
        }
    }

在上面的代码中，我们使用一个 `CalculatorProxy` 类来代理计算器对象。当客户端调用代理类的方法时，代理类会通过实际对象来真正执行计算操作。在代理类的方法前或方法后，可以添加一些额外的操作，例如日志记录、性能监控等。

#### 2.2 使用场景 ####

静态代理适用于以下情况：

*  对象创建和销毁比较频繁，例如数据库连接池等场景；
 *  在调用实际对象的方法前或方法后需要添加一些额外的操作，例如日志记录、性能监控等；
 *  对象需要在不同的环境中进行不同的处理，例如权限控制、事务管理等。

#### 2.3 实现方式 ####

静态代理的实现方式比较简单，但也存在一些问题。首先，由于代理类需要手动编写，因此无法应对复杂的对象结构；其次，代理类与实际对象存在强耦合关系，当实际对象发生变化时需要修改代理类；最后，为每个实际对象编写一个代理类会增加系统中类的数量，使得系统变得更加复杂和难以维护。

### 3. 动态代理 ###

动态代理是一种更加灵活和高效的代理模式，它可以在运行时动态生成代理类，避免了手动编写大量代理类的繁琐工作。在 Java 中，动态代理主要有两种实现方式：JDK 动态代理和 CGLIB 动态代理。

#### 3.1 JDK 动态代理 ####

JDK 动态代理是 Java 标准库提供的一种动态代理实现方式，它基于接口代理实现。在 JDK 动态代理中，我们需要通过 `java.lang.reflect.Proxy` 类来生成代理对象。

假设我们还是需要一个计算器程序，我们可以重新定义一个计算器接口：

public interface Calculator {
        
        int add(int a, int b);
        int sub(int a, int b);
        int mul(int a, int b);
        int div(int a, int b);
    }

然后，我们可以使用 JDK 动态代理来生成代理对象：

public class CalculatorInvocationHandler implements InvocationHandler {
        
        private final Object target;
    
        public CalculatorInvocationHandler(Object target) {
        
            this.target = target;
        }
    
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        
            System.out.println("执行方法前");
            Object result = method.invoke(target, args);
            System.out.println("执行方法后");
            return result;
        }
    }
    
    public class Main {
        
        public static void main(String[] args) {
        
            Calculator calculator = new RealCalculator();
            CalculatorInvocationHandler handler = new CalculatorInvocationHandler(calculator);
            Calculator proxy = (Calculator) Proxy.newProxyInstance(
                calculator.getClass().getClassLoader(),
                calculator.getClass().getInterfaces(),
                handler);
    
            int a = 1, b = 2;
            System.out.println("add: " + proxy.add(a, b));
            System.out.println("sub: " + proxy.sub(a, b));
            System.out.println("mul: " + proxy.mul(a, b));
            System.out.println("div: " + proxy.div(a, b));
        }
    }

在上面的代码中，我们定义了一个 `CalculatorInvocationHandler` 类来实现 `java.lang.reflect.InvocationHandler` 接口。当客户端调用代理对象的方法时，JDK 动态代理会自动调用 `invoke` 方法，并将原始方法的调用转发给 `RealCalculator` 对象。在 `invoke` 方法前或方法后，我们可以添加一些额外的操作，例如日志记录、性能监控等。

#### 3.2 CGLIB 动态代理 ####

CGLIB 动态代理是一种不基于接口的动态代理实现方式，它可以代理没有实现接口的类。在 CGLIB 动态代理中，我们需要通过 `net.sf.cglib.proxy.Enhancer` 类来生成代理对象。

假设我们有一个没有实现任何接口的类：

public class UserService {
        
        public void addUser(String username, String password) {
        
            System.out.println("add user: " + username + ", " + password);
        }
    
        public void updateUser(String username, String password) {
        
            System.out.println("update user: " + username + ", " + password);
        }
    
        public void deleteUser(String username) {
        
            System.out.println("delete user: " + username);
        }
    }

然后，我们可以使用 CGLIB 动态代理来生成代理对象：

public class UserServiceInterceptor implements MethodInterceptor {
        
        @Override
        public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        
            System.out.println("执行方法前");
            Object result = proxy.invokeSuper(obj, args);
            System.out.println("执行方法后");
            return result;
        }
    }
    
    public class Main {
        
        public static void main(String[] args) {
        
            Enhancer enhancer = new Enhancer();
            enhancer.setSuperclass(UserService.class);
            enhancer.setCallback(new UserServiceInterceptor());
            UserService proxy = (UserService) enhancer.create();
    
            proxy.addUser("Tom", "123456");
            proxy.updateUser("Tom", "654321");
            proxy.deleteUser("Tom");
        }
    }

在上面的代码中，我们定义了一个 `UserServiceInterceptor` 类来实现 `net.sf.cglib.proxy.MethodInterceptor` 接口。当客户端调用代理对象的方法时，CGLIB 动态代理会自动调用 `intercept` 方法，并将原始方法的调用转发给 `UserService` 类。在 `intercept` 方法前或方法后，我们可以添加一些额外的操作，例如日志记录、性能监控等。

#### 3.3 使用场景 ####

动态代理适用于以下情况：

*  对象结构比较复杂，手动编写代理类比较困难；
 *  需要对多个对象进行代理操作，手动编写代理类比较繁琐；
 *  在不修改实际对象的情况下添加一些额外的功能，例如日志记录、性能监控等。

### 4. 总结 ###

代理模式是一种非常常用的设计模式，它可以通过添加一个代理对象来控制对另一个对象的访问。在 Java 中，代理模式主要有两种实现方式：静态代理和动态代理。

静态代理需要手动编写代理类，通常需要针对每个实际对象编写一个代理类，在系统中管理多个代理类比较麻烦。而动态代理则可以在运行时动态生成代理类，使得客户端代码更加简洁和易于维护。

JDK 动态代理基于接口代理实现，适用于需要代理接口的场景；而 CGLIB 动态代理不基于接口，并且可以代理没有实现接口的类。动态代理适用于对象结构比较复杂、需要对多个对象进行代理操作或需要添加一些额外的功能的场景。

无论是静态代理还是动态代理，代理对象和实际对象都应该具有相同的接口，使得客户端可以使用代理对象进行操作。代理对象在与客户端进行交互时，可以控制对实际对象的访问，以实现一些额外的功能，例如访问计数、延迟加载、权限控制等。