经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置:技术经验 » Java相关 » Java » 查看文章
Java JDK动态代理Proxy类的原理是什么? - 知乎(重排版)
来源:cnblogs  作者:chentnt  时间:2018/10/16 9:40:25  对本文有异议

本文转载自知乎问题Java JDK动态代理Proxy类的原理是什么?下用户@胖君回答

  1. 什么是代理?

先从代理开始讲。
代理这种设计模式其实很好理解,基本就是最简单的一个 “组合”。比如说下面这个例子,我们有 A 这个类,本来可以直接调用 A 类的 foo() 方法。但代理模式就非要把 A 类当成 B 类的一个成员字段放在 B 类里面。然后因为 A 类和 B 类都实现了 Interface 这个接口,所以 B 类里也有 foo()方法。而且 B 类里的 foo()方法就是傻瓜式的调用 A 类的 foo()方法。

  1. interface Interface{public void foo();}
  2. /**委托类*/
  3. class A implements Interface{
  4. public void foo(){System.out.println("Method a of class A!");}
  5. }
  6. /**代理类*/
  7. class B implements Interface{
  8. public A a=new A();
  9. public void foo(){a.foo();}
  10. }
  11. /**用户*/
  12. class Consumer{
  13. public static void consum(Interface i){
  14. i.foo();
  15. }
  16. }
  17. /**测试*/
  18. public class TestProxy{
  19. public static void main(String[] args){
  20. Interface i=new B();
  21. Consumer.consum(i);
  22. }
  23. }
  1. 代理有什么好处?

乍一看,代理方法完全是多此一举,B 类的行为和 A 类完全一样,没有任何意义。但实际上,B 类的 foo() 方法在直接调用 A 类 foo() 方法之前和之后,可以做很多事情。举个例子,如果在 B 类里加个静态计数字段 count,然后每次调用 foo() 方法之后都计一下数,就可以监控 A 类 foo() 方法被调用的次数。

  1. class B implements Interface{
  2. public static long count=0;
  3. public A a=new A();
  4. public void foo(){a.foo();count++;}
  5. }

所以代理类里能非常好地控制,辅助被代理类,甚至是增加额外的功能。而且一般来说代理类 B 和被代理 A 都会实现同样的接口,这样对用户端(就是上面例子里的 Consumer 类)的代码没有任何影响,耦合很低。

  1. 什么是动态代理?

上面例子里在 A 类外面套一个 B 类好像很简单,但实际到了工程级别的代码,需要代理的就不止一个两个了。每个代理类都手动写会累死,而且很枯燥,是没有技术含量的重复。所以这个时候 Java 的反射功能就立功了。代理类 B 是可以完全用反射动态生成的。
怎么动态生成 B 类呢?下面有个例子,通过反射动态加载 B 类,然后调用 B 类的 foo() 方法。

  1. public class TestDynamicProxy{
  2. public static void main(String[] args){
  3. try{
  4. Class<?> refB=B.class;
  5. Method refFoo=refB.getDeclaredMethod("foo");
  6. Object refObj=refB.newInstance();
  7. refFoo.invoke(refObj);
  8. }catch(Exception e){
  9. System.out.println(e);
  10. }
  11. }
  12. }
  1. B.class 获得了 B 类的 Class 对象。
  2. Class#getDeclaredMethod() 方法根据方法的名称"foo"获得了 foo() 方法的 Method 对象。
  3. 最后调用这个 Method 对象的 invoke() 来执行这个方法。

但这个是动态生成吗?明显不是!上面这个方法只是在 B 类已经写好了的情况下动态调用 B 类。其实并没有动态生成 B 类,根本不能叫动态生成。真的要完全凭空用反射 “写” 一个 B 类的字节码文件出来然后加载它,其实要复杂地多,这就是为什么需要 Proxy 工具来替我们做的原因。

4.Proxy 类怎么实现动态代理?

Proxy 类里能替我们生成一个代理类对象的,就是 newProxyInstance() 方法。现在回过头看它的三个参数,

  1. newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)
  1. 第一个 ClassLoader 是为了生成 B 类的 Class 对象。作用是根据一组类的字节码 byte[] 直接生成这个类的 Class 对象。
  2. 第二个参数是由委托类实现的接口的 Class 对象数组。主要是包含了最重要的代理类需要实现的接口方法的信息。
  3. 最后一个最重要的就是一个实现了 InvocationHandler 接口的对象。InvocationHandler 接口在 java.lang.reflect 包里。最主要的就是定义了 invoke( ) 方法。它就是假设在已经动态生成了最后的 proxy 代理对象,以及所有接口定义的方法 Method 对象以及方法的参数的情况下,定义我们要怎么调用这些方法的地方。

这三个参数的分工用大白话讲就是:第一参数 ClassLoader 和第二参数接口的 Class 对象是用来动态生成委托类的包括类名,方法名,继承关系在内的一个空壳。用 B 类的例子演示就像下面这样,

  1. class $ProxyN implements Interface{
  2. public void foo(){
  3. //do something...
  4. }
  5. }

只有接口定义的方法名,没有实际操作。实际的操作是交给第三个参数 InvocationHandlerinvoke() 方法来执行。

所以最主要的业务逻辑应该是在第三个参数 InvocationHandlerinvoke() 方法里定义。下面代码,是根据之前 A 类 B 类的例子用 Proxy 类实现动态代理的 Demo。代码里原先的 B 类被擦掉了,完全由 Proxy 类动态生成。

  1. interface Interface{public void foo();}
  2. class A implements Interface{
  3. public void foo(){System.out.println("Method a of class A!");}
  4. }
  5. /* //这是Proxy要动态生成的B类。
  6. class B implements Interface{
  7. public void foo(){a.foo();}
  8. public A a=new A();
  9. }
  10. */
  11. class Consumer{
  12. public static void consum(Interface i){
  13. i.foo();
  14. }
  15. }
  16. class DynamicProxyHandler implements InvocationHandler {
  17. private Object proxied;
  18. public DynamicProxyHandler(Object proxied) {
  19. this.proxied = proxied;
  20. }
  21. public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  22. try{
  23. return method.invoke(proxied, args);
  24. }catch(Exception e){
  25. System.out.println(e);
  26. return null;
  27. }
  28. }
  29. }
  30. public class TestDynamicProxy{
  31. public static void main(String[] args){
  32. A a=new A();
  33. //直接把A类对象a当参数传进去,就动态产生一个代理类对象
  34. Interface proxy = (Interface)Proxy.newProxyInstance(Interface.class.getClassLoader(), new Class<?>[]{Interface.class }, new DynamicProxyHandler(a));
  35. Consumer.consum(proxy);
  36. }
  37. }

在实现了 InvocationHandler 接口的 DynamicProxyHandler 类里有一个被代理类的对象 proxied 作为成员字段。在获得了参数传进来的代理类对象和 Method 对象之后,直接用 Method#invoke(Object o) 方法,调用了代理类对象的方法。第一个参数 ClassLoader 直接用的是 Interface 接口的类加载器 (Interface.class.getClassLoader())。第二参数就是 Interface 接口的 Class 对象。

然后,剩下的事就交给 Proxy 来完成。关键的难点在于怎么根据给定的 ClassLoader 和接口的方法信息动态生成一个所谓 “空壳”。其实 newProxyInstance() 方法隐藏了非常多其他的复杂性,比如说访问权限检查,包路径设置,安全检查等等琐碎的事,但这里先不说。只说核心步骤。

下面截取 newProxyInstance() 方法源码里比较重要的一段贴上来,看看底层是怎么实现的。

  1. /*
  2. * Choose a name for the proxy class to generate.
  3. */
  4. long num;
  5. synchronized (nextUniqueNumberLock) {
  6. num = nextUniqueNumber++;
  7. }
  8. String proxyName = proxyPkg + proxyClassNamePrefix + num;
  9. /*
  10. * Generate the specified proxy class.
  11. */
  12. byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
  13. proxyName, interfaces);
  14. try {
  15. proxyClass = defineClass0(loader, proxyName, proxyClassFile, 0, proxyClassFile.length);
  16. } catch (ClassFormatError e) {
  17. throw new IllegalArgumentException(e.toString());
  18. }

可以看到,proxyName 是动态生成的代理类的名称,一般是 ·$ProxyN 的格式。N 代表代理是 N 次生成动态代理。

然后见证奇迹的时刻到了,关键的核心步骤有两个:

  1. ProxyGenerator.generateProxyClass() 方法生成了类加载器要用到的字节码。它需要的参数只有两个,1)类名,2)实现的接口的 Class 对象。然后它就神奇地生成了一堆字节码 byte[],基本就是一个凭空造出来的编译好的. class 文件。这个方法来自神秘的 sun.misc 包。也查不到源码。
  2. 最后神秘的字节码和加载器,以及类名一起被交到另一个 native 方法 defineClass0( ) 里,由它生成代理类的 Class 对象。至于 native 方法怎么实现,源码里也查不到。

最后再总结一下,使用 Proxy 的三步,

  1. 在第三个参数,实现 InvocationHandler 接口的对象的 invoke() 方法里写业务逻辑。
  2. 第二个参数是代理实现接口的 Class 对象
  3. 第一个参数是一个 ClassLoader。一般直接用调用类的加载器

如果实在想知道鬼畜的 ProxyGenerator.generateProxyClass()的内部原理,就看谁能把人肉源码机 R 大 @RednaxelaFX 召唤出来了,哈哈:v

 友情链接:直通硅谷  点职佳  北美留学生论坛

本站QQ群:前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

W3xue 的所有内容仅供测试,对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接(目前9元/月)请联系QQ:27243702 沸活量
皖ICP备17017327号-2 皖公网安备34020702000426号