黑马程序员技术交流社区

标题: 大家学了高新技术里面的动态代理了吗 哎谁能给我讲讲 [打印本页]

作者: 沙漠里的小鱼    时间: 2013-2-2 23:00
标题: 大家学了高新技术里面的动态代理了吗 哎谁能给我讲讲
本帖最后由 张向辉 于 2013-2-5 12:26 编辑

我不太理解啊  求高手指点一下
作者: 铿锵科技    时间: 2013-2-2 23:38
我也不是很明白。求指教
作者: 杨浩    时间: 2013-2-3 00:08
  1. //这个是被代理类的接口
  2. public interface XiangQinInterface {
  3.     public void xiangQin();  
  4. }  
  5. /**
  6. * 张三相亲实现类,这个是被代理类
  7. */  
  8. public class ZhangSanXiangQinInterfaceImpl implements XiangQinInterface {  
  9.     public void xiangQin() {  
  10.         System.out.println("张三去相亲,娶个漂亮老婆。");  
  11.     }  
  12. }  
  13. import java.lang.reflect.InvocationHandler;  
  14. import java.lang.reflect.Method;  
  15.   
  16. //这个InvocationHandler你可以把它理解成Java用来对代理对象的限制
  17. public class ReadyInvocationHandler implements InvocationHandler {  
  18.     private Object zhangSan = null;  
  19.     public ReadyInvocationHandler(Object realSubject) {  
  20.         this.zhangSan = realSubject;  
  21.     }  
  22.         //继承了InvocationHandler,必须要覆盖的方法
  23.     public Object invoke(Object proxy, Method m, Object[] args) {  
  24.         Object result = null;  
  25.         try {  
  26.             /**
  27.              * 动态代理类$Proxy0调用xiangQin方法时会调用它自己的xiangQin方法,
  28.              * 而它自己的xiangQin方法里面调用的是super.h.invoke(this, , ),也就是父类Proxy的h的invoke方法,
  29.              * 也就是ReadyInvocationHandler类的invoke方法。
  30.              * 所以,invoke(Object proxy, Method m, Object[] args)种的proxy实际上就是动态代理类$Proxy0,
  31.              * 如果你将其强转成XiangQinInterface然后调用它的xiangQin方法,然后它就会调用super.h.invoke(this, , ),这样就会死循环。
  32.              */  
  33.             /**
  34.              * 上面这一点是原例子上的注释,在我看来,需要弄的很清楚,你还需要去看API
  35.              * 你要关注的是在这个方法体里面,写上代理类的实际操作,而第二个方法参数的调用,传入被代理对象,就会执行被代理对象的方法了。
  36.              */  
  37.             System.out.println(proxy.getClass().getSimpleName());  
  38.             System.out.println("张三相亲前,代理人给他打扮了打扮。");  
  39.             result = m.invoke(zhangSan, args);  
  40.         } catch (Exception ex) {  
  41.             System.exit(1);  
  42.         }  
  43.         return result;  
  44.     }  
  45. }  
  46. import java.lang.reflect.InvocationHandler;  
  47. import java.lang.reflect.Method;  
  48. import java.lang.reflect.Proxy;  
  49.   
  50. public class HunJieSuo {  
  51.     public static void main(String args[]) {  
  52.         //将要被代理的对象,就是真正的主体
  53.         XiangQinInterface zhangSan = new ZhangSanXiangQinInterfaceImpl();  
  54.         /**
  55.          * 得到ZhangSanXiangQinInterfaceImpl这个类的一个代理类,同时为代理类绑定了一个处理类ReadyInvocationHandler。
  56.          * 听着很绕口,其实就是每次调用ZhangSanXiangQinInterfaceImpl这个子类的xiangQin方法时,
  57.          * 不是zhangSan这个ZhangSanXiangQinInterfaceImpl类的实例去调用,
  58.          * 而是这个ZhangSanXiangQinInterfaceImpl的代理类ReadyInvocationHandler去调用它自己的invoke方法,
  59.          * 这个invoke方法里呢可以调用zhangSan这个实例的xiangQin方法
  60.          */  
  61.         /**
  62.          * 在java种怎样实现动态代理呢
  63.          * 第一步,我们要有一个接口,还要有一个接口的实现类,而这个实现类呢就是我们要代理的对象,
  64.          * 所谓代理呢也就是在调用实现类的方法时,可以在方法执行前后做额外的工作,这个就是代理。
  65.          * 第二步,我们要自己写一个在要代理类的方法执行时,能够做额外工作的类,而这个类必须继承InvocationHandler接口,
  66.          * 为什么要继承它呢?因为代理类的实例在调用实现类的方法的时候,不会调真正的实现类的这个方法,
  67.          * 而是转而调用这个类的invoke方法(继承时必须实现的方法),在这个方法中你可以调用真正的实现类的这个方法。
  68.          * 第三步,在要用代理类的实例去调用实现类的方法的时候,写出下面两段代码。
  69.          */  
  70.                  
  71.                  //这里,通过Java的Proxy类的静态方法,创建代理类,参数需要的就是被代理类的类加载器,接口,还有上面创建的InvocationHandler的子类对象(里面包含代理对象要做的事情,但是它的行为是被Java内部限制着的)
  72.         XiangQinInterface proxy = (XiangQinInterface) Proxy.newProxyInstance(  
  73.                 zhangSan.getClass().getClassLoader(),  
  74.                 zhangSan.getClass().getInterfaces(),  
  75.                 new ReadyInvocationHandler(zhangSan));  
  76.         proxy.xiangQin();  
  77.         /**
  78.          * 这里要解释下中部那段长长的代码的意思,以及具体做了哪些工作?
  79.          * 第一,根据zhangSan.getClass().getClassLoader()这个要代理类的类加载器和
  80.          * zhangSan.getClass().getInterfaces()要代理类所实现的所有的接口
  81.          * 作为参数调用Proxy.getProxyClass(ClassLoader loader, Class<?>... interfaces)
  82.          * 的方法返回代理类的java.lang.Class对象,也就是得到了java动态生成的代理类$Proxy0的Class对象。
  83.          * 同时,java还让这个动态生成的$Proxy0类实现了要代理类的实现的所有接口,并继承了Proxy接口。
  84.          * 第二,实例化这个动态生成的$Proxy0类的一个实例,实例化代理类的构造函数为Proxy(InvocationHandler h),
  85.          * 也就是说要实例化这个动态生成的$Proxy0类,必须给它一个InvocationHandler参数,也就是我们自己实现的用来在代理类
  86.          * 方法执行前后做额外工作的类ReadyInvocationHandler。
  87.          * 这段代码Proxy.newProxyInstance(zhangSan.getClass().getClassLoader(),zhangSan.getClass().getInterfaces(),new ReadyInvocationHandler(zhangSan))
  88.          * 得到的其实是一个类名叫$Proxy0 extends Proxy implements XiangQinInterface的类。
  89.          * 第三,将这个$Proxy0类强制转型成XiangQinInterface类型,调用xiangQin方法。
  90.          */  
  91.     }  
  92. }
复制代码
动态代理是不太好理解,我也不敢说自己弄明白了,而且弄明白了的意思仅仅是会用,这里还有一个不错的解说,你可以参考下。
还有更多的人来讨论,一起把这个难点搞定,期待高手来用通俗的语言来讲解下。
http://paddy-w.iteye.com/blog/841798 参考地址


作者: 沙漠里的小鱼    时间: 2013-2-3 19:37
杨浩 发表于 2013-2-3 00:08
动态代理是不太好理解,我也不敢说自己弄明白了,而且弄明白了的意思仅仅是会用,这里还有一个不错的解说, ...

哎 谢谢啊  有高手来讲讲吗




欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2