JdkProxy的进阶知识

如果想增强一个方法的功能，无非就是直接在方法体内直接修改。但这也无非给一些有代码洁癖人士一丝丝不悦！于是乎我们即不想在原来的代码里修改，又不想把原有的代码重新写一次，那么前辈们就发明了代理.
注意：本文以 JdkProxy 为基础展开所有描述！
参与对象

那么一个代理过程参与的对象有以下几项：

• 目标接口
  
• 目标类(Target)
  
• 代理基类(Proxy)
  
• 生成的代理类
  
• 调用处理程序(InvocationHandler)
  

目标接口。

至于为什么要用接口，这是JdkProxy的理论知识。文章结束后你也会明白！

1. public interface Fight {
3.     /**
4.      * 射击
5.      */
6.     void shot();
8.     /**
9.      * 炸弹
10.      */
11.     void bomb();
12. }

复制代码

目标类

就是需要被代理的类！

1. public class BeautifulCountryTarget implements Fight {
4.     private static final Logger LOGGER = LoggerFactory.getLogger(BeautifulCountryTarget.class);
7.     /**
8.      * 射击
9.      */
10.     @Override
11.     public void shot() {
12.         
13.         LOGGER.debug("M4 shot ---> big goose!");
14.         
15.     }
17.     /**
18.      * 炸弹
19.      */
20.     @Override
21.     public void bomb() {
22.         
23.         LOGGER.debug("HIMARS fire ---> big goose!");
24.     }
25. }

复制代码

调试和输出结果

1. public class JdkProxy {
2.    
3.    
4.     private static final Logger LOGGER = LoggerFactory.getLogger(JdkProxy.class);
7.     /**
8.      * 通过 Proxy.create 生成的对象是代理对象，基于 接口的代理对象，那么有以下几点是需要注意
9.      *  
10.      * 1：生成的 代理对象 是实现了 目标接口
11.      * 2：生成的 代理对象 与 代理目标 是兄弟关系 (都实现了同一个目标接口)
12.      *
13.      */
14.     public static void main(String[] args) throws InterruptedException {
15.         
16.         // jdkProxy
17.         jdkProxyTest();
18.         
19.     }
20.    
21.    
22.     public static void jdkProxyTest() throws InterruptedException {
23.         //类加载器，负责把生成的class($Proxy???)文件加载到JVM
24.         ClassLoader loader = JdkProxy.class.getClassLoader();
26.         //需要代理的目标(对象)
27.         BeautifulCountryTarget target = new BeautifulCountryTarget();
29.         //增强目标方法的处理程序
30.         InvocationHandler handler = (proxy, method, args) -> {
32.             LOGGER.debug("大哥你在旁边看着喝Coffee！，武器开给，我来打！");
34.             //方法调用，（目标对象，参数）
35.             return method.invoke(target, args);
37.         };
40.         //创建代理人
41.         Fight w_k_l_Fight = (Fight)Proxy.newProxyInstance(
42.                 loader,
43.                 new Class[]{Fight.class},
44.                 handler
45.         );
46.         
47.         //打印下类路径，方便使用 arthas 进行反张译
48.         LOGGER.debug("proxy<w_k_l_Fight> class {}", w_k_l_Fight.getClass());
49.    
50.         //代理人调用方法
51.         w_k_l_Fight.shot();
52.         w_k_l_Fight.bomb();
53.         
54.     }
56. }

复制代码

打印出

1. 19:22:41.839 [main] DEBUG com.java.coffeetime.aop.JdkProxy -- proxy<w_k_l_Fight> class class jdk.proxy1.$Proxy0
2. 19:22:41.842 [main] DEBUG com.java.coffeetime.aop.JdkProxy -- 大哥你在旁边看着喝Coffee！，武器开给，我来打！
3. 19:22:41.842 [main] DEBUG com.java.coffeetime.aop.BeautifulCountryTarget -- M4 shot ---> big goose!
4. 19:22:41.842 [main] DEBUG com.java.coffeetime.aop.JdkProxy -- 大哥你在旁边看着喝Coffee！，武器开给，我来打！
5. 19:22:41.842 [main] DEBUG com.java.coffeetime.aop.BeautifulCountryTarget -- HIMARS fire ---> big goose!

复制代码

可以看出代理生效了，-_-!
那么通过 Proxy.create函数生成的是一字节码文件（至于怎么生成，太高端没去研究），它被 loader 加载到JVM，通过 debug只看了类名$Proxy0
模拟手写代理类

既然是系统自己生成的，那么我们自己可以自己写一个，不用系统生成的～。由理论知识可以写出以下 代理类

1. /**
2. * 模拟 通过 Proxy.create 出来的 $Proxy?? 类，
3. *
4. */
5. public class SimulateProxy extends Proxy implements Fight {
6.    
7.    
8.     protected SimulateProxy(InvocationHandler h) {
9.         super(h);
10.     }
11.    
12.    
13.     /**
14.      * 射击
15.      */
16.     @Override
17.     public void shot() {
18.         try {
19.             // 代理的方法
20.             Method pMethod = Fight.class.getMethod("shot");
22.             //调用增强处理器
23.             super.h.invoke(this, pMethod, null);   
24.         } catch (Throwable e) {
25.             e.printStackTrace();
26.         }
27.     }
29.     /**
30.      * 炸弹
31.      */
32.     @Override
33.     public void bomb() {
34.         try {
35.             // 代理的方法
36.             Method pMethod = Fight.class.getMethod("bomb");
38.             //调用增强处理器
39.             super.h.invoke(this, pMethod, null);   
40.         } catch (Throwable e) {
41.             e.printStackTrace();
42.         }
43.     }
44. }

复制代码

调试输出

1. public class JdkProxy {
2.    
3.    
4.     private static final Logger LOGGER = LoggerFactory.getLogger(JdkProxy.class);
7.     /**
8.      * 通过 Proxy.create 生成的对象是代理对象，基于 接口的代理对象，那么有以下几点是需要注意
9.      *  
10.      * 1：生成的 代理对象 是实现了 目标接口
11.      * 2：生成的 代理对象 与 代理目标 是兄弟关系 (都实现了同一个目标接口)
12.      *
13.      */
14.     public static void main(String[] args) throws InterruptedException {
15.         
16.         // 模拟代理类
17.         simulateProxyTest();
18.         
19.     }
20.    
21.    
22.     public static void simulateProxyTest() {
23.         
24.         //需要代理的目标(对象)
25.         BeautifulCountryTarget target = new BeautifulCountryTarget();
27.         //增强目标方法的函数
28.         InvocationHandler handler = (proxy, method, args) -> {
30.             LOGGER.debug("大哥你在旁边看着喝Coffee！，武器开给，我来打！");
32.             return method.invoke(target, args);
34.         };
35.         
36.         //创建代理人 这里换成自己手写的
37.         Fight w_k_l_Fight = new SimulateProxy(handler);
40.         //代理人调用方法
41.         w_k_l_Fight.shot();
42.         w_k_l_Fight.bomb();
43.     }
45. }

复制代码

同样输出

1. 19:38:23.950 [main] DEBUG com.java.coffeetime.aop.JdkProxy -- 大哥你在旁边看着喝Coffee！，武器开给，我来打！
2. 19:38:23.951 [main] DEBUG com.java.coffeetime.aop.BeautifulCountryTarget -- M4 shot ---> big goose!
3. 19:38:23.951 [main] DEBUG com.java.coffeetime.aop.JdkProxy -- 大哥你在旁边看着喝Coffee！，武器开给，我来打！
4. 19:38:23.951 [main] DEBUG com.java.coffeetime.aop.BeautifulCountryTarget -- HIMARS fire ---> big goose!

复制代码

总结

我们先来看下系统生成的$Proxy0是什么样。
现在通过在main方法添加 System.setProperty("jdk.proxy.ProxyGenerator.saveGeneratedFiles", "true");可以把系统生成的代理class文件写到目录里root/jdk/proxy1/$Proxy0.class。我这里直接贴出来，方便和上下文对比。

1. public final class $Proxy0 extends Proxy implements Fight {
2.     private static final Method m0;
3.     private static final Method m1;
4.     private static final Method m2;
5.     private static final Method m3;
6.     private static final Method m4;
8.     public $Proxy0(InvocationHandler param1) {
9.         super(var1);
10.     }
12.     public final int hashCode() {
13.         try {
14.             return (Integer)super.h.invoke(this, m0, (Object[])null);
15.         } catch (RuntimeException | Error var2) {
16.             throw var2;
17.         } catch (Throwable var3) {
18.             throw new UndeclaredThrowableException(var3);
19.         }
20.     }
22.     public final boolean equals(Object var1) {
23.         try {
24.             return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
25.         } catch (RuntimeException | Error var2) {
26.             throw var2;
27.         } catch (Throwable var3) {
28.             throw new UndeclaredThrowableException(var3);
29.         }
30.     }
32.     public final String toString() {
33.         try {
34.             return (String)super.h.invoke(this, m2, (Object[])null);
35.         } catch (RuntimeException | Error var2) {
36.             throw var2;
37.         } catch (Throwable var3) {
38.             throw new UndeclaredThrowableException(var3);
39.         }
40.     }
42.     public final void shot() {
43.         try {
44.             super.h.invoke(this, m3, (Object[])null);
45.         } catch (RuntimeException | Error var2) {
46.             throw var2;
47.         } catch (Throwable var3) {
48.             throw new UndeclaredThrowableException(var3);
49.         }
50.     }
52.     public final void bomb() {
53.         try {
54.             super.h.invoke(this, m4, (Object[])null);
55.         } catch (RuntimeException | Error var2) {
56.             throw var2;
57.         } catch (Throwable var3) {
58.             throw new UndeclaredThrowableException(var3);
59.         }
60.     }
62.     static {
63.         try {
64.             m0 = Class.forName("java.lang.Object").getMethod("hashCode");
65.             m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
66.             m2 = Class.forName("java.lang.Object").getMethod("toString");
67.             m3 = Class.forName("com.java.coffeetime.aop.Fight").getMethod("shot");
68.             m4 = Class.forName("com.java.coffeetime.aop.Fight").getMethod("bomb");
69.         } catch (NoSuchMethodException var2) {
70.             throw new NoSuchMethodError(var2.getMessage());
71.         } catch (ClassNotFoundException var3) {
72.             throw new NoClassDefFoundError(var3.getMessage());
73.         }
74.     }
76.     private static Lookup proxyClassLookup(Lookup var0) throws IllegalAccessException {
77.         if (var0.lookupClass() == Proxy.class && var0.hasFullPrivilegeAccess()) {
78.             return MethodHandles.lookup();
79.         } else {
80.             throw new IllegalAccessException(var0.toString());
81.         }
82.     }
83. }

复制代码

那么对比下系统生成的和自己手写的代理类区别 SimulateProxy和 $Proxy0,可以看出系统生成的代理类比我们手写的比较优雅一些！

• 利用静态方法把需要代理的目标方法在加载阶段就初始化了，而不需要每次调用的时候去通过反射获取到.
  
• 多了 equals,toString,hashCode,有意思的是代理类和目标类 equals 是 ture, 但是不同的实例!
  1. 19:49:59.622 [main] DEBUG com.java.coffeetime.aop.JdkProxy -- w_k_l_Fight equals target ? true
  2. 19:49:59.622 [main] DEBUG com.java.coffeetime.aop.JdkProxy -- w_k_l_Fight == target ? false

  复制代码
• 通过生成的代理类可以看出，的确是实现了 目标接口（和目标类一样），和代理类是兄弟关系，但又胜似兄弟！
  
• 对异常的处理
  

本文示例代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！