代理模式1. 代理模式的原理解析代理模式（Proxy Design Pattern）的原理和代码实现都不难掌握。它在不

1. 代理模式的原理解析

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

当时我们开发了一个 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数据...
  }
}

很明显，上面的写法有两个问题。

第一，性能计数器框架代码侵入到业务代码中，跟业务代码高度耦合。如果未来需要替换这个框架，那替换的成本会比较大。
第二，收集接口请求的代码跟业务代码无关，本就不应该放到一个类中。业务类最好职责更加单一，只聚焦业务处理。

1.1 代理模式

代理模式：为一个对象提供一个替身，以控制对这个对象的访问，即通过代理对象访问目标对象，这样做的好处是：可以在目标对象的实现基础上，增强额外的功能操作，即扩展目标对象的功能
被代理的对象可以是远程对象，创建开销大的对象或需要安全控制的对象
代理模式有不同的形式，主要有三种：静态代理类，动态代理类(JDK代理，接口代理)和Cglib代理(可以在内存动态的创建对象，而不需要实现接口，它是属于动态代理的范畴)

2 静态代理模式

2.1 基于接口实现静态代理模式

为了将框架代码和业务代码解耦，代理模式就派上用场了。代理类 UserControllerProxy 和原始类 UserController 实现相同的接口 IUserController。UserController 类只负责业务功能。代理类 UserControllerProxy 负责在业务代码执行前后附加其他逻辑代码，并通过委托的方式调用原始类来执行业务代码。具体的代码实现如下所示：

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

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数据...
  }
}

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();

2.3 静态代理优缺点

优点

在不修改目标对象的功能的前提下，能通过代理对象对目标功能的拓展

缺点：

假设一个系统中有100个Service，则需要创建100个代理对象
如果一个Service中有很多方法需要事务（增强动作），发现代理对象的方法中还是有很多重复的代码
一旦接口中方法变化，目标对象与代理对象都要维护
由第一点和第二点可以得出：静态代理的重用性不强

3 动态代理

3.1 动态代理的原理解析

不过，刚刚的代码实现还是有点问题。一方面，我们需要在代理类中，将原始类中的所有的方法，都重新实现一遍，并且为每个方法都附加相似的代码逻辑。另一方面，如果要添加的附加功能的类有不止一个，我们需要针对每个类都创建一个代理类。

如果有 50 个要添加附加功能的原始类，那我们就要创建 50 个对应的代理类。这会导致项目中类的个数成倍增加，增加了代码维护成本。并且，每个代理类中的代码都有点像模板式的“重复”代码，也增加了不必要的开发成本。那这个问题怎么解决呢？

我们可以使用动态代理来解决这个问题。所谓动态代理（Dynamic Proxy），就是我们不事先为每个原始类编写代理类，而是在运行的时候，动态地创建原始类对应的代理类，然后在系统中用代理类替换掉原始类。 那如何实现动态代理呢？

如果你熟悉的是 Java 语言，实现动态代理就是件很简单的事情。因为 Java 语言本身就已经提供了动态代理的语法（实际上，动态代理底层依赖的就是 Java 的反射语法）。我们来看一下，如何用 Java 的动态代理来实现刚刚的功能。具体的代码如下所示。其中，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使用举例
MetricsCollectorProxy proxy = new MetricsCollectorProxy();
IUserController userController = (IUserController) proxy.createProxy(new UserController());

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

Proxy.newProxyInstance()三个参数

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

ClassLoader loader：指定当前目标对象使用的类加载器，获取加载器的方法固定
Class<?>[] interfaces：目标对象实现的接口类型，使用泛型方法确认类型
InvocationHandler h：事情处理，执行目标对象的方法时，会触发该拦截器，把当前执行的目标对象方法作为参数传入

4 另外一个Demo

4.1 静态代理

静态代理在使用时，需要定义接口或者父类，被代理对象（目标方法）与代理对象一起实现相同的接口或者继承相同的父类

package com.evan.proxy.staticproxy;

public interface ITeacherDao {

    void teacher();
}

package com.evan.proxy.staticproxy;

public class TeacherDao implements ITeacherDao{
    @Override
    public void teacher() {
        System.out.println("这个是目标方法，被代理的方法");
    }
}

package com.evan.proxy.staticproxy;


// 代理对象 静态代理
public class ProxyTeacherDao implements  ITeacherDao {

    private ITeacherDao target;
    public ProxyTeacherDao(ITeacherDao target){
        this.target = target;
    }


    @Override
    public void teacher() {

        System.out.println("代理开始，完成某些操作");
        target.teacher();
        System.out.println("代理关闭，完成某些操作");
    }


}

package com.evan.proxy.staticproxy;

public class Client {
    public static void main(String[] args) {

        // 创建目标对象（被代理对象）
        TeacherDao teacherDao = new TeacherDao();

        // 创建代理对象，同事将被代理的对象传递给代理对象

        ProxyTeacherDao proxy = new ProxyTeacherDao(teacherDao);

        // 通知代理对象，调用到被代理对象的方法
        // 即：执行的是代理对象的方法，代理对象再去调用被代理对象的方法
        proxy.teacher();

    }
}

4.2动态代理方式

package com.evan.proxy.dynamicproxy;

public interface ITeacherDao {

    void teacher();
}

package com.evan.proxy.dynamicproxy;

public class TeacherDao implements ITeacherDao {
    @Override
    public void teacher() {
        System.out.println("这个是目标方法，被代理的方法");
    }
}

package com.evan.proxy.dynamicproxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class DynamicProxy {

    // 维护一个目标对象
    private Object target;

    public DynamicProxy(ITeacherDao target) {
        this.target = target;
    }

    // 给目标对象生成一个代理对象
    public Object getProxyInstance() {
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

                        System.out.println("动态代理开始了");
                        Object returnValue = method.invoke(target, args);
                        System.out.println("动态代理结束啦");
                        return returnValue;
                    }
                });
    }
}

package com.evan.proxy.dynamicproxy;



public class Client {
    public static void main(String[] args) {

        // 创建目标对象
        ITeacherDao target = new TeacherDao();
        DynamicProxy proxy = new DynamicProxy(target);


        ITeacherDao teacherDao = (ITeacherDao) proxy.getProxyInstance();

        // class com.sun.proxy.$Proxy0 内存中动态生成了代理对象
        System.out.println(teacherDao.getClass());

        // 通过代理对象，调用目标对象的方法
        teacherDao.teacher();


    }
}

第二种写法

package com.evan.proxy.dynamicproxy;

public class MyTransaction {
    public void beginTransaction(){
        System.out.println("开启事务 ");
    }
    public void commit(){
        System.out.println("提交事务");
    }

}

在动态代理在生成代理对象的时候需要一个拦截器 InvocationHandler 因此需要写一个拦截器

package com.evan.proxy.dynamicproxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class DynamicProxy implements InvocationHandler{

    // 维护一个目标对象
    private Object target;
    //增强类
    private MyTransaction myTransaction;
    //构造函数注入目标类和增强类
    public DynamicProxy(Object target,MyTransaction myTransaction){
        this.target = target;
        this.myTransaction = myTransaction;
    }


    //代理类的每一个方法被调用的时候都会调用下边的这个invoke方法
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("动态代理开始了");
        this.myTransaction.beginTransaction();
        Object returnValue = method.invoke(target, args);
        this.myTransaction.commit();
        System.out.println("动态代理结束啦");
        return returnValue;
    }
}


package com.evan.proxy.dynamicproxy;


import java.lang.reflect.Proxy;

public class Client {
    public static void main(String[] args) {

        // 创建目标对象
        ITeacherDao target = new TeacherDao();
        MyTransaction myTransaction = new MyTransaction();
        DynamicProxy proxy = new DynamicProxy(target,myTransaction);


        // 通过代理对象，调用目标对象的方法
        ITeacherDao teacherDao = (ITeacherDao) Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(),proxy);
        
         // class com.sun.proxy.$Proxy0 内存中动态生成了代理对象
        System.out.println(teacherDao.getClass());
        teacherDao.teacher();
    }
}

4.3 Cglib 代理

静态代理和动态代理都要求目标对象实现一个接口，但是有的时候目标对象就是一个单独的对象，并没有实现任何的接口，这个时候可以使用目标对象子类实现代理，这就是 Cglib 代理
Cglib 代理也叫子类代理，它是在内存中构建一个类对象从而实现对目标对象功能扩展
Cglib 是一个强大的高性能的代码生成包，可以在运行期扩展java类与实现java接口。它广泛的被许多aop的框架使用，例如spring aop
在aop编程中，如何选择代理模式
- 目标对象需要实现接口用jdk代理
- 目标对象不需要实现接口，用 Cglib 代理
Cglib 包的底层是通过使用字节码处理框架asm来转换字节码并生成新的类

4.3.1 Cglib 代理模式实现步骤

引入jar

<!-- https://mvnrepository.com/artifact/org.ow2.asm/asm -->
<dependency>
    <groupId>org.ow2.asm</groupId>
    <artifactId>asm</artifactId>
    <version>6.0</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.ow2.asm/asm-commons -->
<dependency>
    <groupId>org.ow2.asm</groupId>
    <artifactId>asm-commons</artifactId>
    <version>6.0</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.ow2.asm/asm-tree -->
<dependency>
    <groupId>org.ow2.asm</groupId>
    <artifactId>asm-tree</artifactId>
    <version>6.0</version>
</dependency>
<!-- https://mvnrepository.com/artifact/cglib/cglib -->
<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>3.2.0</version>
</dependency>

在内存中动态构建子类，注意代理的类不能为final,否则会报错
目标对象的方法如果为final/static,那么就不会被拦截，即不会执行目标方法额外的业务方法。

package com.evan.proxy.cglib;

public class TeacherDao {

    public void teacher() {
        System.out.println("这个是目标方法，被代理的方法");
    }
}

实现MethodInterceptor接口

package com.evan.proxy.cglib;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

public class CglibProxy implements MethodInterceptor {


    // 维护一个目标对象
    private Object target;


    public CglibProxy(Object target) {
        this.target = target;
    }


    // 返回一个代理对象，是target对象的代理对象
    public Object getProxyInstance() {
        //1. 创建一个工具类
        Enhancer enhancer = new Enhancer();
        //2. 设置父类
        enhancer.setSuperclass(target.getClass());
        //3. 设置返回函数
        enhancer.setCallback(this);
        //4. 创建子类对象，即代理对象
        return enhancer.create();
    }


    //重写intercept 方法，这个方法会调用目标对象的方法
    @Override
    public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {

        System.out.println("CGlib代理开始了");
        Object returnValue = method.invoke(target, args);
        System.out.println("CGlib代理结束啦");
        return returnValue;
    }
}

package com.evan.proxy.cglib;

public class Client {

    public static void main(String[] args) {

        CglibProxy proxy = new CglibProxy(new TeacherDao());

        TeacherDao  teacherDao = (TeacherDao) proxy.getProxyInstance();

        // class com.sun.proxy.$Proxy0 内存中动态生成了代理对象
        System.out.println(teacherDao.getClass());
        
        teacherDao.teacher();


    }
}

5 代理模式的应用场景

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

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

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

如果你熟悉 Java 语言和 Spring 开发框架，这部分工作都是可以在 Spring AOP 切面中完成的。前面我们也提到，Spring AOP 底层的实现原理就是基于动态代理。

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

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

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

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

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

代理模式的意图：为其他对象提供一种代理以控制对这个对象的访问。

5.3 代理模式的优缺点

优点：

职责清晰。
高扩展性。
智能化。

缺点：

由于在客户端和真实主题之间增加了代理对象，因此有些类型的代理模式可能会造成请求的处理速度变慢。
实现代理模式需要额外的工作，有些代理模式的实现非常复杂。