AOP示例(再续)

java.lang.reflect.Proxy 、java.lang.reflect.InvocationHandler

不知道怎么去解释了，如果使用Proxy 获取一个类的实例，那么在调用这个类的方法前会先执行InvocationHandler 的invoke方法，那么我们就可以利用这个特性来实现自己的AOP了，下面的例子将介绍如何实现Spring 中AOP的前通知、后通知和环绕通知。实现思路如下：

1.DynaProxy动态代理类实现接口InvocationHandler，getBean方法 返回要代理的类，（这个类必须是基于接口的），invoke方法被代理的类执行其方法前一定要调用的方法，在这个方法里面可以在控制被调用的方法是否执行，或者做点其他事情。写日志，性能计算，权限控制等，setMethodAdvice方法，绑定自己定义的通知类。

2.MethodAdvice，加载自己定义的消息通知。目前支持前通知，后通知，和环绕通知，要实现这个三个功能只需要实现对应的接口，（^_^这些接口也是我自己定义的），然后通用方法AddAdvice加载进去，这里支持多个消息通知，对于多个消息通知执行的顺序是环绕通知，前通知，后通知。

3.定义了四个接口Advice、AroundAdvice、BeforeAdvice、AfterAdvice

4.实现3个Advice的实现类，分别对应环绕通知，前通知，后通知。

5.实现自己的消息通知类MyAdvice

6.编写测试类Test

下面看具体的代码实现

1. /**
2.  * 
3.  */
4. package com.advice;
6. import java.lang.reflect.InvocationHandler;
7. import java.lang.reflect.Method;
8. import java.lang.reflect.Proxy;
10. /**
11.  * @author zjb
12.  *
13.  */
14. public class DynaProxy implements InvocationHandler {
15.     
16.     private MethodAdvice methodAdvice;
17.     private Object delegate;
18.     @Override
19.     public Object invoke(Object porxy, Method method, Object[] args)
20.             throws Throwable {
21.         methodAdvice.setArgs(args);
22.         methodAdvice.setMethod(method);
23.         methodAdvice.setProxy(this);
24.         methodAdvice.setPos(-1);
25.         methodAdvice.setDone(false);
26.         return methodAdvice.proceed();
27.     }
28.     public Object getBean(String className){
29.         try {
30.             delegate=Class.forName(className).newInstance();
31.             methodAdvice.setTarget(delegate);
32.             return Proxy.newProxyInstance(
33.                     delegate.getClass().getClassLoader(),
34.                     delegate.getClass().getInterfaces(), this);
35.         } catch (Exception e) {
36.             e.printStackTrace();
37.         } 
38.         return null;
39.     }
40.     public MethodAdvice getMethodAdvice() {
41.         return methodAdvice;
42.     }
43.     public void setMethodAdvice(MethodAdvice methodAdvice) {
44.         this.methodAdvice = methodAdvice;
45.     }
46.     
47.     
48. }

1. package com.advice;
3. import java.lang.reflect.InvocationTargetException;
4. import java.lang.reflect.Method;
5. import java.util.ArrayList;
6. import java.util.List;
8. import com.advice.impl.AfterAdviceImpl;
9. import com.advice.impl.AroundAdviceImpl;
10. import com.advice.impl.BeforeAdviceImpl;
12. public class MethodAdvice {
13.     private List<Advice> adviceList=new ArrayList<Advice>();
14.     private Object target;
15.     private Method method;
16.     private Object[] args;
17.     private int pos=-1;
18.     private boolean done;
19.     private DynaProxy proxy;
20.     
21.     public void AddAdvice(Object [] advices){
22.         adviceList.clear();
23.         List<Advice> aroundAdvice=new ArrayList<Advice>();
24.         List<Advice> beforeAdvice=new ArrayList<Advice>();
25.         List<Advice> afterAdvice=new ArrayList<Advice>();
26.         for(Object o:advices){
27.             if (o instanceof AroundAdvice) {
28.                 AroundAdviceImpl temp= new AroundAdviceImpl((AroundAdvice)o);
29.                 aroundAdvice.add(temp);
30.             }
31.             if (o instanceof BeforeAdvice) {
32.                 BeforeAdviceImpl ba= new BeforeAdviceImpl((BeforeAdvice)o);
33.                 beforeAdvice.add(ba);
34.             }
35.             if (o instanceof AfterAdvice) {
36.                 AfterAdviceImpl aa= new AfterAdviceImpl((AfterAdvice)o);
37.                 afterAdvice.add(aa);
38.             }
39.         }
40.         adviceList.addAll(aroundAdvice);
41.         adviceList.addAll(beforeAdvice);
42.         adviceList.addAll(afterAdvice);
43.     }
44.     
45.     public Object proceed(){
46.         pos++;
47.         if(pos>=adviceList.size()&&!done){
48.              return invoke();
49.         }
50.         Object o=null;
51.         //如果执行到后通知了，那就去执行目标方法
52.         if(!done&& adviceList.get(pos) instanceof AfterAdvice){
53.             o=invoke();
54.         }
55.         adviceList.get(pos).invoke(this);
56.         return o;
57.         
58.     }
59.     private Object invoke(){
60.         done=true;
61.         try {
62.             return method.invoke(target, args);
63.         } catch (IllegalArgumentException e) {
64.             // TODO Auto-generated catch block
65.             e.printStackTrace();
66.         } catch (IllegalAccessException e) {
67.             // TODO Auto-generated catch block
68.             e.printStackTrace();
69.         } catch (InvocationTargetException e) {
70.             // TODO Auto-generated catch block
71.             e.printStackTrace();
72.         }
73.         return null;
74.     }
76.     public DynaProxy getProxy() {
77.         return proxy;
78.     }
79.     public void setProxy(DynaProxy proxy) {
80.         this.proxy = proxy;
81.     }
82.     public void setTarget(Object target) {
83.         this.target = target;
84.     }
85.     public void setArgs(Object[] args) {
86.         this.args = args;
87.     }
88.     public void setMethod(Method method) {
89.         this.method = method;
90.     }
91.     public Object getTarget() {
92.         return target;
93.     }
94.     public Method getMethod() {
95.         return method;
96.     }
97.     public Object[] getArgs() {
98.         return args;
99.     }
100.     public int getPos() {
101.         return pos;
102.     }
103.     public void setPos(int pos) {
104.         this.pos = pos;
105.     }
107.     public boolean isDone() {
108.         return done;
109.     }
111.     public void setDone(boolean done) {
112.         this.done = done;
113.     }
114. }

1. package com.advice;
4. public interface Advice {
5.     public Object invoke(MethodAdvice methodAdvice) ;
6. }

1. package com.advice;
3. public interface AroundAdvice extends Advice {
5. }

1. package com.advice;
3. import java.lang.reflect.Method;
5. public interface BeforeAdvice {
6.     public void before(Method m, Object[] args, Object target) ;
7. }

1. package com.advice;
3. import java.lang.reflect.Method;
5. public interface AfterAdvice {
6.     public void after(Method m, Object[] args, Object target) ;
7. }

1. package com.advice.impl;
3. import com.advice.Advice;
4. import com.advice.MethodAdvice;
6. public class AroundAdviceImpl implements Advice {
8.     private Advice advice;
9.     
10.     @SuppressWarnings("unused")
11.     private AroundAdviceImpl(){};
12.     public AroundAdviceImpl(Advice advice){
13.         this.advice=advice;
14.     }
15.     
16.     @Override
17.     public Object invoke(MethodAdvice methodAdvice) {
18.         return advice.invoke(methodAdvice);
19.     }
21. }

1. package com.advice.impl;
3. import com.advice.Advice;
4. import com.advice.BeforeAdvice;
5. import com.advice.MethodAdvice;
7. public class BeforeAdviceImpl implements  Advice {
8.     
9.     private BeforeAdvice beforeAdvice;
10.     @SuppressWarnings("unused")
11.     private BeforeAdviceImpl(){
12.         
13.     }
14.     public BeforeAdviceImpl(BeforeAdvice beforeAdvice){
15.         this.beforeAdvice=beforeAdvice;
16.     }
18.     @Override
19.     public Object invoke(MethodAdvice methodAdvice){
20.         beforeAdvice.before(methodAdvice.getMethod(), methodAdvice.getArgs(), methodAdvice.getTarget());
21.         return methodAdvice.proceed();
22.     }
24. }

 

1. package com.advice.impl;
3. import com.advice.Advice;
4. import com.advice.AfterAdvice;
5. import com.advice.MethodAdvice;
7. public class AfterAdviceImpl implements Advice {
9.     private AfterAdvice afterAdvice;
10.     @SuppressWarnings("unused")
11.     private AfterAdviceImpl(){}
12.     
13.     public AfterAdviceImpl(AfterAdvice afterAdvice){
14.         this.afterAdvice=afterAdvice;
15.     }
16.     @Override
17.     public Object invoke(MethodAdvice methodAdvice){
18.         Object retVal=methodAdvice.proceed();
19.         afterAdvice.after(methodAdvice.getMethod(), methodAdvice.getArgs(), methodAdvice.getTarget());
20.         return retVal;
21.     }
23. }

1. package com.myadvice.test; 
3. import java.lang.reflect.Method;
4. import java.util.Arrays;
6. import bsh.EvalError;
7. import bsh.Interpreter;
9. import com.advice.AfterAdvice;
10. import com.advice.AroundAdvice;
11. import com.advice.BeforeAdvice;
12. import com.advice.MethodAdvice;
15. public class MyAdvice implements BeforeAdvice,AfterAdvice,AroundAdvice{ 
16.     /** 
17.      * 后通知 
18.      */
19.     @Override
20.     public void after(Method m, Object[] args, Object target){
21.         System.out.println("后通知，调用的方法："+m.getName()+",参数："+Arrays.toString(args));
22.         
23.     }
24.     /** 
25.      * 环绕通知，最维强大的通知，可以控制目标方法是否执行，也可以改变方法的返回值 
26.      */ 
27.     @Override
28.     public Object invoke(MethodAdvice methodAdvice) {
29.         System.out.println("[环绕通知]"); 
30.         /** 
31.          * 这里我们禁止李四发表任何的评论 
32.          */ 
33.         if(methodAdvice.getMethod().getName().equals("comment")"李四".equals(methodAdvice.getArgs()[0])){ 
34.             System.out.println("屏蔽李四所有的评论"); 
35.             String returnType=methodAdvice.getMethod().getReturnType().getName(); 
36.             if("int".equals(returnType)||"long".equals(returnType)||"float".equals(returnType)||"double".equals(returnType)||"byte".equals(returnType)||"short".equals(returnType)){ 
37.                 //利用BeanShell 构造一个内置变量返回，这里想了好久，没有想到什么方法可以根据 
38.                 //指定数据类型 返回指定的变量 
39.                 Interpreter i = new Interpreter(); 
40.                 try {
41.                     return i.eval("("+returnType+")0");
42.                 } catch (EvalError e) {
43.                     // TODO Auto-generated catch block
44.                     e.printStackTrace();
45.                 } 
46.             }else if("boolean".equals(returnType)){ 
47.                 return false; 
48.             } 
49.             return null; 
50.         }else{ 
51.             return methodAdvice.proceed();
52.         } 
53.     }
54.     
55.     /** 
56.      * 前通知 
57.      */ 
59.     @Override
60.     public void before(Method m, Object[] args, Object target) {
61.         System.out.println("前通知，调用的方法："+m.getName()+",参数："+Arrays.toString(args));
62.     }    
63. } 

1. package com.myadvice.test;
3. import com.advice.DynaProxy;
4. import com.advice.MethodAdvice;
5. import com.test.BookBiz;
6. import com.test.BookBizImpl;
8. public class Test {
10.     /**
11.      * @param args
12.      */
13.     public static void main(String[] args) {
14.         DynaProxy proxy= new DynaProxy();
15.         MethodAdvice methodAdvice= new MethodAdvice();
16.         methodAdvice.AddAdvice(new Object[]{new MyAdvice()});
17.         proxy.setMethodAdvice(methodAdvice);
18.         BookBiz bookBiz=(BookBiz)proxy.getBean(BookBizImpl.class.getName());
19.         bookBiz.buy("张三", "Spring深入潜出", 50); 
20.         bookBiz.comment("李四", "《恐怖世界》一点都不恐怖，很好看！"); 
21.         bookBiz.comment("张三", "《Spring深入潜出》还是写得不错的！");
22.     }
23. }

运行Test类得到下面的结果：

[环绕通知]
前通知，调用的方法：buy,参数：[张三, Spring深入潜出, 50.0]
业务方法buy开始执行
·张三购买图书：Spring深入潜出
·张三增加积分：5
·向物流系统下发货单
业务方法buy结束
后通知，调用的方法：buy,参数：[张三, Spring深入潜出, 50.0]
[环绕通知]
屏蔽李四所有的评论
[环绕通知]
前通知，调用的方法：comment,参数：[张三, 《Spring深入潜出》还是写得不错的！]
业务方法comment开始执行
·张三发表书评《Spring深入潜出》还是写得不错的！
业务方法comment结束
后通知，调用的方法：comment,参数：[张三, 《Spring深入潜出》还是写得不错的！]
 从结果可以看出和使用spring的一样。

这个又个小小的问题，为什么spring里面前通知后通知的接口方法要包含Object object, Method method这两个参数，如果又这里两个参数那么就可以在前后通知里面去执行目标方法了，这样不是很好。还有就是使用jdk的代理，被代理的类都必须是基于接口的，重要也不是很方便，如果使用cglib动态代理类，那么被代理的类就可以不是基于接口的了，这样比较方便，下一篇将介绍如何使用cglib动态代理