引言

创建型模式比较好理解，后面的结构型和行为型设计模式不是那么好理解。如果遇到不好理解的设计模式，我一般会在开头举比较简单的Demo案例来帮助理解。

代理模式【常用】

  1. 前面几节，我们讲了设计模式中的创建型模式。创建型模式主要解决对象的创建问题，封装复杂的创建过程，解耦对象的创建代码和使用代码。
  2. 其中，单例模式用来创建全局唯一的对象。工厂模式用来创建不同但是相关类型的对象（继承同一父类或者接口的一组子类），由给定的参数来决定创建哪种类型的对象。建造者模式是用来创建复杂对象，可以通过设置不同的可选参数，“定制化”地创建不同的对象。原型模式针对创建成本比较大的对象，利用对已有对象进行复制的方式进行创建，以达到节省创建时间的目的。
  3. 现在，我们讲另外一种类型的设计模式：结构型模式。结构型模式主要总结了一些类或对象组合在一起的经典结构，这些经典的结构可以解决特定应用场景的问题。结构型模式包括：代理模式、桥接模式、装饰器模式、适配器模式、门面模式、组合模式、享元模式。今天我们要讲其中的代理模式。它也是在实际开发中经常被用到的一种设计模式。
  4. 代理模式有不同的形式, 主要有三种 静态代理、动态代理 (JDK 代理、接口代理)和 Cglib 代理 (可以在内存 动态的创建对象，而不需要实现接口， 他是属于动态代理的范畴) 。下面先通过几个比较简单的例子理解一下代理模式

静态代理

实例具体要求

  1. 定义一个接口:ITeacherDao
  2. 目标对象 TeacherDAO 实现接口 ITeacherDAO
  3. 使用静态代理方式,就需要在代理对象 TeacherDAOProxy 中也实现 ITeacherDAO
  4. 调用的时候通过调用代理对象的方法来调用目标对象.
  5. 特别提醒：静态代理类与被代理类要实现相同的接口,然后通过调用相同的方法来调用目标对象的方法（实现相同的接口，不改变原有的方法，这样会让调用者在调用代理类的时候就像调用被代理类一样）

ITeacherDao

  1. //接口
  2. public interface ITeacherDao {
  4.     void teach(); // 授课的方法
  5. }

TeacherDao —-> 被代理类

  1. public class TeacherDao implements ITeacherDao {
  3.     @Override
  4.     public void teach() {
  5.         // TODO Auto-generated method stub
  6.         System.out.println(" 老师授课中  。。。。。");
  7.     }
  8. }

TeacherDaoProxy —-> 代理类

  1. //代理对象,静态代理
  2. public class TeacherDaoProxy implements ITeacherDao{
  4.     private ITeacherDao target; // 目标对象，通过接口来聚合
  7.     //构造器
  8.     public TeacherDaoProxy(ITeacherDao target) {
  9.         this.target = target;
  10.     }
  14.     @Override
  15.     public void teach() {
  16.         // TODO Auto-generated method stub
  17.         System.out.println("开始代理  完成某些操作。。。。。 ");//方法
  18.         target.teach();
  19.         System.out.println("提交。。。。。");//方法
  20.     }
  22. }

Client

  1. public class Client {
  3.     public static void main(String[] args) {
  4.         // TODO Auto-generated method stub
  5.         //创建目标对象(被代理对象)
  6.         TeacherDao teacherDao = new TeacherDao();
  8.         //创建代理对象, 同时将被代理对象传递给代理对象
  9.         TeacherDaoProxy teacherDaoProxy = new TeacherDaoProxy(teacherDao);
  11.         //通过代理对象，调用到被代理对象的方法
  12.         //即：执行的是代理对象的方法，代理对象再去调用目标对象的方法 
  13.         teacherDaoProxy.teach();
  14.     }
  16. }

静态代理的缺点：

  1. 被代理对象和代理对象都要实现相同的接口
  2. 在代理类中必须指定特定的被代理对象，通过构造函数注入相应的被代理对象，调用其对象来实现。（不具备通用性）

动态代理

  1. 代理对象,不需要实现接口，但是被代理对象（目标对象）要实现接口，否则不能用动态代理 （其实就是利用反射）
  2. 代理对象的生成，是利用 JDK 的 API，动态的在内存中构建代理对象
  3. 动态代理也叫做：JDK 代理、接口代理
  4. 代理类所在包:java.lang.reflect.Proxy
  5. JDK 实现代理只需要使用 newProxyInstance 方法,但是该方法需要接收三个参数,完整的写法是:

static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,InvocationHandler h )

ITeacherDao

  1. //接口
  2. public interface ITeacherDao {
  4.    void teach(); // 授课方法
  5.    void sayHello(String name);
  6. }

TeacherDao

  1. public class TeacherDao implements ITeacherDao {
  3.    @Override
  4.    public void teach() {
  5.       // TODO Auto-generated method stub
  6.       System.out.println(" 老师授课中.... ");
  7.    }
  9.    @Override
  10.    public void sayHello(String name) {
  11.       // TODO Auto-generated method stub
  12.       System.out.println("hello " + name);
  13.    }
  15. }

ProxyFactory

  1. import java.lang.reflect.InvocationHandler;
  2. import java.lang.reflect.Method;
  3. import java.lang.reflect.Proxy;
  5. public class ProxyFactory {
  7.    //维护一个目标对象 , Object
  8.    private Object target;
  10.    //构造器 ， 对target 进行初始化
  11.    public ProxyFactory(Object target) {
  13.       this.target = target;
  14.    } 
  16.    //给目标对象 生成一个代理对象
  17.    public Object getProxyInstance() {
  19.       /* 说明
  20.          public static Object newProxyInstance(ClassLoader loader,
  21.                                           Class<?>[] interfaces,
  22.                                           InvocationHandler h)
  24.             1. ClassLoader loader ： 指定当前目标对象使用的类加载器, 获取加载器的方法固定
  25.             2. Class<?>[] interfaces: 目标对象实现的接口类型，使用泛型方法确认类型
  26.             3. InvocationHandler h : 事情处理，执行目标对象的方法时，会触发事情处理器方法, 
  27.              会把当前执行的目标对象方法作为参数传入
  28.        */
  29.       return Proxy.newProxyInstance(target.getClass().getClassLoader(), 
  30.             target.getClass().getInterfaces(), 
  31.             new InvocationHandler() {
  33.                @Override
  34.                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  35.                   // TODO Auto-generated method stub
  36.                   System.out.println("JDK代理开始~~");
  37.                   //反射机制调用目标对象的方法
  38.                   Object returnVal = method.invoke(target, args);
  39.                   System.out.println("JDK代理提交");
  40.                   return returnVal;
  41.                }
  42.             }); 
  43.    }
  44. }

Client

  1. public class Client {
  3.    public static void main(String[] args) {
  4.       // TODO Auto-generated method stub
  5.       //创建目标对象
  6.       ITeacherDao target = new TeacherDao();
  8.       //给目标对象，创建代理对象, 可以转成 ITeacherDao
  9.       ITeacherDao proxyInstance = (ITeacherDao)new ProxyFactory(target).getProxyInstance();
  11.       // proxyInstance=class com.sun.proxy.$Proxy0 内存中动态生成了代理对象
  12.       System.out.println("proxyInstance=" + proxyInstance.getClass());
  14.       //通过代理对象，调用目标对象的方法
  15.       //proxyInstance.teach();
  17.       proxyInstance.sayHello(" tom ");
  18.    }
  20. }

我们可以看出来动态代理注入对象时其实不需要指定某个特定的对象，而是利用反射机制动态的将代码加到要指定对象调用方法的前后

cglib代理

  1. 静态代理和 JDK 代理模式都要求目标对象是实现一个接口,但是有时候目标对象只是一个单独的对象,并没有实现任何的接口,这个时候可使用目标对象子类来实现代理-这就是Cglib代理

  2. Cglib代理也叫子类代理它是在内存中构建一个子类对象从而实现对目标对象功能扩展, 有些书也将Cglib代理归属到动态代理。

  3. Cglib 是一个强大的高性能的代码生成包,它可以在运行期扩展 java 类与实现 java 接口.它广泛的被许多 AOP 的 框架使用,例如 Spring AOP，实现方法拦截

  4. 在 AOP 编程中如何选择代理模式：

    • 目标对象需要实现接口，用 JDK 代理

    • 目标对象不需要实现接口，用 Cglib 代理

  5. Cglib 包的底层是通过使用字节码处理框架 ASM 来转换字节码并生成新的类

  6. 需要引入 cglib 的 jar 文件，在内存中动态构建子类，注意代理的类不能为 final，否则报错
    java.lang.IllegalArgumentException，目标对象的方法如果为 final/static,那么就不会被拦截,即不会执行目标对象额外的业务方法.

TeacherDao

  1. public class TeacherDao {
  3.    public String teach() {
  4.       System.out.println(" 老师授课中  ， 我是cglib代理，不需要实现接口 ");
  5.       return "hello";
  6.    }
  7. }

ProxyFactory

  1. import java.lang.reflect.Method;
  2. import net.sf.cglib.proxy.Enhancer;
  3. import net.sf.cglib.proxy.MethodInterceptor;
  4. import net.sf.cglib.proxy.MethodProxy;
  6. public class ProxyFactory implements MethodInterceptor {
  8.    //维护一个目标对象
  9.    private Object target;
  11.    //构造器，传入一个被代理的对象
  12.    public ProxyFactory(Object target) {
  13.       this.target = target;
  14.    }
  16.    //返回一个代理对象:  是 target 对象的代理对象
  17.    public Object getProxyInstance() {
  18.       //1. 创建一个工具类
  19.       Enhancer enhancer = new Enhancer();
  20.       //2. 设置父类
  21.       enhancer.setSuperclass(target.getClass());
  22.       //3. 设置回调函数
  23.       enhancer.setCallback(this);
  24.       //4. 创建子类对象，即代理对象
  25.       return enhancer.create();
  27.    }
  30.    //重写  intercept 方法，会调用目标对象的方法
  31.    @Override
  32.    public Object intercept(Object arg0, Method method, Object[] args, MethodProxy arg3) throws Throwable {
  33.       // TODO Auto-generated method stub
  34.       System.out.println("Cglib代理模式 ~~ 开始");
  35.       Object returnVal = method.invoke(target, args);
  36.       System.out.println("Cglib代理模式 ~~ 提交");
  37.       return returnVal;
  38.    }
  40. }

Client

  1. public class Client {
  3.    public static void main(String[] args) {
  4.       // TODO Auto-generated method stub
  5.       //创建目标对象
  6.       TeacherDao target = new TeacherDao();
  7.       //获取到代理对象，并且将目标对象传递给代理对象
  8.       TeacherDao proxyInstance = (TeacherDao)new ProxyFactory(target).getProxyInstance();
  10.       //执行代理对象的方法，触发intecept 方法，从而实现 对目标对象的调用
  11.       String res = proxyInstance.teach();
  12.       System.out.println("res=" + res);
  13.    }
  15. }

代理模式的原理解析

  1. 代理模式（Proxy Design Pattern）的原理和代码实现都不难掌握。它在不改变原始类（或叫被代理类）代码的情况下，通过引入代理类来给原始类附加功能【装饰器是增强功能，代理是附加新的功能】。我们通过一个简单的例子来解释一下这段话。
  2. 我们开发了一个 MetricsCollector 类，用来收集接口请求的原始数据，比如访问时间、处理时长等。在业务系统中，我们采用如下方式来使用这个 MetricsCollector 类：
  1. public class UserController {
  2.   //...省略其他属性和方法...
  3.   private MetricsCollector metricsCollector; // 依赖注入
  5.   public UserVo login(String telephone, String password) {
  6.     long startTimestamp = System.currentTimeMillis();
  8.     // ... 省略login逻辑...
  10.     long endTimeStamp = System.currentTimeMillis();
  11.     long responseTime = endTimeStamp - startTimestamp;
  12.     RequestInfo requestInfo = new RequestInfo("login", responseTime, startTimestamp);
  13.     metricsCollector.recordRequest(requestInfo);
  15.     //...返回UserVo数据...
  16.   }
  18.   public UserVo register(String telephone, String password) {
  19.     long startTimestamp = System.currentTimeMillis();
  21.     // ... 省略register逻辑...
  23.     long endTimeStamp = System.currentTimeMillis();
  24.     long responseTime = endTimeStamp - startTimestamp;
  25.     RequestInfo requestInfo = new RequestInfo("register", responseTime, startTimestamp);
  26.     metricsCollector.recordRequest(requestInfo);
  28.     //...返回UserVo数据...
  29.   }
  30. }
  1. 很明显，上面的写法有两个问题。第一，性能计数器框架代码侵入到业务代码中，跟业务代码高度耦合。如果未来需要替换这个计数器框架，那替换的成本会比较大。第二，收集接口请求的代码跟业务代码无关，本就不应该放到一个类中。业务类最好职责更加单一，只聚焦业务处理。
  2. 为了将框架代码和业务代码解耦，代理模式就派上用场了。代理类 UserControllerProxy 和原始类 UserController 实现相同的接口 IUserController。UserController 类只负责业务功能。代理类 UserControllerProxy 负责在业务代码执行前后附加其他逻辑代码，并通过委托的方式调用原始类来执行业务代码。具体的代码实现如下所示：

1、使用简单的静态代理方式

  1. public interface IUserController {//需要提供一个接口让他们实现
  2.   UserVo login(String telephone, String password);
  3.   UserVo register(String telephone, String password);
  4. }
  6. public class UserController implements IUserController {
  7.   //...省略其他属性和方法...
  9.   @Override
  10.   public UserVo login(String telephone, String password) {
  11.     //...省略login逻辑...
  12.     //...返回UserVo数据...
  13.   }
  15.   @Override
  16.   public UserVo register(String telephone, String password) {
  17.     //...省略register逻辑...
  18.     //...返回UserVo数据...
  19.   }
  20. }
  22. public class UserControllerProxy implements IUserController {
  23.   private MetricsCollector metricsCollector;
  24.   private UserController userController;
  26.   public UserControllerProxy(UserController userController) { 
  27.     this.userController = userController;
  28.     this.metricsCollector = new MetricsCollector();
  29.   }
  31.   @Override
  32.   public UserVo login(String telephone, String password) {//增强UserController中的login方法
  33.     long startTimestamp = System.currentTimeMillis();
  35.     // 委托
  36.     UserVo userVo = userController.login(telephone, password);
  38.     long endTimeStamp = System.currentTimeMillis();
  39.     long responseTime = endTimeStamp - startTimestamp;
  40.     RequestInfo requestInfo = new RequestInfo("login", responseTime, startTimestamp);
  41.     metricsCollector.recordRequest(requestInfo);
  43.     return userVo;
  44.   }
  46.   @Override
  47.   public UserVo register(String telephone, String password) {//增强UserController中的register方法
  48.     long startTimestamp = System.currentTimeMillis();
  50.     UserVo userVo = userController.register(telephone, password);
  52.     long endTimeStamp = System.currentTimeMillis();
  53.     long responseTime = endTimeStamp - startTimestamp;
  54.     RequestInfo requestInfo = new RequestInfo("register", responseTime, startTimestamp);
  55.     metricsCollector.recordRequest(requestInfo);
  57.     return userVo;
  58.   }
  59. }
  61. //UserControllerProxy使用举例
  62. //因为原始类和代理类实现相同的接口，是基于接口而非实现编程
  63. //将UserController类对象替换为UserControllerProxy类对象，不需要改动太多代码
  64. IUserController userController = new UserControllerProxy(new UserController());
  1. 参照基于接口而非实现编程的设计思想，将原始类对象替换为代理类对象的时候，为了让代码改动尽量少，在刚刚的代理模式的代码实现中，代理类和原始类需要实现相同的接口。但是，如果原始类并没有定义接口，并且原始类代码并不是我们开发维护的（比如它来自一个第三方的类库），我们也没办法直接修改原始类，给它重新定义一个接口。在这种情况下，我们该如何实现代理模式呢？
  2. 对于这种外部类的扩展，我们一般都是采用继承的方式。这里也不例外。我们让代理类继承原始类，然后扩展附加功能。原理很简单，不需要过多解释，你直接看代码就能明白。具体代码如下所示：
  1. public class UserControllerProxy extends UserController {//原类不需要实现接口
  2.   private MetricsCollector metricsCollector;
  4.   public UserControllerProxy() {
  5.     this.metricsCollector = new MetricsCollector();
  6.   }
  8.   public UserVo login(String telephone, String password) { //继承后重写父类的方法
  9.     long startTimestamp = System.currentTimeMillis();
  11.     UserVo userVo = super.login(telephone, password);//直接继承后调用父类的方法
  13.     long endTimeStamp = System.currentTimeMillis();
  14.     long responseTime = endTimeStamp - startTimestamp;
  15.     RequestInfo requestInfo = new RequestInfo("login", responseTime, startTimestamp);
  16.     metricsCollector.recordRequest(requestInfo);
  18.     return userVo;
  19.   }
  21.   public UserVo register(String telephone, String password) {
  22.     long startTimestamp = System.currentTimeMillis();
  24.     UserVo userVo = super.register(telephone, password);//直接继承后调用父类的方法
  26.     long endTimeStamp = System.currentTimeMillis();
  27.     long responseTime = endTimeStamp - startTimestamp;
  28.     RequestInfo requestInfo = new RequestInfo("register", responseTime, startTimestamp);
  29.     metricsCollector.recordRequest(requestInfo);
  31.     return userVo;
  32.   }
  33. }
  34. //UserControllerProxy使用举例
  35. UserController userController = new UserControllerProxy();

动态代理的原理解析

缺点：

  1. 不过，刚刚的代码实现还是有点问题。一方面，我们需要在代理类中，将原始类中的所有的方法，都重新实现一遍，并且为每个方法都附加相似的代码逻辑。另一方面，如果要添加的附加功能的类有不止一个，我们需要针对每个类都创建一个代理类。
  2. 如果有 50 个要添加附加功能的原始类，那我们就要创建 50 个对应的代理类。这会导致项目中类的个数成倍增加，增加了代码维护成本。并且，每个代理类中的代码都有点像模板式的“重复”代码，也增加了不必要的开发成本。那这个问题怎么解决呢？
  3. 我们可以使用动态代理来解决这个问题。所谓动态代理（Dynamic Proxy），就是我们不事先为每个原始类编写代理类，而是在运行的时候，动态地创建原始类对应的代理类，然后在系统中用代理类替换掉原始类。那如何实现动态代理呢？
  4. 如果你熟悉的是 Java 语言，实现动态代理就是件很简单的事情。因为 Java 语言本身就已经提供了动态代理的语法（实际上，动态代理底层依赖的就是 Java 的反射语法）。我们来看一下，如何用 Java 的动态代理来实现刚刚的功能。具体的代码如下所示。其中，MetricsCollectorProxy 作为一个动态代理类，动态地给每个需要收集接口请求信息的类创建代理类。
  1. public class MetricsCollectorProxy {
  2.   private MetricsCollector metricsCollector;
  4.   public MetricsCollectorProxy() {
  5.     this.metricsCollector = new MetricsCollector();
  6.   }
  8.   public Object createProxy(Object proxiedObject) {//此时对象不需要特定的类型，我们可以利用JDK的反射来动态调用
  9.     Class<?>[] interfaces = proxiedObject.getClass().getInterfaces();
  10.     DynamicProxyHandler handler = new DynamicProxyHandler(proxiedObject); 
  11.     return Proxy.newProxyInstance(proxiedObject.getClass().getClassLoader(), interfaces, handler);//调用JDK的动态代理
  12.   }
  14.   private class DynamicProxyHandler implements InvocationHandler {
  15.     private Object proxiedObject;
  17.     public DynamicProxyHandler(Object proxiedObject) {
  18.       this.proxiedObject = proxiedObject;
  19.     }
  21.     @Override
  22.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  23.       long startTimestamp = System.currentTimeMillis();
  24.       Object result = method.invoke(proxiedObject, args);
  25.       long endTimeStamp = System.currentTimeMillis();
  26.       long responseTime = endTimeStamp - startTimestamp;
  27.       String apiName = proxiedObject.getClass().getName() + ":" + method.getName();
  28.       RequestInfo requestInfo = new RequestInfo(apiName, responseTime, startTimestamp);
  29.       metricsCollector.recordRequest(requestInfo);
  30.       return result;
  31.     }
  32.   }
  33. }
  35. //MetricsCollectorProxy使用举例
  36. MetricsCollectorProxy proxy = new MetricsCollectorProxy();
  37. IUserController userController = (IUserController) proxy.createProxy(new UserController());

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

代理模式的应用场景

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

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

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

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

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

代理模式在缓存中的应用

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