代理模式是一种常见的设计模式，在 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 动态代理不基于接口，并且可以代理没有实现接口的类。动态代理适用于对象结构比较复杂、需要对多个对象进行代理操作或需要添加一些额外的功能的场景。
无论是静态代理还是动态代理，代理对象和实际对象都应该具有相同的接口，使得客户端可以使用代理对象进行操作。代理对象在与客户端进行交互时，可以控制对实际对象的访问，以实现一些额外的功能，例如访问计数、延迟加载、权限控制等。
