Spring——AOP原理及源码二【系列完】

回顾：

在上一篇中，我们提到@EnableAspectJAutoProxy注解给容器中加入了一个关键组件internalAutoProxyCreator的BeanDefinition，实际类型为

AnnotationAwareAspectJAutoProxyCreator的BeanDenation

并且发现这是一个后置处理器，也是一个XXXAware接口的实现类。以及探究了它的继承关系如下。

---

 

 接下来我们就从后置处理器和BeanFactoryAware的角度来看看AnnotationAwareAspectJAutoProxyCreator的BeanDefinition创建完成后都做了什么。

 

一、设置调试断点

我们分别进入四个有关类，在类中与后置处理器和BeanFactoryAware有关的方法上打上断点。最终效果如下：

AbstractAutoProxyCreator.setBeanFactory
AbstractAutoProxyCreator有后置处理器逻辑
{
　　postProcessBeforeInstantiation()
　　postProcessAfterInitialization()

}

AbstractAdvisorAutoProxyCreator.initBeanFactory
AbstractAdvisorAutoProxyCreator.setBeanFactory
AnnotationAwareAspectJAutoProxyCreator.initBeanFactory

最后，在配置类中给两个bean方法打上断点。

---

 

二、调试过程

开始调试，我们会发现还是先来到上一篇的AnnotationAwareAspectJAutoProxyCreator的BeanDenation创建过程。

左下角frames框中选到refresh方法可以看到，AnnotationAwareAspectJAutoProxyCreator的BeanDenation的创建是invokeBeanFactoryPostProcessors()方法调用来的。

调用这个方法在上下文中生成后置处理器的BeanDefinition加入容器中。

下一步的registerBeanPostProcessors才是注册后置处理器（利用BeanDefinition的信息注册对应Bean），也是本篇的重点。

 

为了让它快速创建完BeanDefinition，这里我们直接快进到下一个断点。

程序先来到了AbstractAdvisorAutoProxyCreator的setBeanFactory方法

为了从头看起，还是先在frames框中选到refresh方法，可以看到来到了refresh的下一方法，将要开始注册后置处理器。

---

 

 

1、registerBeanPostProcessors()

我们继续在frames中往上点，直到来到PostProcessorRegistrationDelegate.registerBeanPostProcessors()

方法有点长，但关键只在其中几个地方，我们将在下面进行针对分析

 

 1 public static void registerBeanPostProcessors(
 2             ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
 3 
 4         String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
 5 
 6         // Register BeanPostProcessorChecker that logs an info message when
 7         // a bean is created during BeanPostProcessor instantiation, i.e. when
 8         // a bean is not eligible for getting processed by all BeanPostProcessors.
 9         int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
10         beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
11 
12         // Separate between BeanPostProcessors that implement PriorityOrdered,
13         // Ordered, and the rest.
14         List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanPostProcessor>();
15         List<BeanPostProcessor> internalPostProcessors = new ArrayList<BeanPostProcessor>();
16         List<String> orderedPostProcessorNames = new ArrayList<String>();
17         List<String> nonOrderedPostProcessorNames = new ArrayList<String>();
18         for (String ppName : postProcessorNames) {
19             if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
20                 BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
21                 priorityOrderedPostProcessors.add(pp);
22                 if (pp instanceof MergedBeanDefinitionPostProcessor) {
23                     internalPostProcessors.add(pp);
24                 }
25             }
26             else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
27                 orderedPostProcessorNames.add(ppName);
28             }
29             else {
30                 nonOrderedPostProcessorNames.add(ppName);
31             }
32         }
33 
34         // First, register the BeanPostProcessors that implement PriorityOrdered.
35         sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
36         registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
37 
38         // Next, register the BeanPostProcessors that implement Ordered.
39         List<BeanPostProcessor> orderedPostProcessors = new ArrayList<BeanPostProcessor>();
40         for (String ppName : orderedPostProcessorNames) {
41             BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
42             orderedPostProcessors.add(pp);
43             if (pp instanceof MergedBeanDefinitionPostProcessor) {
44                 internalPostProcessors.add(pp);
45             }
46         }
47         sortPostProcessors(orderedPostProcessors, beanFactory);
48         registerBeanPostProcessors(beanFactory, orderedPostProcessors);
49 
50         // Now, register all regular BeanPostProcessors.
51         List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<BeanPostProcessor>();
52         for (String ppName : nonOrderedPostProcessorNames) {
53             BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
54             nonOrderedPostProcessors.add(pp);
55             if (pp instanceof MergedBeanDefinitionPostProcessor) {
56                 internalPostProcessors.add(pp);
57             }
58         }
59         registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);
60 
61         // Finally, re-register all internal BeanPostProcessors.
62         sortPostProcessors(internalPostProcessors, beanFactory);
63         registerBeanPostProcessors(beanFactory, internalPostProcessors);
64 
65         // Re-register post-processor for detecting inner beans as ApplicationListeners,
66         // moving it to the end of the processor chain (for picking up proxies etc).
67         beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
68     }

registerBeanPostProcessors