Spring Aop技术原理分析

　　本篇文章从Aop xml元素的解析开始，分析了Aop在Spring中所使用到的技术。包括Aop各元素在容器中的表示方式、Aop自动代理的技术、代理对象的生成及Aop拦截链的调用等等。将这些技术串联起来，就能勾勒出Aop在Spring中的使用脉络。

一、Spring Aop的解析

　　在Spring xml配置中，不同的功能配置通过不同的命名空间引入，如事务方面的配置通过引入http://www.springframework.org/schema/tx命名空间来实现，而对Aop的配置则是引入http://www.springframework.org/schema/aop。对于引入的这些命名空间及其元素，Spring注册了不同的NamespaceHandler类型来处理，如Aop配置元素的解析就是通过AopNamespaceHandler来实现。在Spring中，各种NamespaceHandler的继承关系如下图所示：





以Aop配置信息为例，对于该命名空间各元素的解析主要是通过AopNamespaceHandler来注册，每一个元素对应一个解析器，其源码如下所示：

public void init() {
// In 2.0 XSD as well as in 2.1 XSD.
registerBeanDefinitionParser("config", new ConfigBeanDefinitionParser());
registerBeanDefinitionParser("aspectj-autoproxy", new AspectJAutoProxyBeanDefinitionParser());
registerBeanDefinitionDecorator("scoped-proxy", new copedProxyBeanDefinitionDecorator());

// Only in 2.0 XSD: moved to context namespace as of 2.1
registerBeanDefinitionParser("spring-configured", new SpringConfiguredBeanDefinitionParser());
}

如果在xml配置文件中配置了<aop:aspectj-autoproxy />元素，则是通过SpringConfiguredBeanDefinitionParser类来解析。Spring将所要用到的handler分别配置在jar包的META-INF/ spring.handlers文件中，spring-aop包中的文件信息如下：

http\://www.springframework.org/schema/aop=org.springframework.aop.config.AopNamespaceHandler

对spring.handlers文件的加载则是在DefaultNamespaceHandlerResolver中，

private Map<String, Object> getHandlerMappings() {
if (this.handlerMappings == null) {
synchronized (this) {
if (this.handlerMappings == null) {
try {
Properties mappings =PropertiesLoaderUtils.loadAllProperties(this.handlerMappingsLocation, this.classLoader);
Map<String, Object> handlerMappings = new ConcurrentHashMap<String, Object>(mappings.size());
CollectionUtils.mergePropertiesIntoMap(mappings, handlerMappings);
his.handlerMappings = handlerMappings;
}
catch (IOException ex) {
}
}
}
}
return this.handlerMappings;
}

其中handlerMappingsLocation为META-INF/spring.handlers。DefaultNamespaceHandlerResolver类存放在XmlReaderContext类中，由BeanDefinitionParserDelegate和BeanDefinitionParserDelegate调用，而这两个则在DefaultBeanDefinitionDocumentReader类中使用，最终由各种BeanFarctory(Spring容器)来调用。

二、注册AutoProxyCreator类

针对@AspectJ风格的AOP,Spring Aop提供了两个AutoProxyCreator实现类进行自动代理，分别是AspectJAwareAdvisorAutoProxyCreator和AnnotationAwareAspectJAutoProxyCreator，对应于配置文件（<aop:config>）和使用注解的方式。在配置文件中加入<aop:aspect-autoproxy/>，spring会使用AnnotationAwareAspectJAutoProxyCreator，而加入<aop:config />则会使用AspectJAwareAdvisorAutoProxyCreator。在Spring内部，只会使用其中之一。如果两种方式都配置了，则会使用AnnotationAwareAspectJAutoProxyCreator（在spring内部注解方式的优先级更高），详情可以查看AopConfigUtils类。因为AnnotationAwareAspectJAutoProxyCreator继承于AspectJAwareAdvisorAutoProxyCreator ，在调用自己的处理逻辑之前，会调用父类的实现逻辑，所以前者兼容后者。

三、Aop代理对象的生成

通过配置文件（或注解）将Aop切面配置好之后，ConfigBeanDefinitionParser类会将pointcut,advisor和aspect解析生成BeanDefinition，并注册到相应的BeanFactory中，以便在AspectJAwareAdvisorAutoProxyCreator中使用，解析的代码如下:

public BeanDefinition parse(Element element, ParserContext parserContext) {
CompositeComponentDefinition compositeDef =
new CompositeComponentDefinition(element.getTagName(), parserContext.extractSource(element));
parserContext.pushContainingComponent(compositeDef);

configureAutoProxyCreator(parserContext, element);

List<Element> childElts = DomUtils.getChildElements(element);
for (Element elt: childElts) {
String localName = parserContext.getDelegate().getLocalName(elt);
if (POINTCUT.equals(localName)) {
parsePointcut(elt, parserContext);
}
else if (ADVISOR.equals(localName)) {
parseAdvisor(elt, parserContext);
}
else if (ASPECT.equals(localName)) {
parseAspect(elt, parserContext);
}
}

parserContext.popAndRegisterContainingComponent();
return null;
}

每当读取到aop:config元素时，spring会将其子元素分别解析并注册到BeanFactory中。当调用getBean()时，BeanFactory会调用注册到容器中的BeanPostProcessor（AspectJAwareAdvisorAutoProxyCreator）对象，判断是否满足拦截请求，如果满足，则获取所有满足条件的Advisor,加入到ProxyFactory中，生成代理对象返回，其代码如下所示：

protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {

// Create proxy if we have advice.
Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
if (specificInterceptors != DO_NOT_PROXY) {
this.advisedBeans.put(cacheKey, Boolean.TRUE);
Object proxy = createProxy(bean.getClass(), beanName,
pecificInterceptors, new SingletonTargetSource(bean));
this.proxyTypes.put(cacheKey, proxy.getClass());
return proxy;
}

this.advisedBeans.put(cacheKey, Boolean.FALSE);
return bean;
}

在BeanFactory生成Bean对象的时候，会对Bean对象进行一些初始化操作，1）判断是否继承aware接口，然后注入相应的aware对象；2）调用BeanPostProcessor类中的postProcessBeforeInitialization方法；3）判断是否继承InitializingBean，然后afterPropertiesSet方法；4），调用BeanPostProcessor类中的postProcessAfterInitialization方法。对代理对象的生成主要是在第2和第4步，其代码如下所示：

protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
if (System.getSecurityManager() != null) {
AccessController.doPrivileged(new PrivilegedAction<Object>() {
public Object run() {
invokeAwareMethods(beanName, bean);
return null;
}
}, getAccessControlContext());
}
else {
// step 1
invokeAwareMethods(beanName, bean);
}

Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
// step 2
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}

try {
// step 3
invokeInitMethods(beanName, wrappedBean, mbd);
}
catch (Throwable ex) {
throw new BeanCreationException(
(mbd != null ? mbd.getResourceDescription() : null),
beanName, "Invocation of init method failed", ex);
}

if (mbd == null || !mbd.isSynthetic()) {
// step 4
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}

在Spring容器中有可能会注册多个BeanPostProcessor,执行第2和第4步时，它会返回第一个不为空的对象，这时起作用的只有一个BeanPostProcessor对象，所以在注册自动代理对象的时候要尤为注意，其代码如下所示：

public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName) throws BeansException {

Object result = existingBean;
for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
result = beanProcessor.postProcessAfterInitialization(result, beanName);
if (result == null) {
return result;
}
}
return result;
}

四、Aop拦截链的调用

在代理对象中，有可能会有多个Advisor对象与之匹配，这些Advisor会在最终目标对象执行之前，按照指定的顺序和优先级执行，顺序号决定优先级，顺序号越小，优先级越高，优先级排在前面的，将被优先执行。默认情况下，如果不明确指定各个Advisor的执行顺序，那么Spring会按照它们的声明顺序应用他们，最先声明的顺序号最小但优先级最大，其次将之。顺序号由Ordered指定，在BeanPostProcessor 各个子类中实现排序，如AspectJAwareAdvisorAutoProxyCreator中的sortAdvisors函数。

代理对象中会存有一个Advisor列表，以JdkDynamicAopProxy（CglibAopProxy类似）为例，它实现了InvocationHandler接口，并将自己传给了代理对象，在代理对象中会调用其invoke方法，在该方法中有一段关键代码：

// 得到这个方法的拦截器链
List<Object> chain =
this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);

// 判断拦截器链是否为空，若为空，直接调用目标方法
if (chain.isEmpty()) {
// 直接调用目标方法
retVal = AopUtils.invokeJoinpointUsingReflection(target, method, args);
}
else {
// 调用拦截器链
invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
retVal = invocation.proceed();
}

调用拦截器链的功能主要ReflectiveMethodInvocation类中的proceed方法来实现，代码如下所示：

public Object proceed() throws Throwable {
// 判断是否到了链尾，如果是则执行目标方法，调用结束。
if (this.currentInterceptorIndex ==
this.interceptorsAndDynamicMethodMatchers.size() - 1) {
return invokeJoinpoint();
}
// 取出当前的Advisor;
Object interceptorOrInterceptionAdvice = this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
// 判断是否需要动态判断参数，如果需要则执行如下操作；
　　　　　　　// 参数验证通过则执行Advisor，否则跳过该Advisor；
InterceptorAndDynamicMethodMatcher dm = (InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
if (dm.methodMatcher.matches(this.method, this.targetClass, this.arguments)) {
return dm.interceptor.invoke(this);
}
else {
return proceed();
}
}
else {
// 如果不需要动态判断参数，则执行该Advisor，因为在之前已经验证通过了；
return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
}
}

在上面的代码中，好像并没有类似递归操作的语句（也没有循环语句）来执行拦截器链，那么代码是怎么执行多个Advisor的？Spring对三种Advisor（MethodBeforeAdvice,AfterReturningAdvice和ThrowsAdvice）采用了适配器方式，将它们转换为MethodInterceptor方法，如MethodBeforeAdviceAdapter实现如下:

class MethodBeforeAdviceAdapter implements AdvisorAdapter, Serializable {

public boolean supportsAdvice(Advice advice) {
return (advice instanceof MethodBeforeAdvice);
}

public MethodInterceptor getInterceptor(Advisor advisor) {
MethodBeforeAdvice advice = (MethodBeforeAdvice) advisor.getAdvice();
return new MethodBeforeAdviceInterceptor(advice);
}
}

MethodBeforeAdvice的语义是指在目标方法之前执行，在MethodBeforeAdviceInterceptor类按照其语义进行了转义，使得在ReflectiveMethodInvocation类中可以统一用invoke方法进行调用，其invoke方法代码如下所示：

public Object invoke(MethodInvocation mi) throws Throwable {
this.advice.before(mi.getMethod(), mi.getArguments(), mi.getThis() );
return mi.proceed();
}

对比BeforeAdvice的适配，现在应该可以想像AfterReturningAdvice的适配了，那就是先执行mi.proceed()方法，然后再执行advice的after方法，用代码来验证一下：

public Object invoke(MethodInvocation mi) throws Throwable {
Object retVal = mi.proceed();
this.advice.afterReturning(retVal, mi.getMethod(), mi.getArguments(), mi.getThis());
return retVal;
}

回到刚才的问题，代码是怎么完成递归操作的？看了代码，应该很清楚了。在MethodBeforeAdviceInterceptor的invoke方法中，有mi.proceed()这样的语句，而mi则是由ReflectiveMethodInvocation传入的this对象，即其自身对象。可以用如下的序列图来表示：





五、总结

用一句话来形容Aop,那就是proxy+Interceptors+target,即一个代理对象，多个拦截器再加目标对象的技术。

附录：

1、《spring揭穿》。

（转载本站文章请注明作者和出处 http://www.cnblogs.com/noahsark/ ，请勿用于任何商业用途)