AOP示例(续)

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

1. /*
2.  * Copyright 2002-2007 the original author or authors.
3.  *
4.  * Licensed under the Apache License, Version 2.0 (the "License");
5.  * you may not use this file except in compliance with the License.
6.  * You may obtain a copy of the License at
7.  *
8.  *      http://www.apache.org/licenses/LICENSE-2.0
9.  *
10.  * Unless required by applicable law or agreed to in writing, software
11.  * distributed under the License is distributed on an "AS IS" BASIS,
12.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13.  * See the License for the specific language governing permissions and
14.  * limitations under the License.
15.  */
17. package org.springframework.aop.framework.adapter;
19. import java.io.Serializable;
21. import org.aopalliance.intercept.MethodInterceptor;
22. import org.aopalliance.intercept.MethodInvocation;
24. import org.springframework.aop.MethodBeforeAdvice;
25. import org.springframework.util.Assert;
27. /**
28.  * Interceptor to wrap am {@link org.springframework.aop.MethodBeforeAdvice}.
29.  * Used internally by the AOP framework; application developers should not need
30.  * to use this class directly.
31.  *
32.  * @author Rod Johnson
33.  */
34. public class MethodBeforeAdviceInterceptor implements MethodInterceptor, Serializable {
36.     private MethodBeforeAdvice advice;
39.     /**
40.      * Create a new MethodBeforeAdviceInterceptor for the given advice.
41.      * @param advice the MethodBeforeAdvice to wrap
42.      */
43.     public MethodBeforeAdviceInterceptor(MethodBeforeAdvice advice) {
44.         Assert.notNull(advice, "Advice must not be null");
45.         this.advice = advice;
46.     }
48.     public Object invoke(MethodInvocation mi) throws Throwable {
49.         this.advice.before(mi.getMethod(), mi.getArguments(), mi.getThis() );
50.         return mi.proceed();
51.     }
53. }

1. /*
2.  * Copyright 2002-2007 the original author or authors.
3.  *
4.  * Licensed under the Apache License, Version 2.0 (the "License");
5.  * you may not use this file except in compliance with the License.
6.  * You may obtain a copy of the License at
7.  *
8.  *      http://www.apache.org/licenses/LICENSE-2.0
9.  *
10.  * Unless required by applicable law or agreed to in writing, software
11.  * distributed under the License is distributed on an "AS IS" BASIS,
12.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13.  * See the License for the specific language governing permissions and
14.  * limitations under the License.
15.  */
17. package org.springframework.aop.framework.adapter;
19. import java.io.Serializable;
21. import org.aopalliance.intercept.MethodInterceptor;
22. import org.aopalliance.intercept.MethodInvocation;
24. import org.springframework.aop.AfterAdvice;
25. import org.springframework.aop.AfterReturningAdvice;
26. import org.springframework.util.Assert;
28. /**
29.  * Interceptor to wrap am {@link org.springframework.aop.AfterReturningAdvice}.
30.  * Used internally by the AOP framework; application developers should not need
31.  * to use this class directly.
32.  *
33.  * @author Rod Johnson
34.  */
35. public class AfterReturningAdviceInterceptor implements MethodInterceptor, AfterAdvice, Serializable {
37.     private final AfterReturningAdvice advice;
40.     /**
41.      * Create a new AfterReturningAdviceInterceptor for the given advice.
42.      * @param advice the AfterReturningAdvice to wrap
43.      */
44.     public AfterReturningAdviceInterceptor(AfterReturningAdvice advice) {
45.         Assert.notNull(advice, "Advice must not be null");
46.         this.advice = advice;
47.     }
49.     public Object invoke(MethodInvocation mi) throws Throwable {
50.         Object retVal = mi.proceed();
51.         this.advice.afterReturning(retVal, mi.getMethod(), mi.getArguments(), mi.getThis());
52.         return retVal;
53.     }
55. }

1. /*
2.  * Copyright 2002-2007 the original author or authors.
3.  *
4.  * Licensed under the Apache License, Version 2.0 (the "License");
5.  * you may not use this file except in compliance with the License.
6.  * You may obtain a copy of the License at
7.  *
8.  *      http://www.apache.org/licenses/LICENSE-2.0
9.  *
10.  * Unless required by applicable law or agreed to in writing, software
11.  * distributed under the License is distributed on an "AS IS" BASIS,
12.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13.  * See the License for the specific language governing permissions and
14.  * limitations under the License.
15.  */
17. package org.springframework.aop.framework.adapter;
19. import java.lang.reflect.InvocationTargetException;
20. import java.lang.reflect.Method;
21. import java.util.HashMap;
22. import java.util.Map;
24. import org.aopalliance.intercept.MethodInterceptor;
25. import org.aopalliance.intercept.MethodInvocation;
26. import org.apache.commons.logging.Log;
27. import org.apache.commons.logging.LogFactory;
29. import org.springframework.aop.AfterAdvice;
30. import org.springframework.util.Assert;
32. /**
33.  * Interceptor to wrap an after-throwing advice.
34.  *
35.  * <p>The signatures on handler methods on the <code>ThrowsAdvice</code>
36.  * implementation method argument must be of the form:<br>
37.  *
38.  * <code>void afterThrowing([Method, args, target], ThrowableSubclass);</code>
39.  *
40.  * <p>Only the last argument is required.
41.  *
42.  * <p>Some examples of valid methods would be:
43.  *
44.  * <pre class="code">public void afterThrowing(Exception ex)</pre>
45.  * <pre class="code">public void afterThrowing(RemoteException)</pre>
46.  * <pre class="code">public void afterThrowing(Method method, Object[] args, Object target, Exception ex)</pre>
47.  * <pre class="code">public void afterThrowing(Method method, Object[] args, Object target, ServletException ex)</pre>
48.  *
49.  * <p>This is a framework class that need not be used directly by Spring users.
50.  *
51.  * @author Rod Johnson
52.  * @author Juergen Hoeller
53.  */
54. public class ThrowsAdviceInterceptor implements MethodInterceptor, AfterAdvice {
56.     private static final String AFTER_THROWING = "afterThrowing";
58.     private static final Log logger = LogFactory.getLog(ThrowsAdviceInterceptor.class);
61.     private final Object throwsAdvice;
63.     /** Methods on throws advice, keyed by exception class */
64.     private final Map exceptionHandlerMap = new HashMap();
67.     /**
68.      * Create a new ThrowsAdviceInterceptor for the given ThrowsAdvice.
69.      * @param throwsAdvice the advice object that defines the exception
70.      * handler methods (usually a {@link org.springframework.aop.ThrowsAdvice}
71.      * implementation)
72.      */
73.     public ThrowsAdviceInterceptor(Object throwsAdvice) {
74.         Assert.notNull(throwsAdvice, "Advice must not be null");
75.         this.throwsAdvice = throwsAdvice;
77.         Method[] methods = throwsAdvice.getClass().getMethods();
78.         for (int i = 0; i < methods.length; i++) {
79.             Method method = 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.                 // Have an exception handler
86.                 this.exceptionHandlerMap.put(method.getParameterTypes()[method.getParameterTypes().length - 1], method);
87.                 if (logger.isDebugEnabled()) {
88.                     logger.debug("Found exception handler method: " + method);
89.                 }
90.             }
91.         }
92.         
93.         if (this.exceptionHandlerMap.isEmpty()) {
94.             throw new IllegalArgumentException(
95.                     "At least one handler method must be found in class [" + throwsAdvice.getClass() + "]");
96.         }
97.     }
98.     
99.     public int getHandlerMethodCount() {
100.         return this.exceptionHandlerMap.size();
101.     }
103.     /**
104.      * Determine the exception handle method. Can return null if not found.
105.      * @param exception the exception thrown
106.      * @return a handler for the given exception type
107.      */
108.     private Method getExceptionHandler(Throwable exception) {
109.         Class exceptionClass = exception.getClass();
110.         if (logger.isTraceEnabled()) {
111.             logger.trace("Trying to find handler for exception of type [" + exceptionClass.getName() + "]");
112.         }
113.         Method handler = (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("Found handler for exception of type [" + exceptionClass.getName() + "]: " + handler);
120.         }
121.         return handler;
122.     }
124.     public Object invoke(MethodInvocation mi) throws Throwable {
125.         try {
126.             return mi.proceed();
127.         }
128.         catch (Throwable ex) {
129.             Method handlerMethod = getExceptionHandler(ex);
130.             if (handlerMethod != null) {
131.                 invokeHandlerMethod(mi, ex, handlerMethod);
132.             }
133.             throw ex;
134.         }
135.     }
136.     
137.     private void invokeHandlerMethod(MethodInvocation mi, Throwable ex, Method method) throws Throwable {
138.         Object[] handlerArgs;
139.         if (method.getParameterTypes().length == 1) {
140.             handlerArgs = new Object[] { ex };
141.         }
142.         else {
143.             handlerArgs = new Object[] {mi.getMethod(), mi.getArguments(), mi.getThis(), ex};
144.         }
145.         try {
146.             method.invoke(this.throwsAdvice, handlerArgs);
147.         }
148.         catch (InvocationTargetException targetEx) {
149.             throw targetEx.getTargetException();
150.         }
151.     }
153. }

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