java 动态代理

1. /** 

2.  * 相亲接口 

3.  *  

4.  * @author zhengt 

5.  * @time Jun 3, 2095 3:13:03 PM 

6.  */  

7. public interface XiangQinInterface {  

8.     /** 

9.      * 相亲方法 

10.      */  

11.     public void xiangQin();  

12. }  

13. /** 

14.  * 张三相亲实现类 

15.  *  

16.  * @author zhengt 

17.  * @time Jun 3, 2095 3:14:48 PM 

18.  */  

19. public class ZhangSanXiangQinInterfaceImpl implements XiangQinInterface {  

20.     public void xiangQin() {  

21.         System.out.println("张三去相亲，娶个漂亮老婆。");  

22.     }  

23. }  

24. import java.lang.reflect.InvocationHandler;  

25. import java.lang.reflect.Method;  

26.   

27. /** 

28.  * 相亲可是一辈子的大事，相亲前要准备一下，打扮得帅气些。 

29.  *  

30.  * @author zhengt 

31.  * @time Jun 3, 2095 3:15:48 PM 

32.  */  

33. public class ReadyInvocationHandler implements InvocationHandler {  

34.     //相亲接口的实现类，也就是张三相亲类  

35.     private Object zhangSan = null;  

36.   

37.     public ReadyInvocationHandler(Object realSubject) {  

38.         this.zhangSan = realSubject;  

39.     }  

40.   

41.     public Object invoke(Object proxy, Method m, Object[] args) {  

42.         Object result = null;  

43.         try {  

44.             /** 

45.              * 动态代理类$Proxy0调用xiangQin方法时会调用它自己的xiangQin方法， 

46.              * 而它自己的xiangQin方法里面调用的是super.h.invoke(this, , )，也就是父类Proxy的h的invoke方法， 

47.              * 也就是ReadyInvocationHandler类的invoke方法。 

48.              * 所以，invoke(Object proxy, Method m, Object[] args)种的proxy实际上就是动态代理类$Proxy0， 

49.              * 如果你将其强转成XiangQinInterface然后调用它的xiangQin方法，然后它就会调用super.h.invoke(this, , )，这样就会死循环。 

50.              */  

51.             /** 

52.              * 网上关于这里最多问题就是Object proxy放在这里用来做什么呢？这个我也不知道， 

53.              * 不过至少我们知道它到底是个什么东西，具体做什么用嘛就不得而知了 

54.              */  

55.             System.out.println(proxy.getClass().getSimpleName());  

56.             System.out.println("张三相亲前，代理人给他打扮了打扮。");  

57.             result = m.invoke(zhangSan, args);  

58.         } catch (Exception ex) {  

59.             System.exit(1);  

60.         }  

61.         return result;  

62.     }  

63. }  

64. import java.lang.reflect.InvocationHandler;  

65. import java.lang.reflect.Method;  

66. import java.lang.reflect.Proxy;  

67.   

68. /** 

69.  * 张三来到了婚介所(相亲现场)，开始相亲。 

70.  *  

71.  * @author zhengt 

72.  * @time Jun 3, 2095 3:17:16 PM 

73.  */  

74. public class HunJieSuo {  

75.     public static void main(String args[]) {  

76.         //先将张三相亲这个相亲的实现类实例化，也就是得到XiangQinInterface接口的一个实例对象  

77.         XiangQinInterface zhangSan = new ZhangSanXiangQinInterfaceImpl();  

78.         /** 

79.          * 得到ZhangSanXiangQinInterfaceImpl这个类的一个代理类，同时为代理类绑定了一个处理类ReadyInvocationHandler。 

80.          * 听着很绕口，其实就是每次调用ZhangSanXiangQinInterfaceImpl这个子类的xiangQin方法时， 

81.          * 不是zhangSan这个ZhangSanXiangQinInterfaceImpl类的实例去调用， 

82.          * 而是这个ZhangSanXiangQinInterfaceImpl的代理类ReadyInvocationHandler去调用它自己的invoke方法, 

83.          * 这个invoke方法里呢可以调用zhangSan这个实例的xiangQin方法 

84.          */  

85.         /** 

86.          * 在java种怎样实现动态代理呢 

87.          * 第一步，我们要有一个接口，还要有一个接口的实现类，而这个实现类呢就是我们要代理的对象， 

88.          * 所谓代理呢也就是在调用实现类的方法时，可以在方法执行前后做额外的工作，这个就是代理。 

89.          * 第二步，我们要自己写一个在要代理类的方法执行时，能够做额外工作的类，而这个类必须继承InvocationHandler接口， 

90.          * 为什么要继承它呢？因为代理类的实例在调用实现类的方法的时候，不会调真正的实现类的这个方法， 

91.          * 而是转而调用这个类的invoke方法（继承时必须实现的方法），在这个方法中你可以调用真正的实现类的这个方法。 

92.          * 第三步，在要用代理类的实例去调用实现类的方法的时候，写出下面两段代码。 

93.          */  

94.         XiangQinInterface proxy = (XiangQinInterface) Proxy.newProxyInstance(  

95.                 zhangSan.getClass().getClassLoader(),  

96.                 zhangSan.getClass().getInterfaces(),  

97.                 new ReadyInvocationHandler(zhangSan));  

98.         proxy.xiangQin();  

99.         /** 

100.          * 这里要解释下中部那段长长的代码的意思，以及具体做了哪些工作？ 

101.          * 第一，根据zhangSan.getClass().getClassLoader()这个要代理类的类加载器和 

102.          * zhangSan.getClass().getInterfaces()要代理类所实现的所有的接口 

103.          * 作为参数调用Proxy.getProxyClass(ClassLoader loader, Class<?>... interfaces) 

104.          * 的方法返回代理类的java.lang.Class对象，也就是得到了java动态生成的代理类$Proxy0的Class对象。 

105.          * 同时，java还让这个动态生成的$Proxy0类实现了要代理类的实现的所有接口，并继承了Proxy接口。 

106.          * 第二，实例化这个动态生成的$Proxy0类的一个实例，实例化代理类的构造函数为Proxy(InvocationHandler h)， 

107.          * 也就是说要实例化这个动态生成的$Proxy0类，必须给它一个InvocationHandler参数，也就是我们自己实现的用来在代理类 

108.          * 方法执行前后做额外工作的类ReadyInvocationHandler。 

109.          * 这段代码Proxy.newProxyInstance(zhangSan.getClass().getClassLoader(),zhangSan.getClass().getInterfaces(),new ReadyInvocationHandler(zhangSan)) 

110.          * 得到的其实是一个类名叫$Proxy0 extends Proxy implements XiangQinInterface的类。 

111.          * 第三，将这个$Proxy0类强制转型成XiangQinInterface类型，调用xiangQin方法。 

112.          */  

113.     }  

114. }  

网上看到一个牛人读过这个动态代理的源代码，现把网址留在这里，希望对网友们有帮助。
http://hi.baidu.com/malecu/blog/item/45d4952b31bc0e27d52af17a.html
我靠，0:21了，抽烟睡觉了。