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);
}
好啦以上就是本期的全部内容了，我是敖丙，你知道的越多，你不知道的越多，我们下期见。