深入理解JDK动态代理

代理模式的目的是在不修改原有类方法设计的基础上，对方法行为进行增强。

创新互联是专业的溧水网站建设公司，溧水接单;提供成都做网站、网站设计、外贸营销网站建设,网页设计,网站设计,建网站,PHP网站建设等专业做网站服务;采用PHP框架,可快速的进行溧水网站开发网页制作和功能扩展;专业做搜索引擎喜爱的网站,专业的做网站团队,希望更多企业前来合作!

为了好理解，举个实际场景，我们业务场景中经常有限流的需求，常规操作是在需要限流的接口代码前加入调用次数判断的代码，但是这样每个需要限流的方法都需要加，工作量大不说，一方面不好维护，不能很清晰的知道每个接口限流值，另一方面，限流代码和业务代码堆叠在一起，也影响代码阅读。解法是做一套统一限流，一般好点的会有专门的接口限流平台，配置对应的接口名，设置限流值，直接就可以限流，实现方式就可以用动态代理。不修改原接口的实现，对接口进行增强。

动态代理的优势是实现无侵入式的代码扩展，做方法的增强;让你可以在不用修改源码的情况下，增强一些方法;在方法的前后你可以做你任何想做的事情(甚至不去执行这个方法就可以)。

静态代理

既然有动态，那一定有静态，说下区别吧，

静态：最大的区别是静态是编译期就决定了，在程序运行之前，代理类的.class文件已经存在了。被代理类是什么，代理类实现方式。

举个栗子：

我现在有个接口，是把Json字符串解析成Object 对象，接口如下：

 
 
 
 
    
  
  
  
  
  1. public interface IProvider { 
    2. 
  
  
  
  
  2.     
    3. 
  
  
  
  
  3.   Object getData(String json); 
    4. 
  
  
  
  
  4.    
    5. 
  
  
  
  
  5. } 
    6.

接口的实现类如下：

 
 
 
 
    
  
  
  
  
  1. public class SimpleProvider implements IProvider { 
    2. 
  
  
  
  
  2.     @Override 
    3. 
  
  
  
  
  3.     public Object getData(String json) { 
    4. 
  
  
  
  
  4.         //解析json 拿到数据 
    5. 
  
  
  
  
  5.         return parseJson(json); 
    6. 
  
  
  
  
  6.     } 
    7.

那现在有个需求，需要对 getData 方法做限流，指定用静态代理的方式。

需要很简单，我就直接贴了：

 
 
 
 
    
  
  
  
  
  1. public class ProviderProxy implements IProvider{ 
    2. 
  
  
  
  
  2.  
    3. 
  
  
  
  
  3.     //持有一个被代理对象的引用（在这里是SimpleProvider） 
    4. 
  
  
  
  
  4.     IProvider iProvider; 
    5. 
  
  
  
  
  5.  
    6. 
  
  
  
  
  6.     public StaticProviderProxy(IProvider iProvider){ 
    7. 
  
  
  
  
  7.         this.iProvider = iProvider; 
    8. 
  
  
  
  
  8.     } 
    9. 
  
  
  
  
  9.  
    10. 
  
  
  
  
  10.     @Override 
    11. 
  
  
  
  
  11.     public Object getData(String json) { 
    12. 
  
  
  
  
  12.         //做限流检查 
    13. 
  
  
  
  
  13.         if(callSpeed > flowLimt) { 
    14. 
  
  
  
  
  14.           //流量超限 
    15. 
  
  
  
  
  15.            throw FlowLimitException(); 
    16. 
  
  
  
  
  16.         } 
    17. 
  
  
  
  
  17.         Object object = iProvider.getData(json); 
    18. 
  
  
  
  
  18.         return object; 
    19. 
  
  
  
  
  19.     } 
    20. 
  
  
  
  
  20. } 
    21. 
  
  
  
  
  21. //main  
    22. 
  
  
  
  
  22. public static void main(String[] args) { 
    23. 
  
  
  
  
  23.   IProvider provider = new ProviderProxy(new SimpleProvider()); 
    24. 
  
  
  
  
  24.     provider.getData("{\"data\":{}}"); 
    25. 
  
  
  
  
  25. } 
    26.

这就是静态代理，代理类(ProviderProxy)实现和需要做方法增强的被代理类(SimpleProvider)实现同一个接口(IProvider)，方法具体实现上做增强，这里是限流检查。

动态代理

Java 动态代理

  • 动态代理类：在程序运行时，通过反射机制动态生成。
  • 动态代理类通常代理接口下的所有类。静态一般指定某个类代理。
  • 动态代理事先不知道要代理的是什么，只有在运行的时候才能确定。静态是编译期确定的。

还是以IProvider 接口为例，同样是要对 SimpleProvider 做增强，如下：

 
 
 
 
    
  
  
  
  
  1. public class ProviderHandler implements InvocationHandler { 
    2. 
  
  
  
  
  2.     Object target; 
    3. 
  
  
  
  
  3.  
    4. 
  
  
  
  
  4.     public Object bind(Object target){ 
    5. 
  
  
  
  
  5.         this.target = target; 
    6. 
  
  
  
  
  6.         //这里生成了代理对象 
    7. 
  
  
  
  
  7.         return Proxy.newProxyInstance(target.getClass().getClassLoader(), 
    8. 
  
  
  
  
  8.                 target.getClass().getInterfaces(), this); 
    9. 
  
  
  
  
  9.     } 
    10. 
  
  
  
  
  10.  
    11. 
  
  
  
  
  11.     @Override 
    12. 
  
  
  
  
  12.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
    13. 
  
  
  
  
  13.         //限流 
    14. 
  
  
  
  
  14.         flowLimit(args); 
    15. 
  
  
  
  
  15.         Object obj = method.invoke(target, args); 
    16. 
  
  
  
  
  16.         //打印日志 
    17. 
  
  
  
  
  17.         logger.info("print log..."); 
    18. 
  
  
  
  
  18.         return obj; 
    19. 
  
  
  
  
  19.     } 
    20. 
  
  
  
  
  20. } 
    21. 
  
  
  
  
  21. //main 
    22. 
  
  
  
  
  22. public static void main(String[] args) { 
    23. 
  
  
  
  
  23.    ProviderHandler providerHandler = new ProviderHandler(); 
    24. 
  
  
  
  
  24.    IProvider iProvider = (IProvider) providerHandler.bind(new SimpleProvider()); 
    25. 
  
  
  
  
  25.    iProvider.getData("weibo.data"); 
    26. 
  
  
  
  
  26. } 
    27.

这里有三个对象：

SimpleProvider 对象 , 我们称之为被代理对象

ProviderHandler 对象,我们称之为执行者对象

Proxy对象 (通过在ProviderHandler bind方法中使用Proxy.newProxyInstance生成的对象) 我们称之为代理对象

这三个对象是什么关系呢?

Proxy是真正的代理类，SimpleProvider是被代理类，ProviderHandler是执行方法增强的执行者。

我们是为了增强SimpleProvider (被代理对象)的getData方法，就Proxy对象来代理被代理对象的执行，Proxy不亲自来做这件事，而是交给执行者对象ProviderHandler 来实现增加的目录，执行调用前的限流校验。

实际怎么实现的呢?

newProxyInstance源码

 
 
 
 
    
  
  
  
  
  1. public static Object newProxyInstance(ClassLoader loader, 
    2. 
  
  
  
  
  2.                                           Class[] interfaces, 
    3. 
  
  
  
  
  3.                                           InvocationHandler h) 
    4. 
  
  
  
  
  4.         throws IllegalArgumentException 
    5. 
  
  
  
  
  5.     { 
    6. 
  
  
  
  
  6.         //对 Invocationhandler做判空处理 
    7. 
  
  
  
  
  7.         Objects.requireNonNull(h); 
    8. 
  
  
  
  
  8.         //复制[IProvider接口] 
    9. 
  
  
  
  
  9.         final Class[] intfs = interfaces.clone(); 
    10. 
  
  
  
  
  10.  
    11. 
  
  
  
  
  11.        //根据IProvider的类加载器IProvider接口生成了Proxy类,关键：根据类加载器和接口对象在JVM缓存中生成一个类对象 
    12. 
  
  
  
  
  12.         Class cl = getProxyClass0(loader, intfs); 
    13. 
  
  
  
  
  13.         //获取构造器 
    14. 
  
  
  
  
  14.         final Constructor cons = cl.getConstructor(constructorParams); 
    15. 
  
  
  
  
  15.         //保存InvocationHandler的引用 
    16. 
  
  
  
  
  16.         final InvocationHandler ih = h; 
    17. 
  
  
  
  
  17.         //通过构造器实例化Proxy代理对象 
    18. 
  
  
  
  
  18.         return cons.newInstance(new Object[]{h}); 
    19. 
  
  
  
  
  19.     } 
    20.

代码注释写的很清晰。

可能这个地方大家都会疑惑，生成的Proxy对象是怎样调用执行者的invoke函数的。

这个地方通过这段代码将Proxy0的class字节码输出到文件。

 
 
 
 
    
  
  
  
  
  1. byte[] classFile = ProxyGenerator.generateProxyClass("$Proxy0", WeiboProvider.class.getInterfaces()); 
    2. 
  
  
  
  
  2. String path = "C:**/IdeaProjects/study/out/production/study/SimpleProxy.class"; 
    3. 
  
  
  
  
  3. try(FileOutputStream fos = new FileOutputStream(path)) { 
    4. 
  
  
  
  
  4.     fos.write(classFile); 
    5. 
  
  
  
  
  5.     fos.flush(); 
    6. 
  
  
  
  
  6.     System.out.println("代理类class文件写入成功"); 
    7. 
  
  
  
  
  7.    } catch (Exception e) { 
    8. 
  
  
  
  
  8.      System.out.println("写文件错误"); 
    9. 
  
  
  
  
  9.  } 
    10.

反编译Proxy0如下：

 
 
 
 
    
  
  
  
  
  1. //Proxy0 是动态生成的类，继承自Proxy，实现了IProvider接口 
    2. 
  
  
  
  
  2. public final class $Proxy0 extends Proxy implements IProvider { 
    3. 
  
  
  
  
  3.     private static Method m1; 
    4. 
  
  
  
  
  4.     private static Method m2; 
    5. 
  
  
  
  
  5.     private static Method m3; 
    6. 
  
  
  
  
  6.     private static Method m0; 
    7. 
  
  
  
  
  7.  
    8. 
  
  
  
  
  8.     public $Proxy0(InvocationHandler var1) throws  { 
    9. 
  
  
  
  
  9.         super(var1); 
    10. 
  
  
  
  
  10.     } 
    11. 
  
  
  
  
  11.  
    12. 
  
  
  
  
  12.     public final boolean equals(Object var1) throws  { 
    13. 
  
  
  
  
  13.         try { 
    14. 
  
  
  
  
  14.             return ((Boolean)super.h.invoke(this, m1, new Object[]{var1})).booleanValue(); 
    15. 
  
  
  
  
  15.         } catch (RuntimeException | Error var3) { 
    16. 
  
  
  
  
  16.             throw var3; 
    17. 
  
  
  
  
  17.         } catch (Throwable var4) { 
    18. 
  
  
  
  
  18.             throw new UndeclaredThrowableException(var4); 
    19. 
  
  
  
  
  19.         } 
    20. 
  
  
  
  
  20.     } 
    21. 
  
  
  
  
  21.  
    22. 
  
  
  
  
  22.     public final String toString() throws  { 
    23. 
  
  
  
  
  23.         try { 
    24. 
  
  
  
  
  24.             return (String)super.h.invoke(this, m2, (Object[])null); 
    25. 
  
  
  
  
  25.         } catch (RuntimeException | Error var2) { 
    26. 
  
  
  
  
  26.             throw var2; 
    27. 
  
  
  
  
  27.         } catch (Throwable var3) { 
    28. 
  
  
  
  
  28.             throw new UndeclaredThrowableException(var3); 
    29. 
  
  
  
  
  29.         } 
    30. 
  
  
  
  
  30.     } 
    31. 
  
  
  
  
  31.  
    32. 
  
  
  
  
  32.     public final String getData(String var1) throws  { 
    33. 
  
  
  
  
  33.         try { 
    34. 
  
  
  
  
  34.             //m3就是IProvider 接口的getData方法  
    35. 
  
  
  
  
  35.             //super.h 是父类java.lang.reflect.Proxy的属性 InvocationHandler 
    36. 
  
  
  
  
  36.             return (String)super.h.invoke(this, m3, new Object[]{var1}); 
    37. 
  
  
  
  
  37.         } catch (RuntimeException | Error var3) { 
    38. 
  
  
  
  
  38.             throw var3; 
    39. 
  
  
  
  
  39.         } catch (Throwable var4) { 
    40. 
  
  
  
  
  40.             throw new UndeclaredThrowableException(var4); 
    41. 
  
  
  
  
  41.         } 
    42. 
  
  
  
  
  42.     } 
    43. 
  
  
  
  
  43.  
    44. 
  
  
  
  
  44.     public final int hashCode() throws  { 
    45. 
  
  
  
  
  45.         try { 
    46. 
  
  
  
  
  46.             return ((Integer)super.h.invoke(this, m0, (Object[])null)).intValue(); 
    47. 
  
  
  
  
  47.         } catch (RuntimeException | Error var2) { 
    48. 
  
  
  
  
  48.             throw var2; 
    49. 
  
  
  
  
  49.         } catch (Throwable var3) { 
    50. 
  
  
  
  
  50.             throw new UndeclaredThrowableException(var3); 
    51. 
  
  
  
  
  51.         } 
    52. 
  
  
  
  
  52.     } 
    53. 
  
  
  
  
  53.  
    54. 
  
  
  
  
  54.     static { 
    55. 
  
  
  
  
  55.         try { 
    56. 
  
  
  
  
  56.             m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[]{Class.forName("java.lang.Object")}); 
    57. 
  
  
  
  
  57.             m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]); 
    58. 
  
  
  
  
  58.             //m3就是IProvider 接口的getData方法 
    59. 
  
  
  
  
  59.             m3 = Class.forName("aop.IProvider").getMethod("getData", new Class[]{Class.forName("java.lang.String")}); 
    60. 
  
  
  
  
  60.             m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]); 
    61. 
  
  
  
  
  61.         } catch (NoSuchMethodException var2) { 
    62. 
  
  
  
  
  62.             throw new NoSuchMethodError(var2.getMessage()); 
    63. 
  
  
  
  
  63.         } catch (ClassNotFoundException var3) { 
    64. 
  
  
  
  
  64.             throw new NoClassDefFoundError(var3.getMessage()); 
    65. 
  
  
  
  
  65.         } 
    66. 
  
  
  
  
  66.     } 
    67. 
  
  
  
  
  67. } 
    68.

重点在 return (String)super.h.invoke(this, m3, new Object[]{var1});代码。

$Proxy0继承Proxy类，实现了IProvider接口，所以也有getData()函数，而getData函数调用的是执行者InvocationHandler的invoke方法，m3是通过反射拿到的Method对象，所以看getData调用invoke传递的。三个参数，第一个是Proxy对象，第二个是getData方法对象，第三个是参数。

总结一下：

  • 动态代理的本质就是，生成一个继承自Proxy，实现被代理接口(IProvider)的类 - Proxy0。
  • Proxy0 持有InvocationHandler实例，InvocationHandler 持有SimpleProvider实例。Proxy0调用接口 getData方法时，先传递给InvocationHandler，InvocationHandler再传递给SimpleProvider实例。

动态代理实际上就是帮我们在JVM内存中直接重新生成了代理类class和对应类对象，然后通过执行者InvocationHandler调用被代理对象SimpleProvider。

Spring AOP中的代理

Spring代理其实是对JDK动态代理和CGLIB代理进行了封装，并且引入了AOP的概念，同时引入了AspectJ中的一些注解：@pointCut @After 等。

 
 
 
 
    
  
  
  
  
  1. public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException { 
    2. 
  
  
  
  
  2.            if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) { 
    3. 
  
  
  
  
  3.    Class targetClass = config.getTargetClass(); 
    4. 
  
  
  
  
  4.    if (targetClass == null) { 
    5. 
  
  
  
  
  5.     throw new AopConfigException("TargetSource cannot determine target class: " + 
    6. 
  
  
  
  
  6.       "Either an interface or a target is required for proxy creation."); 
    7. 
  
  
  
  
  7.    } 
    8. 
  
  
  
  
  8.       // 如果是接口，使用jdk代理  
    9. 
  
  
  
  
  9.    if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) { 
    10. 
  
  
  
  
  10.     return new JdkDynamicAopProxy(config); 
    11. 
  
  
  
  
  11.    } 
    12. 
  
  
  
  
  12.       //否则使用cglib 
    13. 
  
  
  
  
  13.    return new ObjenesisCglibAopProxy(config); 
    14. 
  
  
  
  
  14.   } 
    15. 
  
  
  
  
  15.   else { 
    16. 
  
  
  
  
  16.    return new JdkDynamicAopProxy(config); 
    17. 
  
  
  
  
  17.   } 
    18. 
  
  
  
  
  18.  } 
    19.

本文名称：深入理解JDK动态代理
网址分享：http://www.shufengxianlan.com/qtweb/news42/541292.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

响应式网站知识

同城分类信息

崇州做网站　　 　响应式建站　　 　成都网络推广　　 　成都棕树电信机房　　 　乐山网站建设　　 　雨棚定制　　 　成都门户网站建设　　 　成都画册制作　　 　鸿艺文化　　 　成都定制网站　　 　网站制作　　 　崇州搬家公司　　 　电商网站建设方案　　 　成都网站建设　　 　网站设计制作　　 　电商网站　　 　小谭网创广告　　 　成都网站设计　　 　成都外贸网站建设公司　　 　绵阳网站制作公司