SPRING源码学习之路（三）——<aop:config>自动代理的实现

关于Spring AOP的基本概念这里不作阐述，重点关心autoProxy

对于<aop:config>标签的解析，对应的类 AopNamespaceHandler，ConfigBeanDefinitionParser

ConfigBeanDefinitionParser核心方法parse的具体实现如下：

public BeanDefinition parse(Element element, ParserContext parserContext) {
CompositeComponentDefinition compositeDef = new CompositeComponentDefinition(element.getTagName(), parserContext.extractSource(element));
parserContext.pushContainingComponent(compositeDef);
this.configureAutoProxyCreator(parserContext, element);
List childElts = DomUtils.getChildElements(element);
Iterator i$ = childElts.iterator();

while(i$.hasNext()) {
Element elt = (Element)i$.next();
String localName = parserContext.getDelegate().getLocalName(elt);
if("pointcut".equals(localName)) {
this.parsePointcut(elt, parserContext);
} else if("advisor".equals(localName)) {
this.parseAdvisor(elt, parserContext);
} else if("aspect".equals(localName)) {
this.parseAspect(elt, parserContext);
}
}

parserContext.popAndRegisterContainingComponent();
return null;
}

其中

this.configureAutoProxyCreator(parserContext, element);

这行代码 会创建AspectJAwareAdvisorAutoProxyCreator类 并向容器注册

从名字就可以看出，这个类是自带代理实现的核心类，继承关系图：



实现了BeanPostProcessor，BeanFactoryAware接口，这下就有意思了，即可以通过容器获取bean信息，也可以在bean初始化时候增强处理

那到底该类是如何实现对需要的类实现自动代理的呢，在祖父类AbstractAutoProxyCreator中可以看到 对BeanPostProcessor接口的实现 postProcessBeforeInstantiation方法

public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
Object cacheKey = this.getCacheKey(beanClass, beanName);
if(beanName == null || !this.targetSourcedBeans.containsKey(beanName)) {
if(this.advisedBeans.containsKey(cacheKey)) {
return null;
}

if(this.isInfrastructureClass(beanClass) || this.shouldSkip(beanClass, beanName)) {
this.advisedBeans.put(cacheKey, Boolean.FALSE);
return null;
}
}

if(beanName != null) {
TargetSource targetSource = this.getCustomTargetSource(beanClass, beanName);
if(targetSource != null) {
this.targetSourcedBeans.put(beanName, Boolean.TRUE);
//获取advice和advisor
Object[] specificInterceptors = this.getAdvicesAndAdvisorsForBean(beanClass, beanName, targetSource);
Object proxy = this.createProxy(beanClass, beanName, specificInterceptors, targetSource);
this.proxyTypes.put(cacheKey, proxy.getClass());
return proxy;
}
}

return null;
}

getAdvicesAndAdvisorsForBean方法的实现具体如下：

protected Object[] getAdvicesAndAdvisorsForBean(Class beanClass, String beanName, TargetSource targetSource) {
List advisors = this.findEligibleAdvisors(beanClass, beanName);
return advisors.isEmpty()?DO_NOT_PROXY:advisors.toArray();
}

protected List<Advisor> findEligibleAdvisors(Class beanClass, String beanName) {
List candidateAdvisors = this.findCandidateAdvisors();
List eligibleAdvisors = this.findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
this.extendAdvisors(eligibleAdvisors);
if(!eligibleAdvisors.isEmpty()) {
eligibleAdvisors = this.sortAdvisors(eligibleAdvisors);
}

return eligibleAdvisors;
}

protected List<Advisor> findCandidateAdvisors() {
return this.advisorRetrievalHelper.findAdvisorBeans();
}

最终调用findAdvisorBeans方法 具体实现：

public List<Advisor> findAdvisorBeans() {
String[] advisorNames = null;
synchronized(this) {
advisorNames = this.cachedAdvisorBeanNames;
if(advisorNames == null) {
advisorNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(this.beanFactory, Advisor.class, true, false);
this.cachedAdvisorBeanNames = advisorNames;
}
}

if(advisorNames.length == 0) {
return new LinkedList();
} else {
LinkedList advisors = new LinkedList();
String[] arr$ = advisorNames;
int len$ = advisorNames.length;

for(int i$ = 0; i$ < len$; ++i$) {
String name = arr$[i$];
if(this.isEligibleBean(name)) {
if(this.beanFactory.isCurrentlyInCreation(name)) {
if(logger.isDebugEnabled()) {
logger.debug("Skipping currently created advisor \'" + name + "\'");
}
} else {
try {
advisors.add(this.beanFactory.getBean(name, Advisor.class));
} catch (BeanCreationException var10) {
Throwable rootCause = var10.getMostSpecificCause();
if(rootCause instanceof BeanCurrentlyInCreationException) {
BeanCreationException bce = (BeanCreationException)rootCause;
if(this.beanFactory.isCurrentlyInCreation(bce.getBeanName())) {
if(logger.isDebugEnabled()) {
logger.debug("Skipping advisor \'" + name + "\' with dependency on currently created bean: " + var10.getMessage());
}
continue;
}
}

throw var10;
}
}
}
}

return advisors;
}
}

advisorNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(this.beanFactory, Advisor.class, true, false);查找容器中 Advisor类型的类

回头看postProcessBeforeInstantiation方法 在获取到advice和advisor以后，就对满足条件的类生产代理对象

Object proxy = this.createProxy(beanClass, beanName, specificInterceptors, targetSource);

createProxy方法这里暂且不作深入分析，我们从方法名知道是创建代理对象

补充：那为什么getBean时候 回去调用AbstractAutoProxyCreator 的 postProcessAfterInitialization方法呢

结合前面对bean加载过程的分析，我们可以看到 在spring容器启动的时候，refresh（）方法中

// Register bean processors that intercept bean creation.

registerBeanPostProcessors(beanFactory);

向bean工厂注册 beanPostProcessors 具体实现：

public static void registerBeanPostProcessors(
ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
// 获取类型为BeanPostProcessor的所有beanName
String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);

// Register BeanPostProcessorChecker that logs an info message when
// a bean is created during BeanPostProcessor instantiation, i.e. when
// a bean is not eligible for getting processed by all BeanPostProcessors.
int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));

// Separate between BeanPostProcessors that implement PriorityOrdered,
// Ordered, and the rest.
List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanPostProcessor>();
List<BeanPostProcessor> internalPostProcessors = new ArrayList<BeanPostProcessor>();
List<String> orderedPostProcessorNames = new ArrayList<String>();
List<String> nonOrderedPostProcessorNames = new ArrayList<String>();
for (String ppName : postProcessorNames) {
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
//循环获取对应的bean 加入到 列表中
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
priorityOrderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessorNames.add(ppName);
}
else {
nonOrderedPostProcessorNames.add(ppName);
}
}

// First, register the BeanPostProcessors that implement PriorityOrdered.
sortPostProcessors(beanFactory, priorityOrderedPostProcessors);
registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

// Next, register the BeanPostProcessors that implement Ordered.
List<BeanPostProcessor> orderedPostProcessors = new ArrayList<BeanPostProcessor>();
for (String ppName : orderedPostProcessorNames) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
orderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
sortPostProcessors(beanFactory, orderedPostProcessors);
registerBeanPostProcessors(beanFactory, orderedPostProcessors);

// Now, register all regular BeanPostProcessors.
List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<BeanPostProcessor>();
for (String ppName : nonOrderedPostProcessorNames) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
nonOrderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);

// Finally, re-register all internal BeanPostProcessors.
sortPostProcessors(beanFactory, internalPostProcessors);
registerBeanPostProcessors(beanFactory, internalPostProcessors);

beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}

registerBeanPostProcessors 方法如下：

private static void registerBeanPostProcessors(
ConfigurableListableBeanFactory beanFactory, List<BeanPostProcessor> postProcessors) {

for (BeanPostProcessor postProcessor : postProcessors) {
beanFactory.addBeanPostProcessor(postProcessor);
}
}

addBeanPostProcessor：

public void addBeanPostProcessor(BeanPostProcessor beanPostProcessor) {
Assert.notNull(beanPostProcessor, "BeanPostProcessor must not be null");
this.beanPostProcessors.remove(beanPostProcessor);
this.beanPostProcessors.add(beanPostProcessor);
if (beanPostProcessor instanceof InstantiationAwareBeanPostProcessor) {
this.hasInstantiationAwareBeanPostProcessors = true;
}
if (beanPostProcessor instanceof DestructionAwareBeanPostProcessor) {
this.hasDestructionAwareBeanPostProcessors = true;
}
}

可以看到是对 最终存储在 beanFactory 的 beanPostProcessors中 而我们的AbstractAutoProxyCreator 实现了 BeanPostProcessor 所以也会保存在列表中

回头再来看 getBean的过程 前面文章已经分析过 就不再啰嗦 直接跳到重点地方 doCreateBean方法中

try {
populateBean(beanName, mbd, instanceWrapper);
if (exposedObject != null) {
exposedObject = initializeBean(beanName, exposedObject, mbd);
}
}

初始化bean 方法具体实现：

wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);

看看方法具体实现：

@Override
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;
}

循环调用 beanPostProcessor的 postProcessAfterInitialization方法 而 getBeanPostProcessors实际就是容器启动时候 我们向beanFactory注册的 beanPostProcessors属性

到此就彻底清楚了为什么每次获取bean的时候 都会经过AbstractAutoProxyCreator来生成代理对象