首页 代理模式
文章
取消

代理模式

作者 flameking
发表于 2022-03-18 更新于 04-06 18 分钟阅读

通用工作模式

代理通用工作模式

上图中，Subject 是一个抽象类/接口，RealSubject 是实现方法类，是具体的业务执行，Proxy 则是 RealSubject 的代理，它同样继承/实现 Subject，并直接和 Client 接触的。

进一步来说代理模式可以在不直接修改被代理对象（RealSubject）的基础上，通过扩展代理类（Proxy）进行一些功能的附加和增强。值得注意的是，代理类和被代理类应该共同实现一个接口，或者是共同继承某个类。

举个现实中的例子：4s店和汽车生产厂家就是代理和被代理的关系，汽车生产厂家把造好的车交给4s店代为销售，而4s店除了销售汽车外还会为顾客提供汽车维修、配件和信息反馈等一系列售后服务。显然顾客想买车肯定不是去汽车制造厂，直接去4s店就行了。

又比如：

  • 房屋中介，客户手里没有房源信息，那么可以找中介。
  • 商品代购，代购者拥有价格更加低廉的购买渠道。

为什么要使用代理模式

总之代理模式又被称为委托模式。作为被委托方/机构往往会在前者的基础上为客户提供更加便利的服务。那么作为消费者（客户）可以挑选房源租到好的住房/通过更加低廉的价格购买物品。

概述

代理模式（Proxy Pattern）：是 23 中设计模式中的一种，属于结构型模式，它在不改变原始类（或叫被代理类）代码的情况下，通过引入代理类来给原始类附加功能。客户端不直接操作原始类，而是通过它的代理类

意义

原始类只需要关注自己的业务实现，通过代理类对业务进行增强以扩展原始类的功能。

实现

以性能计数器为例，下面是一个用户接口 UserController 提供了登录（login）和注册（register）的功能。性能计数器则会在这些接口执行完毕后打印出它的相应时间。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

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;

    log.debug("响应时间是{}毫秒", responseTime);
    //...返回 UserVo 数据...
  }

  public UserVo register(String telephone, String password) {
    long startTimestamp = System.currentTimeMillis();

    // ... 省略register逻辑...

    long endTimeStamp = System.currentTimeMillis();
    long responseTime = endTimeStamp - startTimestamp;

    log.debug("响应时间是{}毫秒", responseTime);
    //...返回 UserVo 数据...
  }
}

但是，不难看出这样的实现有一个很严重的问题：

  • 性能计数器代码与业务代码耦合，如果未来需要替换这种实现，成本将会比较昂贵
  • 增强代码没有得到复用，每个业务方法内部都需要实现一遍。

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

通过代理模式改造如下：

代理类（UserControllerProxy）和被代理类（UserController）实现相同的接口 IUserController。UserController 类只负责业务功能，代理类（UserControllerProxy）通过组合的方式调用被代理类（UserController）来执行业务代码，并在业务代码执行前后附加额外的功能。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

public interface IUserController {
  UserVo login(String telephone, String password);
  UserVo register(String telephone, String password);
}


public class UserControllerProxy implements IUserController {
  //性能计数器
  private MetricsCollector metricsCollector;
  //组合被代理类
  private UserController userController;

  //省略无参有参构造器

  @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;

    log.debug("响应时间是{}毫秒", responseTime);

    //...返回 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;

    log.debug("响应时间是{}毫秒", responseTime);

    //...返回 UserVo 数据...
  }
}

这样修改后被代理类（UserControll）的业务更加单一，当需要替换性能计数器实现时就不用动 UserController，更改它的代理类就行了。

同样的如果原始类并没有定义接口，并且原始类代码并不是我们开发维护的（比如它来自一个第三方的类库），我们也没办法直接修改原始类，给它重新定义一个接口。在这种情况下，我们该如何实现代理模式呢？

对于这种外部类的扩展，我们一般都是采用继承的方式。这里也不例外。我们让代理类继承原始类，然后扩展附加功能。code 如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

public class UserControllerProxy extends UserController {
  //性能计数器
  private MetricsCollector metricsCollector;

  //省略有参无参构造器

  public UserVo login(String telephone, String password) {
    long startTimestamp = System.currentTimeMillis();

    //super 调用父类方法
    UserVo userVo = super.login(telephone, password);

    long endTimeStamp = System.currentTimeMillis();
    long responseTime = endTimeStamp - startTimestamp;

    log.debug("响应时间是{}毫秒", responseTime);

    //返回结果
  }

  //regiter 代码格式同 login
}

动态代理

经过上面的改造，虽然业务代码和性能计数器代码解耦了，但增强逻辑没法复用的问题依然存在，并且还产生了新的问题：

由于代理模式的特点，每个原始类需要创建一个代理类，这样如果有大量的类需要进行增强，那么就会生产大量的代理类，大大增加维护的难度

其实上面的实现被称为静态代理，而在静态代理的基础之上又诞生了动态代理

下面看看动态代理是如何解决静态代理的问题呢？

所谓动态代理（Dynamic Proxy），就是我们不事先为每个原始类编写代理类，而是在运行的时候，动态地创建原始类对应的代理类。那如何实现动态代理呢？

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

/**
 * 代理类
 */
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);
    //newProxyInstance 是 JDK 提供的 Proxy 类的方法，通过它可以创建代理对象
    return Proxy.newProxyInstance(proxiedObject.getClass().getClassLoader(), interfaces, handler);
  }

  /**
   * 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;

      //打印日志
      //返回结果
    }
  }
}


//MetricsCollectorProxy 使用
MetricsCollectorProxy proxy = new MetricsCollectorProxy();
IUserController userController = (IUserController) proxy.createProxy(new UserController());

JDK 动态代理

Java 本身提供了动态代理语法，我们称之为 JDK 动态代理。

在 Java 动态代理机制中 InvocationHandler 接口和 Proxy 类是核心。

Proxy 类中使用频率最高的方法是：newProxyInstance() ，这个方法主要用来生成一个代理对象。

1
2
3
4
5
6
7

public static Object newProxyInstance(ClassLoader loader,
                                      Class<?>[] interfaces,
                                      InvocationHandler h)
    throws IllegalArgumentException
{
    ......
}

这个方法一共有 3 个参数：

  • loader :类加载器，用于加载代理对象。
  • interfaces : 被代理类实现的一些接口；
  • h : 实现了 InvocationHandler 接口的对象；

使用与我们自定义的 MetricsCollectorProxy 使用方法相同

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

代理模式不仅能增强原业务功能，更重要的是还能对其进行业务管控。对用户来讲，隐藏于代理中的实际业务被透明化了，而暴露出来的是代理业务，以此避免客户端直接进行业务访问所带来的安全隐患，从而保证系统业务的可控性、安全性。

静态代理和JDK动态代理的区别

  • JDK 动态代理不用自定义代理类，由 jdk 为我们提供的 Proxy 作为代理类，在动态代理中我们只在意代理对象和增强代码，因而代理类对我们来说是多余的，我们只要能获取到代理对象就 OK 了
  • JDK 动态代理的增强代码（InvocationHandler 封装的内容）不与代理类耦合，可以复用
  • 代理就是俄罗斯套娃，层层封装，层层屏蔽

代理模式的应用场景

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

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

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

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

RPC demo

再来看代理模式在缓存中的应用。假设我们要开发一个接口请求的缓存功能，对于某些接口请求，如果入参相同，在设定的过期时间内，直接返回缓存结果，而不用重新进行逻辑处理。比如，针对获取用户个人信息的需求，我们可以开发两个接口，一个支持缓存，一个支持实时查询。对于需要实时数据的需求，我们让其调用实时查询接口，对于不需要实时数据的需求，我们让其调用支持缓存的接口。那如何来实现接口请求的缓存功能呢？最简单的实现方法就是刚刚我们讲到的，给每个需要支持缓存的查询需求都开发两个不同的接口，一个支持缓存，一个支持实时查询。但是，这样做显然增加了开发成本，而且会让代码看起来非常臃肿（接口个数成倍增加），也不方便缓存接口的集中管理（增加、删除缓存接口）、集中配置（比如配置每个接口缓存过期时间）。针对这些问题，代理模式就能派上用场了，确切地说，应该是动态代理。如果是基于Spring框架来开发的话，那就可以在AOP切面中完成接口缓存的功能。在应用启动的时候，我们从配置文件中加载需要支持缓存的接口，以及相应的缓存策略（比如过期时间）等。当请求到来的时候，我们在AOP切面中拦截请求，如果请求中带有支持缓存的字段（比如http://…?..&cached=true），我们便从缓存（内存缓存或者Redis缓存等）中获取数据直接返回。

设计模式
本文由作者按照 CC BY 4.0 进行授权
最近更新
文章内容

Java字节码技术

单例模式