Proxy Design Pattern，它在不改变原始类（被代理类）代码的情况下，通过引入代理类来给原始类附加功能。

结构型设计模式，核心是在调用方和被调用方之间增加一个中介者的角色，也就是代理。
image.png
比如生活中的：
image.png
（专业的事情就应该交给专业的人来办，如果我们试图省去中间人，只会带来更多的麻烦）

原始定义：让你能够提供对象的替代品或其占位符代理控制着对于原对象的访问，并允许将请求提交给对象前后进行一些处理。
基本理念：作为一个外包装的中间层，享有控制住访问对象的权利，同时也能扩展一些功能。
为什么不直接使用原来的对象，而要加一层代理：

  1. 客户端无法直接操作某些对象，比如远程代理，rpc
  2. 客户端执行某些耗时操作容易造成服务端阻塞
  3. 服务端需要控制客户端的访问权限，可以设计成代理类，然后在代理类里面做权限判断

核心能力：对某一个具体的功能进行增强和补充
一些使用场景
image.png
image.png
image.png
image.png

实战

  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 负责在业务代码执行前后附加其他逻辑代码，并通过委托的方式调用原始类来执行业务代码。

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

被代理类如果可控，就是自己写的话，推荐用接口 implement 来实现，如果不可控，比如第三方的类，我们就需要用到继承方式。

  2. public class UserControllerProxy extends UserController {
  3.   private MetricsCollector metricsCollector;
  5.   public UserControllerProxy() {
  6.     this.metricsCollector = new MetricsCollector();
  7.   }
  9.   public UserVo login(String telephone, String password) {
  10.     long startTimestamp = System.currentTimeMillis();
  12.     UserVo userVo = super.login(telephone, password);
  14.     long endTimeStamp = System.currentTimeMillis();
  15.     long responseTime = endTimeStamp - startTimestamp;
  16.     RequestInfo requestInfo = new RequestInfo("login", responseTime, startTimestamp);
  17.     metricsCollector.recordRequest(requestInfo);
  19.     return userVo;
  20.   }
  22.   public UserVo register(String telephone, String password) {
  23.     long startTimestamp = System.currentTimeMillis();
  25.     UserVo userVo = super.register(telephone, password);
  27.     long endTimeStamp = System.currentTimeMillis();
  28.     long responseTime = endTimeStamp - startTimestamp;
  29.     RequestInfo requestInfo = new RequestInfo("register", responseTime, startTimestamp);
  30.     metricsCollector.recordRequest(requestInfo);
  32.     return userVo;
  33.   }
  34. }
  35. //UserControllerProxy使用举例
  36. UserController userController = new UserControllerProxy();

动态代理

上面的代码还是有问题，比如，需要为50个类，每个类都需要重写所有方法？

Dynamic Proxy，就是我们不事先为每个原始类编写代理类，而是在运行的时候，动态地创建原始类对应的代理类，然后在系统中用代理类替换掉原始类。

Java 语言本身就已经提供了动态代理的语法（实际上，动态代理底层依赖的就是 Java 的反射语法）。

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

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

应用场景

Android 中的 Retrofit 库就是动态代理实现。

1.业务系统的非功能性需求开发

代理模式最常用的一个应用场景就是，在业务系统中开发一些非功能性需求，比如：监控、统计、鉴权、限流、事务、幂等、日志。我们将这些附加功能与业务功能解耦，放到代理类中统一处理，让程序员只需要关注业务方面的开发。实际上，前面举的搜集接口请求信息的例子，就是这个应用场景的一个典型例子。

如果你熟悉 Java 语言和 Spring 开发框架，这部分工作都是可以在 Spring AOP 切面中完成的。前面我们也提到，Spring AOP 底层的实现原理就是基于动态代理。

2.代理模式在 RPC、缓存中的应用

实际上，RPC 框架也可以看作一种代理模式，GoF 的《设计模式》一书中把它称作远程代理。通过远程代理，将网络通信、数据编解码等细节隐藏起来。客户端在使用 RPC 服务的时候，就像使用本地函数一样，无需了解跟服务器交互的细节。除此之外，RPC 服务的开发者也只需要开发业务逻辑，就像开发本地使用的函数一样，不需要关注跟客户端的交互细节。

关于远程代理的代码示例，我自己实现了一个简单的 RPC 框架 Demo，放到了 GitHub 中，你可以点击这里的链接查看。

我们再来看代理模式在缓存中的应用。假设我们要开发一个接口请求的缓存功能，对于某些接口请求，如果入参相同，在设定的过期时间内，直接返回缓存结果，而不用重新进行逻辑处理。比如，针对获取用户个人信息的需求，我们可以开发两个接口，一个支持缓存，一个支持实时查询。对于需要实时数据的需求，我们让其调用实时查询接口，对于不需要实时数据的需求，我们让其调用支持缓存的接口。那如何来实现接口请求的缓存功能呢？

最简单的实现方法就是刚刚我们讲到的，给每个需要支持缓存的查询需求都开发两个不同的接口，一个支持缓存，一个支持实时查询。但是，这样做显然增加了开发成本，而且会让代码看起来非常臃肿（接口个数成倍增加），也不方便缓存接口的集中管理（增加、删除缓存接口）、集中配置（比如配置每个接口缓存过期时间）。

针对这些问题，代理模式就能派上用场了，确切地说，应该是动态代理。如果是基于 Spring 框架来开发的话，那就可以在 AOP 切面中完成接口缓存的功能。在应用启动的时候，我们从配置文件中加载需要支持缓存的接口，以及相应的缓存策略（比如过期时间）等。当请求到来的时候，我们在 AOP 切面中拦截请求，如果请求中带有支持缓存的字段（比如 http://…?..&cached=true），我们便从缓存（内存缓存或者 Redis 缓存等）中获取数据直接返回。

小结

静态代理需要针对每个类都创建一个代理类，并且每个代理类中的代码都有点像模板式的“重复”代码，增加了维护成本和开发成本。对于静态代理存在的问题，我们可以通过动态代理来解决。我们不事先为每个原始类编写代理类，而是在运行的时候动态地创建原始类对应的代理类，然后在系统中用代理类替换掉原始类。

动态代理的主要优势不在于节省了一点编码的工作量。而是在被代理类和接口还未知的时候就确定了代理行为，实现了解藕

Other

装饰器是增强功能，代理是附加新的功能?