Java Dynamic Agent

2. /**

4. * Blind Date interface

6.  * 

8. * @author zhengt

10. * @time June 3, 2095 3:13:03 PM

12.  */

14. Public Interface Xiangqininterface {

16. /**

18. * Method of Blind Date

20.      */

22. Public void xiangqin ();

24. }

26. /**

28. * Zhang San Blind Date realization class

30.  * 

32. * @author zhengt

34. * @time June 3, 2095 3:14:48 PM

36.  */

38. Public class Zhangsanxiangqininterfaceimpl implements Xiangqininterface {

40. Public void Xiangqin () {

42. System.out.println ("Zhang San to a blind date, marry a beautiful wife." ");

44. }

46. }

48. import Java.lang.reflect.InvocationHandler;

50. import Java.lang.reflect.Method;

54. /**

56. * Blind Date is a lifelong event, before a blind date to prepare, dressed up handsome.

58.  * 

60. * @author zhengt

62. * @time June 3, 2095 3:15:48 PM

64.  */

66. Public class Readyinvocationhandler implements Invocationhandler {

68. ///Blind Date interface implementation class, that is, Zhang San Blind Date class

70. Private Object Zhangsan = null;

74. Public Readyinvocationhandler (Object realsubject) {

76. this. Zhangsan = Realsubject;

78. }

82. Public Object Invoke (object proxy, Method m, object[] args) {

84. Object result = null;

86. Try {

88. /**

90. * Dynamic proxy class $proxy0 calls its own Xiangqin method when calling the Xiangqin method,

92. * and its own Xiangqin method is called the Super.h.invoke (this,), that is, the parent proxy of the H invoke method,

94. * This is the Invoke method of the Readyinvocationhandler class.

96. * So, the proxy of Invoke (Object Proxy, Method m, object[] args) is actually a dynamic proxy class $proxy0,

98. * If you turn it into Xiangqininterface and then call its Xiangqin method, then it will call Super.h.invoke (this,,), so it will die loop.

100.              */

102. /**

104. * Online about the most problem here is the object proxy put here to do what? I don't know about this, either.

106. * But at least we know what it is, and what it does, it's unclear.

108.              */

110. System.out.println (Proxy.getclass (). Getsimplename ());

112. System.out.println ("Zhang San before the blind date, the agent dressed him up." ");

114. result = M.invoke (Zhangsan, args);

116. } catch (Exception ex) {

118. System.exit (1);

120. }

122. return result;

124. }

126. }

128. import Java.lang.reflect.InvocationHandler;

130. import Java.lang.reflect.Method;

132. import java.lang.reflect.Proxy;

136. /**

138. * Zhang San came to the dating agency (blind Spot) and began a blind date.

140.  * 

142. * @author zhengt

144. * @time June 3, 2095 3:17:16 PM

146.  */

148. Public class Hunjiesuo {

150. Public Static void Main (String args[]) {

152. ///Zhang San a blind date the implementation class instantiation of the matchmaking, that is, to get an instance object of the Xiangqininterface interface

154. Xiangqininterface Zhangsan = new Zhangsanxiangqininterfaceimpl ();

156. /**

158. * Get Zhangsanxiangqininterfaceimpl a proxy class for this class, and bind a handler class Readyinvocationhandler for the proxy class.

160. * Listen very much to the mouth, in fact, every time you call Zhangsanxiangqininterfaceimpl this subclass of the Xiangqin method,

162. * Not Zhangsan This instance of the Zhangsanxiangqininterfaceimpl class to invoke,

164. * But this Zhangsanxiangqininterfaceimpl proxy class Readyinvocationhandler to invoke its own Invoke method,

166. * In this invoke method, you can call the Xiangqin method of this instance of Zhangsan

168.          */

170. /**

172. * How to implement dynamic Proxy in Java?

174. * The first step, we have an interface, there is an interface implementation class, and this implementation class is the object we want to proxy,

176. * The so-called Proxy is called the implementation of the method of the class, you can do before and after the method execution of extra work, this is the proxy.

178. * The second step is to write ourselves a class that can do extra work when the method of the proxy class is executed, and this class must inherit the Invocationhandler interface.

180. * Why do you inherit it? Because an instance of the proxy class does not tune the actual implementation of this method of the class when invoking the method of implementing the class,

182. instead, call the Invoke method of the class (the method that must be implemented when inheriting), in which you can invoke the method of the real implementation class.

184. * The third step, when you want to use the proxy class instance to invoke the implementation of the method of the class, write down the following two pieces of code.

186.          */

188. Xiangqininterface proxy = (xiangqininterface) proxy.newproxyinstance (

190. Zhangsan.getclass (). getClassLoader (),

192. Zhangsan.getclass (). Getinterfaces (),

194. New Readyinvocationhandler (Zhangsan));

196. Proxy.xiangqin ();

198. /**

200. * Here to explain the meaning of the long-length code in the middle, and what exactly did it work?

202. * First, according to Zhangsan.getclass (). getClassLoader () This class loader to proxy classes and

204. * Zhangsan.getclass (). Getinterfaces () All interfaces to be implemented by the proxy class

206. * Call Proxy.getproxyclass as a parameter (ClassLoader loader, class<?> .... interfaces)

208. the * method returns the Java.lang.Class object of the proxy class, which is the class object that the Java dynamically generated proxy class $proxy0.

210. * At the same time, Java also allows the dynamically generated $PROXY0 class to implement all interfaces for the implementation of the proxy class, and inherits the proxy interface.

212. * Second, instantiate an instance of the dynamically generated $proxy0 class, and instantiate the proxy class's constructor as a proxy (Invocationhandler h),

214. * That is, to instantiate the dynamically generated $proxy0 class, you must give it a invocationhandler parameter, which we implement ourselves to use in the proxy class

216. * The class Readyinvocationhandler to do extra work before and after the method is performed.

218. * This Code proxy.newproxyinstance (Zhangsan.getclass (). getClassLoader (), Zhangsan.getclass (). Getinterfaces (), New Re Adyinvocationhandler (Zhangsan))

220. * Get is actually a class called $proxy0 extends Proxy implements Xiangqininterface class.

222. * Third, the $proxy0 class is forced into the xiangqininterface type, calling the Xiangqin method.

224.          */

226. }

228. }

Online to see a cow people read this dynamic agent source code, now the Web site to stay here, I hope to help friends.
Http://hi.baidu.com/malecu/blog/item/45d4952b31bc0e27d52af17a.html
It's 0:21 and I'm smoking and sleeping.

Java Dynamic Agent