深入分析Spring源码(二)----代理模式(jdk动态代理)

偏执的太偏执、 2021-12-10 08:59 331阅读 0赞

代理模式：

特点：1.有执行者，被代理人两个角色

  1.        2.对于被代理人来说，这件事情是一定要做的，但自己又不想做或者没有时间做，找代理
  3.        3.需要获取被代理人的个人资料

首先来看一下如何使用JDK动态代理。JDK提供了java.lang.reflect.Proxy类来实现动态代理的，可通过它的newProxyInstance来获得代理实现类。同时对于代理的接口的实际处理，是一个java.lang.reflect.InvocationHandler，它提供了一个invoke方法供实现者提供相应的代理逻辑的实现。可以对实际的实现进行一些特殊的处理，像Spring AOP中的各种advice。

  1. //静态代理
  3. public interface Person{
  4.     void sing();       
  5.     String getName();
  7.     String getSex(); 
  8. }
  10. public class Star implements Person{
  11.     private String name = "Gongxiaoxiao";
  12.     private String sex = "female";
  13.     @Override
  14.      public  void sing(){
  15.         System.out.println("===Star====Sing===");
  16.     }
  17. }
  19. public class Agent implements Person{
  20.     private Person p;
  22.     Agent(Person p ){
  23.             this.p = p;
  24.     }
  26.     @Override
  27.     public void sing(){
  28.         System.out.println("====唱歌前谈价钱===");
  29.         p.sing();
  30.         System.out.println("======唱歌后护送离场====");
  31.     }
  32. }
  34. public static void main(String[] args){
  35.         Person p = new Star();
  36.         Agent aa = new Agent(p);
  37.         aa.sing();
  38. }
  40. //动态代理
  42. public interface Person{
  43.   public  void sing();        
  44. }
  46. public class Star implements Person{
  47.     @Override
  48.      public  void sing(){
  49.         System.out.println("===Star====Sing===");
  50.     }
  51. }
  53. public class Agent implements InvocationHandler{
  55.        private Person target;
  56.     //获取被代理人的个人资料
  57.       public Object getInstance(Person target) throws Exception{
  58.            this.target = target;
  59.             //Proxy.newProxyInstance(ClassLoader loader,Class<?>            
  60.             //    []interfaces,InvocationHandler h);
  61.            Class clazz = target.getClass();
  62.            //参数1：被代理人对应的类加载器，参数2：被代理人对应实现的接口，参数3：代理人；返回代    
  63.            //理对象    
  64.            //类加载器(ClassLoader)用来加载动态代理类
  65.            //一个要实现接口的数组，从这点就可以看出，要想使用JDK动态代理，必须要有接口类
  66.            return     
  67.              Proxy.newProxyInstance(clazz.getClassLoader(),clazz.getInterfaces(),this); 
  68.       }
  70.     @Override
  71.     public Object invoke(Object proxy,Method method,Object[]args){
  72.         System.out.println("=====付出场费=====");
  73.         method.invoke(target,args);
  74.         System.out.println("=====护送离场=====");
  75.     }   
  76. }
  78. public static void main(String[] args){
  79.      //设置sun.misc.ProxyGenerator.saveGeneratedFiles这个系统属性为true来把生成的class保存到 
  80.      //本地文件来查看。
  81.      System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles","true");
  82.      Person p = new Star();
  83.      Person aa = (Person)Agent.getInstance(p);
  84.      //该代理对象的引用aa的运行时类为 $Proxy0
  85.      System.out.println(aa.getClass());    
  86.      aa.sing();
  87. }
  89. public static Object newProxyInstance(ClassLoader loader,
  90.                                           Class<?>[] interfaces,
  91.                                           InvocationHandler h)
  92.         throws IllegalArgumentException {
  93.         if (h == null) {
  94.             throw new NullPointerException();
  95.         }
  97.         final Class<?>[] intfs = interfaces.clone();
  98.         final SecurityManager sm = System.getSecurityManager();
  99.         if (sm != null) {
  100.             checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
  101.         }
  102.         // 这里是生成class的地方
  103.         Class<?> cl = getProxyClass0(loader, intfs);
  104.         // 使用我们实现的InvocationHandler作为参数调用构造方法来获得代理类的实例
  105.         try {
  106.             final Constructor<?> cons = cl.getConstructor(constructorParams);
  107.             final InvocationHandler ih = h;
  108.             if (sm != null && ProxyAccessHelper.needsNewInstanceCheck(cl)) {
  109.                 return AccessController.doPrivileged(new PrivilegedAction<Object>() {
  110.                     public Object run() {
  111.                         return newInstance(cons, ih);
  112.                     }
  113.                 });
  114.             } else {
  115.                 return newInstance(cons, ih);
  116.             }
  117.         } catch (NoSuchMethodException e) {
  118.             throw new InternalError(e.toString());
  119.         }
  120.     }
  121. 其中newInstance只是调用Constructor.newInstance来构造相应的代理类实例，这里重点是看getProxyClass0这个方法的实现：
  122.  private static Class<?> getProxyClass0(ClassLoader loader,
  123.                                            Class<?>... interfaces) {
  124.         // 代理的接口数量不能超过65535（没有这种变态吧）
  125.         if (interfaces.length > 65535) {
  126.             throw new IllegalArgumentException("interface limit exceeded");
  127.         }
  128.         // JDK对代理进行了缓存，如果已经存在相应的代理类，则直接返回，否则才会通过ProxyClassFactory来创建代理
  129.         return proxyClassCache.get(loader, interfaces);
  130.     }
  131. 其中代理缓存是使用WeakCache实现的，如下
  132.     private static final WeakCache<ClassLoader, Class<?>[], Class<?>>
  133.         proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());
  134. 具体的缓存逻辑这里暂不关心，只需要关心ProxyClassFactory是如何生成代理类的，ProxyClassFactory是Proxy的一个静态内部类，实现了WeakCache的内部接口BiFunction的apply方法：
  135.     private static final class ProxyClassFactory
  136.         implements BiFunction<ClassLoader, Class<?>[], Class<?>> {
  137.         // 所有代理类名字的前缀
  138.         private static final String proxyClassNamePrefix = "$Proxy";
  140.         // 用于生成代理类名字的计数器
  141.         private static final AtomicLong nextUniqueNumber = new AtomicLong();
  143.         @Override
  144.         public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {
  145.             // 省略验证代理接口的代码……
  147.             String proxyPkg = null;     // 生成的代理类的包名
  148.             // 对于非公共接口，代理类的包名与接口的相同
  149.             for (Class<?> intf : interfaces) {
  150.                 int flags = intf.getModifiers();
  151.                 if (!Modifier.isPublic(flags)) {
  152.                     String name = intf.getName();
  153.                     int n = name.lastIndexOf('.');
  154.                     String pkg = ((n == -1) ? "" : name.substring(0, n + 1));
  155.                     if (proxyPkg == null) {
  156.                         proxyPkg = pkg;
  157.                     } else if (!pkg.equals(proxyPkg)) {
  158.                         throw new IllegalArgumentException(
  159.                             "non-public interfaces from different packages");
  160.                     }
  161.                 }
  162.             }
  164.             // 对于公共接口的包名，默认为com.sun.proxy
  165.             if (proxyPkg == null) {
  166.                 proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
  167.             }
  169.             // 获取计数
  170.             long num = nextUniqueNumber.getAndIncrement();
  171.             // 默认情况下，代理类的完全限定名为：com.sun.proxy.$Proxy0，com.sun.proxy.$Proxy1……依次递增
  172.             String proxyName = proxyPkg + proxyClassNamePrefix + num;
  174.             // 这里才是真正的生成代理类的字节码的地方
  175.             byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
  176.                 proxyName, interfaces);
  177.             try {
  178.                 // 根据二进制字节码返回相应的Class实例
  179.                 return defineClass0(loader, proxyName,
  180.                                     proxyClassFile, 0, proxyClassFile.length);
  181.             } catch (ClassFormatError e) {
  182.                 throw new IllegalArgumentException(e.toString());
  183.             }
  184.         }
  185.     }
  188. ProxyGenerator是sun.misc包中的类，它没有开源，但是可以反编译来一探究竟：
  189.     public static byte[] generateProxyClass(final String var0, Class[] var1) {
  190.         ProxyGenerator var2 = new ProxyGenerator(var0, var1);
  191.         final byte[] var3 = var2.generateClassFile();
  192.         // 这里根据参数配置，决定是否把生成的字节码（.class文件）保存到本地磁盘，我们可以通过把相应的class文件保存到本地，再反编译来看看具体的实现，这样更直观
  193.         if(saveGeneratedFiles) {
  194.             AccessController.doPrivileged(new PrivilegedAction() {
  195.                 public Void run() {
  196.                     try {
  197.                         FileOutputStream var1 = new FileOutputStream(ProxyGenerator.dotToSlash(var0) + ".class");
  198.                         var1.write(var3);
  199.                         var1.close();
  200.                         return null;
  201.                     } catch (IOException var2) {
  202.                         throw new InternalError("I/O exception saving generated file: " + var2);
  203.                     }
  204.                 }
  205.             });
  206.         }
  207.         return var3;
  208.     }

对生成的代理类进行反编译可得：

  1. //
  2. // Source code recreated from a .class file by IntelliJ IDEA
  3. // (powered by Fernflower decompiler)
  4. //
  6. package com.sun.proxy;
  8. import com.example.demo1.dynamicProxy.Person;
  9. import java.lang.reflect.InvocationHandler;
  10. import java.lang.reflect.Method;
  11. import java.lang.reflect.Proxy;
  12. import java.lang.reflect.UndeclaredThrowableException;
  14. public final class $Proxy0 extends Proxy implements Person {
  15.     private static Method m1;
  16.     private static Method m4;
  17.     private static Method m3;
  18.     private static Method m2;
  19.     private static Method m5;
  20.     private static Method m0;
  22.     public $Proxy0(InvocationHandler var1) throws  {
  23.         super(var1);
  24.     }
  26.     public final boolean equals(Object var1) throws  {
  27.         try {
  28.             return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
  29.         } catch (RuntimeException | Error var3) {
  30.             throw var3;
  31.         } catch (Throwable var4) {
  32.             throw new UndeclaredThrowableException(var4);
  33.         }
  34.     }
  36.     public final String getSex() throws  {
  37.         try {
  38.             return (String)super.h.invoke(this, m4, (Object[])null);
  39.         } catch (RuntimeException | Error var2) {
  40.             throw var2;
  41.         } catch (Throwable var3) {
  42.             throw new UndeclaredThrowableException(var3);
  43.         }
  44.     }
  46.     public final String getName() throws  {
  47.         try {
  48.             return (String)super.h.invoke(this, m3, (Object[])null);
  49.         } catch (RuntimeException | Error var2) {
  50.             throw var2;
  51.         } catch (Throwable var3) {
  52.             throw new UndeclaredThrowableException(var3);
  53.         }
  54.     }
  56.     public final String toString() throws  {
  57.         try {
  58.             return (String)super.h.invoke(this, m2, (Object[])null);
  59.         } catch (RuntimeException | Error var2) {
  60.             throw var2;
  61.         } catch (Throwable var3) {
  62.             throw new UndeclaredThrowableException(var3);
  63.         }
  64.     }
  66.     public final void sing() throws  {
  67.         try {
  68.             super.h.invoke(this, m5, (Object[])null);
  69.         } catch (RuntimeException | Error var2) {
  70.             throw var2;
  71.         } catch (Throwable var3) {
  72.             throw new UndeclaredThrowableException(var3);
  73.         }
  74.     }
  76.     public final int hashCode() throws  {
  77.         try {
  78.             return (Integer)super.h.invoke(this, m0, (Object[])null);
  79.         } catch (RuntimeException | Error var2) {
  80.             throw var2;
  81.         } catch (Throwable var3) {
  82.             throw new UndeclaredThrowableException(var3);
  83.         }
  84.     }
  86.     static {
  87.         try {
  88.             m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
  89.             m4 = Class.forName("com.example.demo1.dynamicProxy.Person").getMethod("getSex");
  90.             m3 = Class.forName("com.example.demo1.dynamicProxy.Person").getMethod("getName");
  91.             m2 = Class.forName("java.lang.Object").getMethod("toString");
  92.             m5 = Class.forName("com.example.demo1.dynamicProxy.Person").getMethod("sing");
  93.             m0 = Class.forName("java.lang.Object").getMethod("hashCode");
  94.         } catch (NoSuchMethodException var2) {
  95.             throw new NoSuchMethodError(var2.getMessage());
  96.         } catch (ClassNotFoundException var3) {
  97.             throw new NoClassDefFoundError(var3.getMessage());
  98.         }
  99.     }
  100. }

生成的动态代理类$Proxy0的特性：

  1.    继承了Proxy类，实现了代理的接口，由于java不能多继承，这里已经继承了Proxy类了，不能再继承其他的类，所以JDK的动态代理不支持对实现类的代理，只支持接口的代理。

提供了一个使用InvocationHandler作为参数的构造方法。
生成静态代码块来初始化接口中方法的Method对象，以及Object类的equals、hashCode、toString方法。
重写了Object类的equals、hashCode、toString，它们都只是简单的调用了InvocationHandler的invoke方法，即可以对其进行特殊的操作，也就是说JDK的动态代理还可以代理上述三个方法。
代理类实现代理接口的sing方法中，只是简单的调用了InvocationHandler的invoke方法，我们可以在invoke方法中进行一些特殊操作，甚至不调用实现的方法，直接返回。

至此JDK动态代理的实现原理就分析的差不多了。同时我们可以想像一下Spring AOP提供的各种拦截该如何实现，就已经很明了了，如下所示：

  1. public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  2.         // BeforeAdvice
  3.         Object retVal = null;
  4.         try {
  5.             // AroundAdvice
  6.             retVal = method.invoke(target, args);
  7.             // AroundAdvice
  8.             // AfterReturningAdvice
  9.         }
  10.         catch (Throwable e) {
  11.             // AfterThrowingAdvice
  12.         }
  13.         finally {
  14.             // AfterAdvice
  15.         }
  16.         return retVal;
  17.     }

（源码分析部分来自于https://blog.csdn.net/mhmyqn/article/details/48474815）

发表评论

表情：
评论列表 （有 0 条评论，331人围观）

还没有评论，来说两句吧...

相关阅读

    相关 代理模式-JDK动态代理

    对比静态代理 静态代理：是指在程序运行前就已经定义好了目标类的代理类。代理类与目标类的代理关系在程序运行之前就确立了。 动态代理：是指程序在整个运行过程中根本就不存在目标类

    布满荆棘的人生布满荆棘的人生/ 0 赞/ 83 阅读

    相关 从源码分析JDK动态代理

    引言 动态代理非常的重要，虽然我们在日常的工作中没有非常底层的 编写过动态代理的代码，但是动态代理却起着非常重要的功能，想一下我们经常使用的框架： 日志框架、AOP等等，

    Love The Way You LieLove The Way You Lie/ 0 赞/ 98 阅读

    相关 JDK动态代理之源码分析

    一、代理模式是什么？ 代理模式就是给一个对象提供一个代理对象，并由代理对象管理着被代理对象的引用。就像生活中的代理律师，你只需要找好代理律师，剩下的都交给代理律师来打理。

    绝地灬酷狼绝地灬酷狼/ 0 赞/ 303 阅读