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. packagecom.advice;
6. importjava.lang.reflect.InvocationHandler;
7. importjava.lang.reflect.Method;
8. importjava.lang.reflect.Proxy;
10. /**
11. *@authorzjb
12. *
13. */
14. publicclassDynaProxyimplementsInvocationHandler{
16. privateMethodAdvicemethodAdvice;
17. privateObjectdelegate;
18. @Override
19. publicObjectinvoke(Objectporxy,Methodmethod,Object[]args)
20. throwsThrowable{
21. methodAdvice.setArgs(args);
22. methodAdvice.setMethod(method);
23. methodAdvice.setProxy(this);
24. methodAdvice.setPos(-1);
25. methodAdvice.setDone(false);
26. returnmethodAdvice.proceed();
27. }
28. publicObjectgetBean(StringclassName){
29. try{
30. delegate=Class.forName(className).newInstance();
31. methodAdvice.setTarget(delegate);
32. returnProxy.newProxyInstance(
33. delegate.getClass().getClassLoader(),
34. delegate.getClass().getInterfaces(),this);
35. }catch(Exceptione){
36. e.printStackTrace();
37. }
38. returnnull;
39. }
40. publicMethodAdvicegetMethodAdvice(){
41. returnmethodAdvice;
42. }
43. publicvoidsetMethodAdvice(MethodAdvicemethodAdvice){
44. this.methodAdvice=methodAdvice;
45. }
48. }

1. packagecom.advice;
3. importjava.lang.reflect.InvocationTargetException;
4. importjava.lang.reflect.Method;
5. importjava.util.ArrayList;
6. importjava.util.List;
8. importcom.advice.impl.AfterAdviceImpl;
9. importcom.advice.impl.AroundAdviceImpl;
10. importcom.advice.impl.BeforeAdviceImpl;
12. publicclassMethodAdvice{
13. privateList<Advice>adviceList=newArrayList<Advice>();
14. privateObjecttarget;
15. privateMethodmethod;
16. privateObject[]args;
17. privateintpos=-1;
18. privatebooleandone;
19. privateDynaProxyproxy;
21. publicvoidAddAdvice(Object[]advices){
22. adviceList.clear();
23. List<Advice>aroundAdvice=newArrayList<Advice>();
24. List<Advice>beforeAdvice=newArrayList<Advice>();
25. List<Advice>afterAdvice=newArrayList<Advice>();
26. for(Objecto:advices){
27. if(oinstanceofAroundAdvice){
28. AroundAdviceImpltemp=newAroundAdviceImpl((AroundAdvice)o);
29. aroundAdvice.add(temp);
30. }
31. if(oinstanceofBeforeAdvice){
32. BeforeAdviceImplba=newBeforeAdviceImpl((BeforeAdvice)o);
33. beforeAdvice.add(ba);
34. }
35. if(oinstanceofAfterAdvice){
36. AfterAdviceImplaa=newAfterAdviceImpl((AfterAdvice)o);
37. afterAdvice.add(aa);
38. }
39. }
40. adviceList.addAll(aroundAdvice);
41. adviceList.addAll(beforeAdvice);
42. adviceList.addAll(afterAdvice);
43. }
45. publicObjectproceed(){
46. pos++;
47. if(pos>=adviceList.size()&&!done){
48. returninvoke();
49. }
50. Objecto=null;
51. //如果执行到后通知了，那就去执行目标方法
52. if(!done&&adviceList.get(pos)instanceofAfterAdvice){
53. o=invoke();
54. }
55. adviceList.get(pos).invoke(this);
56. returno;
58. }
59. privateObjectinvoke(){
60. done=true;
61. try{
62. returnmethod.invoke(target,args);
63. }catch(IllegalArgumentExceptione){
64. //TODOAuto-generatedcatchblock
65. e.printStackTrace();
66. }catch(IllegalAccessExceptione){
67. //TODOAuto-generatedcatchblock
68. e.printStackTrace();
69. }catch(InvocationTargetExceptione){
70. //TODOAuto-generatedcatchblock
71. e.printStackTrace();
72. }
73. returnnull;
74. }
76. publicDynaProxygetProxy(){
77. returnproxy;
78. }
79. publicvoidsetProxy(DynaProxyproxy){
80. this.proxy=proxy;
81. }
82. publicvoidsetTarget(Objecttarget){
83. this.target=target;
84. }
85. publicvoidsetArgs(Object[]args){
86. this.args=args;
87. }
88. publicvoidsetMethod(Methodmethod){
89. this.method=method;
90. }
91. publicObjectgetTarget(){
92. returntarget;
93. }
94. publicMethodgetMethod(){
95. returnmethod;
96. }
97. publicObject[]getArgs(){
98. returnargs;
99. }
100. publicintgetPos(){
101. returnpos;
102. }
103. publicvoidsetPos(intpos){
104. this.pos=pos;
105. }
107. publicbooleanisDone(){
108. returndone;
109. }
111. publicvoidsetDone(booleandone){
112. this.done=done;
113. }
114. }

1. packagecom.advice;
4. publicinterfaceAdvice{
5. publicObjectinvoke(MethodAdvicemethodAdvice);
6. }

1. packagecom.advice;
3. publicinterfaceAroundAdviceextendsAdvice{
5. }

1. packagecom.advice;
3. importjava.lang.reflect.Method;
5. publicinterfaceBeforeAdvice{
6. publicvoidbefore(Methodm,Object[]args,Objecttarget);
7. }

1. packagecom.advice;
3. importjava.lang.reflect.Method;
5. publicinterfaceAfterAdvice{
6. publicvoidafter(Methodm,Object[]args,Objecttarget);
7. }

1. packagecom.advice.impl;
3. importcom.advice.Advice;
4. importcom.advice.MethodAdvice;
6. publicclassAroundAdviceImplimplementsAdvice{
8. privateAdviceadvice;
10. @SuppressWarnings("unused")
11. privateAroundAdviceImpl(){};
12. publicAroundAdviceImpl(Adviceadvice){
13. this.advice=advice;
14. }
16. @Override
17. publicObjectinvoke(MethodAdvicemethodAdvice){
18. returnadvice.invoke(methodAdvice);
19. }
21. }

1. packagecom.advice.impl;
3. importcom.advice.Advice;
4. importcom.advice.BeforeAdvice;
5. importcom.advice.MethodAdvice;
7. publicclassBeforeAdviceImplimplementsAdvice{
9. privateBeforeAdvicebeforeAdvice;
10. @SuppressWarnings("unused")
11. privateBeforeAdviceImpl(){
13. }
14. publicBeforeAdviceImpl(BeforeAdvicebeforeAdvice){
15. this.beforeAdvice=beforeAdvice;
16. }
18. @Override
19. publicObjectinvoke(MethodAdvicemethodAdvice){
20. beforeAdvice.before(methodAdvice.getMethod(),methodAdvice.getArgs(),methodAdvice.getTarget());
21. returnmethodAdvice.proceed();
22. }
24. }

1. packagecom.advice.impl;
3. importcom.advice.Advice;
4. importcom.advice.AfterAdvice;
5. importcom.advice.MethodAdvice;
7. publicclassAfterAdviceImplimplementsAdvice{
9. privateAfterAdviceafterAdvice;
10. @SuppressWarnings("unused")
11. privateAfterAdviceImpl(){}
13. publicAfterAdviceImpl(AfterAdviceafterAdvice){
14. this.afterAdvice=afterAdvice;
15. }
16. @Override
17. publicObjectinvoke(MethodAdvicemethodAdvice){
18. ObjectretVal=methodAdvice.proceed();
19. afterAdvice.after(methodAdvice.getMethod(),methodAdvice.getArgs(),methodAdvice.getTarget());
20. returnretVal;
21. }
23. }

1. packagecom.myadvice.test;
3. importjava.lang.reflect.Method;
4. importjava.util.Arrays;
6. importbsh.EvalError;
7. importbsh.Interpreter;
9. importcom.advice.AfterAdvice;
10. importcom.advice.AroundAdvice;
11. importcom.advice.BeforeAdvice;
12. importcom.advice.MethodAdvice;
15. publicclassMyAdviceimplementsBeforeAdvice,AfterAdvice,AroundAdvice{
16. /**
17. *后通知
18. */
19. @Override
20. publicvoidafter(Methodm,Object[]args,Objecttarget){
21. System.out.println("后通知，调用的方法："+m.getName()+",参数："+Arrays.toString(args));
23. }
24. /**
25. *环绕通知，最维强大的通知，可以控制目标方法是否执行，也可以改变方法的返回值
26. */
27. @Override
28. publicObjectinvoke(MethodAdvicemethodAdvice){
29. System.out.println("[环绕通知]");
30. /**
31. *这里我们禁止李四发表任何的评论
32. */
33. if(methodAdvice.getMethod().getName().equals("comment")"李四".equals(methodAdvice.getArgs()[0])){
34. System.out.println("屏蔽李四所有的评论");
35. StringreturnType=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. Interpreteri=newInterpreter();
40. try{
41. returni.eval("("+returnType+")0");
42. }catch(EvalErrore){
43. //TODOAuto-generatedcatchblock
44. e.printStackTrace();
45. }
46. }elseif("boolean".equals(returnType)){
47. returnfalse;
48. }
49. returnnull;
50. }else{
51. returnmethodAdvice.proceed();
52. }
53. }
55. /**
56. *前通知
57. */
59. @Override
60. publicvoidbefore(Methodm,Object[]args,Objecttarget){
61. System.out.println("前通知，调用的方法："+m.getName()+",参数："+Arrays.toString(args));
62. }
63. }

1. packagecom.myadvice.test;
3. importcom.advice.DynaProxy;
4. importcom.advice.MethodAdvice;
5. importcom.test.BookBiz;
6. importcom.test.BookBizImpl;
8. publicclassTest{
10. /**
11. *@paramargs
12. */
13. publicstaticvoidmain(String[]args){
14. DynaProxyproxy=newDynaProxy();
15. MethodAdvicemethodAdvice=newMethodAdvice();
16. methodAdvice.AddAdvice(newObject[]{newMyAdvice()});
17. proxy.setMethodAdvice(methodAdvice);
18. BookBizbookBiz=(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动态代理