AOP原理 - 深入分析AnnotationAwareAspectJAutoProxyCreator注册流程

一、debug分析AnnotationAwareAspectJAutoProxyCreator执行过程

以debug模式来运行IOCTest_AOP测试类之后，会先来到AbstractAdvisorAutoProxyCreator类的setBeanFactory()方法中，如下图所示：

上图中，方法调用栈记录了从test01()测试方法到AbstractAdvisorAutoProxyCreator中setBeanFactory()方法的调用过程

1. 调用AnnotationConfigApplicationContext类中的refresh()方法

执行test01()测试方法的下一步，调用AnnotationConfigApplicationContext类中的refresh()方法

2. 调用refresh()方法中的registerBeanPostProcessors(beanFactory)方法

进入refresh()方法，下一步执行的是refresh()方法中的registerBeanPostProcessors(beanFactory)方法

registerBeanPostProcessors(beanFactory)方法的作用是：注册bean的后置处理器，该后置处理器可以拦截bean的创建

3. 调用registerBeanPostProcessors()方法中的PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this)方法

接着调用registerBeanPostProcessors()方法中的PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this)方法

4. 调用PostProcessorRegistrationDelegate中的registerBeanPostProcessors(beanFactory, this)方法

PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this)方法完整代码如下：

public static void registerBeanPostProcessors(
			ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
    
    

	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<>();
	List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
	List<String> orderedPostProcessorNames = new ArrayList<>();
	List<String> nonOrderedPostProcessorNames = new ArrayList<>();
	for (String ppName : postProcessorNames) {
    
    
		if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
    
    
			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(priorityOrderedPostProcessors, beanFactory);
	registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

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

	// Now, register all regular BeanPostProcessors.
	List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
	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(internalPostProcessors, beanFactory);
	registerBeanPostProcessors(beanFactory, internalPostProcessors);

	// Re-register post-processor for detecting inner beans as ApplicationListeners,
	// moving it to the end of the processor chain (for picking up proxies etc).
	beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}

接下来详细分析PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this)方法整体逻辑：

1. 首先获取IOC容器中已经定义了的所有BeanPostProcessor

你可能要问了，为什么IOC容器中会有一些已定义的BeanPostProcessor呢？这是因为在前面创建IOC容器时，需要先传入配置类，而我们在解析配置类的时候，由于这个配置类里面有一个@EnableAspectJAutoProxy注解，对于该注解，我们之前也说过，它会为我们容器中注册一个AnnotationAwareAspectJAutoProxyCreator（后置处理器），这还仅仅是这个@EnableAspectJAutoProxy注解做的事，除此之外，容器中还有一些默认的后置处理器的定义。

所以，程序运行到这，容器中已经有一些我们将要用的后置处理器了，只不过现在还没创建对象，都只是一些定义，也就是说容器中有哪些后置处理器。

2. 接着执行beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));

注册BeanPostProcessorChecker，当bean在BeanPostProcessor实例化期间创建时，即当bean没有资格被所有BeanPostProcessor处理时，它会记录一条消息。

3. 接着会创建几个集合，表示在实现PriorityOrdered、Ordered和其他的beanpostprocessor之间进行分离。
   即分离这些BeanPostProcessor，看哪些是实现了PriorityOrdered接口的，哪些是实现了Ordered接口的，哪些是原生实现接口的。

可以看到，还会对BeanPostProcessor做一下划分，如果BeanPostProcessor实现了PriorityOrdered接口，那么就将其保存在名为priorityOrderedPostProcessors的List集合中，并且要是该BeanPostProcessor还是MergedBeanDefinitionPostProcessor这种类型的，则还得将其保存在名为internalPostProcessors的List集合中。

首先，注册实现PriorityOrdered的BeanPostProcessors。

通过PriorityOrdered源码看到，PriorityOrdered继承了Ordered接口。进一步说明，IOC容器中的那些BeanPostProcessor是有优先级排序的。

public interface PriorityOrdered extends Ordered {
    
    
}

接下来，注册实现Ordered的BeanPostProcessors。

接着注册所有常规的beanPostProcessors。

最后，重新注册所有内部的BeanPostProcessors。

重新注册后处理器，用于将内部bean检测为applicationListener，将其移动到处理器链的末端(用于选择代理等)。

回到方法栈中执行的逻辑

为什么方法栈会停留在这里？因为现在即将要创建的名称为internalAutoProxyCreator的组件（它的类型为AnnotationAwareAspectJAutoProxyCreator）实现了Ordered接口。

可以看到，需要先拿到要注册的BeanPostProcessor的名字，然后再从beanFactory中来获取。

5. 调用AbstractBeanFactory中的getBean()方法

接下来，我们就要获取相应名字的BeanPostProcessor了，怎么获取呢？继续跟进方法调用栈，如下图所示，可以看到现在是定位到了AbstractBeanFactory抽象类的getBean()方法中。

6. 调用AbstractBeanFactory中的doGetBean()方法

doGetBean()方法很长，这里就不再详细分析它了，只须关注程序停留的这行代码即可。这行代码的意思是调用getSingleton()方法来获取单实例的bean，但是呢，IOC容器中第一次并不会有这个bean，所以接下来会创建bean。

7. 调用DefaultSingletonBeanRegistry中的getSingleton()方法

第一次从IOC容器中获取不到单实例bean时，那么就会调用singletonFactory的getObject()方法

8. 调用doGetBean()方法中的createBean()方法

可以看到，第一次从IOC容器中获取不到bean时，最终会执行createBean()方法创建bean。
现在就是需要创建AnnotationAwareAspectJAutoProxyCreator对象，然后保存在容器中。

9. 调用AbstractAutowireCapableBeanFactory中的createBean()方法

10. 调用AbstractAutowireCapableBeanFactory中的doCreateBean()方法

程序停留在这，接下来准备初始化bean，说明在这之前bean实例已经创建好了。在doCreateBean()方法中，会先执行createBeanInstance()方法，创建bean实例。（因为创建bean的顺序是，先实例化bean，再初始化bean）

执行完createBeanInstance()后，再执行populateBean()、initializeBean()

doCreateBean()的流程：

1. 首先createBeanInstance()创建bean的实例
2. 然后populateBean()给bean的各种属性赋值
3. 接着initializeBean()初始化bean（这个初始化bean很重要，因为后置处理器就是在bean初始化前后进行工作的）。

11. 调用AbstractAutowireCapableBeanFactory中的initializeBean()方法

接下来，详细分析一下初始化bean的流程

（1）执行invokeAwareMethods()方法

其实，这个方法是来判断这个bean对象是不是实现了Aware接口，如果是，并且它还是BeanNameAware、BeanClassLoaderAware以及BeanFactoryAware这几个Aware接口中的其中一个，那么就调用相关的Aware接口方法，即处理Aware接口的方法回调。

现在当前的这个bean叫internalAutoProxyCreator（类型为AnnotationAwareAspectJAutoProxyCreator），它实现了BeanFactoryAware接口的，因此会调用相关的Aware接口方法，这也是程序为什么会停留在invokeAwareMethods()这个方法的原因。

接着执行BeanFactoryAware接口的回调方法setBeanFactory()

可以看到super.setBeanFactory(beanFactory)调用的是AbstractAdvisorAutoProxyCreator抽象类中的setBeanFactory()方法。我们要创建的是AnnotationAwareAspectJAutoProxyCreator对象，但是调用的却是它父类的setBeanFactory()方法。

继续向下执行initBeanFactory()方法

该initBeanFactory()方法就是用来初始化BeanFactory的。进入到当前方法内部，如下图所示，可以看到调用了AnnotationAwareAspectJAutoProxyCreator这个类的initBeanFactory()方法

可以看到这个initBeanFactory()方法创建了两个对象，一个叫ReflectiveAspectJAdvisorFactory，还有一个叫BeanFactoryAspectJAdvisorsBuilderAdapter，它相当于把之前创建的aspectJAdvisorFactory以及beanFactory重新包装了一下。

（2）执行applyBeanPostProcessorsBeforeInitialization()方法

这个方法调用完以后，会返回一个被包装的bean。

该方法的意思其实就是应用后置处理器的postProcessBeforeInitialization()方法。我们可以进入该方法中去看一看，到底是怎么应用后置处理器的postProcessBeforeInitialization()方法的？

可以看到，它是拿到所有的后置处理器，然后再调用后置处理器的postProcessBeforeInitialization()方法，也就是说bean初始化之前后置处理器的调用在这。

（3）执行invokeInitMethods()方法

执行自定义的初始化方法。

（4）执行postProcessAfterInitialization()方法

依旧是拿到所有的后置处理器，然后再调用后置处理器的postProcessAfterInitialization()方法。

所以，初始化方法前后会执行后置处理器的这两个postProcessBeforeInitialization()与postProcessAfterInitialization()方法。

12. 初始化完bean后，回退方法栈到getSingleton()方法

初始化完bean后，回退方法栈到getSingleton()方法，最终将创建完成的bean添加到IOC容器中。

13. 最终回退到registerBeanPostProcessors中，继续注册下一个BeanPostProcessors

AnnotationAwareAspectJAutoProxyCreator在registerBeanPostProcessors中被注册完后，接着在for循环中继续遍历下一个BeanPostProcessors进行注册，流程与注册AnnotationAwareAspectJAutoProxyCreator一致，最终存到IOC容器中。

for循环执行完后，继续向下执行，会调用sortPostProcessors()方法按照优先级给这些后置处理器们排一个序。
程序再往下运行，就会调用到registerBeanPostProcessors()方法了，进到该方法中去看一下。

最终将所有创建完的BeanPostProcessor，调用beanFactory的addBeanPostProcessor()方法注册到BeanFactory中。