服务器之家:专注于服务器技术及软件下载分享
分类导航

PHP教程|ASP.NET教程|Java教程|ASP教程|编程技术|正则表达式|C/C++|IOS|C#|Swift|Android|VB|R语言|JavaScript|易语言|vb.net|

服务器之家 - 编程语言 - Java教程 - 肝疼了3万字的Spring容器启动流程

肝疼了3万字的Spring容器启动流程

2020-11-23 23:28三太子敖丙 Java教程

Spring Framework 是 Java 语言中影响最为深远的框架之一,其中的 IOC 和 AOP 两个经典思想更是一直被程序员津津乐道,后面推出的 Spring Boot、Spring Cloud 系列也是在其基础之上开发,要想搞明白 Spring 全家桶系列

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 类,可以绘制成如下流程图:

肝疼了3万字的Spring容器启动流程

看完流程图,我们应该思考一下:如果让你去设计一个 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万字的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 类。

肝疼了3万字的Spring容器启动流程

此时再看上图,是不是发现和喝水一般简单,首先会回调 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);

}

好啦以上就是本期的全部内容了,我是敖丙,你知道的越多,你不知道的越多,我们下期见。

延伸 · 阅读

精彩推荐