• java 代理 终于讲清楚了，万字详解！

    什么是代理

    代理模式是常用的 java 设计模式，他的特征是代理类与委托类有同样的接口，代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。代理类与委托类之间通常会存在关联关系，一个代理类的对象与一个委托类的对象关联，代理类的对象本身并不真正实现服务，而是通过调用委托类的对象的相关方法，来提供特定的服务。

    ​代理其实不仅仅是在软件开发领域，在我们的日常生活中也是时常可见。比如某 p2p 老板突然携款带着小姨子跑路了，可怜了下面一堆的程序员背负一身房贷，上有老下有小，程序员只能被迫去申请劳动仲裁，劳动局就会为其指派一位代理律师全权负责程序员的仲裁事宜（PS:p2p 跑路仲裁拿回工资的可能性非常低，没让你把工资退回就算好的了）。那这里面就是使用了代理模式，因为在劳动仲裁这个活动中，代理律师会全权代理程序员。比如：房东要将房子出售，于是到房地产中介公司找一个中介（代理），由他来帮房东完成销售房屋，签订合同、网签、贷款过户等等事宜。

    代理模式

    这是常见代理模式常见的 UML 示意图。

    需要注意的有下面几点：

    1. 用户只关心接口功能，而不在乎谁提供了功能。上图中接口是 Subject。

    2. 接口真正实现者是上图的 RealSubject，但是它不与用户直接接触，而是通过代理。

    3. 代理就是上图中的 Proxy，由于它实现了 Subject 接口，所以它能够直接与用户接触。

    4. 用户调用 Proxy 的时候，Proxy 内部调用了 RealSubject。所以，Proxy 是中介者，它可以增强 RealSubject 操作。

    • 代理又可以分为静态代理和动态代理两种。我们先来看下静态代理。

    静态代理

    电影是电影公司委托给影院进行播放的，但是影院可以在播放电影的时候，产生一些自己的经济收益，比如提供按摩椅，娃娃机（这个每次去电影院都会尝试下，基本上是夹不起来，有木有大神可以传授下诀窍），卖爆米花、饮料（贵的要死，反正吃不起）等。我们平常去电影院看电影的时候，在电影开始的阶段是不是经常会放广告呢？然后在影片开始结束时播放一些广告。

    下面我们通过代码来模拟下电影院这一系列的赚钱操作。

    首先得有一个接口，通用的接口是代理模式实现的基础。这个接口我们命名为 Movie，代表电影播放的能力。

    1. package com.workit.demo.proxy;
    2.  
    3. public interface Movie {
    4.     void play();
    5. }

     

    • 接下来我们要创建一个真正的实现这个 Movie 接口的类，和一个实现该接口的代理类。

    真正的类《美国队长》电影：

    1. package com.workit.demo.proxy;
    2.  
    3. public class CaptainAmericaMovie implements Movie {
    4.     @Override
    5.     public void play() {
    6.         System.out.println("普通影厅正在播放的电影是《美国队长》");
    7.     }
    8. }

    代理类：

    1. package com.workit.demo.proxy;
    2.  
    3. public class MovieStaticProxy implements Movie {
    4.     Movie movie;
    5.  
    6.     public MovieStaticProxy(Movie movie) {
    7.         this.movie = movie;
    8.     }
    9.  
    10.     @Override
    11.     public void play() {
    12.         playStart();
    13.         movie.play();
    14.         playEnd();
    15.     }
    16.  
    17.     public void playStart() {
    18.         System.out.println("电影开始前正在播放广告");
    19.     }
    20.     public void playEnd() {
    21.         System.out.println("电影结束了，接续播放广告");
    22.     }
    23. }
    24.

    测试类：

    1. package com.workit.demo.proxy;
    2.  
    3. package com.workit.demo.proxy;
    4.  
    5. public class StaticProxyTest {
    6.     public static void main(String[] args) {
    7.         Movie captainAmericaMovie = new CaptainAmericaMovie();
    8.         Movie movieStaticProxy = new MovieStaticProxy(captainAmericaMovie);
    9.         movieStaticProxy.play();
    10.  
    11.     }
    12. }

    运行结果：

    1. 电影开始前正在播放广告
    2. 正在播放的电影是《美国队长》
    3. 电影结束了，接续播放广告

    现在可以看到，代理模式可以在不修改被代理对象的基础上，通过扩展代理类，进行一些功能的附加与增强。值得注意的是，代理类和被代理类应该共同实现一个接口，或者是共同继承某个类。这个就是是静态代理的内容，为什么叫做静态呢？因为它的类型是事先预定好的，比如上面代码中的 MovieStaticProxy 这个类。

    优点

    • 代理模式在客户端与目标对象之间起到一个中介作用和保护目标对象的作用

    • 代理对象可以扩展目标对象的功能

    • 代理模式能将客户端与目标对象分离，在一定程度上降低了系统的耦合度。

    缺点

    • 代理对象需要与目标对象实现一样的接口,所以会有很多代理类,类太多.同时,一旦接口增加方法,目标对象与代理对象都要维护。

    jdk 动态代理

    与静态代理类对照的是动态代理类，动态代理类的字节码在程序运行时由 Java 反射机制动态生成，无需程序员手工编写它的源代码。动态代理类不仅简化了编程工作，而且提高了软件系统的可扩展性，因为 Java 反射机制可以生成任意类型的动态代理类。java.lang.reflect 包中的 Proxy 类和InvocationHandler 接口提供了生成动态代理类的能力。

    • 接着上面的例子，刚看完《美国队长》不过瘾，还想继续去看一场《钢铁侠》。一直在普通影厅看电影觉得没啥意思，那就赶紧去 VIP 影厅（至今不知道长啥样子）体验一把。既然 实体店没体验过那就用代码来体验一次吧。创建一个 VIPMovie 电影接口

    1. package com.workit.demo.proxy;
    2. public interface VIPMovie {
    3.     void vipPlay();
    4. }

    紧接着创建一个 VIP 影厅的播放实现类

    1. package com.workit.demo.proxy;
    2.  
    3. public class IronManVIPMovie implements VIPMovie {
    4.     @Override
    5.     public void vipPlay() {
    6.         System.out.println("VI影厅正在播放的电影是《钢铁侠》");
    7.     }
    8. }

    如果按照静态代理我们是不是又要创建一个 VIP 影厅播放的代理实现类，这种方式我们就不演示了。下面我们来看看通过动态代理怎么来实现吧。

    1. package com.workit.demo.proxy;
    2.  
    3. import java.lang.reflect.InvocationHandler;
    4. import java.lang.reflect.Method;
    5.  
    6. public class MyInvocationHandler implements InvocationHandler {
    7.  
    8.     private Object object;
    9.  
    10.     public MyInvocationHandler(Object object) {
    11.         this.object = object;
    12.     }
    13.  
    14.     @Override
    15.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    16.         playStart();
    17.         Object invoke = method.invoke(object, args);
    18.         playEnd();
    19.         return invoke;
    20.     }
    21.  
    22.     public void playStart() {
    23.         System.out.println("电影开始前正在播放广告");
    24.     }
    25.     public void playEnd() {
    26.         System.out.println("电影结束了，接续播放广告");
    27.     }
    28. }

    MyInvocationHandler实现了 InvocationHandler 这个类，这个类是什么意思呢？大家不要慌张，下面我会解释。然后，我们就可以在 VIP 影厅看电影了。

    1. package com.workit.demo.proxy;
    2.  
    3. import java.lang.reflect.InvocationHandler;
    4. import java.lang.reflect.Proxy;
    5.  
    6. public class DynamicProxyTest {
    7.     public static void main(String[] args) {
    8.         IronManVIPMovie ironManVIPMovie = new IronManVIPMovie();
    9.         InvocationHandler invocationHandler = new MyInvocationHandler(ironManVIPMovie);
    10.         VIPMovie dynamicProxy = (VIPMovie) Proxy.newProxyInstance(IronManVIPMovie.class.getClassLoader(),
    11.                 IronManVIPMovie.class.getInterfaces(), invocationHandler);
    12.         dynamicProxy.vipPlay();
    13.     }
    14. }

    输出结果：

    1. 电影开始前正在播放广告
    2. VI影厅正在播放的电影是《钢铁侠》
    3. 电影结束了，接续播放广告

    看到没有，我们并没有像静态代理那样为 VIPMovie接口实现一个代理类，但最终它仍然实现了相同的功能，这其中的差别，就是之前讨论的动态代理所谓“动态”的原因。

    我们顺带把《美国队长》也用动态代理实现下吧。

    1. package com.workit.demo.proxy;
    2.  
    3. import java.lang.reflect.InvocationHandler;
    4. import java.lang.reflect.Proxy;
    5.  
    6. public class DynamicProxyTest {
    7.     public static void main(String[] args) {
    8.         // VIP 影厅《钢铁侠》
    9.         IronManVIPMovie ironManVIPMovie = new IronManVIPMovie();
    10.         InvocationHandler invocationHandler = new MyInvocationHandler(ironManVIPMovie);
    11.         VIPMovie dynamicProxy = (VIPMovie) Proxy.newProxyInstance(IronManVIPMovie.class.getClassLoader(),
    12.                 IronManVIPMovie.class.getInterfaces(), invocationHandler);
    13.         dynamicProxy.vipPlay();
    14.         
    15.         // 普通影厅《美国队长》
    16.         CaptainAmericaMovie captainAmericaMovie = new CaptainAmericaMovie();
    17.         InvocationHandler invocationHandler1 = new MyInvocationHandler(captainAmericaMovie);
    18.         Movie dynamicProxy1 = (Movie) Proxy.newProxyInstance(CaptainAmericaMovie.class.getClassLoader(),
    19.                 CaptainAmericaMovie.class.getInterfaces(), invocationHandler1);
    20.         dynamicProxy1.play();
    21.     }
    22. }

    输出结果：

    1. 电影开始前正在播放广告
    2. VI影厅正在播放的电影是《钢铁侠》
    3. 电影结束了，接续播放广告
    4. 电影开始前正在播放广告
    5. 正在播放的电影是《美国队长》
    6. 电影结束了，接续播放广告

    **我们通过 Proxy.newProxyInstance() 方法，却产生了 Movie和 VIPMovie两种接口的实现类代理，这就是动态代理的魔力。**

    JDK 动态代理到底是怎么实现的呢

    动态代码涉及了一个非常重要的类 Proxy。正是通过 Proxy 的静态方法 newProxyInstance 才会动态创建代理。具体怎么去创建代理类就不分析了,感兴趣的可以去看下源码。我们直接看下生成的代理类。

    如何查看生成的代理类？

    在生成代理类之前加上以下代码(我用的 jdk1.8)：

    1.  //新版本 jdk产生代理类   
    2.  System.getProperties().put("jdk.proxy.ProxyGenerator.saveGeneratedFiles", "true");
    3.  ```
    4.  如果上述代码加上不生效可以考虑加下下面的代码：
    5.  ```java
    6.  // 老版本jdk
    7. System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
    8. //  该设置用于输出cglib动态代理产生的类
    9. System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "C:\\class");

    代码如下：

    1.   public static void main(String[] args) {
    2.         //新版本 jdk产生代理类
    3.        System.getProperties().put("jdk.proxy.ProxyGenerator.saveGeneratedFiles", "true");
    4.         // VIP 影厅《钢铁侠》
    5.         IronManVIPMovie ironManVIPMovie = new IronManVIPMovie();
    6.         InvocationHandler invocationHandler = new MyInvocationHandler(ironManVIPMovie);
    7.         VIPMovie dynamicProxy = (VIPMovie) Proxy.newProxyInstance(IronManVIPMovie.class.getClassLoader(),
    8.                 IronManVIPMovie.class.getInterfaces(), invocationHandler);
    9.         dynamicProxy.vipPlay();
    10.  
    11.         // 普通影厅《美国队长》
    12.         CaptainAmericaMovie captainAmericaMovie = new CaptainAmericaMovie();
    13.         InvocationHandler invocationHandler1 = new MyInvocationHandler(captainAmericaMovie);
    14.         Movie dynamicProxy1 = (Movie) Proxy.newProxyInstance(CaptainAmericaMovie.class.getClassLoader(),
    15.                 CaptainAmericaMovie.class.getInterfaces(), invocationHandler1);
    16.         dynamicProxy1.play();
    17.         System.out.println("VIP 影厅《钢铁侠》代理类："+dynamicProxy.getClass());
    18.         System.out.println("普通影厅《美国队长》："+dynamicProxy1.getClass());
    19.     }
    20.    ```
    21. 我们可以看到结果
    22.  
    23. ```java
    24. 电影开始前正在播放广告
    25. VI影厅正在播放的电影是《钢铁侠》
    26. 电影结束了，接续播放广告
    27. 电影开始前正在播放广告
    28. 正在播放的电影是《美国队长》
    29. 电影结束了，接续播放广告
    30. VIP 影厅《钢铁侠》代理类：class com.sun.proxy.$Proxy0
    31. 普通影厅《美国队长》：class com.sun.proxy.$Proxy1

    产生了两个代理类分别是$Proxy0和$Proxy1。

    下面们来看下"钢铁侠"的代理类$Proxy0

    1. //
    2. // Source code recreated from a .class file by IntelliJ IDEA
    3. // (powered by Fernflower decompiler)
    4. //
    5.  
    6. package com.sun.proxy;
    7.  
    8. import com.workit.demo.proxy.VIPMovie;
    9. import java.lang.reflect.InvocationHandler;
    10. import java.lang.reflect.Method;
    11. import java.lang.reflect.Proxy;
    12. import java.lang.reflect.UndeclaredThrowableException;
    13.  
    14. public final class $Proxy0 extends Proxy implements VIPMovie {
    15.     private static Method m1;
    16.     private static Method m3;
    17.     private static Method m2;
    18.     private static Method m0;
    19.  
    20.     public $Proxy0(InvocationHandler var1) throws  {
    21.         super(var1);
    22.     }
    23.  
    24.     public final boolean equals(Object var1) throws  {
    25.         try {
    26.             return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
    27.         } catch (RuntimeException | Error var3) {
    28.             throw var3;
    29.         } catch (Throwable var4) {
    30.             throw new UndeclaredThrowableException(var4);
    31.         }
    32.     }
    33.  
    34.     public final void vipPlay() throws  {
    35.         try {
    36.             super.h.invoke(this, m3, (Object[])null);
    37.         } catch (RuntimeException | Error var2) {
    38.             throw var2;
    39.         } catch (Throwable var3) {
    40.             throw new UndeclaredThrowableException(var3);
    41.         }
    42.     }
    43.  
    44.     public final String toString() throws  {
    45.         try {
    46.             return (String)super.h.invoke(this, m2, (Object[])null);
    47.         } catch (RuntimeException | Error var2) {
    48.             throw var2;
    49.         } catch (Throwable var3) {
    50.             throw new UndeclaredThrowableException(var3);
    51.         }
    52.     }
    53.  
    54.     public final int hashCode() throws  {
    55.         try {
    56.             return (Integer)super.h.invoke(this, m0, (Object[])null);
    57.         } catch (RuntimeException | Error var2) {
    58.             throw var2;
    59.         } catch (Throwable var3) {
    60.             throw new UndeclaredThrowableException(var3);
    61.         }
    62.     }
    63.  
    64.     static {
    65.         try {
    66.             m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
    67.             m3 = Class.forName("com.workit.demo.proxy.VIPMovie").getMethod("vipPlay");
    68.             m2 = Class.forName("java.lang.Object").getMethod("toString");
    69.             m0 = Class.forName("java.lang.Object").getMethod("hashCode");
    70.         } catch (NoSuchMethodException var2) {
    71.             throw new NoSuchMethodError(var2.getMessage());
    72.         } catch (ClassNotFoundException var3) {
    73.             throw new NoClassDefFoundError(var3.getMessage());
    74.         }
    75.     }
    76. },

    通过上述代码我们可以看到 $Proxy0 extends Proxy implements VIPMovie继承了Proxy 且实现了VIPMovie接口，这也就是为什么 jdk 动态代理必须基于接口,java 是单继承的。

    然后再看下代理类实现的方法：

    1.  public final void vipPlay() throws  {
    2.         try {
    3.             super.h.invoke(this, m3, (Object[])null);
    4.         } catch (RuntimeException | Error var2) {
    5.             throw var2;
    6.         } catch (Throwable var3) {
    7.             throw new UndeclaredThrowableException(var3);
    8.         }
    9.     }

    这个supper.h.invoke Proxy中的 h 的 invoke 方法，即InvocationHandler.invoke也就是上面 MyInvocationHandler.invoke 方法，至此整个流程就清晰了。这就是 jdk 的动态代理。

    cglib 动态代理

    上面说 jdk 动态代理只能基于接口，那么如果是类要动态代理怎么办呢？cglib 动态代理就可解决关于类的动态代理。

    下面我们来创建一个“《美国队长 2》”

    1. package com.workit.demo.proxy;
    2.  
    3. public class CaptainAmerica2MovieImpl {
    4.  
    5.     public void play(){
    6.         System.out.println("正在播放的电影是《美国队长2》");
    7.     }
    8. }

    引入 cglib pom 依赖

    1. <!-- https://mvnrepository.com/artifact/cglib/cglib -->
    2. <dependency>
    3.     <groupId>cglib</groupId>
    4.     <artifactId>cglib</artifactId>
    5.     <version>3.3.0</version>
    6. </dependency>

    创建一个自定义 MethodInterceptor。

    1. package com.workit.demo.proxy;
    2.  
    3. import net.sf.cglib.proxy.MethodInterceptor;
    4. import net.sf.cglib.proxy.MethodProxy;
    5.  
    6. import java.lang.reflect.Method;
    7.  
    8. public class CglibProxyInterceptor implements MethodInterceptor {
    9.     @Override
    10.     public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
    11.         playStart();
    12.         Object object = methodProxy.invokeSuper(o, objects);
    13.         playEnd();
    14.         return object;
    15.     }
    16.  
    17.     public void playStart() {
    18.         System.out.println("电影开始前正在播放广告");
    19.     }
    20.  
    21.     public void playEnd() {
    22.         System.out.println("电影结束了，接续播放广告");
    23.     }
    24. }

    测试类

    1. package com.workit.demo.proxy;
    2.  
    3. import net.sf.cglib.core.DebuggingClassWriter;
    4. import net.sf.cglib.proxy.Enhancer;
    5.  
    6. public class CglibProxyTest {
    7.     public static void main(String[] args) {
    8.         // //在指定目录下生成动态代理类
    9.         System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "C:\\class");
    10.         //创建Enhancer对象，类似于JDK动态代理的Proxy类，下一步就是设置几个参数
    11.         Enhancer enhancer = new Enhancer();
    12.         //设置目标类的字节码文件
    13.         enhancer.setSuperclass(CaptainAmerica2MovieImpl.class);
    14.         //设置回调函数
    15.         enhancer.setCallback(new CglibProxyInterceptor());
    16.         //这里的creat方法就是正式创建代理类
    17.         CaptainAmerica2MovieImpl captainAmerica2Movie = (CaptainAmerica2MovieImpl)enhancer.create();
    18.         //调用代理类的play方法
    19.         captainAmerica2Movie.play();
    20.         System.out.println("cglib动态代理《美国队长2》："+captainAmerica2Movie.getClass());
    21.     }
    22. }

    输出结果：

    1. 电影开始前正在播放广告
    2. 正在播放的电影是《美国队长2》
    3. 电影结束了，接续播放广告
    4. cglib动态代理《美国队长2》：class com.workit.demo.proxy.CaptainAmerica2MovieImpl$$EnhancerByCGLIB$$5c3ddcfe

    我们看下最终创建的代理类生成的play方法

    1. public class CaptainAmerica2MovieImpl$$EnhancerByCGLIB$$5c3ddcfe extends CaptainAmerica2MovieImpl implements Factory {
    2.  
    3.   public final void play() {
    4.  
    5.         MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
    6.  
    7.         if (var10000 == null) {
    8.  
    9.             CGLIB$BIND_CALLBACKS(this);
    10.  
    11.             var10000 = this.CGLIB$CALLBACK_0;
    12.  
    13.         }
    14.  
    15.         if (var10000 != null) {
    16.  
    17.             var10000.intercept(this, CGLIB$play$0$Method, CGLIB$emptyArgs, CGLIB$play$0$Proxy);
    18.  
    19.         } else {
    20.  
    21.             super.play();
    22.  
    23.         }
    24.  
    25.     }
    26.

    从代理对象反编译源码可以知道，代理对象继承于CaptainAmerica2MovieImpl ，拦截器调用intercept()方法，

    intercept()方法由自定义CglibProxyInterceptor实现，所以，最后调用CglibProxyInterceptor中的intercept()方法，从而完成了由代理对象访问到目标对象的动态代理实现。

    • CGlib 是一个强大的,高性能,高质量的 Code 生成类库。它可以在运行期扩展 Java 类与实现 Java 接口。

    • 用 CGlib 生成代理类是目标类的子类。

    • 用 CGlib 生成 代理类不需要接口。

    • 用 CGLib 生成的代理类重写了父类的各个方法。

    • 拦截器中的 intercept 方法内容正好就是代理类中的方法体。

    总结

    • 代理分为静态代理和动态代理两种。

    • 静态代理，代理类需要自己编写代码写成。

    • 动态代理有 jdk 和 cglib，代理类通过 Proxy.newInstance()或者ASM 生成。

    • 静态代理和动态代理的区别是在于要不要开发者自己定义 Proxy 类。

    动态代理通过 Proxy 动态生成 proxy class，但是它也指定了一个 InvocationHandler 或者 MethodInterceptor的实现类。

    • 代理模式本质上的目的是为了增强现有代码的功能。

    结束

    • 由于自己才疏学浅，难免会有纰漏，假如你发现了错误的地方，还望留言给我指出来,我会对其加以修正。

  • 相关阅读:
    SpringBoot基于RBAC自制简易的权限验证（AOP自定义注解）
    Java面试题：Java中垃圾回收机制是如何工作的？请描述几种常见的垃圾回收算法
    点云数据结构化与体素化理论学习
    MariaDB 10.5，MySQL乱码问题，设置字符编码UTF8
    关于图灵测试和中文屋Chinese room的理解
    驱动开发：内核无痕隐藏自身分析
    iOS播放MP3视频流AudioContext解码报错null问题处理
    Pytorch2.0发布了，向下兼容，加一句代码，性能翻番
    java框架-Spring-AOP
    Faiss原理和使用总结
  • 原文地址：https://blog.csdn.net/zhaohuodian/article/details/126405636