實現Aop功能有兩種方式，

1. ProxyFactoryBean方式： 這種方式是通過配置實現

2. ProxyFactory方式：這種方式是通過程式設計實現

這裡只說ProxyFactoryBean方式

首先說下具體的配置，一個例子如下：

1. <beanid="testAdvisor"class="com.abc.TestAdvisor"
2.     <propertyname="pointcut"ref="bookPointcut"/>
3.         <propertyname="advice"ref="aroundMethod"></property>
4. </
   bean>
5. <beanid="testAop"class="org.springframeword.aop.ProxyFactoryBean">
6.       <propertyname="proxyInterfaces">
7.               <value>com.test.AbcInterface</value>
8.       </property>
9.       <propertyname="target">
10.               <beanclass="com.abc.TestTarget"/>
11.       </
    property>
12.       <propertyname="interceptorNames">
13.               <list>
14.                         <value>testAdvisor</value>
15.               </list>
16.       </property>
17. </bean>

上述配置中，testAdvisor是配置了一個通知器，該通知器配置了pointcut，即執行該通知需要滿足的條件，還配置了匹配條件時要執行的方法，target配置的是要被增強的目標物件，interceptorNames配置的是一些通知，用來增強目標物件。proxyInterfaces配置的是需要代理的介面名的字串陣列。如果沒有提供，將為目標類使用一個CGLIB代理，即這個介面的配置將會影響是用JDK還是CGLIB來建立目標物件的代理物件。

首先看下ProxyFactoryBean的getObject方法

1. @Override  
2.     public Object getObject() throws BeansException {  
3.         initializeAdvisorChain();  
4.         //生成代理物件時,因為Spring中有singleton型別和prototype型別這兩種不同的Bean,所以要對代理物件的生成做一個區分  
5.         if (isSingleton()) {  
6.             //生成singleton的代理物件,這個方法是ProxyFactoryBean生成AOPProxy代理物件的呼叫入口  
7.             //代理物件會封裝對target目標物件的呼叫,也就是說針對target物件的方法呼叫行為會被這裡生成的代理物件所攔截  
8.             return getSingletonInstance();  
9.         }  
10.         else {  
11.             if (this.targetName == null) {  
12.                 logger.warn("Using non-singleton proxies with singleton targets is often undesirable. " +  
13.                         "Enable prototype proxies by setting the 'targetName' property.");  
14.             }  
15.             return newPrototypeInstance();  
16.         }  
17.     }  

這個方法其實就是用來為目標物件生成代理物件的

initializeAdvisorChain是初始化通知器鏈，即從上述配置中讀取interceptorNames引數的值就可以拿到所有為目標物件配置的通知器，該方法的程式碼如下：

1. /**  
2.      * Create the advisor (interceptor) chain. Advisors that are sourced  
3.      * from a BeanFactory will be refreshed each time a new prototype instance  
4.      * is added. Interceptors added programmatically through the factory API  
5.      * are unaffected by such changes.  
6.      * 初始化通知器鏈,通知器鏈封裝了一系列的攔截器,這些攔截器都需要從配置中讀取,然後為代理物件的生成做好準備  
7.      */  
8.     private synchronized void initializeAdvisorChain() throws AopConfigException, BeansException {  
9.         //這個標誌位是用來表示通知器鏈是否已經初始化,初始化的工作發生在應用第一次通過ProxyFactoryBean去獲取代理物件的時候  
10.         if (this.advisorChainInitialized) {  
11.             return;  
12.         }  
13.         if (!ObjectUtils.isEmpty(this.interceptorNames)) {  
14.             if (this.beanFactory == null) {  
15.                 throw new IllegalStateException("No BeanFactory available anymore (probably due to serialization) " +  
16.                         "- cannot resolve interceptor names " + Arrays.asList(this.interceptorNames));  
17.             }  
18.             // Globals can't be last unless we specified a targetSource using the property...  
19.             if (this.interceptorNames[this.interceptorNames.length - 1].endsWith(GLOBAL_SUFFIX) &&  
20.                     this.targetName == null && this.targetSource == EMPTY_TARGET_SOURCE) {  
21.                 throw new AopConfigException("Target required after globals");  
22.             }  
23.             // Materialize interceptor chain from bean names.  
24.             //這裡是新增Advisor鏈的呼叫,是通過interceptorNames屬性進行配置的  
25.             //this.interceptorNames就是配置中配置的所有通知器  
26.             for (String name : this.interceptorNames) {  
27.                 if (logger.isTraceEnabled()) {  
28.                     logger.trace("Configuring advisor or advice '" + name + "'");  
29.                 }  
30.                 if (name.endsWith(GLOBAL_SUFFIX)) {  
31.                     if (!(this.beanFactory instanceof ListableBeanFactory)) {  
32.                         throw new AopConfigException(  
33.                                 "Can only use global advisors or interceptors with a ListableBeanFactory");  
34.                     }  
35.                     addGlobalAdvisor((ListableBeanFactory) this.beanFactory,  
36.                             name.substring(0, name.length() - GLOBAL_SUFFIX.length()));  
37.                 }  
38.                 else {  
39.                     // If we get here, we need to add a named interceptor.  
40.                     // We must check if it's a singleton or prototype.  
41.                     //如果程式在這裡被呼叫,那麼需要加入命名的攔截器advice,並且需要檢查這個Bean是singleton還是prototype  
42.                     Object advice;  
43.                     if (this.singleton || this.beanFactory.isSingleton(name)) {  
44.                         // Add the real Advisor/Advice to the chain.  
45.                         //取得advisor的地方,是通過beanFactory取得的,把intercepNames這個List中的interceptor的名字交給BeanFactory,然後通過getBean去獲取  
46.                         advice = this.beanFactory.getBean(name);  
47.                     }  
48.                     else {  
49.                         // It's a prototype Advice or Advisor: replace with a prototype.  
50.                         // Avoid unnecessary creation of prototype bean just for advisor chain initialization.  
51.                         advice = new PrototypePlaceholderAdvisor(name);  
52.                     }  
53.                     addAdvisorOnChainCreation(advice, name);  
54.                 }  
55.             }  
56.         }  
57.         this.advisorChainInitialized = true;  
58.     }  

其他的getSingletonInstance方法和newPrototypeInstance類其實就是構造代理物件

其中getSingletonInstance方法的程式碼如下：

1. private synchronized Object getSingletonInstance() {  
2.         if (this.singletonInstance == null) {  
3.             this.targetSource = freshTargetSource();  
4.             if (this.autodetectInterfaces && getProxiedInterfaces().length == 0 && !isProxyTargetClass()) {  
5.                 // Rely on AOP infrastructure to tell us what interfaces to proxy.  
6.                 //根據AOP框架來判斷需要代理的介面  
7.                 Class<?>targetClass = getTargetClass();  
8.                 if (targetClass == null) {  
9.                     throw new FactoryBeanNotInitializedException("Cannot determine target class for proxy");  
10.                 }  
11.                 //設定代理物件的介面  
12.                 setInterfaces(ClassUtils.getAllInterfacesForClass(targetClass, this.proxyClassLoader));  
13.             }  
14.             // Initialize the shared singleton instance.  
15.             super.setFrozen(this.freezeProxy);  
16.             //createAopProxy()方法可能會返回ObjenesisCglibAopProxy物件,也可能會返回JdkDynamicAopProxy物件  
17.             //然後getProxy方法會根據ObjenesisCglibAopProxy或者JdkDynamicAopProxy物件的getProxy方法來生成最終的代理物件  
18.             //這就是所謂的,Spring生成代理物件的兩種方式,一種是CGLIB,一種是JDK  
19.             this.singletonInstance = getProxy(createAopProxy());    //這裡的方法會使用ProxyFactory來生成需要的Proxy,通過createAopProxy返回的AopProxy來得到代理物件  
20.         }  
21.         return this.singletonInstance;  
22.     }  

注意this.singletonInstance = getProxy(createAopProxy());這行程式碼

createAopProxy()方法可能會返回ObjenesisCglibAopProxy物件,也可能會返回JdkDynamicAopProxy物件，這個邏輯是在DefaultAopProxyFactory
類中實現的，邏輯如下：

1. public class DefaultAopProxyFactory implements AopProxyFactory, Serializable {  
2.     //config裡面封裝了想要生成的代理物件的資訊  
3.     @Override  
4.     public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {  
5.         if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {  
6.             Class<?>targetClass = config.getTargetClass();   //首先要從AdvisedSupport物件中取得配置的目標物件,如果目標物件為空,則直接丟擲異常,因為連目標物件都沒有,還為誰建立代理物件  
7.             if (targetClass == null) {  
8.                 throw new AopConfigException("TargetSource cannot determine target class: " +  
9.                         "Either an interface or a target is required for proxy creation.");  
10.             }  
11.             //關於AopProxy代理物件的生成,需要考慮使用哪種生成方式,如果目標物件是介面類,那麼適合使用JDK來生成代理物件,否則spring會使用CGLIB來生成目標物件的代理物件  
12.             //對於具體的AopProxy代理物件的生成,最終並不是由DefaultAopProxyFactory來完成,而是分別由JdkDynamicAopProxy和ObjenesisCglibAopProxy完成  
13.             if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {  
14.                 return new JdkDynamicAopProxy(config);  //使用JDK來生成AOPProxy代理物件  
15.             }  
16.             return new ObjenesisCglibAopProxy(config);  //使用第三方CGLIB來生成AOPProxy代理物件  
17.         }  
18.         else {  
19.             return new JdkDynamicAopProxy(config);  
20.         }  
21.     }  

可以看到，它會根據目標類是不是介面等資訊來判定使用ObjenesisCglibAopProxy還是JdkDynamicAopProxy

然後getProxy方法會根據ObjenesisCglibAopProxy或者JdkDynamicAopProxy物件的getProxy方法來生成最終的代理物件
這就是所謂的,Spring生成代理物件的兩種方式,一種是CGLIB,一種是JDK

下面說說用JdkDynamicAopProxy方式生成的代理物件的攔截方式，它實際用的就是JDK的動態代理

我們知道，動態代理攔截的入口是實現了InvocationHandler介面後的invoke方法，即所有對目標方法的呼叫首先會被invoke方法攔截

而JdkDynamicAopProxy方式實現的動態代理的攔截入口也是該類的invoke方法，該類的部分方法如下：

1. /**  
2.  * JDK-based {@link AopProxy} implementation for the Spring AOP framework  
3.  *InvocationHandler介面的invoke方法就是攔截回撥的入口,即對目標方法的呼叫會先被invoke方法攔截,並在invoke方法裡面來呼叫目標方法  
4.  */  
5. final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializable {  
6.     public JdkDynamicAopProxy(AdvisedSupport config) throws AopConfigException {  
7.         Assert.notNull(config, "AdvisedSupport must not be null");  
8.         if (config.getAdvisors().length == 0 && config.getTargetSource() == AdvisedSupport.EMPTY_TARGET_SOURCE) {  
9.             throw new AopConfigException("No advisors and no TargetSource specified");  
10.         }  
11.         this.advised = config;  
12.     }  
13.     @Override  
14.     public Object getProxy() {  
15.         return getProxy(ClassUtils.getDefaultClassLoader());  
16.     }  
17.     @Override  
18.     public Object getProxy(ClassLoader classLoader) {  
19.         if (logger.isDebugEnabled()) {  
20.             logger.debug("Creating JDK dynamic proxy: target source is " + this.advised.getTargetSource());  
21.         }  
22.         //首先從advised物件中取得代理物件的代理介面配置  
23.         Class<?>[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised, true);  
24.         findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);  
25.         //第三個引數需要實現InvocationHandler介面和invoke方法,這個invoke方法是Proxy代理物件的回撥方法  
26.         //這種方式其實就是用JDK的動態代理來為目標物件建立代理物件,對目標物件方法的呼叫就是由這個代理物件來呼叫的  
27.         return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);  
28.     }  
29.     /**  
30.      * Implementation of {@code InvocationHandler.invoke}.  
31.      * <p>Callers will see exactly the exception thrown by the target,  
32.      * unless a hook method throws an exception.  
33.      * 攔截回撥入口  
34.      */  
35.     @Override  
36.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {  
37.         MethodInvocation invocation;  
38.         Object oldProxy = null;  
39.         boolean setProxyContext = false;  
40.         TargetSource targetSource = this.advised.targetSource;  
41.         Class<?>targetClass = null;  
42.         Object target = null;  
43.         try {  
44.             //如果目標物件沒有實現Object類的基本方法:equals  
45.             if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) {  
46.                 // The target does not implement the equals(Object) method itself.  
47.                 return equals(args[0]);  
48.             }  
49.             //如果目標物件沒有實現Object類的基本方法:hashcode  
50.             else if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {  
51.                 // The target does not implement the hashCode() method itself.  
52.                 return hashCode();  
53.             }  
54.             else if (method.getDeclaringClass() == DecoratingProxy.class) {  
55.                 // There is only getDecoratedClass() declared -> dispatch to proxy config.  
56.                 return AopProxyUtils.ultimateTargetClass(this.advised);  
57.             }  
58.             else if (!this.advised.opaque && method.getDeclaringClass().isInterface() &&  
59.                     method.getDeclaringClass().isAssignableFrom(Advised.class)) {  
60.                 // Service invocations on ProxyConfig with the proxy config...  
61.                 //根據代理物件的配置來呼叫服務  
62.                 return AopUtils.invokeJoinpointUsingReflection(this.advised, method, args);  
63.             }  
64.             Object retVal;  
65.             if (this.advised.exposeProxy) {  
66.                 // Make invocation available if necessary.  
67.                 oldProxy = AopContext.setCurrentProxy(proxy);  
68.                 setProxyContext = true;  
69.             }  
70.             // May be null. Get as late as possible to minimize the time we "own" the target,  
71.             // in case it comes from a pool.  
72.             //得到目標物件  
73.             target = targetSource.getTarget();  
74.             if (target != null) {  
75.                 targetClass = target.getClass();  
76.             }  
77.             // Get the interception chain for this method.  獲取方法method的攔截器鏈  
78.             // 攔截器鏈實際就是由一系列的Advice通知物件組成的  
79.             List<Object>chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);  
80.             // Check whether we have any advice. If we don't, we can fallback on direct  
81.             // reflective invocation of the target, and avoid creating a MethodInvocation.  
82.             //如果沒有定義攔截器鏈,就直接呼叫target物件的對應方法  
83.             if (chain.isEmpty()) {  
84.                 // We can skip creating a MethodInvocation: just invoke the target directly  
85.                 // Note that the final invoker must be an InvokerInterceptor so we know it does  
86.                 // nothing but a reflective operation on the target, and no hot swapping or fancy proxying.  
87.                 Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args); //適配引數  
88.                 //呼叫target物件的對應方法  
89.                 retVal = AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);  
90.             }  
91.             else {  
92.                 // We need to create a method invocation...  
93.                 //如果有攔截器的設定,那麼需要呼叫攔截器之後才呼叫目標物件的相應方法,通過構造一個ReflectiveMethodInvocation來實現  
94.                 invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);  
95.                 // Proceed to the joinpoint through the interceptor chain.  
96.                 //沿著攔截器鏈繼續前進  
97.                 retVal = invocation.proceed();  
98.             }  
99.             // Massage return value if necessary.  
100.             Class<?>returnType = method.getReturnType();  
101.             if (retVal != null && retVal == target && returnType.isInstance(proxy) &&  
102.                     !RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())) {  
103.                 // Special case: it returned "this" and the return type of the method  
104.                 // is type-compatible. Note that we can't help if the target sets  
105.                 // a reference to itself in another returned object.  
106.                 retVal = proxy;  
107.             }  
108.             else if (retVal == null && returnType != Void.TYPE && returnType.isPrimitive()) {  
109.                 throw new AopInvocationException(  
110.                         "Null return value from advice does not match primitive return type for: " + method);  
111.             }  
112.             return retVal;  
113.         }  
114.         finally {  
115.             if (target != null && !targetSource.isStatic()) {  
116.                 // Must have come from TargetSource.  
117.                 targetSource.releaseTarget(target);  
118.             }  
119.             if (setProxyContext) {  
120.                 // Restore old proxy.  
121.                 AopContext.setCurrentProxy(oldProxy);  
122.             }  
123.         }  
124.     }  
125. }  

上述getProxy方法其實就是JdkDynamicAopProxy用來給目標物件生成程式碼物件的方法

而invoke就是對目標方法呼叫時的攔截入口

其中的

List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);

這行程式碼就是獲取到目標物件所有的攔截器，為什麼這裡是獲取攔截器？其實在上面初始化通知器鏈的時候拿到的都是配置的通知器，這個方法是要將這些通知器用對應的介面卡

適配成對應的攔截器，至於為什麼要做這個步驟，在我的另外一篇部落格中說的很清楚了，地址如下：

http://blog.csdn.NET/u011734144/article/details/73436539

這裡轉換成攔截器後，也並不是直接就要將該攔截器加入最終要執行的攔截器鏈中，還需要判斷對應的通知是否應該執行，對應的程式碼片段如下：

1. //對配置的advisor通知器進行逐個遍歷,這個通知器鏈都是配置在interceptorNames中的  
2.         for (Advisor advisor : config.getAdvisors()) {  
3.             if (advisor instanceof PointcutAdvisor) {  
4.                 // Add it conditionally.  
5.                 PointcutAdvisor pointcutAdvisor = (PointcutAdvisor) advisor;  
6.                 if (config.isPreFiltered() || pointcutAdvisor.getPointcut().getClassFilter().matches(actualClass)) {  
7.                     //registry.getInterceptors(advisor)是對從ProxyFactoryBean配置中得到的通知進行適配,從而得到相應的攔截器,再把它加入到前面設定好的list中去  
8.                     //從而完成所謂的攔截器註冊過程  
9.                     MethodInterceptor[] interceptors = registry.getInterceptors(advisor);  
10.                     MethodMatcher mm = pointcutAdvisor.getPointcut().getMethodMatcher();  
11.                     if (MethodMatchers.matches(mm, method, actualClass, hasIntroductions)) {  
12.                         if (mm.isRuntime()) {  
13.                             // Creating a new object instance in the getInterceptors() method  
14.                             // isn't a problem as we normally cache created chains.  
15.                             for (MethodInterceptor interceptor : interceptors) {  
16.                                 interceptorList.add(new InterceptorAndDynamicMethodMatcher(interceptor, mm));  
17.                             }  
18.                         }  
19.                         else {  
20.                             interceptorList.addAll(Arrays.asList(interceptors));  
21.                         }  
22.                     }  
23.                 }  
24.             }  
25.             else if (advisor instanceof IntroductionAdvisor) {  
26.                 IntroductionAdvisor ia = (IntroductionAdvisor) advisor;  
27.                 if (config.isPreFiltered() || ia.getClassFilter().matches(actualClass)) {  
28.                     Interceptor[] interceptors = registry.getInterceptors(advisor);  
29.                     interceptorList.addAll(Arrays.asList(interceptors));  
30.                 }  
31.             }  
32.             else {  
33.                 Interceptor[] interceptors = registry.getInterceptors(advisor);  
34.                 interceptorList.addAll(Arrays.asList(interceptors));  
35.             }  
36.         }  

這裡需要判斷通知器中配置的切入點是否匹配當前要被呼叫的方法，即MethodMatchers.matches是否為true，只有匹配的通知才會將對應的攔截器加入到最終待執行的攔截器鏈中

接下來invoke方法中比較核心的就是如下程式碼：

1. retVal = invocation.proceed();  

這個方法其實就是啟動攔截器鏈的執行，依次執行每一個攔截器鏈，在每一個攔截器裡面都會根據通知的型別來決定是先執行通知的方法還是先繼續執行下一個攔截器，