代理模式定义
代理模式(Proxy Design Pattern)是一种结构型设计模式, 它在不改变原始类(或叫被代理类)代码的情况下,通过引入代理类来给原始类附加功能。
解决什么问题
假设我们开发了一个 MetricsCollector
类,用来收集接口请求的原始数据,比如访问时间、处理时长等。
在业务系统中,我们采用如下方式来使用这个 MetricsCollector 类:
public class UserController {
//...省略其他属性和方法...
private MetricsCollector metricsCollector; // 依赖注入
public UserVo 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);
//...返回UserVo数据...
}
}
很明显,上面的写法有两个问题。
- 性能计数器框架代码侵入到业务代码中,跟业务代码高度耦合。如果未来需要替换这个框架,那替换的成本会比较大。
- 收集接口请求的代码跟业务代码无关,本就不应该放到一个类中。业务类最好职责更加单一,只聚焦业务处理。
为了将框架代码和业务代码解耦,代理模式就派上用场了。
代理类 UserControllerProxy
和原始类 UserController
实现相同的接口 IUserController。
UserController 类只负责业务功能。代理类 UserControllerProxy 负责在业务代码执行前后附加其他逻辑代码,并通过委托的方式调用原始类来执行业务代码。
具体的代码实现如下所示:
// 1.定义接口
public interface IUserController {
UserVo login(String telephone, String password);
UserVo register(String telephone, String password);
}
// 2.原始业务类
public class UserController implements IUserController {
//...省略其他属性和方法...
@Override
public UserVo login(String telephone, String password) {
//...省略login逻辑...
//...返回UserVo数据...
}
}
// 3.代理类
public class UserControllerProxy implements IUserController {
private MetricsCollector metricsCollector;
private UserController userController;
public UserControllerProxy(UserController userController) {
this.userController = userController;
this.metricsCollector = new MetricsCollector();
}
@Override
public UserVo 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);
return userVo;
}
}
//4.UserControllerProxy使用举例
//因为原始类和代理类实现相同的接口,是基于接口而非实现编程
//将UserController类对象替换为UserControllerProxy类对象,不需要改动太多代码
IUserController userController = new UserControllerProxy(new UserController());
如果以上代码中原始类并没有定义接口,或者原始类并不是我们开发维护的(比如它来自一个第三方的类库),我们没办法直接修改原始类,给它重新定义一个接口时。在这种情况下,我们该如何实现代理模式呢?
对于这种外部类的扩展,我们一般都是采用继承的方式。
我们让代理类继承原始类,然后扩展附加功能。具体代码如下所示:
// 1.改为继承的方式
public class UserControllerProxy extends UserController {
private MetricsCollector metricsCollector;
public UserControllerProxy() {
this.metricsCollector = new MetricsCollector();
}
public UserVo login(String telephone, String password) {
long startTimestamp = System.currentTimeMillis();
UserVo userVo = super.login(telephone, password);
long endTimeStamp = System.currentTimeMillis();
long responseTime = endTimeStamp - startTimestamp;
RequestInfo requestInfo = new RequestInfo("login", responseTime, startTimestamp);
metricsCollector.recordRequest(requestInfo);
return userVo;
}
}
// 2.UserControllerProxy使用举例
UserController userController = new UserControllerProxy();
动态代理
静态代理的问题
上面的代码实现还是有点问题的。
- 一方面,我们需要在代理类中,将原始类中的所有的方法,都重新实现一遍,并且为每个方法都附加相似的代码逻辑。
- 另一方面,如果要添加的附加功能的类有不止一个,我们需要针对每个类都创建一个代理类。
如果有 50 个要添加附加功能的原始类,那我们就要创建 50 个对应的代理类。这会导致项目中代理类的个数成倍增加,增加了代码维护成本。并且,每个代理类中的代码都有点像模板式的“重复”代码,也增加了不必要的开发成本。
那这个问题怎么解决呢?
动态代理定义
我们可以使用动态代理来解决这个问题。
所谓动态代理(Dynamic Proxy),就是我们不事先为每个原始类编写代理类,而是在运行的时候,动态地创建原始类对应的代理类,然后在系统中用代理类替换掉原始类。
那如何实现动态代理呢?
实现动态代理
我们来看一下,如何用 Java 的动态代理来实现刚刚的功能。
其中,MetricsCollectorProxy
作为一个动态代理类,动态地给每个需要收集接口请求信息的类创建代理类。
具体的代码如下所示:
// 1.创建代理
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);
}
// 2.动态代理处理程序
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;
}
}
}
//3.MetricsCollectorProxy使用举例
MetricsCollectorProxy proxy = new MetricsCollectorProxy();
// 创建一个UserController的代理类
IUserController userController = (IUserController) proxy.createProxy(new UserController());
实际上,Spring AOP 底层的实现原理就是基于动态代理。用户配置好需要给哪些类创建代理,并定义好在执行原始类的业务代码前后执行哪些附加功能。Spring 为这些类创建动态代理对象,并在 JVM 中替代原始类对象。原本在代码中执行的原始类的方法,被换作执行代理类的方法,也就实现了给原始类添加附加功能的目的。
代理模式的应用场景
-
非功能性需求开发
- 比如:监控、统计、鉴权、限流、事务、幂等、日志。
- 我们将这些附加功能与业务功能解耦,放到代理类中统一处理,让程序员只需要关注业务方面的开发。 实际上,前面举的搜集接口请求信息的例子,就是这个应用场景的一个典型例子。
-
在 RPC、缓存中的应用
-
RPC 框架也可以看作一种代理模式 通过远程代理,将网络通信、数据编解码等细节隐藏起来。客户端在使用 RPC 服务的时候,就像使用本地函数一样,无需了解跟服务器交互的细节。
-
在缓存中的应用
我们可以在 AOP 切面中拦截请求,如果请求中带有支持缓存的字段(比如 http://…?..&cached=true),我们便从缓存(内存缓存或者 Redis 缓存等)中获取数据直接返回。
-
设计模式系列阅读目录
- 设计模式:创建型—单例模式
- 设计模式:创建型—原型模式
- 设计模式:创建型—工厂模式
- 设计模式:创建型—建造者模式
- 设计模式:结构型—享元模式
- 设计模式:结构型—组合模式
- 设计模式:结构型—代理模式
- 设计模式:结构型—桥接模式
- 设计模式:结构型—装饰器模式
- 设计模式:结构型—适配器模式
- 设计模式:结构型—门面模式
- 设计模式:行为型—中介模式
- 设计模式:行为型—命令模式
- 设计模式:行为型—备忘录模式
- 设计模式:行为型—模板模式
- 设计模式:行为型—状态模式
- 设计模式:行为型—策略模式
- 设计模式:行为型—职责链模式
- 设计模式:行为型—观察者模式
- 设计模式:行为型—解释器模式
- 设计模式:行为型—访问者模式
- 设计模式:行为型—迭代器模式