Spring Framework 是 Java 語言中影響最為深遠的框架之一，其中的 IOC 和 AOP 兩個經典思想更是一直被程序員津津樂道，后面推出的 Spring Boot、Spring Cloud 系列也是在其基礎之上開發，要想搞明白 Spring 全家桶系列，必須腳踏實地的從 Spring Framework 學習起。
這是我 Spring Framework 源碼解析系列的第一篇，主要是從代碼層面對 Spring 框架的啟動做一個完整解析，這里的思想都是筆者根據自己使用 Spring 的經驗和對 Spring 的了解綜合而成，以下內容謹代表個人看法，若有疑問請不吝賜教。
另外提醒一下，本篇文章是基于 5.1.6.RELEASE 版本的代碼進行分析，入口代碼也是采用官方推薦的 java-config 技術，而非 xml。
源碼解析
考慮到直接看源碼是一個非常枯燥無味的過程，而且 Spring 的代碼設計非常優秀規范，這會導致在翻開源碼時，類與類之間的跳躍會非常頻繁，不熟悉的同學可能直接暈菜，所以每一個重要流程前我都會先準備一個流程圖，建議大家先通過流程圖了解一下整體步驟，然后再對代碼硬擼，這樣能夠降低不少難度。
相信每一個使用過 Spring 技術的同學都知道 Spring 在初始化過程中有一個非常重要的步驟，即 Spring 容器的刷新，這個步驟固然重要，但是刷新前的初始化流程也非常重要。
本篇文章將整個啟動過程分為了兩個部分，即容器的初始化與刷新，下面正式開始。
初始化流程
流程分析
因為是基于 java-config 技術分析源碼，所以這里的入口是 AnnotationConfigApplicationContext ，如果是使用 xml 分析，那么入口即為 ClassPathXmlApplicationContext ，它們倆的共同特征便是都繼承了 AbstractApplicationContext 類，而大名鼎鼎的 refresh 方法便是在這個類中定義的，現在就不劇透了，我們接著分析 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 自動注入。
publicstaticSetregisterAnnotationConfigProcessors(
BeanDefinitionRegistryregistry,@NullableObjectsource){
DefaultListableBeanFactorybeanFactory=unwrapDefaultListableBeanFactory(registry);
if(beanFactory!=null){
if(!(beanFactory.getDependencyComparator()instanceofAnnotationAwareOrderComparator)){
beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
}
if(!(beanFactory.getAutowireCandidateResolver()instanceofContextAnnotationAutowireCandidateResolver)){
beanFactory.setAutowireCandidateResolver(newContextAnnotationAutowireCandidateResolver());
}
}
SetbeanDefs=newLinkedHashSet<>(8);
//向beanDefinitionMap中注冊【BeanFactoryPostProcessor】：【ConfigurationClassPostProcessor】
if(!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)){
RootBeanDefinitiondef=newRootBeanDefinition(ConfigurationClassPostProcessor.class);
def.setSource(source);
beanDefs.add(registerPostProcessor(registry,def,CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
}
//向beanDefinitionMap中注冊【BeanPostProcessor】：【AutowiredAnnotationBeanPostProcessor】
if(!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)){
RootBeanDefinitiondef=newRootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
def.setSource(source);
beanDefs.add(registerPostProcessor(registry,def,AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
}
//CheckforJSR-250support,andifpresentaddtheCommonAnnotationBeanPostProcessor.
//向beanDefinitionMap中注冊【BeanPostProcessor】：【CommonAnnotationBeanPostProcessor】
if(jsr250Present&&!registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)){
RootBeanDefinitiondef=newRootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
def.setSource(source);
beanDefs.add(registerPostProcessor(registry,def,COMMON_ANNOTATION_PROCESSOR_BEAN_NAME));
}
//CheckforJPAsupport,andifpresentaddthePersistenceAnnotationBeanPostProcessor.
//向beanDefinitionMap中注冊【BeanPostProcessor】：【PersistenceAnnotationBeanPostProcessor】，前提條件是在jpa環境下
if(jpaPresent&&!registry.containsBeanDefinition(PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)){
RootBeanDefinitiondef=newRootBeanDefinition();
try{
def.setBeanClass(ClassUtils.forName(PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME,
AnnotationConfigUtils.class.getClassLoader()));
}
catch(ClassNotFoundExceptionex){
thrownewIllegalStateException(
"Cannotloadoptionalframeworkclass:"+PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME,ex);
}
def.setSource(source);
beanDefs.add(registerPostProcessor(registry,def,PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME));
}
//向beanDefinitionMap中注冊【BeanFactoryPostProcessor】：【EventListenerMethodProcessor】
if(!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)){
RootBeanDefinitiondef=newRootBeanDefinition(EventListenerMethodProcessor.class);
def.setSource(source);
beanDefs.add(registerPostProcessor(registry,def,EVENT_LISTENER_PROCESSOR_BEAN_NAME));
}
//向beanDefinitionMap中注冊組件：【DefaultEventListenerFactory】
if(!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)){
RootBeanDefinitiondef=newRootBeanDefinition(DefaultEventListenerFactory.class);
def.setSource(source);
beanDefs.add(registerPostProcessor(registry,def,EVENT_LISTENER_FACTORY_BEAN_NAME));
}
returnbeanDefs;
}
org.springframework.context.annotation.AnnotatedBeanDefinitionReader#doRegisterBean
這個步驟主要是用來解析用戶傳入的 Spring 配置類，其實也是解析成一個 BeanDefinition 然后注冊到容器中，沒有什么好說的。
voiddoRegisterBean(ClassannotatedClass,@NullableSupplierinstanceSupplier,@NullableStringname,
@NullableClass[]qualifiers,BeanDefinitionCustomizer...definitionCustomizers){
//解析傳入的配置類，實際上這個方法既可以解析配置類，也可以解析Springbean對象
AnnotatedGenericBeanDefinitionabd=newAnnotatedGenericBeanDefinition(annotatedClass);
//判斷是否需要跳過，判斷依據是此類上有沒有@Conditional注解
if(this.conditionEvaluator.shouldSkip(abd.getMetadata())){
return;
}
abd.setInstanceSupplier(instanceSupplier);
ScopeMetadatascopeMetadata=this.scopeMetadataResolver.resolveScopeMetadata(abd);
abd.setScope(scopeMetadata.getScopeName());
StringbeanName=(name!=null?name:this.beanNameGenerator.generateBeanName(abd,this.registry));
//處理類上的通用注解
AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
if(qualifiers!=null){
for(Classqualifier:qualifiers){
if(Primary.class==qualifier){
abd.setPrimary(true);
}
elseif(Lazy.class==qualifier){
abd.setLazyInit(true);
}
else{
abd.addQualifier(newAutowireCandidateQualifier(qualifier));
}
}
}
//封裝成一個BeanDefinitionHolder
for(BeanDefinitionCustomizercustomizer:definitionCustomizers){
customizer.customize(abd);
}
BeanDefinitionHolderdefinitionHolder=newBeanDefinitionHolder(abd,beanName);
//處理scopedProxyMode
definitionHolder=AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata,definitionHolder,this.registry);
//把BeanDefinitionHolder注冊到registry
BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder,this.registry);
}
刷新流程
流程分析
下面這一段代碼則是 Spring 中最為重要的一個步驟：容器刷新，同樣先看圖再分析。
看完流程圖，我們也先思考一下：在 3.1 中我們知道了如何去初始化一個 IOC 容器，那么接下來就是讓這個 IOC 容器真正起作用的時候了：即先掃描出要放入容器的 bean，將其包裝成 BeanDefinition 對象，然后通過反射創建 bean，并完成賦值操作，這個就是 IOC 容器最簡單的功能了。
但是看完上圖，明顯 Spring 的初始化過程比這個多的多，下面我們就詳細分析一下這樣設計的意圖：
如果用戶想在掃描完 bean 之后做一些自定義的操作：假設容器中包含了 a 和 b，那么就動態向容器中注入 c，不滿足就注入 d，這種騷操作 Spring 也是支持的，得益于它提供的 BeanFactoryPostProcessor 后置處理器，對應的是上圖中的 invokeBeanFactoryPostProcessors 操作。
如果用戶還想在 bean 的初始化前后做一些操作呢?比如生成代理對象，修改對象屬性等，Spring 為我們提供了 BeanPostProcessor 后置處理器，實際上 Spring 容器中的大多數功能都是通過 Bean 后置處理器完成的，Spring 也是給我們提供了添加入口，對應的是上圖中的 registerBeanPostProcessors 操作。
整個容器創建過程中，如果用戶想監聽容器啟動、刷新等事件，根據這些事件做一些自定義的操作呢?Spring 也早已為我們考慮到了，提供了添加監聽器接口和容器事件通知接口，對應的是上圖中的 registerListeners 操作。
此時再看上圖，是不是就覺得簡單很多呢，下面就一些重要代碼進行分析。
核心代碼剖析
org.springframework.context.support.AbstractApplicationContext#refresh
這個方法是對上圖中的具體代碼實現，可劃分為12個步驟，其中比較重要的步驟下面會有詳細說明。
在這里，我們需要記住：Spring 中的每一個容器都會調用 refresh 方法進行刷新，無論是 Spring 的父子容器，還是 Spring Cloud Feign 中的 feign 隔離容器，每一個容器都會調用這個方法完成初始化。
publicvoidrefresh()throwsBeansException,IllegalStateException{
synchronized(this.startupShutdownMonitor){
//Preparethiscontextforrefreshing.
//1.刷新前的預處理
prepareRefresh();
//Tellthesubclasstorefreshtheinternalbeanfactory.
//2.獲取beanFactory，即前面創建的【DefaultListableBeanFactory】
ConfigurableListableBeanFactorybeanFactory=obtainFreshBeanFactory();
//Preparethebeanfactoryforuseinthiscontext.
//3.預處理beanFactory，向容器中添加一些組件
prepareBeanFactory(beanFactory);
try{
//Allowspost-processingofthebeanfactoryincontextsubclasses.
//4.子類通過重寫這個方法可以在BeanFactory創建并與準備完成以后做進一步的設置
postProcessBeanFactory(beanFactory);
//Invokefactoryprocessorsregisteredasbeansinthecontext.
//5.執行BeanFactoryPostProcessor方法，beanFactory后置處理器
invokeBeanFactoryPostProcessors(beanFactory);
//Registerbeanprocessorsthatinterceptbeancreation.
//6.注冊BeanPostProcessors，bean后置處理器
registerBeanPostProcessors(beanFactory);
//Initializemessagesourceforthiscontext.
//7.初始化MessageSource組件(做國際化功能;消息綁定，消息解析)
initMessageSource();
//Initializeeventmulticasterforthiscontext.
//8.初始化事件派發器，在注冊監聽器時會用到
initApplicationEventMulticaster();
//Initializeotherspecialbeansinspecificcontextsubclasses.
//9.留給子容器(子類)，子類重寫這個方法，在容器刷新的時候可以自定義邏輯，web場景下會使用
onRefresh();
//Checkforlistenerbeansandregisterthem.
//10.注冊監聽器，派發之前步驟產生的一些事件(可能沒有)
registerListeners();
//Instantiateallremaining(non-lazy-init)singletons.
//11.初始化所有的非單實例bean
finishBeanFactoryInitialization(beanFactory);
//Laststep:publishcorrespondingevent.
//12.發布容器刷新完成事件
finishRefresh();
}
...
}
}
org.springframework.context.support.AbstractApplicationContext#prepareBeanFactory
顧名思義，這個接口是為 beanFactory 工廠添加一些內置組件，預處理過程。
protectedvoidprepareBeanFactory(ConfigurableListableBeanFactorybeanFactory){
//Telltheinternalbeanfactorytousethecontext'sclassloaderetc.
//設置classLoader
beanFactory.setBeanClassLoader(getClassLoader());
//設置bean表達式解析器
beanFactory.setBeanExpressionResolver(newStandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
beanFactory.addPropertyEditorRegistrar(newResourceEditorRegistrar(this,getEnvironment()));
//Configurethebeanfactorywithcontextcallbacks.
//添加一個BeanPostProcessor【ApplicationContextAwareProcessor】
beanFactory.addBeanPostProcessor(newApplicationContextAwareProcessor(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);
//BeanFactoryinterfacenotregisteredasresolvabletypeinaplainfactory.
//MessageSourceregistered(andfoundforautowiring)asabean.
//注冊可以解析的自動裝配類，即可以在任意組件中通過注解自動注入
beanFactory.registerResolvableDependency(BeanFactory.class,beanFactory);
beanFactory.registerResolvableDependency(ResourceLoader.class,this);
beanFactory.registerResolvableDependency(ApplicationEventPublisher.class,this);
beanFactory.registerResolvableDependency(ApplicationContext.class,this);
//Registerearlypost-processorfordetectinginnerbeansasApplicationListeners.
//添加一個BeanPostProcessor【ApplicationListenerDetector】
beanFactory.addBeanPostProcessor(newApplicationListenerDetector(this));
//DetectaLoadTimeWeaverandprepareforweaving,iffound.
//添加編譯時的AspectJ
if(beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)){
beanFactory.addBeanPostProcessor(newLoadTimeWeaverAwareProcessor(beanFactory));
//SetatemporaryClassLoaderfortypematching.
beanFactory.setTempClassLoader(newContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}
//Registerdefaultenvironmentbeans.
//注冊environment組件，類型是【ConfigurableEnvironment】
if(!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)){
beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME,getEnvironment());
}
//注冊systemProperties組件，類型是【Map】
if(!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)){
beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME,getEnvironment().getSystemProperties());
}
//注冊systemEnvironment組件，類型是【Map】
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，那么就動態向容器中注入 c，不滿足就注入 d。
熟悉 Spring 的同學都知道，Spring 中的同類型組件是允許我們控制順序的，比如在 AOP 中我們常用的 @Order 注解，這里的 BeanFactoryPostProcessor 接口當然也是提供了順序，最先被執行的是實現了 PriorityOrdered 接口的實現類，然后再到實現了 Ordered 接口的實現類，最后就是剩下來的常規 BeanFactoryPostProcessor 類。
此時再看上圖，是不是發現和喝水一般簡單，首先會回調 postProcessBeanDefinitionRegistry() 方法，然后再回調 postProcessBeanFactory() 方法，最后注意順序即可，下面一起看看具體的代碼實現吧。
publicstaticvoidinvokeBeanFactoryPostProcessors(
ConfigurableListableBeanFactorybeanFactory,ListbeanFactoryPostProcessors){
//beanFactoryPostProcessors這個參數是指用戶通過AnnotationConfigApplicationContext.addBeanFactoryPostProcessor()方法手動傳入的BeanFactoryPostProcessor，沒有交給spring管理
//InvokeBeanDefinitionRegistryPostProcessorsfirst,ifany.
//代表執行過的BeanDefinitionRegistryPostProcessor
SetprocessedBeans=newHashSet<>();
if(beanFactoryinstanceofBeanDefinitionRegistry){
BeanDefinitionRegistryregistry=(BeanDefinitionRegistry)beanFactory;
//常規后置處理器集合，即實現了BeanFactoryPostProcessor接口
ListregularPostProcessors=newArrayList<>();
//注冊后置處理器集合，即實現了BeanDefinitionRegistryPostProcessor接口
ListregistryProcessors=newArrayList<>();
//處理自定義的beanFactoryPostProcessors(指調用context.addBeanFactoryPostProcessor()方法)，一般這里都沒有
for(BeanFactoryPostProcessorpostProcessor:beanFactoryPostProcessors){
if(postProcessorinstanceofBeanDefinitionRegistryPostProcessor){
BeanDefinitionRegistryPostProcessorregistryProcessor=
(BeanDefinitionRegistryPostProcessor)postProcessor;
//調用postProcessBeanDefinitionRegistry方法
registryProcessor.postProcessBeanDefinitionRegistry(registry);
registryProcessors.add(registryProcessor);
}
else{
regularPostProcessors.add(postProcessor);
}
}
//DonotinitializeFactoryBeanshere:Weneedtoleaveallregularbeans
//uninitializedtoletthebeanfactorypost-processorsapplytothem!
//SeparatebetweenBeanDefinitionRegistryPostProcessorsthatimplement
//PriorityOrdered,Ordered,andtherest.
//定義一個變量currentRegistryProcessors，表示當前要處理的BeanFactoryPostProcessors
ListcurrentRegistryProcessors=newArrayList<>();
//First,invoketheBeanDefinitionRegistryPostProcessorsthatimplementPriorityOrdered.
//首先，從容器中查找實現了PriorityOrdered接口的BeanDefinitionRegistryPostProcessor類型，這里只會查找出一個【ConfigurationClassPostProcessor】
String[]postProcessorNames=
beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class,true,false);
for(StringppName:postProcessorNames){
//判斷是否實現了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);
//執行[postProcessBeanDefinitionRegistry]回調方法
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors,registry);
//將currentRegistryProcessors變量清空，下面會繼續用到
currentRegistryProcessors.clear();
//Next,invoketheBeanDefinitionRegistryPostProcessorsthatimplementOrdered.
//接下來，從容器中查找實現了Ordered接口的BeanDefinitionRegistryPostProcessors類型，這里可能會查找出多個
//因為【ConfigurationClassPostProcessor】已經完成了postProcessBeanDefinitionRegistry()方法，已經向容器中完成掃描工作，所以容器會有很多個組件
postProcessorNames=beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class,true,false);
for(StringppName:postProcessorNames){
//判斷processedBeans是否處理過這個類，且是否實現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);
//執行[postProcessBeanDefinitionRegistry]回調方法
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors,registry);
//將currentRegistryProcessors變量清空，下面會繼續用到
currentRegistryProcessors.clear();
//Finally,invokeallotherBeanDefinitionRegistryPostProcessorsuntilnofurtheronesappear.
//最后，從容器中查找剩余所有常規的BeanDefinitionRegistryPostProcessors類型
booleanreiterate=true;
while(reiterate){
reiterate=false;
//根據類型從容器中查找
postProcessorNames=beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class,true,false);
for(StringppName:postProcessorNames){
//判斷processedBeans是否處理過這個類
if(!processedBeans.contains(ppName)){
//添加到currentRegistryProcessors
currentRegistryProcessors.add(beanFactory.getBean(ppName,BeanDefinitionRegistryPostProcessor.class));
//添加到processedBeans，表示已經處理過這個類了
processedBeans.add(ppName);
//將標識設置為true，繼續循環查找，可能隨時因為防止下面調用了invokeBeanDefinitionRegistryPostProcessors()方法引入新的后置處理器
reiterate=true;
}
}
//設置排列順序
sortPostProcessors(currentRegistryProcessors,beanFactory);
//添加到registry中
registryProcessors.addAll(currentRegistryProcessors);
//執行[postProcessBeanDefinitionRegistry]回調方法
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors,registry);
//將currentRegistryProcessors變量清空，因為下一次循環可能會用到
currentRegistryProcessors.clear();
}
//Now,invokethepostProcessBeanFactorycallbackofallprocessorshandledsofar.
//現在執行registryProcessors的[postProcessBeanFactory]回調方法
invokeBeanFactoryPostProcessors(registryProcessors,beanFactory);
//執行regularPostProcessors的[postProcessBeanFactory]回調方法，也包含用戶手動調用addBeanFactoryPostProcessor()方法添加的BeanFactoryPostProcessor
invokeBeanFactoryPostProcessors(regularPostProcessors,beanFactory);
}
else{
//Invokefactoryprocessorsregisteredwiththecontextinstance.
invokeBeanFactoryPostProcessors(beanFactoryPostProcessors,beanFactory);
}
//DonotinitializeFactoryBeanshere:Weneedtoleaveallregularbeans
//uninitializedtoletthebeanfactorypost-processorsapplytothem!
//從容器中查找實現了BeanFactoryPostProcessor接口的類
String[]postProcessorNames=
beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class,true,false);
//SeparatebetweenBeanFactoryPostProcessorsthatimplementPriorityOrdered,
//Ordered,andtherest.
//表示實現了PriorityOrdered接口的BeanFactoryPostProcessor
ListpriorityOrderedPostProcessors=newArrayList<>();
//表示實現了Ordered接口的BeanFactoryPostProcessor
ListorderedPostProcessorNames=newArrayList<>();
//表示剩下來的常規的BeanFactoryPostProcessors
ListnonOrderedPostProcessorNames=newArrayList<>();
for(StringppName:postProcessorNames){
//判斷是否已經處理過，因為postProcessorNames其實包含了上面步驟處理過的BeanDefinitionRegistry類型
if(processedBeans.contains(ppName)){
//skip-alreadyprocessedinfirstphaseabove
}
//判斷是否實現了PriorityOrdered接口
elseif(beanFactory.isTypeMatch(ppName,PriorityOrdered.class)){
priorityOrderedPostProcessors.add(beanFactory.getBean(ppName,BeanFactoryPostProcessor.class));
}
//判斷是否實現了Ordered接口
elseif(beanFactory.isTypeMatch(ppName,Ordered.class)){
orderedPostProcessorNames.add(ppName);
}
//剩下所有常規的
else{
nonOrderedPostProcessorNames.add(ppName);
}
}
//First,invoketheBeanFactoryPostProcessorsthatimplementPriorityOrdered.
//先將priorityOrderedPostProcessors集合排序
sortPostProcessors(priorityOrderedPostProcessors,beanFactory);
//執行priorityOrderedPostProcessors的[postProcessBeanFactory]回調方法
invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors,beanFactory);
//Next,invoketheBeanFactoryPostProcessorsthatimplementOrdered.
//接下來，把orderedPostProcessorNames轉成orderedPostProcessors集合
ListorderedPostProcessors=newArrayList<>();
for(StringpostProcessorName:orderedPostProcessorNames){
orderedPostProcessors.add(beanFactory.getBean(postProcessorName,BeanFactoryPostProcessor.class));
}
//將orderedPostProcessors集合排序
sortPostProcessors(orderedPostProcessors,beanFactory);
//執行orderedPostProcessors的[postProcessBeanFactory]回調方法
invokeBeanFactoryPostProcessors(orderedPostProcessors,beanFactory);
//Finally,invokeallotherBeanFactoryPostProcessors.
//最后把nonOrderedPostProcessorNames轉成nonOrderedPostProcessors集合，這里只有一個，myBeanFactoryPostProcessor
ListnonOrderedPostProcessors=newArrayList<>();
for(StringpostProcessorName:nonOrderedPostProcessorNames){
nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName,BeanFactoryPostProcessor.class));
}
//執行nonOrderedPostProcessors的[postProcessBeanFactory]回調方法
invokeBeanFactoryPostProcessors(nonOrderedPostProcessors,beanFactory);
//Clearcachedmergedbeandefinitionssincethepost-processorsmighthave
//modifiedtheoriginalmetadata,e.g.replacingplaceholdersinvalues...
//清除緩存
beanFactory.clearMetadataCache();
org.springframework.context.support.PostProcessorRegistrationDelegate#registerBeanPostProcessors
這一步是向容器中注入 BeanPostProcessor ，注意這里僅僅是向容器中注入而非使用。參考上面的步驟和下面的代碼，讀者自行分析即可，應該不是很困難。
關于 BeanPostProcessor ，它的作用在后續 Spring 創建 bean 流程文章里我會詳細分析一下，當然不可能分析全部的 BeanPostProcessor 組件，那樣可能得寫好幾篇續文，這里我們只需要簡單明白這個組件會干預 Spring 初始化 bean 的流程，從而完成代理、自動注入、循環依賴等各種功能。
publicstaticvoidregisterBeanPostProcessors(
ConfigurableListableBeanFactorybeanFactory,AbstractApplicationContextapplicationContext){
//從容器中獲取BeanPostProcessor類型
String[]postProcessorNames=beanFactory.getBeanNamesForType(BeanPostProcessor.class,true,false);
//RegisterBeanPostProcessorCheckerthatlogsaninfomessagewhen
//abeaniscreatedduringBeanPostProcessorinstantiation,i.e.when
//abeanisnoteligibleforgettingprocessedbyallBeanPostProcessors.
intbeanProcessorTargetCount=beanFactory.getBeanPostProcessorCount()+1+postProcessorNames.length;
//向容器中添加【BeanPostProcessorChecker】，主要是用來檢查是不是有bean已經初始化完成了，
//如果沒有執行所有的beanPostProcessor(用數量來判斷)，如果有就會打印一行info日志
beanFactory.addBeanPostProcessor(newBeanPostProcessorChecker(beanFactory,beanProcessorTargetCount));
//SeparatebetweenBeanPostProcessorsthatimplementPriorityOrdered,
//Ordered,andtherest.
//存放實現了PriorityOrdered接口的BeanPostProcessor
ListpriorityOrderedPostProcessors=newArrayList<>();
//存放MergedBeanDefinitionPostProcessor類型的BeanPostProcessor
ListinternalPostProcessors=newArrayList<>();
//存放實現了Ordered接口的BeanPostProcessor的name
ListorderedPostProcessorNames=newArrayList<>();
//存放剩下來普通的BeanPostProcessor的name
ListnonOrderedPostProcessorNames=newArrayList<>();
//從beanFactory中查找postProcessorNames里的bean，然后放到對應的集合中
for(StringppName:postProcessorNames){
//判斷有無實現PriorityOrdered接口
if(beanFactory.isTypeMatch(ppName,PriorityOrdered.class)){
BeanPostProcessorpp=beanFactory.getBean(ppName,BeanPostProcessor.class);
priorityOrderedPostProcessors.add(pp);
//如果實現了PriorityOrdered接口，且屬于MergedBeanDefinitionPostProcessor
if(ppinstanceofMergedBeanDefinitionPostProcessor){
//把MergedBeanDefinitionPostProcessor類型的添加到internalPostProcessors集合中
internalPostProcessors.add(pp);
}
}
elseif(beanFactory.isTypeMatch(ppName,Ordered.class)){
orderedPostProcessorNames.add(ppName);
}
else{
nonOrderedPostProcessorNames.add(ppName);
}
}
//First,registertheBeanPostProcessorsthatimplementPriorityOrdered.
//給priorityOrderedPostProcessors排序
sortPostProcessors(priorityOrderedPostProcessors,beanFactory);
//先注冊實現了PriorityOrdered接口的beanPostProcessor
registerBeanPostProcessors(beanFactory,priorityOrderedPostProcessors);
//Next,registertheBeanPostProcessorsthatimplementOrdered.
//從beanFactory中查找orderedPostProcessorNames里的bean，然后放到對應的集合中
ListorderedPostProcessors=newArrayList<>();
for(StringppName:orderedPostProcessorNames){
BeanPostProcessorpp=beanFactory.getBean(ppName,BeanPostProcessor.class);
orderedPostProcessors.add(pp);
if(ppinstanceofMergedBeanDefinitionPostProcessor){
internalPostProcessors.add(pp);
}
}
//給orderedPostProcessors排序
sortPostProcessors(orderedPostProcessors,beanFactory);
//再注冊實現了Ordered接口的beanPostProcessor
registerBeanPostProcessors(beanFactory,orderedPostProcessors);
//Now,registerallregularBeanPostProcessors.
ListnonOrderedPostProcessors=newArrayList<>();
for(StringppName:nonOrderedPostProcessorNames){
BeanPostProcessorpp=beanFactory.getBean(ppName,BeanPostProcessor.class);
nonOrderedPostProcessors.add(pp);
if(ppinstanceofMergedBeanDefinitionPostProcessor){
internalPostProcessors.add(pp);
}
}
//再注冊常規的beanPostProcessor
registerBeanPostProcessors(beanFactory,nonOrderedPostProcessors);
//Finally,re-registerallinternalBeanPostProcessors.
//排序MergedBeanDefinitionPostProcessor這種類型的beanPostProcessor
sortPostProcessors(internalPostProcessors,beanFactory);
//最后注冊MergedBeanDefinitionPostProcessor類型的beanPostProcessor
registerBeanPostProcessors(beanFactory,internalPostProcessors);
//Re-registerpost-processorfordetectinginnerbeansasApplicationListeners,
//movingittotheendoftheprocessorchain(forpickingupproxiesetc).
//給容器中添加【ApplicationListenerDetector】beanPostProcessor，判斷是不是監聽器，如果是就把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(newApplicationListenerDetector(applicationContext));
}
org.springframework.context.support.AbstractApplicationContext#initApplicationEventMulticaster
前文我們說到，在整個容器創建過程中，Spring 會發布很多容器事件，如容器啟動、刷新、關閉等，這個功能的實現得益于這里的 ApplicationEventMulticaster 廣播器組件，通過它來派發事件通知。
在這里 Spring 也為我們提供了擴展，SimpleApplicationEventMulticaster 默認是同步的，如果我們想改成異步的，只需要在容器里自定義一個 name 為 applicationEventMulticaster 的容器即可，類似的思想在后續的 Spring Boot 中會有更多的體現，這里不再贅述。
protectedvoidinitApplicationEventMulticaster(){
//獲取beanFactory
ConfigurableListableBeanFactorybeanFactory=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("UsingApplicationEventMulticaster["+this.applicationEventMulticaster+"]");
}
}
else{
//沒有，就創建一個SimpleApplicationEventMulticaster
this.applicationEventMulticaster=newSimpleApplicationEventMulticaster(beanFactory);
//將創建的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
如果用戶想監聽容器事件，那么就必須按照規范實現 ApplicationListener 接口并放入到容器中，在這里會被 Spring 掃描到，添加到 ApplicationEventMulticaster 廣播器里，以后就可以發布事件通知，對應的 Listener 就會收到消息進行處理。
protectedvoidregisterListeners(){
//Registerstaticallyspecifiedlistenersfirst.
//獲取之前步驟中保存的ApplicationListener
for(ApplicationListenerlistener:getApplicationListeners()){
//getApplicationEventMulticaster()就是獲取之前步驟初始化的applicationEventMulticaster
getApplicationEventMulticaster().addApplicationListener(listener);
}
//DonotinitializeFactoryBeanshere:Weneedtoleaveallregularbeans
//uninitializedtoletpost-processorsapplytothem!
//從容器中獲取所有的ApplicationListener
String[]listenerBeanNames=getBeanNamesForType(ApplicationListener.class,true,false);
for(StringlistenerBeanName:listenerBeanNames){
getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
}
//Publishearlyapplicationeventsnowthatwefinallyhaveamulticaster...
//派發之前步驟產生的applicationevents
SetearlyEventsToProcess=this.earlyApplicationEvents;
this.earlyApplicationEvents=null;
if(earlyEventsToProcess!=null){
for(ApplicationEventearlyEvent:earlyEventsToProcess){
getApplicationEventMulticaster().multicastEvent(earlyEvent);
}
}
}
org.springframework.beans.factory.support.DefaultListableBeanFactory#preInstantiateSingletons
在上面的步驟中，Spring 的大多數組件都已經初始化完畢了，剩下來的這個步驟就是初始化所有剩余的單實例 bean，在 Spring 中初始化一個 bean 對象是非常復雜的，如循環依賴、bean 后置處理器運用、aop 代理等，這些內容都不在此展開贅述了，后面的系列文章會具體探究，這里我們只需要明白 Spring 是通過這個方法把容器中的 bean 都初始化完畢即可。
publicvoidpreInstantiateSingletons()throwsBeansException{
if(logger.isTraceEnabled()){
logger.trace("Pre-instantiatingsingletonsin"+this);
}
//Iterateoveracopytoallowforinitmethodswhichinturnregisternewbeandefinitions.
//Whilethismaynotbepartoftheregularfactorybootstrap,itdoesotherwiseworkfine.
//獲取容器中的所有beanDefinitionName
ListbeanNames=newArrayList<>(this.beanDefinitionNames);
//Triggerinitializationofallnon-lazysingletonbeans...
//循環進行初始化和創建對象
for(StringbeanName:beanNames){
//獲取RootBeanDefinition，它表示自己的BeanDefinition和可能存在父類的BeanDefinition合并后的對象
RootBeanDefinitionbd=getMergedLocalBeanDefinition(beanName);
//如果是非抽象的，且單實例，非懶加載
if(!bd.isAbstract()&&bd.isSingleton()&&!bd.isLazyInit()){
//如果是factoryBean，利用下面這種方法創建對象
if(isFactoryBean(beanName)){
//如果是factoryBean，則加上&，先創建工廠bean
Objectbean=getBean(FACTORY_BEAN_PREFIX+beanName);
if(beaninstanceofFactoryBean){
finalFactoryBeanfactory=(FactoryBean)bean;
booleanisEagerInit;
if(System.getSecurityManager()!=null&&factoryinstanceofSmartFactoryBean){
isEagerInit=AccessController.doPrivileged((PrivilegedAction)
((SmartFactoryBean)factory)::isEagerInit,
getAccessControlContext());
}
else{
isEagerInit=(factoryinstanceofSmartFactoryBean&&
((SmartFactoryBean)factory).isEagerInit());
}
if(isEagerInit){
getBean(beanName);
}
}
}
else{
//不是工廠bean，用這種方法創建對象
getBean(beanName);
}
}
}
//Triggerpost-initializationcallbackforallapplicablebeans...
for(StringbeanName:beanNames){
ObjectsingletonInstance=getSingleton(beanName);
//檢查所有的bean是否是SmartInitializingSingleton接口
if(singletonInstanceinstanceofSmartInitializingSingleton){
finalSmartInitializingSingletonsmartSingleton=(SmartInitializingSingleton)singletonInstance;
if(System.getSecurityManager()!=null){
AccessController.doPrivileged((PrivilegedAction
smartSingleton.afterSingletonsInstantiated();
returnnull;
},getAccessControlContext());
}
else{
//回調afterSingletonsInstantiated()方法，可以在回調中做一些事情
smartSingleton.afterSingletonsInstantiated();
}
}
}
}
org.springframework.context.support.AbstractApplicationContext#finishRefresh
整個容器初始化完畢之后，會在這里進行一些掃尾工作，如清理緩存，初始化生命周期處理器，發布容器刷新事件等。
protectedvoidfinishRefresh(){
//Clearcontext-levelresourcecaches(suchasASMmetadatafromscanning).
//清理緩存
clearResourceCaches();
//Initializelifecycleprocessorforthiscontext.
//初始化和生命周期有關的后置處理器
initLifecycleProcessor();
//Propagaterefreshtolifecycleprocessorfirst.
//拿到前面定義的生命周期處理器【LifecycleProcessor】回調onRefresh()方法
getLifecycleProcessor().onRefresh();
//Publishthefinalevent.
//發布容器刷新完成事件
publishEvent(newContextRefreshedEvent(this));
//ParticipateinLiveBeansViewMBean,ifactive.
LiveBeansView.registerApplicationContext(this);
}
好啦以上就是本期的全部內容了，我是敖丙，你知道的越多，你不知道的越多，我們下期見。
