AOP原理 - 深入分析AnnotationAwareAspectJAutoProxyCreator注册流程
文章目录
- 一、debug分析AnnotationAwareAspectJAutoProxyCreator执行过程
-
- 1. 调用AnnotationConfigApplicationContext类中的refresh()方法
- 2. 调用refresh()方法中的registerBeanPostProcessors(beanFactory)方法
- 3. 调用registerBeanPostProcessors()方法中的PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this)方法
- 4. 调用PostProcessorRegistrationDelegate中的registerBeanPostProcessors(beanFactory, this)方法
- 5. 调用AbstractBeanFactory中的getBean()方法
- 6. 调用AbstractBeanFactory中的doGetBean()方法
- 7. 调用DefaultSingletonBeanRegistry中的getSingleton()方法
- 8. 调用doGetBean()方法中的createBean()方法
- 9. 调用AbstractAutowireCapableBeanFactory中的createBean()方法
- 10. 调用AbstractAutowireCapableBeanFactory中的doCreateBean()方法
- 11. 调用AbstractAutowireCapableBeanFactory中的initializeBean()方法
-
- （1）执行invokeAwareMethods()方法
- （2）执行applyBeanPostProcessorsBeforeInitialization()方法
- （3）执行invokeInitMethods()方法
- （4）执行postProcessAfterInitialization()方法
- 12. 初始化完bean后，回退方法栈到getSingleton()方法
- 13. 最终回退到registerBeanPostProcessors中，继续注册下一个BeanPostProcessors
一、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)方法整体逻辑：
- 首先获取IOC容器中已经定义了的所有BeanPostProcessor
你可能要问了，为什么IOC容器中会有一些已定义的BeanPostProcessor呢？这是因为在前面创建IOC容器时，需要先传入配置类，而我们在解析配置类的时候，由于这个配置类里面有一个@EnableAspectJAutoProxy注解，对于该注解，我们之前也说过，它会为我们容器中注册一个AnnotationAwareAspectJAutoProxyCreator（后置处理器），这还仅仅是这个@EnableAspectJAutoProxy注解做的事，除此之外，容器中还有一些默认的后置处理器的定义。
所以，程序运行到这，容器中已经有一些我们将要用的后置处理器了，只不过现在还没创建对象，都只是一些定义，也就是说容器中有哪些后置处理器。
- 接着执行beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
注册BeanPostProcessorChecker，当bean在BeanPostProcessor实例化期间创建时，即当bean没有资格被所有BeanPostProcessor处理时，它会记录一条消息。
- 接着会创建几个集合，表示在实现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()的流程：
- 首先createBeanInstance()创建bean的实例
- 然后populateBean()给bean的各种属性赋值
- 接着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中。