设计模式基础（五）——代理模式
代理模式（Proxy Design Pattern），是一种结构型模式。所谓结构型模式，就是一些类或对象组合在一起的经典结构，这些经典的结构可以解决特定应用场景的问题。
代理模式可以在不改变原始类（或叫被代理类）代码的情况下，通过引入代理类来给原始类附加功能。最常用的一个应用场景就是，在业务系统中开发一些非功能性需求，比如：监控、统计、鉴权、限流、事务、幂等、日志。我们将这些附加功能与业务功能解耦，放到代理类中统一处理，让程序员只需要关注业务方面的开发。
我们先来看下最原生的代理模式，理解下它的基本思想和原理。
一、基本原理
1.1 使用代理模式前
假设我们有下面这样的一个用户控制器类，然后需要统计每个接口的一些性能相关信息。为了实现统计功能，我们引入MetricsCollector类，然后在UserController的每个接口的前后都加上统计的逻辑：
public class UserController {
private MetricsCollector metricsCollector; // 依赖注入
public void login(String telephone, String password) {
long startTimestamp = System.currentTimeMillis();
// ... 省略login逻辑...
long endTimeStamp = System.currentTimeMillis();
long responseTime = endTimeStamp - startTimestamp;
RequestInfo requestInfo = new RequestInfo("login", responseTime, startTimestamp);
metricsCollector.recordRequest(requestInfo);
}
public void register(String telephone, String password) {
long startTimestamp = System.currentTimeMillis();
// ... 省略register逻辑...
long endTimeStamp = System.currentTimeMillis();
long responseTime = endTimeStamp - startTimestamp;
RequestInfo requestInfo = new RequestInfo("register", responseTime, startTimestamp);
metricsCollector.recordRequest(requestInfo);
}
}
这种写法各位一定不陌生，问题也非常明显：
- 性能统计的代码侵入到业务代码中，跟业务代码高度耦合。如果未来需要替换性能统计的逻辑，替换成本会比较大；
- 性能统计的代码跟业务代码无关，本就不应该放到一个类中。
1.2 使用代理模式后
我们来看下如何使用最简单的代理模式来解决这个问题。我们新建一个代理类 UserControllerProxy，它和原始类 UserController 实现相同的接口 IUserController。
代理类 UserControllerProxy 负责在业务代码执行前后附加其他逻辑代码，并通过委托方式调用原始类来执行业务代码。具体的代码实现如下所示：
public class UserControllerProxy implements IUserController {
private MetricsCollector metricsCollector;
private UserController userController;
public UserControllerProxy(UserController userController) {
this.userController = userController;
this.metricsCollector = new MetricsCollector();
}
@Override
public void login(String telephone, String password) {
long startTimestamp = System.currentTimeMillis();
// 委托
UserVo userVo = userController.login(telephone, password);
long endTimeStamp = System.currentTimeMillis();
long responseTime = endTimeStamp - startTimestamp;
RequestInfo requestInfo = new RequestInfo("login", responseTime, startTimestamp);
metricsCollector.recordRequest(requestInfo);
}
@Override
public void register(String telephone, String password) {
long startTimestamp = System.currentTimeMillis();
// 委托
UserVo userVo = userController.register(telephone, password);
long endTimeStamp = System.currentTimeMillis();
long responseTime = endTimeStamp - startTimestamp;
RequestInfo requestInfo = new RequestInfo("register", responseTime, startTimestamp);
metricsCollector.recordRequest(requestInfo);
}
}
最后，客户端可以像下面这样来使用，直接面向接口编程：
IUserController userController = new UserControllerProxy(new UserController());
如果原始类没有定义接口，或原始类代码并不是我们开发维护的（比如它来自一个第三方的类库），我们没办法直接修改原始类。在这种情况下，我们可以让代理类继承原始类，然后扩展附加功能，不再赘述。
上述的这种代理模式，其实也叫静态代理，本质是一种委托。它存在两个明显的问题：
- 我们需要在代理类中，将原始类中的所有的方法，都重新实现一遍，并且为每个方法都附加相似的代码逻辑；
- 如果要附加的功能不止一个，我们需要针对每项附加功能都创建一个代理类，导致项目中类的个数成倍增加，增加了代码维护成本。
所以，我们就需要用到动态代理。
二、动态代理
所谓动态代理（Dynamic Proxy），就是我们不事先为每个原始类编写代理类，而是在运行的时候，动态地创建原始类对应的代理类，然后在系统中用代理类替换掉原始类。
2.1 JDK动态代理
Java 语言本身就已经提供了动态代理的语法（实际上，动态代理底层依赖的就是 Java 反射语法）。我们来看一下，如何用 JDK动态代理来实现刚刚的功能。
MetricsCollectorProxy 作为一个动态代理类，动态地给每个需要收集接口请求信息的类创建代理类。
public class MetricsCollectorProxy {
private MetricsCollector metricsCollector;
public MetricsCollectorProxy() {
this.metricsCollector = new MetricsCollector();
}
public Object createProxy(Object proxiedObject) {
// 拿到被代理类的所有接口
Class<?>[] interfaces = proxiedObject.getClass().getInterfaces();
DynamicProxyHandler handler = new DynamicProxyHandler(proxiedObject);
return Proxy.newProxyInstance(proxiedObject.getClass().getClassLoader(), interfaces, handler);
}
private class DynamicProxyHandler implements InvocationHandler {
private Object proxiedObject;
public DynamicProxyHandler(Object proxiedObject) {
this.proxiedObject = proxiedObject;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
long startTimestamp = System.currentTimeMillis();
// 执行被代理类的方法
Object result = method.invoke(proxiedObject, args);
long endTimeStamp = System.currentTimeMillis();
long responseTime = endTimeStamp - startTimestamp;
String apiName = proxiedObject.getClass().getName() + ":" + method.getName();
RequestInfo requestInfo = new RequestInfo(apiName, responseTime, startTimestamp);
metricsCollector.recordRequest(requestInfo);
return result;
}
}
}
使用方式如下：
MetricsCollectorProxy proxy = new MetricsCollectorProxy();
IUserController userController = (IUserController) proxy.createProxy(new UserController());
实际上，Spring AOP 底层的实现原理就是基于动态代理。用户配置好需要给哪些类创建代理，并定义好原始类前后要执行的附加功能。Spring 为这些类创建动态代理对象，并在 JVM 中替代原始类对象，这样原本在代码中执行的原始类的方法，就被换作执行代理类的方法，也就实现了给原始类添加附加功能的目的。
2.2 CGLIB动态代理
JDK动态代理，本地是为被代理对象的接口创建代理类，也就是基于接口的代理，如果被代理对象没有实现特定的接口，则可以使用CGLIB动态代理。
CGLIB代理也叫子类代理，它是在内存中构建一个被代理对象的子类对象，从而实现对被代理对象的扩展。CGLIB可以在运行期扩展Java类或实现Java接口。Spring AOP除了支持JDK代理外，也支持CGLIB代理。
CGLIB包的底层是通过一个字节码处理框架ASM来转换字节码并生成新的类。
三、总结
代理模式的应用非常广泛，包括非功能性逻辑的嵌入，比如我们本章的示例。RPC 框架也可以看作一种代理模式，它将网络通信、数据编解码等细节隐藏起来，让客户端在使用 RPC 服务的时候，就像使用本地函数一样，无需了解跟服务器交互的细节。代理模式（Proxy Design Pattern），是一种结构型模式。所谓结构型模式，就是一些类或对象组合在一起的经典结构，这些经典的结构可以解决特定应用场景的问题。
代理模式可以在不改变原始类（或叫被代理类）代码的情况下，通过引入代理类来给原始类附加功能。最常用的一个应用场景就是，在业务系统中开发一些非功能性需求，比如：监控、统计、鉴权、限流、事务、幂等、日志。我们将这些附加功能与业务功能解耦，放到代理类中统一处理，让程序员只需要关注业务方面的开发。
我们先来看下最原生的代理模式，理解下它的基本思想和原理。
一、基本原理
1.1 使用代理模式前
假设我们有下面这样的一个用户控制器类，然后需要统计每个接口的一些性能相关信息。为了实现统计功能，我们引入MetricsCollector类，然后在UserController的每个接口的前后都加上统计的逻辑：
public class UserController {
private MetricsCollector metricsCollector; // 依赖注入
public void login(String telephone, String password) {
long startTimestamp = System.currentTimeMillis();
// ... 省略login逻辑...
long endTimeStamp = System.currentTimeMillis();
long responseTime = endTimeStamp - startTimestamp;
RequestInfo requestInfo = new RequestInfo("login", responseTime, startTimestamp);
metricsCollector.recordRequest(requestInfo);
}
public void register(String telephone, String password) {
long startTimestamp = System.currentTimeMillis();
// ... 省略register逻辑...
long endTimeStamp = System.currentTimeMillis();
long responseTime = endTimeStamp - startTimestamp;
RequestInfo requestInfo = new RequestInfo("register", responseTime, startTimestamp);
metricsCollector.recordRequest(requestInfo);
}
}
这种写法各位一定不陌生，问题也非常明显：
- 性能统计的代码侵入到业务代码中，跟业务代码高度耦合。如果未来需要替换性能统计的逻辑，替换成本会比较大；
- 性能统计的代码跟业务代码无关，本就不应该放到一个类中。
1.2 使用代理模式后
我们来看下如何使用最简单的代理模式来解决这个问题。我们新建一个代理类 UserControllerProxy，它和原始类 UserController 实现相同的接口 IUserController。
代理类 UserControllerProxy 负责在业务代码执行前后附加其他逻辑代码，并通过委托方式调用原始类来执行业务代码。具体的代码实现如下所示：
public class UserControllerProxy implements IUserController {
private MetricsCollector metricsCollector;
private UserController userController;
public UserControllerProxy(UserController userController) {
this.userController = userController;
this.metricsCollector = new MetricsCollector();
}
@Override
public void login(String telephone, String password) {
long startTimestamp = System.currentTimeMillis();
// 委托
UserVo userVo = userController.login(telephone, password);
long endTimeStamp = System.currentTimeMillis();
long responseTime = endTimeStamp - startTimestamp;
RequestInfo requestInfo = new RequestInfo("login", responseTime, startTimestamp);
metricsCollector.recordRequest(requestInfo);
}
@Override
public void register(String telephone, String password) {
long startTimestamp = System.currentTimeMillis();
// 委托
UserVo userVo = userController.register(telephone, password);
long endTimeStamp = System.currentTimeMillis();
long responseTime = endTimeStamp - startTimestamp;
RequestInfo requestInfo = new RequestInfo("register", responseTime, startTimestamp);
metricsCollector.recordRequest(requestInfo);
}
}
最后，客户端可以像下面这样来使用，直接面向接口编程：
IUserController userController = new UserControllerProxy(new UserController());
如果原始类没有定义接口，或原始类代码并不是我们开发维护的（比如它来自一个第三方的类库），我们没办法直接修改原始类。在这种情况下，我们可以让代理类继承原始类，然后扩展附加功能，不再赘述。
上述的这种代理模式，其实也叫静态代理，本质是一种委托。它存在两个明显的问题：
- 我们需要在代理类中，将原始类中的所有的方法，都重新实现一遍，并且为每个方法都附加相似的代码逻辑；
- 如果要附加的功能不止一个，我们需要针对每项附加功能都创建一个代理类，导致项目中类的个数成倍增加，增加了代码维护成本。
所以，我们就需要用到动态代理。
二、动态代理
所谓动态代理（Dynamic Proxy），就是我们不事先为每个原始类编写代理类，而是在运行的时候，动态地创建原始类对应的代理类，然后在系统中用代理类替换掉原始类。
2.1 JDK动态代理
Java 语言本身就已经提供了动态代理的语法（实际上，动态代理底层依赖的就是 Java 反射语法）。我们来看一下，如何用 JDK动态代理来实现刚刚的功能。
MetricsCollectorProxy 作为一个动态代理类，动态地给每个需要收集接口请求信息的类创建代理类。
public class MetricsCollectorProxy {
private MetricsCollector metricsCollector;
public MetricsCollectorProxy() {
this.metricsCollector = new MetricsCollector();
}
public Object createProxy(Object proxiedObject) {
// 拿到被代理类的所有接口
Class<?>[] interfaces = proxiedObject.getClass().getInterfaces();
DynamicProxyHandler handler = new DynamicProxyHandler(proxiedObject);
return Proxy.newProxyInstance(proxiedObject.getClass().getClassLoader(), interfaces, handler);
}
private class DynamicProxyHandler implements InvocationHandler {
private Object proxiedObject;
public DynamicProxyHandler(Object proxiedObject) {
this.proxiedObject = proxiedObject;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
long startTimestamp = System.currentTimeMillis();
// 执行被代理类的方法
Object result = method.invoke(proxiedObject, args);
long endTimeStamp = System.currentTimeMillis();
long responseTime = endTimeStamp - startTimestamp;
String apiName = proxiedObject.getClass().getName() + ":" + method.getName();
RequestInfo requestInfo = new RequestInfo(apiName, responseTime, startTimestamp);
metricsCollector.recordRequest(requestInfo);
return result;
}
}
}
使用方式如下：
MetricsCollectorProxy proxy = new MetricsCollectorProxy();
IUserController userController = (IUserController) proxy.createProxy(new UserController());
实际上，Spring AOP 底层的实现原理就是基于动态代理。用户配置好需要给哪些类创建代理，并定义好原始类前后要执行的附加功能。Spring 为这些类创建动态代理对象，并在 JVM 中替代原始类对象，这样原本在代码中执行的原始类的方法，就被换作执行代理类的方法，也就实现了给原始类添加附加功能的目的。
2.2 CGLIB动态代理
JDK动态代理，本地是为被代理对象的接口创建代理类，也就是基于接口的代理，如果被代理对象没有实现特定的接口，则可以使用CGLIB动态代理。
CGLIB代理也叫子类代理，它是在内存中构建一个被代理对象的子类对象，从而实现对被代理对象的扩展。CGLIB可以在运行期扩展Java类或实现Java接口。Spring AOP除了支持JDK代理外，也支持CGLIB代理。
CGLIB包的底层是通过一个字节码处理框架ASM来转换字节码并生成新的类。
三、总结
代理模式的应用非常广泛，包括非功能性逻辑的嵌入，比如我们本章的示例。RPC 框架也可以看作一种代理模式，它将网络通信、数据编解码等细节隐藏起来，让客户端在使用 RPC 服务的时候，就像使用本地函数一样，无需了解跟服务器交互的细节。
感谢赞赏~
