Spring实例化源码解析之registerBeanPostProcessors(六)

BeanPostProcessors是Spring框架中的一个扩展机制，它允许开发人员在Spring容器实例化、配置和初始化Bean的过程中干预和定制化。BeanPostProcessor接口定义了两个方法：postProcessBeforeInitialization和postProcessAfterInitialization，分别在Bean初始化之前和之后被调用。

BeanPostProcessors的作用是在Bean的初始化过程中提供额外的处理逻辑。通过实现BeanPostProcessor接口并注册到Spring容器中，开发人员可以在Bean实例化后的早期和后期阶段对Bean进行修改、增强或执行其他自定义逻辑。这样可以实现很多功能，如属性注入、AOP代理、资源初始化等。

猜测

入口是在AbstractApplicationContext的refresh方法中，在方法中调用了registerBeanPostProcessors(beanFactory)，从字面意思来说就是注册BeanPostProcessors，BeanPostProcessor具体做什么用的上面也有介绍，本章就分析一下这个注册做了哪些事情。

分析

老规矩，从入口的注释开始，这个方法就是实例化和注册所有的BeanPostProcessor，尊重期望的排序，如果有给出的话，这个方法必须在我们应用bean实力化之前被调用。

/*** Instantiate and register all BeanPostProcessor beans,* respecting explicit order if given.* <p>Must be called before any instantiation of application beans.*/
protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
}

方法实际调用的是PostProcessorRegistrationDelegate类中的registerBeanPostProcessors方法，如果调用参数的详细入下截图所示：
请添加图片描述

PostProcessorRegistrationDelegate

这个类中的方法其实就是整个代码的核心，接下来我们继续用拆解的方式来进行分析，下面是其所有的代码块。

public static void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {// WARNING: Although it may appear that the body of this method can be easily// refactored to avoid the use of multiple loops and multiple lists, the use// of multiple lists and multiple passes over the names of processors is// intentional. We must ensure that we honor the contracts for PriorityOrdered// and Ordered processors. Specifically, we must NOT cause processors to be// instantiated (via getBean() invocations) or registered in the ApplicationContext// in the wrong order.//// Before submitting a pull request (PR) to change this method, please review the// list of all declined PRs involving changes to PostProcessorRegistrationDelegate// to ensure that your proposal does not result in a breaking change:// https://github.com/spring-projects/spring-framework/issues?q=PostProcessorRegistrationDelegate+is%3Aclosed+label%3A%22status%3A+declined%22String[] 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));
}

步骤一：

直接通过类型去获取所有的BeanPostProcessor的BeanNames，存在postProcessorNames数组中。

String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);

步骤二：

注册一个名为BeanPostProcessorChecker的BeanPostProcessor，并将其添加到beanFactory中。

具体分析如下：

获取已注册的BeanPostProcessor数量：

int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount();
```
这行代码获取已经注册到beanFactory的BeanPostProcessor的数量。

计算新的BeanPostProcessor的目标数量：

beanProcessorTargetCount = beanProcessorTargetCount + 1 + postProcessorNames.length;
```
在已有的BeanPostProcessor数量基础上，加上1（表示新注册的BeanPostProcessorChecker）以及postProcessorNames的长度（表示后续要注册的BeanPostProcessor的数量），计算出新的目标数量。

创建并注册BeanPostProcessorChecker：

beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
```
创建一个名为BeanPostProcessorChecker的BeanPostProcessor实例，并将其添加到beanFactory中。BeanPostProcessorChecker是一个自定义的BeanPostProcessor，它在BeanPostProcessor实例化期间检查并记录信息。具体来说，当创建BeanPostProcessor期间创建了一个Bean（即一个Bean不符合所有BeanPostProcessor的处理条件）时，BeanPostProcessorChecker会记录一个信息日志。

步骤三：

对已注册的BeanPostProcessor进行分类，并按照优先级顺序注册到beanFactory中。

创建用于存储实现PriorityOrdered接口的BeanPostProcessor的列表：

List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
```
创建一个名为priorityOrderedPostProcessors的列表，用于存储实现了PriorityOrdered接口的BeanPostProcessor。

创建用于存储内部BeanPostProcessor的列表：

List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
```
创建一个名为internalPostProcessors的列表，用于存储内部的BeanPostProcessor。

创建用于存储实现Ordered接口的BeanPostProcessor名称的列表：

List<String> orderedPostProcessorNames = new ArrayList<>();
```
创建一个名为orderedPostProcessorNames的列表，用于存储实现了Ordered接口的BeanPostProcessor的名称。

创建用于存储未实现Ordered接口的BeanPostProcessor名称的列表：

List<String> nonOrderedPostProcessorNames = new ArrayList<>();
```
创建一个名为nonOrderedPostProcessorNames的列表，用于存储未实现Ordered接口的BeanPostProcessor的名称。

遍历已注册的BeanPostProcessor名称列表，根据其类型进行分类：

for (String ppName : postProcessorNames) {if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {// BeanPostProcessor实现了PriorityOrdered接口BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);priorityOrderedPostProcessors.add(pp);if (pp instanceof MergedBeanDefinitionPostProcessor) {// 内部的BeanPostProcessorinternalPostProcessors.add(pp);}}else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {// BeanPostProcessor实现了Ordered接口orderedPostProcessorNames.add(ppName);}else {// 未实现Ordered接口的BeanPostProcessornonOrderedPostProcessorNames.add(ppName);}
}
```
遍历已注册的BeanPostProcessor名称列表postProcessorNames，根据名称对应的BeanPostProcessor的类型进行分类。如果BeanPostProcessor实现了PriorityOrdered接口，则将其添加到priorityOrderedPostProcessors列表中；如果是MergedBeanDefinitionPostProcessor的实例，则也添加到internalPostProcessors列表中；如果实现了Ordered接口，则将其名称添加到orderedPostProcessorNames列表中；否则，将其名称添加到nonOrderedPostProcessorNames列表中。

对实现PriorityOrdered接口的BeanPostProcessor进行排序：

sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
```
调用sortPostProcessors方法对priorityOrderedPostProcessors列表中的BeanPostProcessor进行排序，按照优先级顺序进行排序。

注册实现PriorityOrdered接口的BeanPostProcessor到beanFactory中：

registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
```
调用registerBeanPostProcessors方法，将priorityOrderedPostProcessors列表中的BeanPostProcessor注册到beanFactory中。

步骤四：

实现了Ordered接口的BeanPostProcessor到beanFactory中。

创建用于存储实现Ordered接口的BeanPostProcessor的列表：

List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
```
创建一个名为orderedPostProcessors的列表，用于存储实现了Ordered接口的BeanPostProcessor。

遍历实现了Ordered接口的BeanPostProcessor的名称列表，并将它们实例化并添加到orderedPostProcessors列表中：

for (String ppName : orderedPostProcessorNames) {BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);orderedPostProcessors.add(pp);if (pp instanceof MergedBeanDefinitionPostProcessor) {// 内部的BeanPostProcessorinternalPostProcessors.add(pp);}
}
```
遍历实现了Ordered接口的BeanPostProcessor的名称列表orderedPostProcessorNames，通过beanFactory.getBean方法实例化每个BeanPostProcessor，并将其添加到orderedPostProcessors列表中。如果BeanPostProcessor是MergedBeanDefinitionPostProcessor的实例，则也添加到internalPostProcessors列表中。

对实现Ordered接口的BeanPostProcessor进行排序：

sortPostProcessors(orderedPostProcessors, beanFactory);
```
调用sortPostProcessors方法对orderedPostProcessors列表中的BeanPostProcessor进行排序，按照Ordered接口的顺序进行排序。

注册实现Ordered接口的BeanPostProcessor到beanFactory中：

registerBeanPostProcessors(beanFactory, orderedPostProcessors);
```
调用registerBeanPostProcessors方法，将orderedPostProcessors列表中的BeanPostProcessor注册到beanFactory中。

步骤五：

注册剩余的未实现Ordered接口的BeanPostProcessor，并重新注册内部的BeanPostProcessor。

创建用于存储未实现Ordered接口的BeanPostProcessor的列表：

List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
```
创建一个名为nonOrderedPostProcessors的列表，用于存储未实现Ordered接口的BeanPostProcessor。

遍历未实现Ordered接口的BeanPostProcessor的名称列表，并将它们实例化并添加到nonOrderedPostProcessors列表中：

for (String ppName : nonOrderedPostProcessorNames) {BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);nonOrderedPostProcessors.add(pp);if (pp instanceof MergedBeanDefinitionPostProcessor) {// 内部的BeanPostProcessorinternalPostProcessors.add(pp);}
}
```
遍历未实现Ordered接口的BeanPostProcessor的名称列表nonOrderedPostProcessorNames，通过beanFactory.getBean方法实例化每个BeanPostProcessor，并将其添加到nonOrderedPostProcessors列表中。如果BeanPostProcessor是MergedBeanDefinitionPostProcessor的实例，则也添加到internalPostProcessors列表中。

注册未实现Ordered接口的BeanPostProcessor到beanFactory中：

registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);
```
调用registerBeanPostProcessors方法，将nonOrderedPostProcessors列表中的BeanPostProcessor注册到beanFactory中。

对内部的BeanPostProcessor进行排序：

sortPostProcessors(internalPostProcessors, beanFactory);
```
调用sortPostProcessors方法对internalPostProcessors列表中的BeanPostProcessor进行排序。

重新注册内部的BeanPostProcessor到beanFactory中：

registerBeanPostProcessors(beanFactory, internalPostProcessors);
```
调用registerBeanPostProcessors方法，将internalPostProcessors列表中的BeanPostProcessor重新注册到beanFactory中。

重新注册用于检测内部Bean作为ApplicationListeners的后处理器：

beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
```
创建一个ApplicationListenerDetector的实例，并将其作为BeanPostProcessor添加到beanFactory中。这个后处理器用于检测内部Bean是否为ApplicationListeners，并将其移动到处理器链的末尾，以便在处理代理等情况时能够正确拾取内部Bean。