使用Proxy反射类实现AOP动态代理技术

Spring框架实现了AOP技术，但是，在没有支持框架的情况下，仅仅使用JDK 的反射包，还是可以实现AOP的。也

就是说，对于一个类，可以对其所有的方法进行反射控制拦截权限，然后决定是否允许调用，下面我们来写一个这样的

实现的例子。

首先建立一个接口，

[java] view plain copy print?

1. package com.bird.service;  
2.   
3. public interface PersonService {  
4.       
5.     public void save(String name);  
6.     public void update(String name, Integer personid);  
7.     public String getPersonName(Integer personid);  
8. }  

然后写一个实现这个接口的实现类

[java] view plain copy print?

1. package com.bird.service.impl;  
2.   
3. import com.bird.service.PersonService;  
4.   
5. public class PersonServiceBean implements PersonService {  
6.     private String user = null;  
7.   
8.     public String getUser() {  
9.         return user;  
10.     }  
11.   
12.     public PersonServiceBean() {  
13.     }  
14.   
15.     public PersonServiceBean(String user) {  
16.         this.user = user;  
17.     }  
18.   
19.     @Override  
20.     public void save(String name) {  
21.         System.out.println("我是save()方法");  
22.   
23.     }  
24.   
25.     @Override  
26.     public void update(String name, Integer personid) {  
27.         System.out.println("我是uodate()方法");  
28.     }  
29.   
30.     @Override  
31.     public String getPersonName(Integer personid) {  
32.         System.out.println("我是getPersonName()方法");  
33.         return "xxx";  
34.     }  
35.   
36. }  

下面就是最重要的构建反射类工厂的代码了

[java] view plain copy print?

1. package com.bird.aop;  
2.   
3. import java.lang.reflect.InvocationHandler;  
4. import java.lang.reflect.Method;  
5. import java.lang.reflect.Proxy;  
6.   
7. import com.bird.service.impl.PersonServiceBean;  
8.   
9. /** 
10.  * 使用proxy实现方法的拦截 
11.  * @author Bird 
12.  * 
13.  */  
14. public class JDKProxyFactory implements InvocationHandler{  
15.       
16.     private Object targetObject;  
17.       
18.     public Object creatProxyInstance(Object targetObject){  
19.         this.targetObject = targetObject;  
20.         return Proxy.newProxyInstance(this.targetObject.getClass().getClassLoader(),  
21.                 this.targetObject.getClass().getInterfaces(), this);  
22.     }  
23.   
24.     @Override  
25.     public Object invoke(Object proxy, Method method, Object[] args)  
26.             throws Throwable {  
27.         PersonServiceBean bean = (PersonServiceBean)this.targetObject;  
28.         Object result = null;  
29.         if(bean.getUser() != null){  
30.             result = method.invoke(targetObject, args);  
31.         }  
32.         return result;  
33.     }  
34. }  

首先把需要反射的类传进来，然后使用proxy创建这个类实例和实现这个类的所有接口，最后是一个回调，调用factory

工厂的一个实现方法。这个方法里面来判断是否满足权限控制条件，如果满足，就将调用请求发送给具体的类，然后

执行相应的方法，如果不满足，返回空，也就是不能执行任何方法。

测试情况如下

[java] view plain copy print?

1. package junit.test;  
2.   
3. import org.junit.Test;  
4.   
5. import com.bird.aop.JDKProxyFactory;  
6. import com.bird.service.PersonService;  
7. import com.bird.service.impl.PersonServiceBean;  
8.   
9. public class AOPTest {  
10.       
11.     @Test  
12.     public void test(){  
13.         JDKProxyFactory factory = new JDKProxyFactory();  
14.         PersonService service = (PersonService)factory.creatProxyInstance(new PersonServiceBean());  
15.         service.getPersonName(123);  
16.     }  
17. }  

因为工厂创建的类已经实现了接口，所以可以直接使用接口调用。整体来说，使用JDk 的Proxy方法还是非常简单

的。