spring4.0源碼分析━━━（AOP實現）

• AOP的概念

         AOP爲Aspect Oriented Programming的縮寫，意爲：面向切面編程（也叫面向方面）。這就讓一些問題很簡單化了，例如：開始咱們實現了一些邏輯並上線了，如今客戶又來了一個新的需求。要在每次交易以前統計下，或者記錄下他們的交易簡單資料。而你發現你其餘模塊可能正好有這部分的功能。那AOP就能夠用得上了，使用AOP就能夠在不修改源代碼的狀況下新增這些功能。就是在交易前這個切面，新裝你的一些功能。這有點像攔截器和Filter。其實都是一個原理。前面說了解析xml和Bean的實例化。

         而AOP的實現的話都是在我前面兩篇spring3.0源碼分析的基礎上實現。其實AOP算是對本身自己IOC的實例，你學好弄懂AOP。基本IOC的也是懂了。可是這裏的AOP也用到了一些新的東西，像Aspect，還有JVM的反射和動態代理。還有CGLIB這裏也是有用到的。可是默認的實現是用JVM的動態代理。

 

• AOP的實例

        AOP用起來仍是很簡單的。就把xml配置好就算完工了。有Advisor和aspect兩種方式來完成。若是是用Advisor的話須要實現AfterReturningAdvice，MethodBeforeAdvice，ThrowsAdvice等接口。而若是用aspect的話則不用繼承或者實現其餘的類，一個普通的類便可。

     

Java代碼  

1. public class LogAop {  
2.     private final static Log log = LogFactory.getLog(LogAop.class);  
3.     public void addLog(){  
4.         log.info("add log ========================");  
5.     }  
6. }  

 

Java代碼  

1. public class BeforeAdvisor implements MethodBeforeAdvice {  
2.     private final static Log log =LogFactory.getLog(BeforeAdvisor.class);  
3.       
4.     private int testSEL;  
5.   
6.     @Override  
7.     public void before(Method method, Object[] args, Object target)  
8.             throws Throwable {  
9.         log.info("in before advice and method="+method.getName()+ " args "+args.length);  
10.     }  
11.  ..........  

 

Java代碼  

1. public class AfterAdvisor implements AfterReturningAdvice {  
2.     private final static Log log =LogFactory.getLog(AfterAdvisor.class);  
3.       
4. ........  
5.   
6.     @Override  
7.     public void afterReturning(Object returnValue, Method method,  
8.             Object[] args, Object target) throws Throwable {  
9.         // TODO Auto-generated method stub  
10.         log.info("test sel the testSEL "+testSEL);  
11.         log.info("after return advice");  
12.     }  
13.   
14. }  

 

 

     而配置文件以下：

Java代碼  

1. <bean id="LogAop" class="com.zzx.study.aop.LogAop" />  
2. <bean id="beforeAdvisor" class="com.zzx.study.aop.BeforeAdvisor" >  
3.    <property name="testSEL" value="11"/>  
4. </bean>  
5. <bean id="beforeAdvisor2" class="com.zzx.study.aop.BeforeAdvisor2" >  
6.    <property name="testSEL" value="23"/>  
7. </bean>  
8. <bean id="afterAdvisor" class="com.zzx.study.aop.AfterAdvisor" >  
9.    <property name="testSEL" value="11"/>  
10. </bean>  
11. <aop:config>  
12.    <aop:pointcut expression="execution(* com.zzx.study.di.BankSecurityDaoImpl.add(..))" id="target" />  
13.    <aop:pointcut expression="execution(* com.zzx.study.di.Ban*.ad*(..))" id="nonePointCutTest" />  
14.    <aop:advisor id="bid" pointcut-ref="target" advice-ref="beforeAdvisor" />  
15.    <aop:advisor id="noAdvisor" pointcut-ref="nonePointCutTest" advice-ref="beforeAdvisor2" />  
16.    <aop:advisor id="aid" pointcut-ref="target" advice-ref="afterAdvisor" />  
17.    <aop:aspect ref="LogAop" >  
18.        <aop:after method="addLog"  pointcut-ref="target"/>  
19.    </aop:aspect>  
20. </aop:config>    

       向上面實現後則若是執行BankSecurityDaoImpl的add方法前就會執行BeforeAdvisor的before方法，而後執行add方法，最後是LogAop的addLog方法，AfterAdvisor的afterReturning方法。這裏還可讓Advisor實現Order定義這些執行的先後。

Java代碼  

1. public class BeforeAdvisor implements MethodBeforeAdvice,Ordered {  
2.     ............  
3.   
4.     @Override  
5.     public int getOrder() {  
6.         // TODO Auto-generated method stub  
7.         return 2;  
8.     }  
9.   
10. }  

 

      這裏的有一個getOrder方法，返回int值，越小則越先執行。

 

• AOP在spring中的實現

       在解析xml的時候說過，若是發現不是bean標籤，則會是不一樣的類來解析。解析aop的爲http\://www.springframework.org/schema/aop=org.springframework.aop.config.AopNamespaceHandler。也就是AopNamespaceHandler類。進去到AopNamespaceHandler類中parse方法，實際是調用其父類的NamespaceHandlerSupport的parse方法。

Java代碼  

1. private BeanDefinitionParser findParserForElement(Element element, ParserContext parserContext) {  
2.         String localName = parserContext.getDelegate().getLocalName(element);  
3.         BeanDefinitionParser parser = this.parsers.get(localName);  
4.         if (parser == null) {  
5.             parserContext.getReaderContext().fatal(  
6.                     "Cannot locate BeanDefinitionParser for element [" + localName + "]", element);  
7.         }  
8.         return parser;  
9. }  

 這裏的parses是在解析xml的時候初始化。

Java代碼  

1. public void init() {  
2.         // In 2.0 XSD as well as in 2.1 XSD.  
3.         registerBeanDefinitionParser("config", new ConfigBeanDefinitionParser());  
4.         registerBeanDefinitionParser("aspectj-autoproxy", new AspectJAutoProxyBeanDefinitionParser());  
5.         registerBeanDefinitionDecorator("scoped-proxy", new ScopedProxyBeanDefinitionDecorator());  
6.   
7.         // Only in 2.0 XSD: moved to context namespace as of 2.1  
8.         registerBeanDefinitionParser("spring-configured", new SpringConfiguredBeanDefinitionParser());  
9. }  

 

 

 若是是config標籤，則是用ConfigBeanDefinitionParser類了，若是是aspectj-autoproxy標籤則是用AspectJAutoProxyBeanDefinitionParser類來解析了。其實這兩個的解析最終都是向DefaultListableBeanFactory中註冊class爲AspectJAwareAdvisorAutoProxyCreator的BeanDefinition。而AspectJAwareAdvisorAutoProxyCreator是有實現BeanPostProcessor、BeanFactoryAware接口的。而實例化一個bean的時候會通過這些BeanPostProcessor的處理。也就是這些BeanPostProcessor最終實現了把目標對象代理掉，而用代理先後spring就會調用到配置的這些Advisor來處理一些業務邏輯了。其中的BeanFactoryAware接口是把BeanFactory注入到AspectJAwareAdvisorAutoProxyCreator這個類中，而最終執行方法前經過這裏注入的BeanFactory獲得這些Advisor類並調用。

 

這裏講使用java動態代理的實現。在JdkDynamicAopProxy類中。使用到了責任鏈的模式，會先獲得一個Advisor的list，而後在list中用鏈的方式執行下去。若是chain不是空的則會到ReflectiveMethodInvocation類中執行processed方法。

Java代碼  

1. public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {  
2.         MethodInvocation invocation;  
3.         Object oldProxy = null;  
4.         boolean setProxyContext = false;  
5.   
6.         TargetSource targetSource = this.advised.targetSource;  
7.         Class targetClass = null;  
8.         Object target = null;  
9.   
10.         try {  
11.             if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) {  
12.                 // The target does not implement the equals(Object) method itself.  
13.                 return equals(args[0]);  
14.             }  
15.             if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {  
16.                 // The target does not implement the hashCode() method itself.  
17.                 return hashCode();  
18.             }  
19.             if (!this.advised.opaque && method.getDeclaringClass().isInterface() &&  
20.                     method.getDeclaringClass().isAssignableFrom(Advised.class)) {  
21.                 // Service invocations on ProxyConfig with the proxy config...  
22.                 return AopUtils.invokeJoinpointUsingReflection(this.advised, method, args);  
23.             }  
24.   
25.             Object retVal;  
26.   
27.             if (this.advised.exposeProxy) {  
28.                 // Make invocation available if necessary.  
29.                 oldProxy = AopContext.setCurrentProxy(proxy);  
30.                 setProxyContext = true;  
31.             }  
32.   
33.             // May be null. Get as late as possible to minimize the time we "own" the target,  
34.             // in case it comes from a pool.  
35.             target = targetSource.getTarget();  
36.             if (target != null) {  
37.                 targetClass = target.getClass();  
38.             }  
39.   
40.             // Get the interception chain for this method.  
41.             List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);  
42.   
43.             // Check whether we have any advice. If we don't, we can fallback on direct  
44.             // reflective invocation of the target, and avoid creating a MethodInvocation.  
45.             if (chain.isEmpty()) {  
46.                 // We can skip creating a MethodInvocation: just invoke the target directly  
47.                 // Note that the final invoker must be an InvokerInterceptor so we know it does  
48.                 // nothing but a reflective operation on the target, and no hot swapping or fancy proxying.  
49.                 retVal = AopUtils.invokeJoinpointUsingReflection(target, method, args);  
50.             }  
51.             else {  
52.                 // We need to create a method invocation...  
53.                 invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);  
54.                 // Proceed to the joinpoint through the interceptor chain.  
55.                 retVal = invocation.proceed();  
56.             }  
57.   
58.             // Massage return value if necessary.  
59.             if (retVal != null && retVal == target && method.getReturnType().isInstance(proxy) &&  
60.                     !RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())) {  
61.                 // Special case: it returned "this" and the return type of the method  
62.                 // is type-compatible. Note that we can't help if the target sets  
63.                 // a reference to itself in another returned object.  
64.                 retVal = proxy;  
65.             }  
66.             return retVal;  
67.         }  
68.         finally {  
69.             if (target != null && !targetSource.isStatic()) {  
70.                 // Must have come from TargetSource.  
71.                 targetSource.releaseTarget(target);  
72.             }  
73.             if (setProxyContext) {  
74.                 // Restore old proxy.  
75.                 AopContext.setCurrentProxy(oldProxy);  
76.             }  
77.         }  
78. }  

 

 

Java代碼  

1. public Object proceed() throws Throwable {  
2.         //  We start with an index of -1 and increment early.  
3.         if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {  
4.             return invokeJoinpoint();  
5.         }  
6.   
7.         Object interceptorOrInterceptionAdvice =  
8.             this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);  
9.         if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {  
10.             // Evaluate dynamic method matcher here: static part will already have  
11.             // been evaluated and found to match.  
12.             InterceptorAndDynamicMethodMatcher dm =  
13.                 (InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;  
14.             if (dm.methodMatcher.matches(this.method, this.targetClass, this.arguments)) {  
15.                 return dm.interceptor.invoke(this);  
16.             }  
17.             else {  
18.                 // Dynamic matching failed.  
19.                 // Skip this interceptor and invoke the next in the chain.  
20.                 return proceed();  
21.             }  
22.         }  
23.         else {  
24.             // It's an interceptor, so we just invoke it: The pointcut will have  
25.             // been evaluated statically before this object was constructed.  
26.             return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);  
27.         }  
28. }  

 

這裏的interceptorOrInterceptionAdvice都是MethodInterceptor類型。由於解析xml的時候，會把<aop:advisor>最終生成class爲DefaultBeanFactoryPointcutAdvisor類的BeanDefinition類，而<aop:aspect>會生成class爲AspectJPointcutAdvisor的BeanDefinition。又經過DefaultAdvisorAdapterRegistry類把Advisor轉換爲MethodInterceptor類。

Java代碼  

1. public class DefaultAdvisorAdapterRegistry implements AdvisorAdapterRegistry, Serializable {  
2.   
3. ...........................  
4.   
5.   
6.     public MethodInterceptor[] getInterceptors(Advisor advisor) throws UnknownAdviceTypeException {  
7.         List<MethodInterceptor> interceptors = new ArrayList<MethodInterceptor>(3);  
8.         Advice advice = advisor.getAdvice();  
9.         if (advice instanceof MethodInterceptor) {  
10.             interceptors.add((MethodInterceptor) advice);  
11.         }  
12.         for (AdvisorAdapter adapter : this.adapters) {  
13.             if (adapter.supportsAdvice(advice)) {  
14.                 interceptors.add(adapter.getInterceptor(advisor));  
15.             }  
16.         }  
17.         if (interceptors.isEmpty()) {  
18.             throw new UnknownAdviceTypeException(advisor.getAdvice());  
19.         }  
20.         return interceptors.toArray(new MethodInterceptor[interceptors.size()]);  
21.     }  
22.   
23.     public void registerAdvisorAdapter(AdvisorAdapter adapter) {  
24.         this.adapters.add(adapter);  
25.     }  
26.   
27. }  

    像beforeAdvisor則轉換爲MethodBeforeAdviceInterceptor這樣的攔截器了。在這個攔截器中的invoke方法中會發現會先調用本身advice的before方法，也就是你本身實現的業務類。接着又會調用processed，也就是鏈接鏈的方式，一直調用下去，知道chain中全部都執行完成。

Java代碼  

1. public class MethodBeforeAdviceInterceptor implements MethodInterceptor, Serializable {  
2.   
3.     private MethodBeforeAdvice advice;  
4.   
5.   
6.     /** 
7.      * Create a new MethodBeforeAdviceInterceptor for the given advice. 
8.      * @param advice the MethodBeforeAdvice to wrap 
9.      */  
10.     public MethodBeforeAdviceInterceptor(MethodBeforeAdvice advice) {  
11.         Assert.notNull(advice, "Advice must not be null");  
12.         this.advice = advice;  
13.     }  
14.   
15.     public Object invoke(MethodInvocation mi) throws Throwable {  
16.         this.advice.before(mi.getMethod(), mi.getArguments(), mi.getThis() );  
17.         return mi.proceed();  
18.     }  
19.   
20. }  

     

       這裏的advice