专栏：设计模式-代理模式

Posted 2021-04-25 EAIPLUS

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了专栏：设计模式-代理模式相关的知识，希望对你有一定的参考价值。

图片 | Google

文章 | 靳天

校对 | 靳天

前言

你也许知道python的Decorator，你也许会想web app中如何设计未登录的用户无权限查看的功能，你也许了解过Spring AOP.....

这些都和代理模式密不可分，如果你想更好的了解这些问题，请仔细看今天的代理模式。

话不多说，开始今天的学习：)

太长不看型选手请直接看总结：(

代理模式的原理解析

代理模式（Proxy Design Pattern）的原理和代码实现都不难掌握。它在不改变原始类（或叫被代理类）代码的情况下，通过引入代理类来给原始类附加功能。我们通过一个简单的例子来解释一下这段话。

这个例子是一个user类，有登录，退出等等接口。当时我们开发了一个 Monitor类，用来收集接口请求的原始数据，比如访问时间、处理时长等。在业务系统中，我们采用如下方式来使用这个Monitor类：


public class UserController { //...省略其他属性和方法... private Monitor monitor; // 依赖注入
  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); monitor.recordRequest(requestInfo);
  }
  public void exit(String telephone, String password) { long startTimestamp = System.currentTimeMillis();
    // ... 省略exit逻辑...
 long endTimeStamp = System.currentTimeMillis(); long responseTime = endTimeStamp - startTimestamp; RequestInfo requestInfo = new RequestInfo("register", responseTime, startTimestamp);    monitor.recordRequest(requestInfo); } }

很明显，上面的写法有两个问题。第一，Monitor框架代码侵入到业务代码中，跟业务代码高度耦合。如果未来需要替换这个框架，那替换的成本会比较大。第二，收集接口请求的代码跟业务代码无关，本就不应该放到一个类中。业务类最好职责更加单一，只聚焦业务处理。为了将框架代码和业务代码解耦，代理模式就派上用场了。代理类 MonitorProxy 和原始类 UserController 实现相同的接口 IUserController。UserController 类只负责业务功能。代理类 MonitorProxy 负责在业务代码执行前后附加其他逻辑代码，并通过委托的方式调用原始类来执行业务代码。具体的代码实现如下所示：

public class MonitorProxy implements IUserController {
 private UserController userController; private Monitor monitor;
 public MonitorProxy(UserController userController){ this.userController =userController; this.monitor = new Monitor(); }
 @Override public void login(){ long startTime = System.currentTimeMillis(); //do 被代理的方法 userController.login();
 long endTime = System.currentTimeMillis(); long responseTime = endTime - startTime;
 String apiName = userController.getClass().getName() + ":" +Thread.currentThread().getStackTrace()[1].getMethodName(); monitor.record(apiName,responseTime);
 }
 @Override public void exit(){ // ignore ... like above       userController.exit(); }
}
//使用eg: MonitorProxy monitorProxy = new MonitorProxy(new UserController()); monitorProxy.login();

这样就是实现了代理模式，这是一种静态代理模式，

让login，exit方法上附加了监控（调用时间，处理时长等等）功能。

重点在proxy类和被代理类实现同一个接口，但是这种静态代理有很多缺点

1）代理类通过委托类实现了相同的方法。这样就出现了大量的代码重复。如果接口增加一个方法，除了所有实现类需要实现这个方法外，所有代理类也需要实现此方法。增加了代码维护的复杂度。

2）代理对象只服务于一种类型的对象，如果要服务多类型的对象。势必要为每一种对象都进行代理，静态代理在程序规模稍大时就无法胜任了。如上的代码是只为UserController类的访问提供了代理，但是如果还要为其他类如Department类提供代理的话，就需要我们再次添加代理Department的代理类。

动态代理（重点✨）

上述的缺陷可以通过动态代理来解决，正好java中的反射机制可以很容易地实现代理模式

所谓动态代理（Dynamic Proxy），就是我们不事先为每个原始类编写代理类，而是在运行的时候，动态地创建原始类对应的代理类，然后在系统中用代理类替换掉原始类。那如何实现动态代理呢？如果你熟悉的是 Java 语言，实现动态代理就是件很简单的事情。我们来看一下，如何用 Java 的动态代理来实现刚刚的功能。具体的代码如下所示。其中，MonitorProxy 作为一个动态代理类，动态地给每个需要收集接口请求信息的类创建代理类。

public class MonitorProxy { private Monitor monitor;
 public MonitorProxy(){ this.monitor = new Monitor(); }
 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{ //统计被代理的api的运行时间，各种时间，name等信息 long startTime = System.currentTimeMillis(); //do 被代理的方法 Object result = method.invoke(this.proxiedObject, args);
 long endTime = System.currentTimeMillis(); long responseTime = endTime - startTime;
 String apiName = proxiedObject.getClass().getName() + ":" +method.getName(); monitor.record(apiName,responseTime); return result; }

 }  public static void main(String[] args) { // do proxy MonitorProxy monitorProxy = new MonitorProxy(); IUserController userController = (IUserController) monitorProxy.createProxy(new UserController()); userController.proxiedMethod();        //no proxy //UserController userController1 = new UserController(); //userController1.proxiedMethod();    }  }

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

代理模式的开发场景

代理模式的应用场景代理模式的应用场景非常多。

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

代理模式最常用的一个应用场景就是，在业务系统中开发一些非功能性需求，比如：监控、统计、鉴权、限流、事务、幂等、日志。我们将这些附加功能与业务功能解耦，放到代理类中统一处理，让程序员只需要关注业务方面的开发。实际上，前面举的搜集接口请求信息的例子，就是这个应用场景的一个典型例子。如果你熟悉 Java 语言和 Spring 开发框架，这部分工作都是可以在 Spring AOP 切面中完成的。前面我们也提到，Spring AOP 底层的实现原理就是基于动态代理。

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

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

3. 代理模式在缓存中的应用

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

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

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