Spring源碼分析容器啟動流程
更新時間：2022年09月14日 16:27:25 作者：gao_ohun
Spring的啟動流程可以歸納為三個步驟：初始化Spring容器，注冊內置的BeanPostProcessor的BeanDefinition到容器中、將配置類的BeanDefinition注冊到容器中、調用refresh()方法刷新容器
前言
本文基于 Spring 的 5.1.6.RELEASE 版本
Spring的啟動流程可以歸納為三個步驟：
1、初始化Spring容器，注冊內置的BeanPostProcessor的BeanDefinition到容器中
2、將配置類的BeanDefinition注冊到容器中
3、調用refresh()方法刷新容器
Spring Framework 是 Java 語言中影響最為深遠的框架之一，其中的 IOC 和 AOP 兩個經典思想更是一直被程序員津津樂道，后面推出的 Spring Boot、Spring Cloud 系列也是在其基礎之上開發(fā)，要想搞明白 Spring 全家桶系列，必須腳踏實地的從 Spring Framework 學習起。
本篇文章是 Spring Framework 源碼解析系列的第一篇，主要是從代碼層面對 Spring 框架的啟動做一個完整解析，這里的思想都是筆者根據自己使用 Spring 的經驗和對 Spring 的了解綜合而成，以下內容謹代表個人看法，若有疑問請不吝賜教。
另外提醒一下，本篇文章是基于 5.1.6.RELEASE 版本的代碼進行分析，入口代碼也是采用官方推薦的 java-config 技術，而非 xml。
源碼解析
考慮到直接看源碼是一個非?？菰餆o味的過程，而且 Spring 的代碼設計非常優(yōu)秀規(guī)范，這會導致在翻開源碼時，類與類之間的跳躍會非常頻繁，不熟悉的同學可能直接暈菜，所以每一個重要流程前我都會先準備一個流程圖，建議大家先通過流程圖了解一下整體步驟，然后再對代碼硬擼，這樣能夠降低不少難度。
相信每一個使用過 Spring 技術的同學都知道 Spring 在初始化過程中有一個非常重要的步驟，即 Spring 容器的刷新，這個步驟固然重要，但是刷新前的初始化流程也非常重要。本篇文章將整個啟動過程分為了兩個部分，即容器的初始化與刷新，下面正式開始。開始之前先插播一條廣告：需要開通正版IDEA的可以聯(lián)系我，56元一年，正版授權激活，官網可查有效期，有需要的加我微信：poxiaozhiai6，備注：912。
1、初始化流程
流程分析
因為是基于 java-config 技術分析源碼，所以這里的入口是 AnnotationConfigApplicationContext ，如果是使用 xml 分析，那么入口即為 ClassPathXmlApplicationContext ，它們倆的共同特征便是都繼承了 AbstractApplicationContext 類，而大名鼎鼎的 refresh 方法便是在這個類中定義的，現(xiàn)在就不劇透了，我們接著分析 AnnotationConfigApplicationContext 類，可以繪制成如下流程圖：
看完流程圖，我們應該思考一下：如果讓你去設計一個 IOC 容器，你會怎么做？首先我肯定會提供一個入口（AnnotationConfigApplicationContext ）給用戶使用，然后需要去初始化一系列的工具組件：
①：如果我想生成 bean 對象，那么就需要一個 beanFactory 工廠（DefaultListableBeanFactory）；
②：如果我想對加了特定注解（如 @Service、@Repository）的類進行讀取轉化成 BeanDefinition 對象（BeanDefinition 是 Spring 中極其重要的一個概念，它存儲了 bean 對象的所有特征信息，如是否單例，是否懶加載，factoryBeanName 等），那么就需要一個注解配置讀取器（AnnotatedBeanDefinitionReader）；
③：如果我想對用戶指定的包目錄進行掃描查找 bean 對象，那么還需要一個路徑掃描器（ClassPathBeanDefinitionScanner）。
通過上面的思考，是不是上面的圖理解起來就輕而易舉呢？
ps：圖中的黃色備注可以不看，只是在這里明確展示出來 Spring 的部分內置組件是何時何地添加到容器中的，關于組件的作用在后面的系列文章中會詳細分析。
核心代碼剖析
考慮到要是對所有代碼都進行解析，那么文章篇幅會過長，因此這里只對核心內容進行源碼層面的分析，凡是圖中標注了 ①、②、③等字樣的步驟，都可以理解為是一個比較重要的步驟，下面開始進行詳細分析。
org.springframework.context.annotation.AnnotationConfigUtils#registerAnnotationConfigProcessors
根據上圖分析，代碼運行到這里時候，Spring 容器已經構造完畢，那么就可以為容器添加一些內置組件了，其中最主要的組件便是 ConfigurationClassPostProcessor 和 AutowiredAnnotationBeanPostProcessor ，前者是一個 beanFactory 后置處理器，用來完成 bean 的掃描與注入工作，后者是一個 bean 后置處理器，用來完成 @AutoWired 自動注入。
org.springframework.context.annotation.AnnotatedBeanDefinitionReader#doRegisterBean
這個步驟主要是用來解析用戶傳入的 Spring 配置類，其實也是解析成一個 BeanDefinition 然后注冊到容器中，沒有什么好說的。
<T> void doRegisterBean(Class<T> annotatedClass, @Nullable Supplier<T> instanceSupplier, @Nullable String name,
@Nullable Class<? extends Annotation>[] qualifiers, BeanDefinitionCustomizer... definitionCustomizers) {
// 解析傳入的配置類，實際上這個方法既可以解析配置類，也可以解析 Spring bean 對象
AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(annotatedClass);
// 判斷是否需要跳過，判斷依據是此類上有沒有 @Conditional 注解
if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
return;
}
abd.setInstanceSupplier(instanceSupplier);
ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
abd.setScope(scopeMetadata.getScopeName());
String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));
// 處理類上的通用注解
AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
if (qualifiers != null) {
for (Class<? extends Annotation> qualifier : qualifiers) {
if (Primary.class == qualifier) {
abd.setPrimary(true);
}
else if (Lazy.class == qualifier) {
abd.setLazyInit(true);
}
else {
abd.addQualifier(new AutowireCandidateQualifier(qualifier));
}
}
}
// 封裝成一個 BeanDefinitionHolder
for (BeanDefinitionCustomizer customizer : definitionCustomizers) {
customizer.customize(abd);
}
BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
// 處理 scopedProxyMode
definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
// 把 BeanDefinitionHolder 注冊到 registry
BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
}2、刷新流程
流程分析
下面這一段代碼則是 Spring 中最為重要的一個步驟：容器刷新，同樣先看圖再分析。
看完流程圖，我們也先思考一下：在 3.1 中我們知道了如何去初始化一個 IOC 容器，那么接下來就是讓這個 IOC 容器真正起作用的時候了：即先掃描出要放入容器的 bean，將其包裝成 BeanDefinition 對象，然后通過反射創(chuàng)建 bean，并完成賦值操作，這個就是 IOC 容器最簡單的功能了。但是看完上圖，明顯 Spring 的初始化過程比這個多的多，下面我們就詳細分析一下這樣設計的意圖：
如果用戶想在掃描完 bean 之后做一些自定義的操作：假設容器中包含了 a 和 b，那么就動態(tài)向容器中注入 c，不滿足就注入 d，這種騷操作 Spring 也是支持的，得益于它提供的 BeanFactoryPostProcessor 后置處理器，對應的是上圖中的 invokeBeanFactoryPostProcessors 操作。
如果用戶還想在 bean 的初始化前后做一些操作呢？比如生成代理對象，修改對象屬性等，Spring 為我們提供了 BeanPostProcessor 后置處理器，實際上 Spring 容器中的大多數(shù)功能都是通過 Bean 后置處理器完成的，Spring 也是給我們提供了添加入口，對應的是上圖中的 registerBeanPostProcessors 操作。
整個容器創(chuàng)建過程中，如果用戶想監(jiān)聽容器啟動、刷新等事件，根據這些事件做一些自定義的操作呢？Spring 也早已為我們考慮到了，提供了添加監(jiān)聽器接口和容器事件通知接口，對應的是上圖中的 registerListeners 操作。
此時再看上圖，是不是就覺得簡單很多呢，下面就一些重要代碼進行分析。
核心代碼剖析
org.springframework.context.support.AbstractApplicationContext#refresh
這個方法是對上圖中的具體代碼實現(xiàn)，可劃分為12個步驟，其中比較重要的步驟下面會有詳細說明。
在這里，我們需要記?。篠pring 中的每一個容器都會調用 refresh 方法進行刷新，無論是 Spring 的父子容器，還是 Spring Cloud Feign 中的 feign 隔離容器，每一個容器都會調用這個方法完成初始化。
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// Prepare this context for refreshing.
// 1. 刷新前的預處理
prepareRefresh();
// Tell the subclass to refresh the internal bean factory.
// 2. 獲取 beanFactory，即前面創(chuàng)建的【DefaultListableBeanFactory】
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// Prepare the bean factory for use in this context.
// 3. 預處理 beanFactory，向容器中添加一些組件
prepareBeanFactory(beanFactory);
try {
// Allows post-processing of the bean factory in context subclasses.
// 4. 子類通過重寫這個方法可以在 BeanFactory 創(chuàng)建并與準備完成以后做進一步的設置
postProcessBeanFactory(beanFactory);
// Invoke factory processors registered as beans in the context.
// 5. 執(zhí)行 BeanFactoryPostProcessor 方法，beanFactory 后置處理器
invokeBeanFactoryPostProcessors(beanFactory);
// Register bean processors that intercept bean creation.
// 6. 注冊 BeanPostProcessors，bean 后置處理器
registerBeanPostProcessors(beanFactory);
// Initialize message source for this context.
// 7. 初始化 MessageSource 組件（做國際化功能；消息綁定，消息解析）
initMessageSource();
// Initialize event multicaster for this context.
// 8. 初始化事件派發(fā)器，在注冊監(jiān)聽器時會用到
initApplicationEventMulticaster();
// Initialize other special beans in specific context subclasses.
// 9. 留給子容器（子類），子類重寫這個方法，在容器刷新的時候可以自定義邏輯，web 場景下會使用
onRefresh();
// Check for listener beans and register them.
// 10. 注冊監(jiān)聽器，派發(fā)之前步驟產生的一些事件（可能沒有）
registerListeners();
// Instantiate all remaining (non-lazy-init) singletons.
// 11. 初始化所有的非單實例 bean
finishBeanFactoryInitialization(beanFactory);
// Last step: publish corresponding event.
// 12. 發(fā)布容器刷新完成事件
finishRefresh();
}
...
}
}org.springframework.context.support.AbstractApplicationContext#prepareBeanFactory
顧名思義，這個接口是為 beanFactory 工廠添加一些內置組件，預處理過程。
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
// Tell the internal bean factory to use the context's class loader etc.
// 設置 classLoader
beanFactory.setBeanClassLoader(getClassLoader());
//設置 bean 表達式解析器
beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
// Configure the bean factory with context callbacks.
// 添加一個 BeanPostProcessor【ApplicationContextAwareProcessor】
beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
// 設置忽略自動裝配的接口，即不能通過注解自動注入
beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
// BeanFactory interface not registered as resolvable type in a plain factory.
// MessageSource registered (and found for autowiring) as a bean.
// 注冊可以解析的自動裝配類，即可以在任意組件中通過注解自動注入
beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
beanFactory.registerResolvableDependency(ResourceLoader.class, this);
beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
beanFactory.registerResolvableDependency(ApplicationContext.class, this);
// Register early post-processor for detecting inner beans as ApplicationListeners.
// 添加一個 BeanPostProcessor【ApplicationListenerDetector】
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
// Detect a LoadTimeWeaver and prepare for weaving, if found.
// 添加編譯時的 AspectJ
if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
// Set a temporary ClassLoader for type matching.
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}
// Register default environment beans.
// 注冊 environment 組件，類型是【ConfigurableEnvironment】
if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
}
// 注冊 systemProperties 組件，類型是【Map<String, Object>】
if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
}
// 注冊 systemEnvironment 組件，類型是【Map<String, Object>】
if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
}
}org.springframework.context.support.PostProcessorRegistrationDelegate#invokeBeanFactoryPostProcessors
前文我們說過，Spring 在掃描完所有的 bean 轉成 BeanDefinition 時候，我們是可以做一些自定義操作的，這得益于 Spring 為我們提供的 BeanFactoryPostProcessor 接口。
其中 BeanFactoryPostProcessor 又有一個子接口 BeanDefinitionRegistryPostProcessor ，前者會把 ConfigurableListableBeanFactory 暴露給我們使用，后者會把 BeanDefinitionRegistry 注冊器暴露給我們使用，一旦獲取到注冊器，我們就可以按需注入了，例如搞定這種需求：假設容器中包含了 a 和 b，那么就動態(tài)向容器中注入 c，不滿足就注入 d。
熟悉 Spring 的同學都知道，Spring 中的同類型組件是允許我們控制順序的，比如在 AOP 中我們常用的 @Order 注解，這里的 BeanFactoryPostProcessor 接口當然也是提供了順序，最先被執(zhí)行的是實現(xiàn)了 PriorityOrdered 接口的實現(xiàn)類，然后再到實現(xiàn)了 Ordered 接口的實現(xiàn)類，最后就是剩下來的常規(guī) BeanFactoryPostProcessor 類。
此時再看上圖，是不是發(fā)現(xiàn)和喝水一般簡單，首先會回調 postProcessBeanDefinitionRegistry() 方法，然后再回調 postProcessBeanFactory() 方法，最后注意順序即可，下面一起看看具體的代碼實現(xiàn)吧。
public static void invokeBeanFactoryPostProcessors(
ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
// beanFactoryPostProcessors 這個參數(shù)是指用戶通過 AnnotationConfigApplicationContext.addBeanFactoryPostProcessor() 方法手動傳入的 BeanFactoryPostProcessor，沒有交給 spring 管理
// Invoke BeanDefinitionRegistryPostProcessors first, if any.
// 代表執(zhí)行過的 BeanDefinitionRegistryPostProcessor
Set<String> processedBeans = new HashSet<>();
if (beanFactory instanceof BeanDefinitionRegistry) {
BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
// 常規(guī)后置處理器集合，即實現(xiàn)了 BeanFactoryPostProcessor 接口
List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
// 注冊后置處理器集合，即實現(xiàn)了 BeanDefinitionRegistryPostProcessor 接口
List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();
// 處理自定義的 beanFactoryPostProcessors（指調用 context.addBeanFactoryPostProcessor() 方法），一般這里都沒有
for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
BeanDefinitionRegistryPostProcessor registryProcessor =
(BeanDefinitionRegistryPostProcessor) postProcessor;
// 調用 postProcessBeanDefinitionRegistry 方法
registryProcessor.postProcessBeanDefinitionRegistry(registry);
registryProcessors.add(registryProcessor);
}
else {
regularPostProcessors.add(postProcessor);
}
}
// Do not initialize FactoryBeans here: We need to leave all regular beans
// uninitialized to let the bean factory post-processors apply to them!
// Separate between BeanDefinitionRegistryPostProcessors that implement
// PriorityOrdered, Ordered, and the rest.
// 定義一個變量 currentRegistryProcessors，表示當前要處理的 BeanFactoryPostProcessors
List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();
// First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
// 首先，從容器中查找實現(xiàn)了 PriorityOrdered 接口的 BeanDefinitionRegistryPostProcessor 類型，這里只會查找出一個【ConfigurationClassPostProcessor】
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
// 判斷是否實現(xiàn)了 PriorityOrdered 接口
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
// 添加到 currentRegistryProcessors
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
// 添加到 processedBeans，表示已經處理過這個類了
processedBeans.add(ppName);
}
}
// 設置排列順序
sortPostProcessors(currentRegistryProcessors, beanFactory);
// 添加到 registry 中
registryProcessors.addAll(currentRegistryProcessors);
// 執(zhí)行 [postProcessBeanDefinitionRegistry] 回調方法
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
// 將 currentRegistryProcessors 變量清空，下面會繼續(xù)用到
currentRegistryProcessors.clear();
// Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
// 接下來，從容器中查找實現(xiàn)了 Ordered 接口的 BeanDefinitionRegistryPostProcessors 類型，這里可能會查找出多個
// 因為【ConfigurationClassPostProcessor】已經完成了 postProcessBeanDefinitionRegistry() 方法，已經向容器中完成掃描工作，所以容器會有很多個組件
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
// 判斷 processedBeans 是否處理過這個類，且是否實現(xiàn) Ordered 接口
if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
}
}
// 設置排列順序
sortPostProcessors(currentRegistryProcessors, beanFactory);
// 添加到 registry 中
registryProcessors.addAll(currentRegistryProcessors);
// 執(zhí)行 [postProcessBeanDefinitionRegistry] 回調方法
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
// 將 currentRegistryProcessors 變量清空，下面會繼續(xù)用到
currentRegistryProcessors.clear();
// Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
// 最后，從容器中查找剩余所有常規(guī)的 BeanDefinitionRegistryPostProcessors 類型
boolean reiterate = true;
while (reiterate) {
reiterate = false;
// 根據類型從容器中查找
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
// 判斷 processedBeans 是否處理過這個類
if (!processedBeans.contains(ppName)) {
// 添加到 currentRegistryProcessors
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
// 添加到 processedBeans，表示已經處理過這個類了
processedBeans.add(ppName);
// 將標識設置為 true，繼續(xù)循環(huán)查找，可能隨時因為防止下面調用了 invokeBeanDefinitionRegistryPostProcessors() 方法引入新的后置處理器
reiterate = true;
}
}
// 設置排列順序
sortPostProcessors(currentRegistryProcessors, beanFactory);
// 添加到 registry 中
registryProcessors.addAll(currentRegistryProcessors);
// 執(zhí)行 [postProcessBeanDefinitionRegistry] 回調方法
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
// 將 currentRegistryProcessors 變量清空，因為下一次循環(huán)可能會用到
currentRegistryProcessors.clear();
}
// Now, invoke the postProcessBeanFactory callback of all processors handled so far.
// 現(xiàn)在執(zhí)行 registryProcessors 的 [postProcessBeanFactory] 回調方法
invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
// 執(zhí)行 regularPostProcessors 的 [postProcessBeanFactory] 回調方法，也包含用戶手動調用 addBeanFactoryPostProcessor() 方法添加的 BeanFactoryPostProcessor
invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
}
else {
// Invoke factory processors registered with the context instance.
invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
}
// Do not initialize FactoryBeans here: We need to leave all regular beans
// uninitialized to let the bean factory post-processors apply to them!
// 從容器中查找實現(xiàn)了 BeanFactoryPostProcessor 接口的類
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
// Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
// Ordered, and the rest.
// 表示實現(xiàn)了 PriorityOrdered 接口的 BeanFactoryPostProcessor
List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
// 表示實現(xiàn)了 Ordered 接口的 BeanFactoryPostProcessor
List<String> orderedPostProcessorNames = new ArrayList<>();
// 表示剩下來的常規(guī)的 BeanFactoryPostProcessors
List<String> nonOrderedPostProcessorNames = new ArrayList<>();
for (String ppName : postProcessorNames) {
// 判斷是否已經處理過，因為 postProcessorNames 其實包含了上面步驟處理過的 BeanDefinitionRegistry 類型
if (processedBeans.contains(ppName)) {
// skip - already processed in first phase above
}
// 判斷是否實現(xiàn)了 PriorityOrdered 接口
else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
}
// 判斷是否實現(xiàn)了 Ordered 接口
else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessorNames.add(ppName);
}
// 剩下所有常規(guī)的
else {
nonOrderedPostProcessorNames.add(ppName);
}
}
// First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
// 先將 priorityOrderedPostProcessors 集合排序
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
// 執(zhí)行 priorityOrderedPostProcessors 的 [postProcessBeanFactory] 回調方法
invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
// Next, invoke the BeanFactoryPostProcessors that implement Ordered.
// 接下來，把 orderedPostProcessorNames 轉成 orderedPostProcessors 集合
List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>();
for (String postProcessorName : orderedPostProcessorNames) {
orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
// 將 orderedPostProcessors 集合排序
sortPostProcessors(orderedPostProcessors, beanFactory);
// 執(zhí)行 orderedPostProcessors 的 [postProcessBeanFactory] 回調方法
invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);
// Finally, invoke all other BeanFactoryPostProcessors.
// 最后把 nonOrderedPostProcessorNames 轉成 nonOrderedPostProcessors 集合，這里只有一個，myBeanFactoryPostProcessor
List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
for (String postProcessorName : nonOrderedPostProcessorNames) {
nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
// 執(zhí)行 nonOrderedPostProcessors 的 [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();
}org.springframework.context.support.PostProcessorRegistrationDelegate#registerBeanPostProcessors
這一步是向容器中注入 BeanPostProcessor ，注意這里僅僅是向容器中注入而非使用。參考上面的步驟和下面的代碼，讀者自行分析即可，應該不是很困難。
關于 BeanPostProcessor ，它的作用在后續(xù) Spring 創(chuàng)建 bean 流程文章里我會詳細分析一下，當然不可能分析全部的 BeanPostProcessor 組件，那樣可能得寫好幾篇續(xù)文，這里我們只需要簡單明白這個組件會干預 Spring 初始化 bean 的流程，從而完成代理、自動注入、循環(huán)依賴等各種功能。
public static void registerBeanPostProcessors(
ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
// 從容器中獲取 BeanPostProcessor 類型
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;
// 向容器中添加【BeanPostProcessorChecker】，主要是用來檢查是不是有 bean 已經初始化完成了，
// 如果沒有執(zhí)行所有的 beanPostProcessor（用數(shù)量來判斷），如果有就會打印一行 info 日志
beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
// Separate between BeanPostProcessors that implement PriorityOrdered,
// Ordered, and the rest.
// 存放實現(xiàn)了 PriorityOrdered 接口的 BeanPostProcessor
List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
// 存放 MergedBeanDefinitionPostProcessor 類型的 BeanPostProcessor
List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
// 存放實現(xiàn)了 Ordered 接口的 BeanPostProcessor 的 name
List<String> orderedPostProcessorNames = new ArrayList<>();
// 存放剩下來普通的 BeanPostProcessor 的 name
List<String> nonOrderedPostProcessorNames = new ArrayList<>();
// 從 beanFactory 中查找 postProcessorNames 里的 bean，然后放到對應的集合中
for (String ppName : postProcessorNames) {
// 判斷有無實現(xiàn) PriorityOrdered 接口
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
priorityOrderedPostProcessors.add(pp);
// 如果實現(xiàn)了 PriorityOrdered 接口，且屬于 MergedBeanDefinitionPostProcessor
if (pp instanceof MergedBeanDefinitionPostProcessor) {
// 把 MergedBeanDefinitionPostProcessor 類型的添加到 internalPostProcessors 集合中
internalPostProcessors.add(pp);
}
}
else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessorNames.add(ppName);
}
else {
nonOrderedPostProcessorNames.add(ppName);
}
}
// First, register the BeanPostProcessors that implement PriorityOrdered.
// 給 priorityOrderedPostProcessors 排序
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
// 先注冊實現(xiàn)了 PriorityOrdered 接口的 beanPostProcessor
registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
// Next, register the BeanPostProcessors that implement Ordered.
// 從 beanFactory 中查找 orderedPostProcessorNames 里的 bean，然后放到對應的集合中
List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>();
for (String ppName : orderedPostProcessorNames) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
orderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
// 給 orderedPostProcessors 排序
sortPostProcessors(orderedPostProcessors, beanFactory);
// 再注冊實現(xiàn)了 Ordered 接口的 beanPostProcessor
registerBeanPostProcessors(beanFactory, orderedPostProcessors);
// Now, register all regular BeanPostProcessors.
List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
for (String ppName : nonOrderedPostProcessorNames) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
nonOrderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
// 再注冊常規(guī)的 beanPostProcessor
registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);
// Finally, re-register all internal BeanPostProcessors.
// 排序 MergedBeanDefinitionPostProcessor 這種類型的 beanPostProcessor
sortPostProcessors(internalPostProcessors, beanFactory);
// 最后注冊 MergedBeanDefinitionPostProcessor 類型的 beanPostProcessor
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).
// 給容器中添加【ApplicationListenerDetector】 beanPostProcessor，判斷是不是監(jiān)聽器，如果是就把 bean 放到容器中保存起來
// 此時容器中默認會有 6 個內置的 beanPostProcessor
// 0 = {ApplicationContextAwareProcessor@1632}
// 1 = {ConfigurationClassPostProcessor$ImportAwareBeanPostProcessor@1633}
// 2 = {PostProcessorRegistrationDelegate$BeanPostProcessorChecker@1634}
// 3 = {CommonAnnotationBeanPostProcessor@1635}
// 4 = {AutowiredAnnotationBeanPostProcessor@1636}
// 5 = {ApplicationListenerDetector@1637}
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}org.springframework.context.support.AbstractApplicationContext#initApplicationEventMulticaster
前文我們說到，在整個容器創(chuàng)建過程中，Spring 會發(fā)布很多容器事件，如容器啟動、刷新、關閉等，這個功能的實現(xiàn)得益于這里的 ApplicationEventMulticaster 廣播器組件，通過它來派發(fā)事件通知。
在這里 Spring 也為我們提供了擴展，SimpleApplicationEventMulticaster 默認是同步的，如果我們想改成異步的，只需要在容器里自定義一個 name 為 applicationEventMulticaster 的容器即可，類似的思想在后續(xù)的 Spring Boot 中會有更多的體現(xiàn)，這里不再贅述。
protected void initApplicationEventMulticaster() {
// 獲取 beanFactory
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
// 看看容器中是否有自定義的 applicationEventMulticaster
if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
// 有就從容器中獲取賦值
this.applicationEventMulticaster =
beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
if (logger.isTraceEnabled()) {
logger.trace("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
}
}
else {
// 沒有，就創(chuàng)建一個 SimpleApplicationEventMulticaster
this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
// 將創(chuàng)建的 ApplicationEventMulticaster 添加到 BeanFactory 中， 其他組件就可以自動注入了
beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
if (logger.isTraceEnabled()) {
logger.trace("No '" + APPLICATION_EVENT_MULTICASTER_BEAN_NAME + "' bean, using " +
"[" + this.applicationEventMulticaster.getClass().getSimpleName() + "]");
}
}
}org.springframework.context.support.AbstractApplicationContext#registerListeners
如果用戶想監(jiān)聽容器事件，那么就必須按照規(guī)范實現(xiàn) ApplicationListener 接口并放入到容器中，在這里會被 Spring 掃描到，添加到 ApplicationEventMulticaster 廣播器里，以后就可以發(fā)布事件通知，對應的 Listener 就會收到消息進行處理。
protected void registerListeners() {
// Register statically specified listeners first.
// 獲取之前步驟中保存的 ApplicationListener
for (ApplicationListener<?> listener : getApplicationListeners()) {
// getApplicationEventMulticaster() 就是獲取之前步驟初始化的 applicationEventMulticaster
getApplicationEventMulticaster().addApplicationListener(listener);
}
// Do not initialize FactoryBeans here: We need to leave all regular beans
// uninitialized to let post-processors apply to them!
// 從容器中獲取所有的 ApplicationListener
String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
for (String listenerBeanName : listenerBeanNames) {
getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
}
// Publish early application events now that we finally have a multicaster...
// 派發(fā)之前步驟產生的 application events
Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
this.earlyApplicationEvents = null;
if (earlyEventsToProcess != null) {
for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
getApplicationEventMulticaster().multicastEvent(earlyEvent);
}
}
}org.springframework.beans.factory.support.DefaultListableBeanFactory#preInstantiateSingletons
在上面的步驟中，Spring 的大多數(shù)組件都已經初始化完畢了，剩下來的這個步驟就是初始化所有剩余的單實例 bean，在 Spring 中初始化一個 bean 對象是非常復雜的，如循環(huán)依賴、bean 后置處理器運用、aop 代理等，這些內容都不在此展開贅述了，后面的系列文章會具體探究，這里我們只需要明白 Spring 是通過這個方法把容器中的 bean 都初始化完畢即可。
public void preInstantiateSingletons() throws BeansException {
if (logger.isTraceEnabled()) {
logger.trace("Pre-instantiating singletons in " + this);
}
// Iterate over a copy to allow for init methods which in turn register new bean definitions.
// While this may not be part of the regular factory bootstrap, it does otherwise work fine.
// 獲取容器中的所有 beanDefinitionName
List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
// Trigger initialization of all non-lazy singleton beans...
// 循環(huán)進行初始化和創(chuàng)建對象
for (String beanName : beanNames) {
// 獲取 RootBeanDefinition，它表示自己的 BeanDefinition 和可能存在父類的 BeanDefinition 合并后的對象
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
// 如果是非抽象的，且單實例，非懶加載
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
// 如果是 factoryBean，利用下面這種方法創(chuàng)建對象
if (isFactoryBean(beanName)) {
// 如果是 factoryBean，則 加上 &，先創(chuàng)建工廠 bean
Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
if (bean instanceof FactoryBean) {
final FactoryBean<?> factory = (FactoryBean<?>) bean;
boolean isEagerInit;
if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)
((SmartFactoryBean<?>) factory)::isEagerInit,
getAccessControlContext());
}
else {
isEagerInit = (factory instanceof SmartFactoryBean &&
((SmartFactoryBean<?>) factory).isEagerInit());
}
if (isEagerInit) {
getBean(beanName);
}
}
}
else {
// 不是工廠 bean，用這種方法創(chuàng)建對象
getBean(beanName);
}
}
}
// Trigger post-initialization callback for all applicable beans...
for (String beanName : beanNames) {
Object singletonInstance = getSingleton(beanName);
// 檢查所有的 bean 是否是 SmartInitializingSingleton 接口
if (singletonInstance instanceof SmartInitializingSingleton) {
final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
smartSingleton.afterSingletonsInstantiated();
return null;
}, getAccessControlContext());
}
else {
// 回調 afterSingletonsInstantiated() 方法，可以在回調中做一些事情
smartSingleton.afterSingletonsInstantiated();
}
}
}
}org.springframework.context.support.AbstractApplicationContext#finishRefresh
整個容器初始化完畢之后，會在這里進行一些掃尾工作，如清理緩存，初始化生命周期處理器，發(fā)布容器刷新事件等。
protected void finishRefresh() {
// Clear context-level resource caches (such as ASM metadata from scanning).
// 清理緩存
clearResourceCaches();
// Initialize lifecycle processor for this context.
// 初始化和生命周期有關的后置處理器
initLifecycleProcessor();
// Propagate refresh to lifecycle processor first.
// 拿到前面定義的生命周期處理器【LifecycleProcessor】回調 onRefresh() 方法
getLifecycleProcessor().onRefresh();
// Publish the final event.
// 發(fā)布容器刷新完成事件
publishEvent(new ContextRefreshedEvent(this));
// Participate in LiveBeansView MBean, if active.
LiveBeansView.registerApplicationContext(this);
}到此這篇關于Spring源碼分析容器啟動流程的文章就介紹到這了,更多相關Spring容器啟動流程內容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！
相關文章
Maven是圍繞著構建生命周期的核心概念為原型，整個項目的創(chuàng)建和部署都是圍繞著生命周期展開的，一個生命周期由若干個生命周期階段組成。下面通過本文給大家介紹Maven 配置文件 生命周期 常用命令詳解，一起看看吧2017-11-11
本篇文章主要介紹了mybatis教程之延遲加載詳解。詳細介紹了延遲加載的意義和用法實現(xiàn)，有興趣的可以了解一下2017-05-05
Java concurrency集合之ConcurrentHashMap_動力節(jié)點Java學院整理
這篇文章主要介紹了Java concurrency集合之ConcurrentHashMap的相關資料,需要的朋友可以參考下2017-06-06
Java回調函數(shù)原理實例與代理模式的區(qū)別講解
今天小編就為大家分享一篇關于Java回調函數(shù)原理實例與代理模式的區(qū)別講解，小編覺得內容挺不錯的，現(xiàn)在分享給大家，具有很好的參考價值，需要的朋友一起跟隨小編來看看吧2019-02-02
JSON.toJSONString()空字段不忽略修改的問題
這篇文章主要介紹了JSON.toJSONString()空字段不忽略修改的問題，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教2022-02-02
Spring Boot如何使用httpcomponents實現(xiàn)http請求
這篇文章主要介紹了Spring Boot使用httpcomponents實現(xiàn)http請求的示例代碼，本文通過實例代碼給大家介紹的非常詳細，對大家的學習或工作具有一定的參考借鑒價值,需要的朋友可以參考下2023-07-07
這篇文章主要介紹了Java內存區(qū)域管理詳解，文章通過圍繞主題展開詳細的內容介紹，具有一定的參考價值，需要的小伙伴可以參考一下2022-09-09
關于jdk環(huán)境變量配置以及javac不是內部或外部命令的解決
這篇文章主要介紹了關于jdk環(huán)境變量配置以及javac不是內部或外部命令的解決方案，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教2023-01-01
這段時間一直在觀看Spring框架，所以下面這篇文章主要給大家介紹了關于Spring項目對JDBC的支持與基本使用的相關資料，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧2018-11-11
詳解Spring Boot 使用Spring security 集成CAS
本篇文章主要介紹了詳解Spring Boot 使用Spring security 集成CAS，具有一定的參考價值，感興趣的小伙伴們可以參考一下2017-05-05