Spring源码阅读（六）—AOP获取增强
本文主要分析了AOP功能实现中的自定义标签解析和增强的获取
个人主页：tuzhenyu’s page 原文地址：Spring源码阅读（六）—AOP获取增强
(0) Spring AOP实现的主要步骤
解析AOP自定义标签，注册AnnotationAwareAspectJAutoProxyCreator自动代理创建器
获取增强
创建代理
(1) 解析AOP自定义标签
AOP功能实现的最基本入口在XML配置文件中的AOP功能的开启；
<aop:aspectj-autoproxy>
在容器初始化解析XML配置文件会将标签分为普通标签和自定义标签分别进行解析处理.
protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate
delegate) {
if (
delegate.isDefaultNamespace(root)) {
NodeList nl = root.getChildNodes();
for (
int i =
0; i < nl.getLength(); i++) {
Node node = nl.item(i);
if (node instanceof Element) {
Element ele = (Element) node;
if (
delegate.isDefaultNamespace(ele)) {
parseDefaultElement(ele,
delegate);
}
else {
delegate.parseCustomElement(ele);
}
}
}
}
else {
delegate.parseCustomElement(root);
}
}
aop标签属于自定义标签会调用相应的处理器进行处理
public BeanDefinition
parseCustomElement(Element ele, BeanDefinition containingBd) {
String namespaceUri = getNamespaceURI(ele);
NamespaceHandler handler =
this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
if (handler ==
null) {
error(
"Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri +
"]", ele);
return null;
}
return handler.parse(ele,
new ParserContext(
this.readerContext,
this, containingBd));
}
从NamespaceHandler中获取aop的aspectj-autoproxy对应的解析器是AspectJAutoProxyBeanDefinitionParser
public void init() {
this.registerBeanDefinitionParser(
"config",
new ConfigBeanDefinitionParser());
this.registerBeanDefinitionParser(
"aspectj-autoproxy",
new AspectJAutoProxyBeanDefinitionParser());
this.registerBeanDefinitionDecorator(
"scoped-proxy",
new ScopedProxyBeanDefinitionDecorator());
this.registerBeanDefinitionParser(
"spring-configured",
new SpringConfiguredBeanDefinitionParser());
}
所有解析器都是由 BeanDefinitionParser 接口的统一实现，入口都是从 parse函数开始的
public BeanDefinition
parse(Element element, ParserContext parserContext) {
AopNamespaceUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(parserContext, element);
extendBeanDefinition(element, parserContext);
return null;
}
registerAspectJAnnotationAutoProxyCreatorIfNecessary 函数是 AnnotationAwareAspectJAutoProxyCreator 注册的地方，也是注册的主要逻辑实现的地方。主要实现了一下三个功能：
AnnotationAwareAspectJAutoProxyCreator的注册或升级
对于 proxy-target-class 以及 expose-proxy 属性的处理，用于判断是否强制使用CGLIB代理模式
注册组件并通知，便于监听器作进一步处理.
public static void registerAspectJAnnotationAutoProxyCreatorIfNecessary(ParserContext parserContext, Element sourceElement) {
BeanDefinition beanDefinition = AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(parserContext.getRegistry(), parserContext.extractSource(sourceElement));
useClassProxyingIfNecessary(parserContext.getRegistry(), sourceElement);
registerComponentIfNecessary(beanDefinition, parserContext);
}
至此，aop自定义标签完成了解析，同时也将AnnotationAwareAspectJAutoProxyCreator注册到了处理器中．
(2) AOP代理实现的入口
spring 容器启动,在每个bean实例话过程中会首先尝试到缓存中获取，获取上失败后会调用createBean()方法从头创建bean．在调用doCreateBean()方法正式创建之前会调用resolveBeforeInstantiation()方法尝试是否创建代理类替代真正的实例，如果创建成功则直接返回跳过后续的真正创建过程，如果创建失败则继续创建bean实例．
Object beanInstance;
try {
beanInstance =
this.resolveBeforeInstantiation(beanName, mbd);
if(beanInstance !=
null) {
return beanInstance;
}
}
catch (Throwable var6) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"BeanPostProcessor before instantiation of bean failed", var6);
}
在resolveBeforeInstantiation()方法中会调用提前注册的处理器AnnotationAwareAspectJAutoProxyCreator的postProcessAfterInitialization()方法实现代理的创建
protected
Object resolveBeforeInstantiation(
String beanName, RootBeanDefinition mbd) {
Object bean =
null;
if(!
Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
if(!mbd.isSynthetic() &&
this.hasInstantiationAwareBeanPostProcessors()) {
Class targetType =
this.determineTargetType(beanName, mbd,
new Class[
0]);
if(targetType !=
null) {
bean =
this.applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
if(bean !=
null) {
bean =
this.applyBeanPostProcessorsAfterInitialization(bean, beanName);
}
}
}
mbd.beforeInstantiationResolved =
Boolean.valueOf(bean !=
null);
}
return bean;
}
postProcessAfterInitialization()方法调用wrapIfNecessary()方法进行代理的实现
public Object <strong>postProcessAfterInitialization</strong>(Object bean, String beanName)
throws BeansException {
if (bean !=
null) {
Object cacheKey = getCacheKey(bean.getClass(), beanName);
if (!
this.earlyProxyReferences.containsKey(cacheKey)) {
return wrapIfNecessary(bean, beanName, cacheKey);
}
}
return bean;
}
wrapIfNecessary()方法实现了aop实现的主要逻辑，调用getAdvicesAndAdvisorsForBean()提取当前bean 的所有增强方法，然后调用createProxy()方法创建具体代理．
protected Object
wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
if (beanName !=
null &&
this.targetSourcedBeans.containsKey(beanName)) {
return bean;
}
if (Boolean.FALSE.equals(
this.advisedBeans.
get(cacheKey))) {
return bean;
}
if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
this.advisedBeans.put(cacheKey, Boolean.FALSE);
return bean;
}
Object[] specificInterceptors = <strong>getAdvicesAndAdvisorsForBean</strong>(bean.getClass(), beanName,
null);
if (specificInterceptors != DO_NOT_PROXY) {
this.advisedBeans.put(cacheKey, Boolean.TRUE);
Object proxy = createProxy(bean.getClass(), beanName, specificInterceptors,
new SingletonTargetSource(bean));
this.proxyTypes.put(cacheKey, proxy.getClass());
return proxy;
}
this.advisedBeans.put(cacheKey, Boolean.FALSE);
return bean;
}
(3) AOP增强的获取
getAdvicesAndAdvisorsForBean()主要是通过调用findEligibleAdvisors()方法用来获取该bean的增强列表．主要步骤包括:
寻找所有增强
从所有增强中获取适合该bean的增强．
protected List<Advisor> findEligibleAdvisors(
Class beanClass, String beanName) {
List<Advisor> candidateAdvisors = findCandidateAdvisors();
List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
extendAdvisors(eligibleAdvisors);
if (!eligibleAdvisors.isEmpty()) {
eligibleAdvisors = sortAdvisors(eligibleAdvisors);
}
return eligibleAdvisors;
}
findCandidateAdvisors()方法是用来获取所有的增强，主要步骤包括：
获取所有在beanFactory中注册的beanName
遍历所有的beanName，判断是否为声明为AspectJ的类，如果是则进行进一步处理
对标记为AspectJ注解的类进行增强器的提取
将提取结果放入缓存
protected List<Advisor>
findCandidateAdvisors() {
List advisors =
super.findCandidateAdvisors();
advisors.addAll(
this.aspectJAdvisorsBuilder.buildAspectJAdvisors());
return advisors;
}
public List<Advisor>
buildAspectJAdvisors() {
List aspectNames =
null;
synchronized(
this) {
aspectNames =
this.aspectBeanNames;
if(aspectNames ==
null) {
LinkedList var16 =
new LinkedList();
LinkedList var15 =
new LinkedList();
String[] var17 = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
this.beanFactory, Object.class,
true,
false);
String[] var18 = var17;
int var19 = var17.length;
for(
int var7 =
0; var7 < var19; ++var7) {
String beanName = var18[var7];
if(
this.isEligibleBean(beanName)) {
Class beanType =
this.beanFactory.getType(beanName);
if(beanType !=
null &&
this.advisorFactory.isAspect(beanType)) {
var15.add(beanName);
AspectMetadata amd =
new AspectMetadata(beanType, beanName);
if(amd.getAjType().getPerClause().getKind() == PerClauseKind.SINGLETON) {
BeanFactoryAspectInstanceFactory factory1 =
new BeanFactoryAspectInstanceFactory(
this.beanFactory, beanName);
List classAdvisors =
this.advisorFactory.getAdvisors(factory1);
if(
this.beanFactory.isSingleton(beanName)) {
this.advisorsCache.put(beanName, classAdvisors);
}
else {
this.aspectFactoryCache.put(beanName, factory1);
}
var16.addAll(classAdvisors);
}
else {
if(
this.beanFactory.isSingleton(beanName)) {
throw new IllegalArgumentException(
"Bean with name \'" + beanName +
"\' is a singleton, but aspect instantiation model is not singleton");
}
PrototypeAspectInstanceFactory var20 =
new PrototypeAspectInstanceFactory(
this.beanFactory, beanName);
this.aspectFactoryCache.put(beanName, var20);
var16.addAll(
this.advisorFactory.getAdvisors(var20));
}
}
}
}
this.aspectBeanNames = var15;
return var16;
}
}
调用findAdvisorsThatCanApply()方法从所有增强中获取适合该bean的增强
protected List<Advisor> findAdvisorsThatCanApply(
List<Advisor> candidateAdvisors,
Class<?> beanClass, String beanName) {
ProxyCreationContext.setCurrentProxiedBeanName(beanName);
List var4;
try {
var4 = AopUtils.findAdvisorsThatCanApply(candidateAdvisors, beanClass);
}
finally {
ProxyCreationContext.setCurrentProxiedBeanName((String)
null);
}
return var4;
}
(4) 总结
AOP功能的实现是从XML配置文件中的aop标签解析开始的，标签的解析会注册代理自动创建器用于后续的调用．当从容器中尝试获取bean的时候会在真正创建bean之前尝试创建代理，创建代理主要包括增强的获取和代理的创建两部分，这篇博文主要分析了增强获取的主要流程．
