本文整理自 设计模式之美：48 | 代理模式：代理在RPC、缓存、监控等场景中的应用

定义

代理模式（Proxy Design Pattern）的原理和代码实现都不难掌握。它在不改变原始类（或叫被代理类）代码的情况下，通过引入代理类来给原始类附加功能。

原理

下面是一段登录和注册逻辑的代码，内部加入了 性能计数器，用来收集接口请求的原始数据。

  2. public class UserController {
  3.   //...省略其他属性和方法...
  4.   private MetricsCollector metricsCollector; // 依赖注入
  6.   public UserVo login(String telephone, String password) {
  7.     long startTimestamp = System.currentTimeMillis();
  9.     // ... 省略login逻辑...
  11.     long endTimeStamp = System.currentTimeMillis();
  12.     long responseTime = endTimeStamp - startTimestamp;
  13.     RequestInfo requestInfo = new RequestInfo("login", responseTime, startTimestamp);
  14.     metricsCollector.recordRequest(requestInfo);
  16.     //...返回UserVo数据...
  17.   }
  19.   public UserVo register(String telephone, String password) {
  20.     long startTimestamp = System.currentTimeMillis();
  22.     // ... 省略register逻辑...
  24.     long endTimeStamp = System.currentTimeMillis();
  25.     long responseTime = endTimeStamp - startTimestamp;
  26.     RequestInfo requestInfo = new RequestInfo("register", responseTime, startTimestamp);
  27.     metricsCollector.recordRequest(requestInfo);
  29.     //...返回UserVo数据...
  30.   }
  31. }

很明显，上面的写法有两个问题。第一，性能计数器框架代码侵入到业务代码中，跟业务代码高度耦合。如果未来需要替换这个框架，那替换的成本会比较大。第二，收集接口请求的代码跟业务代码无关，本就不应该放到一个类中。业务类最好职责更加单一，只聚焦业务处理。

为了将框架代码和业务代码解耦，代理模式就派上用场了。代理类 UserControllerProxy 和原始类 UserController 实现相同的接口 IUserController。UserController 类只负责业务功能。代理类 UserControllerProxy 负责在业务代码执行前后附加其他逻辑代码，并通过委托的方式调用原始类来执行业务代码。具体的代码实现如下所示：

  1. public interface IUserController {
  2.   UserVo login(String telephone, String password);
  3.   UserVo register(String telephone, String password);
  4. }
  6. public class UserController implements IUserController {
  7.   //...省略其他属性和方法...
  9.   @Override
  10.   public UserVo login(String telephone, String password) {
  11.     //...省略login逻辑...
  12.     //...返回UserVo数据...
  13.   }
  15.   @Override
  16.   public UserVo register(String telephone, String password) {
  17.     //...省略register逻辑...
  18.     //...返回UserVo数据...
  19.   }
  20. }
  22. public class UserControllerProxy implements IUserController {
  23.   private MetricsCollector metricsCollector;
  24.   private UserController userController;
  26.   public UserControllerProxy(UserController userController) {
  27.     this.userController = userController;
  28.     this.metricsCollector = new MetricsCollector();
  29.   }
  31.   @Override
  32.   public UserVo login(String telephone, String password) {
  33.     long startTimestamp = System.currentTimeMillis();
  35.     // 委托
  36.     UserVo userVo = userController.login(telephone, password);
  38.     long endTimeStamp = System.currentTimeMillis();
  39.     long responseTime = endTimeStamp - startTimestamp;
  40.     RequestInfo requestInfo = new RequestInfo("login", responseTime, startTimestamp);
  41.     metricsCollector.recordRequest(requestInfo);
  43.     return userVo;
  44.   }
  46.   @Override
  47.   public UserVo register(String telephone, String password) {
  48.     long startTimestamp = System.currentTimeMillis();
  50.     UserVo userVo = userController.register(telephone, password);
  52.     long endTimeStamp = System.currentTimeMillis();
  53.     long responseTime = endTimeStamp - startTimestamp;
  54.     RequestInfo requestInfo = new RequestInfo("register", responseTime, startTimestamp);
  55.     metricsCollector.recordRequest(requestInfo);
  57.     return userVo;
  58.   }
  59. }
  61. //UserControllerProxy使用举例
  62. //因为原始类和代理类实现相同的接口，是基于接口而非实现编程
  63. //将UserController类对象替换为UserControllerProxy类对象，不需要改动太多代码
  64. IUserController userController = new UserControllerProxy(new UserController());

参照基于接口而非实现编程的设计思想，将原始类对象替换为代理类对象的时候，为了让代码改动尽量少，在刚刚的代理模式的代码实现中，代理类和原始类需要实现相同的接口。但是，如果原始类并没有定义接口，并且原始类代码并不是我们开发维护的（比如它来自一个第三方的类库），我们也没办法直接修改原始类，给它重新定义一个接口。在这种情况下，我们该如何实现代理模式呢？对于这种外部类的扩展，我们一般都是采用继承的方式。这里也不例外。我们让代理类继承原始类，然后扩展附加功能。原理很简单，不需要过多解释，你直接看代码就能明白。具体代码如下所示：

  1. public class UserControllerProxy extends UserController {
  2.   private MetricsCollector metricsCollector;
  4.   public UserControllerProxy() {
  5.     this.metricsCollector = new MetricsCollector();
  6.   }
  8.   public UserVo login(String telephone, String password) {
  9.     long startTimestamp = System.currentTimeMillis();
  11.     UserVo userVo = super.login(telephone, password);
  13.     long endTimeStamp = System.currentTimeMillis();
  14.     long responseTime = endTimeStamp - startTimestamp;
  15.     RequestInfo requestInfo = new RequestInfo("login", responseTime, startTimestamp);
  16.     metricsCollector.recordRequest(requestInfo);
  18.     return userVo;
  19.   }
  21.   public UserVo register(String telephone, String password) {
  22.     long startTimestamp = System.currentTimeMillis();
  24.     UserVo userVo = super.register(telephone, password);
  26.     long endTimeStamp = System.currentTimeMillis();
  27.     long responseTime = endTimeStamp - startTimestamp;
  28.     RequestInfo requestInfo = new RequestInfo("register", responseTime, startTimestamp);
  29.     metricsCollector.recordRequest(requestInfo);
  31.     return userVo;
  32.   }
  33. }
  34. //UserControllerProxy使用举例
  35. UserController userController = new UserControllerProxy();

动态代理

动态代理

不过，刚刚的代码实现还是有点问题。一方面，我们需要在代理类中，将原始类中的所有的方法，都重新实现一遍，并且为每个方法都附加相似的代码逻辑。另一方面，如果要添加的附加功能的类有不止一个，我们需要针对每个类都创建一个代理类。

如果有 50 个要添加附加功能的原始类，那我们就要创建 50 个对应的代理类。这会导致项目中类的个数成倍增加，增加了代码维护成本。并且，每个代理类中的代码都有点像模板式的“重复”代码，也增加了不必要的开发成本。那这个问题怎么解决呢？

我们可以使用动态代理来解决这个问题。所谓动态代理（Dynamic Proxy），就是我们不事先为每个原始类编写代理类，而是在运行的时候，动态地创建原始类对应的代理类，然后在系统中用代理类替换掉原始类。那如何实现动态代理呢？

如果你熟悉的是 Java 语言，实现动态代理就是件很简单的事情。因为 Java 语言本身就已经提供了动态代理的语法（实际上，动态代理底层依赖的就是 Java 的反射语法）。我们来看一下，如何用 Java 的动态代理来实现刚刚的功能。具体的代码如下所示。其中，MetricsCollectorProxy 作为一个动态代理类，动态地给每个需要收集接口请求信息的类创建代理类。

  1. public class MetricsCollectorProxy {
  2.   private MetricsCollector metricsCollector;
  4.   public MetricsCollectorProxy() {
  5.     this.metricsCollector = new MetricsCollector();
  6.   }
  8.   public Object createProxy(Object proxiedObject) {
  9.     Class<?>[] interfaces = proxiedObject.getClass().getInterfaces();
  10.     DynamicProxyHandler handler = new DynamicProxyHandler(proxiedObject);
  11.     return Proxy.newProxyInstance(proxiedObject.getClass().getClassLoader(), interfaces, handler);
  12.   }
  14.   private class DynamicProxyHandler implements InvocationHandler {
  15.     private Object proxiedObject;
  17.     public DynamicProxyHandler(Object proxiedObject) {
  18.       this.proxiedObject = proxiedObject;
  19.     }
  21.     @Override
  22.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  23.       long startTimestamp = System.currentTimeMillis();
  24.       Object result = method.invoke(proxiedObject, args);
  25.       long endTimeStamp = System.currentTimeMillis();
  26.       long responseTime = endTimeStamp - startTimestamp;
  27.       String apiName = proxiedObject.getClass().getName() + ":" + method.getName();
  28.       RequestInfo requestInfo = new RequestInfo(apiName, responseTime, startTimestamp);
  29.       metricsCollector.recordRequest(requestInfo);
  30.       return result;
  31.     }
  32.   }
  33. }
  35. //MetricsCollectorProxy使用举例
  36. MetricsCollectorProxy proxy = new MetricsCollectorProxy();
  37. IUserController userController = (IUserController) proxy.createProxy(new UserController());

实际上，Spring AOP 底层的实现原理就是基于动态代理。用户配置好需要给哪些类创建代理，并定义好在执行原始类的业务代码前后执行哪些附加功能。Spring 为这些类创建动态代理对象，并在 JVM 中替代原始类对象。原本在代码中执行的原始类的方法，被换作执行代理类的方法，也就实现了给原始类添加附加功能的目的。