接着学习设计模式系列，今天讲解的是代理模式。

什么是代理模式？

代理模式，也叫委托模式，其定义是给某一个对象提供一个代理对象，并由代理对象控制对原对象的引用。它包含了三个角色：

Subject：抽象主题角色。可以是抽象类也可以是接口，是一个最普通的业务类型定义。

RealSubject：具体主题角色，也就是被代理的对象，是业务逻辑的具体执行者。

Proxy：代理主题角色。负责读具体主题角色的引用，通过真实角色的业务逻辑方法来实现抽象方法，并在前后可以附加自己的操作。

用类图来表示的话大概如下：

我们可以用举一个电影演员拍戏的例子，一般来说，演员最主要的工作就是演戏，其他的事可以交给他的经纪人去做，例如谈合同，安排档期等等，而负责这些场外工作的经纪人就相当于Proxy，而负责核心业务的演员就是 RealSubject 。

这就是代理模式的设计思路，除此之外，代理模式分为静态代理和动态代理，静态代理是我们自己创建一个代理类，而动态代理是程序自动帮我们生成一个代理类，可以在程序运行时再生成对象，下面分别对它们做介绍。

静态代理在程序运行之前，代理类.class文件就已经被创建了。还是用上面演员演戏的例子，在静态代理模式中，我们要先创建一个抽象主题角色 Star ，

  1. public interface Star {
  2.     // 演戏
  3.     void act();
  4. }

接下来就是创建具体的主题角色和代理主题角色，分别实现这个接口，先创建一个具体的主题角色 Actor ，

  1. /**
  2.  * 演员，也就是具体的主题角色
  3.  *
  4.  * @author Tao
  5.  * @since 2019/7/9 18:34
  6.  */
  7. public class Actor implements Star {
  8.     public void act() {
  9.         System.out.println("演员演戏~~~");
  10.     }
  11. }

然后就是创建代理主题角色，也就是代理类，代理类本身并不负责核心业务的执行流程，演戏这事还得明星自己来。所以在代理类中需要将真实对象引入，下面是具体的代码实现：

  1. /**
  2.  * 代理对象
  3.  * @author Tao
  4.  * @since 2019/7/9 18:43
  5.  */
  6. public class Agent implements Star {
  7.     /**
  8.      * 接收真实的明星对象
  9.      */
  10.     private Star star;
  12.     /**
  13.      * 通过构造方法传进来真实的明星对象
  14.      *
  15.      * @param star star
  16.      */
  17.     public Agent(Star star) {
  18.         this.star = star;
  19.     }
  21.     public void act() {
  22.         System.out.println("签合同");
  23.         star.act();
  24.         System.out.println("演完戏就收钱了");
  25.     }
  26. }

代码的逻辑还是比较清晰的，通过维护一个Star对象，可以在act里调用具体主题角色的业务逻辑，并且在核心逻辑前后可以做一些辅助操作，比如签合同，收钱等，这样代理模式的角色就都分工完成了，最后用一个场景类来验证下：

  1. public class Client {
  2.     public static void main(String[] args) {
  3.         Star actor = new Actor();
  4.         Agent agent = new Agent(actor);
  5.         agent.act();
  6.     }
  7. }

运行的结果如下：

签合同
演员演戏~~~
演完戏就收钱了

动态代理分为两种，分别是JDK动态代理和 CGLIB 动态代理，怎么又分了，代理模式分类真多，不过来都来了，就都学习一下吧。

前面说了，在动态代理中我们不再需要再手动的创建代理类，我们只需要编写一个动态处理器就可以了。真正的代理对象由JDK再运行时帮我们动态的来创建。

  1. /**
  2.  * 动态代理处理类
  3.  *
  4.  * @author Tao
  5.  * @since 2019/7/9 19:04
  6.  */
  7. public class JdkProxyHandler {
  9.     /**
  10.      * 用来接收真实明星对象
  11.      */
  12.     private Object star;
  14.     /**
  15.      * 通过构造方法传进来真实的明星对象
  16.      *
  17.      * @param star star
  18.      */
  19.     public JdkProxyHandler(Star star) {
  20.         super();
  21.         this.star = star;
  22.     }
  24.     /**
  25.      * 给真实对象生成一个代理对象实例
  26.      *
  27.      * @return Object
  28.      */
  29.     public Object getProxyInstance() {
  30.         return Proxy.newProxyInstance(star.getClass().getClassLoader(),
  31.                 star.getClass().getInterfaces(), (proxy, method, args) -> {
  33.                     System.out.println("签合同");
  34.                     // 执行具体的业务逻辑
  35.                     Object object = method.invoke(star, args);
  36.                     System.out.println("演出完经纪人去收钱……");
  38.                     return object;
  39.                 });
  40.     }
  41. }

这里说一下Proxy.newProxyInstance 这个方法，该方法包含了三个参数，

  • ClassLoader loader：指定当前目标对象使用的类加载器，获取加载器的方法是固定的；
  • Class<?>[] interfaces：指定目标对象实现的接口的类型，使用泛型方式确认类型；
  • InvocationHandler：指定动态处理器，执行目标对象的方法时会触发事件处理器的方法。

写完了动态代理实现类，我们写个场景类测试下，

  1. public class Client {
  2.     public static void main(String[] args) {
  3.         Star actor = new Actor();
  4.         // 创建动态代理对象实例
  5.         Star jdkProxy = (Star) new JdkProxyHandler(actor).getProxyInstance();
  6.         jdkProxy.act();
  7.     }
  8. }

执行结果正常输出：

签合同
演员演戏~~~
演出完代理去收钱……

由此可见，JDK 动态代理确实发挥了代理的功能，相对于静态代理，JDK 动态代理大大减少了我们的开发任务，同时减少了对业务接口的依赖，降低了耦合度。但它同样有缺陷，就是动态代理的实现类需要类实现接口来完成代理的业务，也就是说它始终无法摆脱仅支持interface代理的桎梏，这是设计上的缺陷。而这时CGLIB 动态代理就派上用场了。

CGLib采用了非常底层的字节码技术，其原理是通过字节码技术为一个类创建子类，并在子类中采用方法拦截的技术拦截所有父类方法的调用，顺势织入横切逻辑。但因为采用的是继承，所以不能对final修饰的类进行代理。下面我们写一个关于CGLib的动态代理类，值得说下的是，CGLib所在的依赖包不是JDK本身就有的，所以我们需要额外引入，如果是用maven来管理的话，就可以直接引入如下的依赖：

  1. <dependencies>
  2.     <dependency>
  3.         <groupId>cglib</groupId>
  4.         <artifactId>cglib</artifactId>
  5.         <version>3.2.3</version>
  6.     </dependency>
  7. </dependencies>

使用 CGLIB 需要实现 MethodInterceptor 接口，并重写intercept 方法，在该方法中对原始要执行的方法前后做增强处理。该类的代理对象可以使用代码中的字节码增强器来获取。具体的代码如下：

  1. public class CglibProxy implements MethodInterceptor {
  2.     /**
  3.      * 维护目标对象
  4.      */
  5.     private Object target;
  7.     public Object getProxyInstance(final Object target) {
  8.         this.target = target;
  9.         // Enhancer类是CGLIB中的一个字节码增强器，它可以方便的对你想要处理的类进行扩展
  10.         Enhancer enhancer = new Enhancer();
  11.         // 将被代理的对象设置成父类
  12.         enhancer.setSuperclass(this.target.getClass());
  13.         // 回调方法，设置拦截器
  14.         enhancer.setCallback(this);
  15.         // 动态创建一个代理类
  16.         return enhancer.create();
  17.     }
  19.     public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
  20.         System.out.println("签合同");
  21.         // 执行具体的业务逻辑
  22.         Object result = methodProxy.invoke(o, objects);
  23.         System.out.println("演出完经纪人去收钱……");
  24.         return result;
  25.     }
  26. }
  28. 场景测试类：
  1. public class Client {
  2.     public static void main(String[] args) {
  3.         Star actor = new Actor();
  4.         // 创建动态代理对象实例
  5.         Star proxy = (Star) new CglibProxy().getProxyInstance(actor);
  6.         proxy.act();
  7.     }
  8. }

可以看出，测试类的逻辑和JDK动态代理差不多，其实套路都是一样的，其实技术实现不同。

总结一下CGLIB代理模式： CGLIB创建的动态代理对象比JDK创建的动态代理对象的性能更高，但是CGLIB创建代理对象时所花费的时间却比JDK多得多。所以对于单例的对象，因为无需频繁创建对象，用CGLIB合适，反之使用JDK方式要更为合适一些。同时由于CGLib由于是采用动态创建子类的方法，对于final修饰的方法无法进行代理。

这里扩展一个知识点，那就是Spring AOP的底层实现，为什么在这里提及呢？因为Spring AOP的底层实现就是基于代理模式，而JDK 动态代理和 CGLIB 动态代理均是实现 Spring AOP 的基础。我们可以看下AOP的部分底层源码：

  1. public class DefaultAopProxyFactory implements AopProxyFactory, Serializable {
  3.     @Override
  4.     public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
  5.         if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
  6.             Class<?> targetClass = config.getTargetClass();
  7.             if (targetClass == null) {
  8.                 throw new AopConfigException("TargetSource cannot determine target class: " +
  9.                         "Either an interface or a target is required for proxy creation.");
  10.             }
  11.             // 判断目标类是否是接口或者目标类是否Proxy类型，若是则使用JDK动态代理
  12.             if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
  13.                 return new JdkDynamicAopProxy(config);
  14.             }
  15.             // 使用CGLIB的方式创建代理对象
  16.             return new ObjenesisCglibAopProxy(config);
  17.         }
  18.         else {
  19.             // 上面条件都不满足就使用JDK的提供的代理方式生成代理对象
  20.             return new JdkDynamicAopProxy(config);
  21.         }
  22.     }
  23. }

源码的判断逻辑并不难，主要是根据目标类是否是接口或者Proxy类型来判断使用哪种代理模式创建代理对象，使用的代理模式正是JDK动态代理和CGLIB 动态代理技术。由此可见，了解代理模式还是很重要的，起码以后面试官问AOP的底层实现时，我们还能吹一波呢，哈哈~~~

版权声明：本文为yeya原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/yeya/p/11169014.html