jdk 动态代理

-- Spring AOP的根基是动态代理。(或者说动态AOP的根基是动态代理，这种AOP会在程序运行过程中在内存中生成代理类的字节码。AspectJ在编译阶段就会将Advice一同编译进Target，属于静态AOP)
-- 动态代理有两种方式：

     -- JDK动态代理：需要被代理类实现接口
      -- CGLIB动态代理：通过继承方式实现，不需要实现接口
-- 下面的内容，从JDK动态代理的使用到其实现原理做了研究。
-- JDK动态代理中涉及到了Java的Reference类： java.lang.ref.Reference 。对于 Reference类在别的文章中另做总结。

--  先看如何使用：

Java代码

1. package dynamic.proxy;   
2.   
3. import java.lang.reflect.InvocationHandler;  
4. import java.lang.reflect.Method;  
5. import java.lang.reflect.Proxy;  
6.   
7.   
8. public class MyInvocationHandler implements InvocationHandler {  
9.       
10.     // 目标对象   
11.     private Object target;  
12.       
13.       
14.     public MyInvocationHandler(Object target) {  
15.         super();  
16.         this.target = target;  
17.     }  
18.   
19.   
20.       
21.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {  
22.           
23.         // 在目标对象的方法执行之前简单的打印一下  
24.         System.out.println("------------------before------------------");  
25.           
26.         // 执行目标对象的方法  
27.         Object result = method.invoke(target, args);  
28.           
29.         // 在目标对象的方法执行之后简单的打印一下  
30.         System.out.println("-------------------after------------------");  
31.           
32.         return result;  
33.     }  
34.   
35.       
36.     public Object getProxy() {  
37.         return Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),   
38.                 target.getClass().getInterfaces(), this);  
39.     }  
40. }  
41.   
42. package dynamic.proxy;  
43.   
44.   
45. public interface UserService {  
46.   
47.       
48.     public abstract void add();  
49.   
50. }  
51.   
52. package dynamic.proxy;   
53.   
54.   
55. public class UserServiceImpl implements UserService {  
56.   
57.       
58.     public void add() {  
59.         System.out.println("--------------------add---------------");  
60.     }  
61. }  
62.   
63. package dynamic.proxy;   
64.   
65. import org.junit.Test;  
66.   
67.   
68. public class ProxyTest {  
69.   
70.     @Test  
71.     public void testProxy() throws Throwable {  
72.         // 实例化目标对象  
73.         UserService userService = new UserServiceImpl();  
74.           
75.         // 实例化InvocationHandler  
76.         MyInvocationHandler invocationHandler = new MyInvocationHandler(userService);  
77.           
78.         // 根据目标对象生成代理对象  
79.         UserService proxy = (UserService) invocationHandler.getProxy();  
80.           
81.         // 调用代理对象的方法  
82.         proxy.add();  
83.           
84.     }  
85. }  

执行结果如下：
------------------before------------------
--------------------add---------------
-------------------after------------------

       用起来是很简单吧，其实这里基本上就是AOP的一个简单实现了，在目标对象的方法执行之前和执行之后进行了增强。Spring的AOP实现其实也是用了Proxy和InvocationHandler这两个东西的。