7：代理模式（结构型）（文末有项目连接）

目录与学习目标

1：什么是代理模式 
2：没用代理模式时的实例
3：使用代理模式将其解耦（静态代理）
4：动态代理的应用场景

1：什么是代理模式

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

2：没用代理模式时的实例

我们通过一个简单的例子：性能计数器 （用来收集接口请求的原始数据，比如访问时间、处理时长）
下面有一个MetricsCollector 类，用来收集接口请求的原始数据，比如访问时间、处理时长等。
在业务系统中，我们采用如下方式来使用这个 MetricsCollector 类：
可以实现功能但存在问题
第一，性能计数器框架代码侵入到业务代码中，跟业务代码高度耦合。如果未来需要替换这个框架，那替换的成本会比较大。
第二，收集接口请求的代码跟业务代码无关，本就不应该放到一个类中。

public class UserController {
    @Autowired
    private MetricsCollector metricsCollector;
    public String login(String telephone, String password) {
        long startTimestamp = System.currentTimeMillis();
        // ... 省略login逻辑...
        long endTimeStamp = System.currentTimeMillis();
        long responseTime = endTimeStamp - startTimestamp;
        MetricsInfo metricsInfo = new MetricsInfo("login", startTimestamp,responseTime);
        metricsCollector.recordRequest(metricsInfo);
        return "login success";
    }
}

3：使用代理模式将其解耦（静态代理）

为了将框架代码和业务代码解耦，代理模式就派上用场了。
代理类 UserControllerProxy 继承了父类UserController
UserController 类只负责业务功能。
代理类 UserControllerProxy ：
    1：负责在业务代码执行前后附加其他逻辑代码
    2：通过委托的方式调用父类来执行业务代码。

public class UserControllerProxy extends UserController{
    @Autowired
    private MetricsCollector metricsCollector;
    public UserControllerProxy() {
        this.metricsCollector = new MetricsCollector();
    }
    //直接继承父类 使用代理类方式即可 注意方法名最好与父类一致
    public String login(String telephone, String password) {
        long startTimestamp = System.currentTimeMillis();
        // 委托执行父类方式
        String userVo = super.login(telephone, password);
        long endTimeStamp = System.currentTimeMillis();
        long responseTime = endTimeStamp - startTimestamp;
        MetricsInfo metricsInfo = new MetricsInfo("login", responseTime, startTimestamp);
        metricsCollector.recordRequest(metricsInfo);
        return userVo;
    }
}

3：使用代理模式将其解耦（动态代理）

静态代理存在的问题：
    一方面：如果要添加的附加功能的类有不止一个，我们需要针对每个类都创建一个代理类。
    一方面：我们需要在代理类中，将原始类中的所有的方法，都重新实现一遍，并且为每个方法都附加相似的代码逻辑；
我们可以使用动态代理来解决这个问题。所谓动态代理（Dynamic Proxy），就是我们不事先为每个原始类编写代理类，
然后在系统中用代理类替换掉原始类。那如何实现动态代理呢？

1：启动类

1：需要调用代理类方法 （入参为实现  返回为接口类 ）
2：调用放回的 userControllerInterface 的相关方法即可

2：UserController 接口类 与 实现类

动态代理必须有 接口类与实现类

3：MetricsCollectorProxy

里面仅有一个方法createProxy
实际上是类似 简单工厂那样构造一个代理类
构造过程需要：
1： 目标类的类加载
2：代理需要实现的接口，可指定多个
3：代理对象对应的自定义 InvocationHandler（即进行方法上 真正的代理）

4：DynamicProxyHandler

在构造代理类的构成中
针对 步骤3 代理对象对应的自定义 InvocationHandler
需要重写 invoke 方法
当真正执行对应的方法的时候 会在  method.invoke(proxiedObject, args); 前后执行相应的逻辑

public class DynamicProxyDemoStart {
    public static void main(String[] args) {
        MetricsCollectorProxy metricsCollectorProxy = new MetricsCollectorProxy();
//         com.sun.proxy.$Proxy0 cannot be cast to com.example.study.structural_design_pattern.proxy.dynamicProxy.UserController
//        UserController userController = (UserController) metricsCollectorProxy.createProxy(new UserController());
//        入参需要为实现类  返回需要使用接口类接收
        UserControllerInterface userControllerInterface = (UserControllerInterface)metricsCollectorProxy.createProxy(new UserController());
        userControllerInterface.login("telephone","password");
    }
}

public interface UserControllerInterface {    
    String login(String telephone, String password);
  }

public class UserController implements UserControllerInterface{
    public String login(String telephone, String password) {
        // ... 省略login逻辑...
        return "login success";
    }
}

public class MetricsCollectorProxy {
    @Autowired
    private MetricsCollector metricsCollector;
    public MetricsCollectorProxy() {
        this.metricsCollector = new MetricsCollector();
    }
    public Object createProxy(Object proxiedObject) {
        // 目标类的类加载
        ClassLoader classLoader = proxiedObject.getClass().getClassLoader();
        // 代理需要实现的接口，可指定多个
        Class<?>[] interfaces = proxiedObject.getClass().getInterfaces();
        //代理对象对应的自定义 InvocationHandler
        //注意 DynamicProxyHandler 是new出来的 因此要通过参数的方式注入metricsCollector
        DynamicProxyHandler handler = new DynamicProxyHandler(proxiedObject,metricsCollector);
        //创建对应需要代理的实例
        return Proxy.newProxyInstance(classLoader, interfaces, handler);
    }
}

class DynamicProxyHandler implements InvocationHandler {
    private Object proxiedObject;
    private MetricsCollector metricsCollector;
    public DynamicProxyHandler(Object proxiedObject,MetricsCollector metricsCollector) {
      this.proxiedObject = proxiedObject;
      this.metricsCollector = metricsCollector;
    }
    @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();
      MetricsInfo metricsInfo = new MetricsInfo(apiName, responseTime, startTimestamp);
      metricsCollector.recordRequest(metricsInfo);
      return result;
    }
  }

4：动态代理的应用场景

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

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

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

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

项目连接

请配合项目代码食用效果更佳：
项目地址：
https://github.com/hesuijin/hesujin-design-pattern
Git下载地址：
https://github.com.cnpmjs.org/hesuijin/hesujin-design-pattern.git
demo-study模块  下 structure_design_pattern  proxy包