文章目录
-
- Spring 初始化核心流程
- invokeBeanFactoryPostProcessors 方法
- registerBeanPostProcessors 方法
- BeanPostProcessor
- InstantiationAwareBeanPostProcessor
- SmartInstantiationAwareBeanPostProcessor
- MergedBeanDefinitionPostProcessor
Spring 初始化核心流程
Spring容器初始化的核心方法是AbstractApplicationContext#refresh() ├─ refresh // Spring 初始化核心流程入口 │ ├─ prepareRefresh // 准备此上下文用于刷新，设置启动时间和active标志，初始化属性 │ ├─ obtainFreshBeanFactory // 创建 BeanFactory │ ├─ prepareBeanFactory // 设置beanFactory的基本属性 │ ├─ postProcessBeanFactory // 子类处理自定义的BeanFactoryPostProcess │ ├─ invokeBeanFactoryPostProcessors // 调用所有的BeanFactoryPostProcessor本节主要跟踪的源码流程 │ ├─ registerBeanPostProcessors // 注册，把实现了BeanPostProcessor接口的类实例化，加到BeanFactory> 本节主要跟踪的源码流程 │ ├─ initMessageSource // 初始化上下文中的资源文件，如国际化文件的处理等 │ ├─ initApplicationEventMulticaster // 初始化上下文的事件传播器 │ ├─ onRefresh // 给子类扩展初始化其他Bean，springboot 中用来做内嵌 tomcat 启动 │ ├─ registerListeners // 在所有bean中查找监听 bean，然后注册到广播器中 │ ├─ finishBeanFactoryInitialization // 初始化所有的单例Bean、ioc、BeanPostProcessor的执行、Aop入口 │ └─ finishRefresh // 完成刷新过程，发布相应的事件invokeBeanFactoryPostProcessors 方法
invokeBeanFactoryPostProcessors invokeBeanFactoryPostProcessors 方法，负责激活各种 BeanFactory 处理器，以及完成实现以下两个核心接口的调用：
|
public static void invokeBeanFactoryPostProcessors(
ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
// Invoke BeanDefinitionRegistryPostProcessors first, if any.
Set<String> processedBeans = new HashSet<>();
if (beanFactory instanceof BeanDefinitionRegistry) {
BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();
for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
BeanDefinitionRegistryPostProcessor registryProcessor =
(BeanDefinitionRegistryPostProcessor) postProcessor;
registryProcessor.postProcessBeanDefinitionRegistry(registry);
registryProcessors.add(registryProcessor);
}
else {
regularPostProcessors.add(postProcessor);
}
}
List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();
// 所有实现BeanDefinitionRegistryPostProcessor接口的所有类的BeanDefinition对象的beanName
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
// 1、最先调用的是实现了 PriorityOrdered 接口的所有BeanDefinitionRegistryPostProcessor中的 postProcessBeanDefinitionRegistry的方法
for (String ppName : postProcessorNames) {
// 判断是否实现了排序接口 PriorityOrdered
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
}
}
// 排序，就是用List中的sort排序，通过Comparator来进行
sortPostProcessors(currentRegistryProcessors, beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
// 调用postProcessBeanDefinitionRegistry方法 （实现BeanDefinitionRegistryPostProcessor类的方法）
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
// 清空
currentRegistryProcessors.clear();
// 2、其次调用的是实现了 Ordered 接口的所有BeanDefinitionRegistryPostProcessor中的 postProcessBeanDefinitionRegistry的方法
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
// 判断是否实现了排序接口 Ordered， currentRegistryProcessors已清空，所以不包含上面已经处理的
if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
}
}
// 排序
sortPostProcessors(currentRegistryProcessors, beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
// 调用postProcessBeanDefinitionRegistry方法 （实现BeanDefinitionRegistryPostProcessor类的方法）
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
currentRegistryProcessors.clear();
// Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
boolean reiterate = true;
while (reiterate) {
reiterate = false;
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
// 3、最后调用的是没实现排序接口的所有实现BeanDefinitionRegistryPostProcessor接口中的 postProcessBeanDefinitionRegistry的方法
if (!processedBeans.contains(ppName)) {
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
reiterate = true;
}
}
sortPostProcessors(currentRegistryProcessors, beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
currentRegistryProcessors.clear();
}
// 调用postProcessBeanFactory方法 （实现BeanDefinitionRegistryPostProcessor类的方法）
invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
}
else {
// Invoke factory processors registered with the context instance.
invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
}
// 获取实现了BeanFactoryPostProcessor接口的类，获取beanDefinition的名称
// Do not initialize FactoryBeans here: We need to leave all regular beans
// uninitialized to let the bean factory post-processors apply to them!
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
// Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
// Ordered, and the rest.
List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
List<String> orderedPostProcessorNames = new ArrayList<>();
List<String> nonOrderedPostProcessorNames = new ArrayList<>();
for (String ppName : postProcessorNames) {
if (processedBeans.contains(ppName)) {
// skip - already processed in first phase above
}
// 实现了PriorityOrdered接口的
else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
}
// 实现了Ordered接口的
else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessorNames.add(ppName);
}
// 没实现接口的
else {
nonOrderedPostProcessorNames.add(ppName);
}
}
// 排序 PriorityOrdered接口的
// First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
// 调用 postProcessBeanFactory 方法
invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
// Next, invoke the BeanFactoryPostProcessors that implement Ordered.
List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
for (String postProcessorName : orderedPostProcessorNames) {
orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
// 排序 Ordered接口的
sortPostProcessors(orderedPostProcessors, beanFactory);
// 调用 postProcessBeanFactory 方法
invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);
// Finally, invoke all other BeanFactoryPostProcessors.
List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
for (String postProcessorName : nonOrderedPostProcessorNames) {
nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
// 调用 postProcessBeanFactory 方法
invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
// Clear cached merged bean definitions since the post-processors might have
// modified the original metadata, e.g. replacing placeholders in values...
beanFactory.clearMetadataCache();
}
| 至此， invokeBeanFactoryPostProcessors 方法调用激活所有实现了BeanDefinitionRegistryPostProcessor接口中的两个方法，执行过程完成。 |
registerBeanPostProcessors 方法
| registerBeanPostProcessors registerBeanPostProcessors 方法，主要是针对实现BeanPostProcessor接口类型实例是针对某种特定功能的埋点，在这个点会根据接口类型来过滤掉不关注这个点的其他类，只有真正关注的类才会在这个点进行相应的功能实现。 |
public static void registerBeanPostProcessors(
ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
// 拿到beanFactory中所有实现了BeanPostProcessor接口的类，获取到BeanDefinition的名称
String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
// 当一个bean是在BeanPostProcessor实例化期间创建的，也就是说当一个 bean不能被所有的beanpostprocessor处理时，
// 注册BeanPostProcessorChecker，记录信息信息
// 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<>();
// 提前实例化 BeanPostProcessor 类型的 bean，然后对 其bean 进行排序
for (String ppName : postProcessorNames) {
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
// 实例化
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
priorityOrderedPostProcessors.add(pp);
// 判断类型是否是 MergedBeanDefinitionPostProcessor，如果是则代码是内部使用的
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessorNames.add(ppName);
}
else {
nonOrderedPostProcessorNames.add(ppName);
}
}
// 首先，注册实现 PriorityOrdered 的 beanpostprocessor。
// First, register the BeanPostProcessors that implement PriorityOrdered.
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
// 注册BeanPostProcessor, 主要就是添加到beanFactory的beanPostProcessors集合属性中
registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
// 然后，注册实现 Ordered 的 BeanPostProcessors。
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);
// 接着注册所有常规的 beanpostprocessor。
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);
// 最后，重新排序，重新注册所有的内部 beanpostprocessor。
// Finally, re-register all internal BeanPostProcessors.
sortPostProcessors(internalPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, internalPostProcessors);
// 将检测内部 bean的后处理器重新注册为 applicationlistener，
// 将它移到处理器链list的末端(用于获取代理等)
// 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));
}
知识点 beanFactory.getBeanPostProcessorCount() 会得到默认容器中注册的 BeanPostProcessor 个数，实际就是调用 List beanPostProcessors = new CopyOnWriteArrayList<>() 方法，默认的容器注册的 BeanPostProcessor 有：
|
BeanPostProcessor
BeanPostProcessor有两个方法，postProcessBeforeInitialization和postProcessAfterInitialization。它们分别在任何bean初始化回调之前或之后执行（例如InitializingBean的afterPropertiesSet方法或自定义init-method方法之前或者之后）， 在这个时候该bean的属性值已经填充完成了，并且我们返回的bean实例可能已经是原始实例的包装类型了。例如返回一个FactoryBean。
InstantiationAwareBeanPostProcessor
InstantiationAwareBeanPostProcessor继承自BeanPostProcessor接口。主要多提供了以下三个方法：
- postProcessBeforeInstantiation：该方法是在Bean实例化目标对象之前调用，返回的Bean对象可以代理目标，从而有效的阻止了目标Bean的默认实例化。
- postProcessAfterInstantiation：该方法执行在通过构造函数或工厂方法在实例化bean之后但在发生Spring属性填充（通过显式属性或自动装配）之前执行操作。这是在Spring的自动装配开始之前对给定的bean实例执行自定义字段注入的理想回调。如果该方法返回false，那么它会阻断后续的实例化流程（AbstractAutowireCapableBeanFactory#populateBean）
- postProcessPropertyValues：在工厂将给定属性值应用于给定bean之前，对它们进行后处理。允许检查是否满足所有依赖关系，例如基于bean属性设置器上的“ Required”注解。还允许替换要应用的属性值，通常是通过基于原始PropertyValues创建新的MutablePropertyValues实例，添加或删除特定值来实现。
SmartInstantiationAwareBeanPostProcessor
智能实例化Bean的后处理器：SmartInstantiationAwareBeanPostProcessor 继承自InstantiationAwareBeanPostProcessor接口。主要多提供了以下三个方法：
- predictBeanType：预测从此处理器的postProcessBeforeInstantiation回调最终返回的bean的类型。
- determineCandidateConstructors：确定合适的实例化Bean的构造函数。
- getEarlyBeanReference：获取提早暴露的Bean的引用，提早暴露的Bean就是只完成了实例化，还未完成属性赋值和初始化的Bean。
MergedBeanDefinitionPostProcessor
MergedBeanDefinitionPostProcessor继承自BeanPostProcessor接口。主要多提供了以下两个方法：
- postProcessMergedBeanDefinition：主要应用于注解的收集
- resetBeanDefinition：重置beanDefinition。应用于同名BeanDefinition的实例化
![Java小案例——随机数猜测随机数猜测[图]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)