设计模式与范式 --- 结构型模式(代理模式)

1.写在前

代理模式(Proxy): 为其他对象提供一个代理,用来控制这个对象的访问。

解读:使用代理模式以后,客户端直接访问代理,代理在客户端和目标对象之间起到中介的作用。

案例分析

当我们开发了一个 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数据...
  }
    
  public UserVo 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);
    //...返回UserVo数据...
  }
}

上述代码存在的问题:非业务代码和业务代码耦合!

  • 第一,性能计数器框架代码侵入到业务代码中,跟业务代码高度耦合。

  • 第二,收集接口请求的代码跟业务代码无关,本就不应该放到一个类中。

2.重构方案

(1)优化方案1:原始类和代理类实现相同的接口

为了将框架代码和业务代码解耦,代理模式就派上用场了。

具体操作:代理类 UserControllerProxy 和原始类 UserController 实现相同的接口 IUserController。UserController 类只负责业务功能。代理类 UserControllerProxy 负责在业务代码执行前后附加其他逻辑代码,并通过委托的方式调用原始类来执行业务代码。

具体操作:代理类 UserControllerProxy 和原始类 UserController 实现相同的接口 IUserController。UserController 类只负责业务功能。代理类 UserControllerProxy 负责在业务代码执行前后附加其他逻辑代码,并通过委托的方式调用原始类来执行业务代码。

//1.抽象角色:抽象主题类的主要职责是生命真实主题和代理的共同接口方法,该类可以是接口,也可以是抽象类。
public interface IUserController {
  UserVo login(String telephone, String password);
  UserVo register(String telephone, String password);
}

//2.原始类/被代理类(RealSubject):定义了代理所表示的真实对象,只负责系统中的真正的业务逻辑对象
public class UserController implements IUserController {
  //...省略其他属性和方法...
  @Override
  public UserVo login(String telephone, String password) {
    //...省略login逻辑...
    //...返回UserVo数据...
  }
  @Override
  public UserVo register(String telephone, String password) {
    //...省略register逻辑...
    //...返回UserVo数据...
  }
}

//3.代理类:具有RealSubject的引用,具备完全的对RealSubject的代理权,客户端调用代理对象的方法,也调用被代理对象的方法,但是会在代理对象前后增加一些逻辑代码。
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;
  }
  @Override
  public UserVo 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);
    return userVo;
  }
}

//UserControllerProxy使用举例
//因为原始类和代理类实现相同的接口,是基于接口而非实现编程!!!
//将UserController类对象替换为UserControllerProxy类对象,不需要改动太多代码
IUserController userController = new UserControllerProxy(new UserController());

(2)优化方案2:代理类继承原始类

如果如果原始类并没有定义接口,并且原始类代码并不是我们开发维护的(比如它来自一个第三方的类库),我们也没办法直接修改原始类,给它重新定义一个接口。

具体操作:对于这种外部类的扩展,我们一般都是采用继承的方式。我们让代理类继承原始类,然后扩展附加功能。

// 代理类继承原始类
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;
  }
    
  public UserVo register(String telephone, String password) {
    long startTimestamp = System.currentTimeMillis();
    UserVo userVo = super.register(telephone, password);
    long endTimeStamp = System.currentTimeMillis();
    long responseTime = endTimeStamp - startTimestamp;
    RequestInfo requestInfo = new RequestInfo("register", responseTime, startTimestamp);
    metricsCollector.recordRequest(requestInfo);
    return userVo;
  }
}

//UserControllerProxy使用举例
UserController userController = new UserControllerProxy();

上文的代码实现还是有点问题:

  • 一方面,我们需要在代理类中,将原始类中的所有的方法,都重新实现一遍,并且为每个方法都附加相似的代码逻辑。
  • 另一方面,如果要添加的附加功能的类有不止一个(这里只包括登录注册功能),我们需要针对每个类都创建一个代理类。
    (3)优化方案3:动态代理原理解析

动态代理(Dynamic Proxy),就是我们不事先为每个原始类编写代理类,而是在运行的时候,动态地创建原始类对应的代理类,然后在系统中用代理类替换掉原始类。实际上,动态代理底层依赖的就是java的反射语法。

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使用举例
MetricsCollectorProxy proxy = new MetricsCollectorProxy();
IUserController userController = (IUserController) proxy.createProxy(new UserController());

3.应用场景

(1)业务系统的非功能性开发

  • 比如:监控、统计、鉴权、限流、事务、幂等、日志。我们将这些附加功能(非功能性开发)与业务功能解耦,放到代理类中统一处理,让程序员只需要关注业务方面的开发。

(2)在RPC和缓存中应用

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

  • 在缓存中的应用:

    • 假设我们要开发一个接口请求的缓存功能,对于某些接口请求,如果入参相同,在设定的过期时间内,直接返回缓存结果,而不用重新进行逻辑处理。

    • 在应用启动的时候,我们从配置文件中加载需要支持缓存的接口,以及相应的缓存策略(比如过期时间)等。当请求到来的时候,我们在 AOP 切面中拦截请求,如果请求中带有支持缓存的字段(比如 http://…?..&cached=true),我们便从缓存(内存缓存或者 Redis 缓存等)中获取数据直接返回。

4.总结与补充

代理模式的优点降低了系统的耦合性,将框架代码(非业务代码/附加功能)和业务代码解耦。

  • 职责清晰

  • 扩展性高

缺点:由于多了一个代理对象,可能会使请求的处理速度变慢。有些代理的实现较为复杂。

补充通过对访问的代理,我们可以用远程代理、虚拟代理、安全代理等,来减少直接对对象访问产生的开销,即不同类型的代理可以对客户端对对象的访问进行不同的控制:

  • 远程代理:使得客户端可以访问在远程机器上的对象,远程机器可能具有更好的计算性能与处理速度,可以快速响应并处理客户端请求。

  • 虚拟代理:通过使用一个小对象来代表一个大对象,可以减少系统资源的消耗,对系统进行优化并提高运行速度。

  • 保护代理:可以控制客户端对真实对象的使用权限。

5.参考

《设计模式之美》 --- 王争

https://www.jianshu.com/p/35918f6946a6

https://www.jianshu.com/p/53388cb1e4e7

你可能感兴趣的:(设计模式与范式 --- 结构型模式(代理模式))