Spring框架学习【创建AOP代理对象并对目标对象切面拦截】

1.Spring AOP的底层实现常用类：

分析Spring AOP的底层实现首先要从ProxyConfig类开始，ProxyConfig是所有产生Spring AOP代理对象的基类，它是一个数据类，主要为其AOP代理对象工厂实现类提供配置属性。根据ProxyConfig的继承体系分析创建AOP代理常用类的作用：

(1).AdvisedSupport是ProxyConfig的子类，它封装了AOP中对通知(Advice)和通知器(Advisor)的相关操作，这些操作对于不同的AOP的代理对象的生成都是一样的，但对于具体的AOP代理对象的创建，AdvisedSupport把它交给子类去实现。

(2).ProxyCreatorSupport是AdvisedSupport的子类，它是其子类创建AOP代理对象的一个辅助类，提供不同AOP代理对象生成的通用操作，具体的AOP代理对象生成，由ProxyCreatorSupport的子类完成。

(3).创建AOP代理对象的类：

ProxyCreatorSupport有3个子类，分别创建不同的AOP代理对象，具体如下：

a.AspectJProxyFactory：主要用于创建AspectJ的AOP应用，起到集成Spring和AspectJ的作用。

b.ProxyFactory：创建编程式的Spring AOP应用。

c.ProxyFactoryBean：创建声明式的Spring AOP应用。

2.声明式Spring AOP代理工厂对象ProxyFactoryBean：

我们以ProxyFactoryBean为例，分析Spring AOP的实现原理，ProxyFactoryBean是Spring中一个非常灵活的创建AOP应用的底层方法，封装了AOP的主要功能。

一个简单的AOP代理工厂对象的配置如下：

[xhtml] view plaincopyprint?

1. <!--配置通知器，通知器的实现定义了需要对目标对象进行的增强行为-->  
2. <bean id=”testAdvisor” class=”com.test.TestAdvisor”/>  
3. <!--配置AOP代理，封装AOP功能的主要类-->  
4. <bean id=”testAOP” class=”org.springframework.aop.ProxyFactoryBean”>  
5.     <!--AOP代理接口-->  
6.     <property name=”proxyInterfaces”>  
7.         <value>com.test.TestProxyInterface</value>  
8.     </property>  
9.     <!--需要使用AOP切面增强的对象-->  
10.     <property name=”target”>  
11.         <bean class=”com.test.TestTarget”/>  
12.     </property>  
13.     <!--代理拦截器，配置通知器的名称，即通知器在AOP代理的配置下通过使用代理对象的拦截机制发挥作用-->  
14.     <property name=”interceptorNames”>  
15.         <list>  
16.             <value>testAdvisor</value>  
17.         </list>  
18.     </property>  
19. </bean>  

<!--配置通知器，通知器的实现定义了需要对目标对象进行的增强行为--><bean id=”testAdvisor” class=”com.test.TestAdvisor”/><!--配置AOP代理，封装AOP功能的主要类--><bean id=”testAOP” class=”org.springframework.aop.ProxyFactoryBean”> <!--AOP代理接口--> <property name=”proxyInterfaces”> <value>com.test.TestProxyInterface</value> </property> <!--需要使用AOP切面增强的对象--> <property name=”target”> <bean class=”com.test.TestTarget”/> </property> <!--代理拦截器，配置通知器的名称，即通知器在AOP代理的配置下通过使用代理对象的拦截机制发挥作用--> <property name=”interceptorNames”> <list> <value>testAdvisor</value> </list> </property></bean>

3.ProxyFactoryBean生成AOPProxy代理对象：

从2中ProxyFactoryBean的简单配置例子我们可以看出，ProxyFactoryBean是用来配置目标对象和切面行为Advice的，ProxyFactoryBean通过其配置的拦截器名称interceptorNames即通知器Advisor将切面行为Advice应用到目标对象中。

在ProxyFactoryBean中，需要为待增强目标对象目标对象生成Proxy代理对象，从而为AOP切面的编织提供基础，下面通过源码分析ProxyFactoryBean的生成AOPProxy代理对象的实现过程：

(1).ProxyFactoryBean产生代理对象的主要源码：

[java] view plaincopyprint?

1. public class ProxyFactoryBean extends ProxyCreatorSupport  
2.         implements FactoryBean<Object>, BeanClassLoaderAware, BeanFactoryAware {  
3. //标注通知器器为全局通用通知器   
4. public static final String GLOBAL_SUFFIX = "*";  
5. //标志通知器链是否已经完成初始化   
6. private boolean advisorChainInitialized = false;  
7. //单态模式对象   
8. private Object singletonInstance;  
9. ……  
10. //ProxyFactoryBean创建AOPProxy代理的入口方法   
11. public Object getObject() throws BeansException {  
12.         //初始化通知器链   
13.         initializeAdvisorChain();  
14.         //如果目标对象是单态模式   
15.         if (isSingleton()) {  
16.             //调用获取单态模式对象的方法产生AOPProxy代理   
17.             return getSingletonInstance();  
18.         }  
19.         //如果目标对象是原型模式   
20.         else {  
21.             if (this.targetName == null) {  
22.                 logger.warn("Using non-singleton proxies with singleton targets is often undesirable. " +  
23.                         "Enable prototype proxies by setting the 'targetName' property.");  
24.             }  
25.             //调用原型模式对象方法每次创建一个新的AOPProxy代理对象   
26.             return newPrototypeInstance();  
27.         }  
28.     }  
29. //初始化通知器链   
30. private synchronized void initializeAdvisorChain() throws AopConfigException, BeansException {  
31.     //如果通知器链已经被初始化，则直接返回，即通知器链只在第一次获取代理对象时产生   
32.         if (this.advisorChainInitialized) {  
33.             return;  
34.         }  
35.         //如果ProxyFactoryBean中配置的连接器列名名称不为空   
36.         if (!ObjectUtils.isEmpty(this.interceptorNames)) {  
37.             //如果没有Bean工厂(容器)   
38.             if (this.beanFactory == null) {  
39.                 throw new IllegalStateException("No BeanFactory available anymore (probably due to serialization) " +  
40.                         "- cannot resolve interceptor names " + Arrays.asList(this.interceptorNames));  
41.             }  
42.             //全局通知器不能是通知器链中最后一个，除非显式使用属性指定了目标   
43.             if (this.interceptorNames[this.interceptorNames.length - 1].endsWith(GLOBAL_SUFFIX) &&  
44.                     this.targetName == null && this.targetSource == EMPTY_TARGET_SOURCE) {  
45.                 throw new AopConfigException("Target required after globals");  
46.             }  
47.             //遍历通知器链，向容器添加通知器   
48.             for (String name : this.interceptorNames) {  
49.                 if (logger.isTraceEnabled()) {  
50.                     logger.trace("Configuring advisor or advice '" + name + "'");  
51.                 }  
52.                 //如果通知器是全局的   
53.                 if (name.endsWith(GLOBAL_SUFFIX)) {  
54.                     if (!(this.beanFactory instanceof ListableBeanFactory)) {  
55.                         throw new AopConfigException(  
56.                                 "Can only use global advisors or interceptors with a ListableBeanFactory");  
57.                     }  
58.                     //向容器中添加全局通知器   
59.                     addGlobalAdvisor((ListableBeanFactory) this.beanFactory,  
60.                             name.substring(0, name.length() - GLOBAL_SUFFIX.length()));  
61.                 }  
62.                 //如果通知器不是全局的   
63.                 else {  
64.                     Object advice;  
65.                     //如果通知器是单态模式   
66.                     if (this.singleton || this.beanFactory.isSingleton(name)) {  
67.                         //从容器获取单态模式的通知或者通知器   
68.                         advice = this.beanFactory.getBean(name);  
69.                     }  
70.                     //如果通知器是原型模式   
71.                     else {  
72.                         //创建一个新的通知或者通知器对象   
73.                         advice = new PrototypePlaceholderAdvisor(name);  
74.                     }  
75.                     //添加通知器   
76.                     addAdvisorOnChainCreation(advice, name);  
77.                 }  
78.             }  
79.         }  
80.         //设置通知器链已初始化标识   
81.         this.advisorChainInitialized = true;  
82.     }  
83. //获取一个单态模式的AOPProxy代理对象   
84. private synchronized Object getSingletonInstance() {  
85.         //如果单态模式的代理对象还未被创建   
86.         if (this.singletonInstance == null) {  
87.             //获取代理的目标源   
88.             this.targetSource = freshTargetSource();  
89.             //如果ProxyFactoryBean设置了自动探测接口属性，并且没有配置代理接   
90.             //且不是目标对象的直接代理类   
91.             if (this.autodetectInterfaces && getProxiedInterfaces().length == 0 && !isProxyTargetClass()) {  
92.                 //获取代理对象的目标类   
93.                 Class targetClass = getTargetClass();  
94.                 if (targetClass == null) {  
95.                     throw new FactoryBeanNotInitializedException("Cannot determine target class for proxy");  
96.                 }  
97.             //设置代理对象的接口 setInterfaces(ClassUtils.getAllInterfacesForClass(targetClass, this.proxyClassLoader));   
98.             }  
99.     //初始化共享的单态模式对象                   super.setFrozen(this.freezeProxy);   
100.     //调用ProxyFactory生成代理AOPProxy对象   
101.             this.singletonInstance = getProxy(createAopProxy());  
102.         }  
103.         return this.singletonInstance;  
104.     }  <