AOP示例(续)

上一篇演示了，Spring得前通知、后通知、环绕通知，仔细想来前通知、后通知和异常通知，都应该是居于环绕通知开发的，想想如果都能控制目标函数是否能执行，那么要在目标函数执行前后，或者目标函数执行过程中发生异常后进行一些处理，那不是太easy了吗?，按照猜想，前通知、后通知，异常通知 应该是重写invoke方法，在invoke方法里面先执行before在执行proceed就是前通知，先执行proceed在执行afterReturning就是后通知，用在try 里面执行invoke方法就是异常通知。我下面来看spring的源码进行验证

1. /*
2. *Copyright2002-2007theoriginalauthororauthors.
3. *
4. *LicensedundertheApacheLicense,Version2.0(the"License");
5. *youmaynotusethisfileexceptincompliancewiththeLicense.
6. *YoumayobtainacopyoftheLicenseat
7. *
8. *http://www.apache.org/licenses/LICENSE-2.0
9. *
10. *Unlessrequiredbyapplicablelaworagreedtoinwriting,software
11. *distributedundertheLicenseisdistributedonan"ASIS"BASIS,
12. *WITHOUTWARRANTIESORCONDITIONSOFANYKIND,eitherexpressorimplied.
13. *SeetheLicenseforthespecificlanguagegoverningpermissionsand
14. *limitationsundertheLicense.
15. */
17. packageorg.springframework.aop.framework.adapter;
19. importjava.io.Serializable;
21. importorg.aopalliance.intercept.MethodInterceptor;
22. importorg.aopalliance.intercept.MethodInvocation;
24. importorg.springframework.aop.MethodBeforeAdvice;
25. importorg.springframework.util.Assert;
27. /**
28. *Interceptortowrapam{@linkorg.springframework.aop.MethodBeforeAdvice}.
29. *UsedinternallybytheAOPframework;applicationdevelopersshouldnotneed
30. *tousethisclassdirectly.
31. *
32. *@authorRodJohnson
33. */
34. publicclassMethodBeforeAdviceInterceptorimplementsMethodInterceptor,Serializable{
36. privateMethodBeforeAdviceadvice;
39. /**
40. *CreateanewMethodBeforeAdviceInterceptorforthegivenadvice.
41. *@paramadvicetheMethodBeforeAdvicetowrap
42. */
43. publicMethodBeforeAdviceInterceptor(MethodBeforeAdviceadvice){
44. Assert.notNull(advice,"Advicemustnotbenull");
45. this.advice=advice;
46. }
48. publicObjectinvoke(MethodInvocationmi)throwsThrowable{
49. this.advice.before(mi.getMethod(),mi.getArguments(),mi.getThis());
50. returnmi.proceed();
51. }
53. }

1. /*
2. *Copyright2002-2007theoriginalauthororauthors.
3. *
4. *LicensedundertheApacheLicense,Version2.0(the"License");
5. *youmaynotusethisfileexceptincompliancewiththeLicense.
6. *YoumayobtainacopyoftheLicenseat
7. *
8. *http://www.apache.org/licenses/LICENSE-2.0
9. *
10. *Unlessrequiredbyapplicablelaworagreedtoinwriting,software
11. *distributedundertheLicenseisdistributedonan"ASIS"BASIS,
12. *WITHOUTWARRANTIESORCONDITIONSOFANYKIND,eitherexpressorimplied.
13. *SeetheLicenseforthespecificlanguagegoverningpermissionsand
14. *limitationsundertheLicense.
15. */
17. packageorg.springframework.aop.framework.adapter;
19. importjava.io.Serializable;
21. importorg.aopalliance.intercept.MethodInterceptor;
22. importorg.aopalliance.intercept.MethodInvocation;
24. importorg.springframework.aop.AfterAdvice;
25. importorg.springframework.aop.AfterReturningAdvice;
26. importorg.springframework.util.Assert;
28. /**
29. *Interceptortowrapam{@linkorg.springframework.aop.AfterReturningAdvice}.
30. *UsedinternallybytheAOPframework;applicationdevelopersshouldnotneed
31. *tousethisclassdirectly.
32. *
33. *@authorRodJohnson
34. */
35. publicclassAfterReturningAdviceInterceptorimplementsMethodInterceptor,AfterAdvice,Serializable{
37. privatefinalAfterReturningAdviceadvice;
40. /**
41. *CreateanewAfterReturningAdviceInterceptorforthegivenadvice.
42. *@paramadvicetheAfterReturningAdvicetowrap
43. */
44. publicAfterReturningAdviceInterceptor(AfterReturningAdviceadvice){
45. Assert.notNull(advice,"Advicemustnotbenull");
46. this.advice=advice;
47. }
49. publicObjectinvoke(MethodInvocationmi)throwsThrowable{
50. ObjectretVal=mi.proceed();
51. this.advice.afterReturning(retVal,mi.getMethod(),mi.getArguments(),mi.getThis());
52. returnretVal;
53. }
55. }

1. /*
2. *Copyright2002-2007theoriginalauthororauthors.
3. *
4. *LicensedundertheApacheLicense,Version2.0(the"License");
5. *youmaynotusethisfileexceptincompliancewiththeLicense.
6. *YoumayobtainacopyoftheLicenseat
7. *
8. *http://www.apache.org/licenses/LICENSE-2.0
9. *
10. *Unlessrequiredbyapplicablelaworagreedtoinwriting,software
11. *distributedundertheLicenseisdistributedonan"ASIS"BASIS,
12. *WITHOUTWARRANTIESORCONDITIONSOFANYKIND,eitherexpressorimplied.
13. *SeetheLicenseforthespecificlanguagegoverningpermissionsand
14. *limitationsundertheLicense.
15. */
17. packageorg.springframework.aop.framework.adapter;
19. importjava.lang.reflect.InvocationTargetException;
20. importjava.lang.reflect.Method;
21. importjava.util.HashMap;
22. importjava.util.Map;
24. importorg.aopalliance.intercept.MethodInterceptor;
25. importorg.aopalliance.intercept.MethodInvocation;
26. importorg.apache.commons.logging.Log;
27. importorg.apache.commons.logging.LogFactory;
29. importorg.springframework.aop.AfterAdvice;
30. importorg.springframework.util.Assert;
32. /**
33. *Interceptortowrapanafter-throwingadvice.
34. *
35. *<p>Thesignaturesonhandlermethodsonthe<code>ThrowsAdvice</code>
36. *implementationmethodargumentmustbeoftheform:<br>
37. *
38. *<code>voidafterThrowing([Method,args,target],ThrowableSubclass);</code>
39. *
40. *<p>Onlythelastargumentisrequired.
41. *
42. *<p>Someexamplesofvalidmethodswouldbe:
43. *
44. *<preclass="code">publicvoidafterThrowing(Exceptionex)</pre>
45. *<preclass="code">publicvoidafterThrowing(RemoteException)</pre>
46. *<preclass="code">publicvoidafterThrowing(Methodmethod,Object[]args,Objecttarget,Exceptionex)</pre>
47. *<preclass="code">publicvoidafterThrowing(Methodmethod,Object[]args,Objecttarget,ServletExceptionex)</pre>
48. *
49. *<p>ThisisaframeworkclassthatneednotbeuseddirectlybySpringusers.
50. *
51. *@authorRodJohnson
52. *@authorJuergenHoeller
53. */
54. publicclassThrowsAdviceInterceptorimplementsMethodInterceptor,AfterAdvice{
56. privatestaticfinalStringAFTER_THROWING="afterThrowing";
58. privatestaticfinalLoglogger=LogFactory.getLog(ThrowsAdviceInterceptor.class);
61. privatefinalObjectthrowsAdvice;
63. /**Methodsonthrowsadvice,keyedbyexceptionclass*/
64. privatefinalMapexceptionHandlerMap=newHashMap();
67. /**
68. *CreateanewThrowsAdviceInterceptorforthegivenThrowsAdvice.
69. *@paramthrowsAdvicetheadviceobjectthatdefinestheexception
70. *handlermethods(usuallya{@linkorg.springframework.aop.ThrowsAdvice}
71. *implementation)
72. */
73. publicThrowsAdviceInterceptor(ObjectthrowsAdvice){
74. Assert.notNull(throwsAdvice,"Advicemustnotbenull");
75. this.throwsAdvice=throwsAdvice;
77. Method[]methods=throwsAdvice.getClass().getMethods();
78. for(inti=0;i<methods.length;i++){
79. Methodmethod=methods[i];
80. if(method.getName().equals(AFTER_THROWING)&
81. //m.getReturnType()==null&&
82. (method.getParameterTypes().length==1||method.getParameterTypes().length==4)&
83. Throwable.class.isAssignableFrom(method.getParameterTypes()[method.getParameterTypes().length-1])
84. ){
85. //Haveanexceptionhandler
86. this.exceptionHandlerMap.put(method.getParameterTypes()[method.getParameterTypes().length-1],method);
87. if(logger.isDebugEnabled()){
88. logger.debug("Foundexceptionhandlermethod:"+method);
89. }
90. }
91. }
93. if(this.exceptionHandlerMap.isEmpty()){
94. thrownewIllegalArgumentException(
95. "Atleastonehandlermethodmustbefoundinclass["+throwsAdvice.getClass()+"]");
96. }
97. }
99. publicintgetHandlerMethodCount(){
100. returnthis.exceptionHandlerMap.size();
101. }
103. /**
104. *Determinetheexceptionhandlemethod.Canreturnnullifnotfound.
105. *@paramexceptiontheexceptionthrown
106. *@returnahandlerforthegivenexceptiontype
107. */
108. privateMethodgetExceptionHandler(Throwableexception){
109. ClassexceptionClass=exception.getClass();
110. if(logger.isTraceEnabled()){
111. logger.trace("Tryingtofindhandlerforexceptionoftype["+exceptionClass.getName()+"]");
112. }
113. Methodhandler=(Method)this.exceptionHandlerMap.get(exceptionClass);
114. while(handler==null&&!exceptionClass.equals(Throwable.class)){
115. exceptionClass=exceptionClass.getSuperclass();
116. handler=(Method)this.exceptionHandlerMap.get(exceptionClass);
117. }
118. if(handler!=null&&logger.isDebugEnabled()){
119. logger.debug("Foundhandlerforexceptionoftype["+exceptionClass.getName()+"]:"+handler);
120. }
121. returnhandler;
122. }
124. publicObjectinvoke(MethodInvocationmi)throwsThrowable{
125. try{
126. returnmi.proceed();
127. }
128. catch(Throwableex){
129. MethodhandlerMethod=getExceptionHandler(ex);
130. if(handlerMethod!=null){
131. invokeHandlerMethod(mi,ex,handlerMethod);
132. }
133. throwex;
134. }
135. }
137. privatevoidinvokeHandlerMethod(MethodInvocationmi,Throwableex,Methodmethod)throwsThrowable{
138. Object[]handlerArgs;
139. if(method.getParameterTypes().length==1){
140. handlerArgs=newObject[]{ex};
141. }
142. else{
143. handlerArgs=newObject[]{mi.getMethod(),mi.getArguments(),mi.getThis(),ex};
144. }
145. try{
146. method.invoke(this.throwsAdvice,handlerArgs);
147. }
148. catch(InvocationTargetExceptiontargetEx){
149. throwtargetEx.getTargetException();
150. }
151. }
153. }

通过spring的源码可以确定刚刚的想法。现在明白了前通知和后通知，异常通知是怎么实现的了，但是问题又来了，怎么在我调用业务方法的前去执行invoke方法呢？看来还要继续研究一下^_^