原创

设计模式基础(五)——代理模式

代理模式(Proxy Design Pattern),是一种结构型模式。所谓结构型模式,就是一些类或对象组合在一起的经典结构,这些经典的结构可以解决特定应用场景的问题。

代理模式可以在不改变原始类(或叫被代理类)代码的情况下,通过引入代理类来给原始类附加功能。最常用的一个应用场景就是,在业务系统中开发一些非功能性需求,比如:监控、统计、鉴权、限流、事务、幂等、日志。我们将这些附加功能与业务功能解耦,放到代理类中统一处理,让程序员只需要关注业务方面的开发。

我们先来看下最原生的代理模式,理解下它的基本思想和原理。

一、基本原理

1.1 使用代理模式前

假设我们有下面这样的一个用户控制器类,然后需要统计每个接口的一些性能相关信息。为了实现统计功能,我们引入MetricsCollector类,然后在UserController的每个接口的前后都加上统计的逻辑:

public class UserController {
  private MetricsCollector metricsCollector; // 依赖注入

  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);
    metricsCollector.recordRequest(requestInfo);
  }

  public void 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);
  }
}

这种写法各位一定不陌生,问题也非常明显:

  1. 性能统计的代码侵入到业务代码中,跟业务代码高度耦合。如果未来需要替换性能统计的逻辑,替换成本会比较大;
  2. 性能统计的代码跟业务代码无关,本就不应该放到一个类中。

1.2 使用代理模式后

我们来看下如何使用最简单的代理模式来解决这个问题。我们新建一个代理类 UserControllerProxy,它和原始类 UserController 实现相同的接口 IUserController。

代理类 UserControllerProxy 负责在业务代码执行前后附加其他逻辑代码,并通过委托方式调用原始类来执行业务代码。具体的代码实现如下所示:

public class UserControllerProxy implements IUserController {
  private MetricsCollector metricsCollector;
  private UserController userController;

  public UserControllerProxy(UserController userController) {
    this.userController = userController;
    this.metricsCollector = new MetricsCollector();
  }

  @Override
  public void 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);
  }

  @Override
  public void 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);
  }
}

最后,客户端可以像下面这样来使用,直接面向接口编程:

IUserController userController = new UserControllerProxy(new UserController());

如果原始类没有定义接口,或原始类代码并不是我们开发维护的(比如它来自一个第三方的类库),我们没办法直接修改原始类。在这种情况下,我们可以让代理类继承原始类,然后扩展附加功能,不再赘述。

上述的这种代理模式,其实也叫静态代理,本质是一种委托。它存在两个明显的问题:

  1. 我们需要在代理类中,将原始类中的所有的方法,都重新实现一遍,并且为每个方法都附加相似的代码逻辑;
  2. 如果要附加的功能不止一个,我们需要针对每项附加功能都创建一个代理类,导致项目中类的个数成倍增加,增加了代码维护成本。

所以,我们就需要用到动态代理

二、动态代理

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

2.1 JDK动态代理

Java 语言本身就已经提供了动态代理的语法(实际上,动态代理底层依赖的就是 Java 反射语法)。我们来看一下,如何用 JDK动态代理来实现刚刚的功能。

MetricsCollectorProxy 作为一个动态代理类,动态地给每个需要收集接口请求信息的类创建代理类。

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

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

2.2 CGLIB动态代理

JDK动态代理,本地是为被代理对象的接口创建代理类,也就是基于接口的代理,如果被代理对象没有实现特定的接口,则可以使用CGLIB动态代理。

CGLIB代理也叫子类代理,它是在内存中构建一个被代理对象的子类对象,从而实现对被代理对象的扩展。CGLIB可以在运行期扩展Java类或实现Java接口。Spring AOP除了支持JDK代理外,也支持CGLIB代理。

CGLIB包的底层是通过一个字节码处理框架ASM来转换字节码并生成新的类。

三、总结

代理模式的应用非常广泛,包括非功能性逻辑的嵌入,比如我们本章的示例。RPC 框架也可以看作一种代理模式,它将网络通信、数据编解码等细节隐藏起来,让客户端在使用 RPC 服务的时候,就像使用本地函数一样,无需了解跟服务器交互的细节。

正文到此结束
本文目录