Spring教程之refresh()执行逻辑浅析

2023-07-17 12:56:03 308

前言

对于AbstractApplicationContex#refresh()方法逻辑，可所谓是贯通spring框架核心逻辑，溪源在debug过程中，理解起来也是懵懵懂懂，自己也买了《Spring源码深度解析》书籍学习其思想和实现逻辑，经过不断的整理学习总结，最终诞生这篇文章，方便后面自己忘记了查看和理解。

下面开始正式踏入refresh方法的整体概览浅析。

概览

refresh

该方法是SpringBean加载的核心，它是ClassPathXmlApplicationContext的父类AbstractApplicationContext的一个方法，顾名思义，用于刷新整个Spring上下文信息，定义了整个Spring上下文加载的流程。
先看下refresh()方法总体：

@Override
publicvoidrefresh()throwsBeansException,IllegalStateException{
synchronized(this.startupShutdownMonitor){
//准备预处理：记录容器的启动时间startupDate,标记容器为激活，初始化上下文环境如文件路径信息，验证必填属性是否填写
this.prepareRefresh();
//**告诉子类去刷新bean工厂，此方法解析配置文件并将bean信息存储到beanDefinition中，注册到BeanFactory（但是未被初始化，仅将信息写到了beanDefination的map中）**重点方法，下面的操作都基于这个beanFactory进行的
ConfigurableListableBeanFactorybeanFactory=this.obtainFreshBeanFactory();
//设置beanFactory的基本属性：类加载器，添加多个beanPostProcesser
this.prepareBeanFactory(beanFactory);
try{
//空实现：允许子类上下文中对beanFactory做后期处理
this.postProcessBeanFactory(beanFactory);
/**************************以上是BeanFactory的创建及预准备工作****************/
//调用BeanFactoryPostProcessor各个实现类的方法
this.invokeBeanFactoryPostProcessors(beanFactory);
//注册BeanPostProcessor的实现类，注意看和BeanFactoryPostProcessor的区别
//此接口两个方法:postProcessBeforeInitialization和postProcessAfterInitialization
//两个方法分别在Bean初始化之前和初始化之后得到执行。注意，到这里Bean还没初始化
this.registerBeanPostProcessors(beanFactory);
//初始化ApplicationContext的MessageSource组件(资源文件)，如国际化文件，消息解析，绑定等
this.initMessageSource();
//初始化ApplicationContext事件广播器
this.initApplicationEventMulticaster();
//初始化子类特殊bean（钩子方法）
this.onRefresh();
//获取所有的事件监听器，并将监听器注册到事件广播器
this.registerListeners();
//**初始化所有singletonbean；**重点方法
this.finishBeanFactoryInitialization(beanFactory);
//广播事件：ApplicationContext初始化完成
this.finishRefresh();
}catch(BeansExceptionex){
	if(logger.isWarnEnabled()){
	logger.warn("Exceptionencounteredduringcontextinitialization-"+"cancellingrefreshattempt:"+ex);
	}
		//销毁bean
		this.destroyBeans();
		//重置'active'标志.
		this.cancelRefresh(ex);
		throwex;
			}
		}

明细

本篇文章，不会仔细往下探讨源码实现逻辑，先总结refresh()方法具体逻辑：

1.prepareRefresh

准备预处理：记录spring容器的启动时间startupDate,标记容器为激活，初始化上下文环境如文件路径信息，验证必填属性是否填写。

initPropertySources():初始化一些属性设置;子类自定义个性化的属性设置方法；
getEnvironment().validateRequiredProperties():检验属性的合法等;
earlyApplicationEvents=newLinkedHashSet():保存容器中的一些早期的事件;

//刷新前的预处理;
protectedvoidprepareRefresh(){
this.startupDate=System.currentTimeMillis();
this.closed.set(false);
this.active.set(true);

if(logger.isInfoEnabled()){
logger.info("Refreshing"+this);
}
//初始化一些属性设置;子类自定义个性化的属性设置方法；
initPropertySources();
//校验配置文件的属性，合法性
getEnvironment().validateRequiredProperties();
//保存容器中的一些事件
this.earlyApplicationEvents=newLinkedHashSet();
}

2.obtainFreshBeanFactory

获取BeanFactory,解析配置文件，生成beanDefinition;

protectedConfigurableListableBeanFactoryobtainFreshBeanFactory(){
refreshBeanFactory();//创建了一个this.beanFactory=newDefaultListableBeanFactory();设置了序列化的ID
//返回刚才创建的DefaultListableBeanFactory
ConfigurableListableBeanFactorybeanFactory=getBeanFactory();
if(logger.isDebugEnabled()){
logger.debug("Beanfactoryfor"+getDisplayName()+":"+beanFactory);
}
returnbeanFactory;
}

3.prepareBeanFactory

该方法主要负责对BeanFactory的预准备工作，配置beanFactory的基础属性，比如ClassLoader和一些PostProcessor等。
这个方法主要是给BeanFactory设置一些基本的属性，比如类加载器、表达式解析器、属性编辑器，注册几个单例、添加一些不用注入的接口、添加解析依赖项等。

设置BeanFactory的类加载器、支持表达式解析器…
添加部分BeanPostProcessor【ApplicationContextAwareProcessor】
设置忽略的自动装配的接口EnvironmentAware、EmbeddedValueResolverAware、xxx；
注册可以解析的自动装配；我们能直接在任何组件中自动注入：
BeanFactory、ResourceLoader、ApplicationEventPublisher、ApplicationContext
添加BeanPostProcessor【ApplicationListenerDetector】
添加编译时的AspectJ；
给BeanFactory中注册一些能用的组件；
environment【ConfigurableEnvironment】、
systemProperties【Map】、
systemEnvironment【Map】

protectedvoidprepareBeanFactory(ConfigurableListableBeanFactorybeanFactory){
	//Telltheinternalbeanfactorytousethecontext'sclassloaderetc.
//设置类加载器
	beanFactory.setBeanClassLoader(getClassLoader());
//设置bean表达式解析器，详解见下文
	beanFactory.setBeanExpressionResolver(newStandardBeanExpressionResolver());
	//资源编辑注册器
	beanFactory.addPropertyEditorRegistrar(newResourceEditorRegistrar(this,getEnvironment()));

	//添加一个BeanPostProcessor：ApplicationContextAwareProcessor，用于向实现类ApplitionContextAware中，调用setApplicationContext方法，并将ApplicationContext作为参数。
	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);


	//注册几个解析依赖项，意思是，当一个Bean需要注入对应的类时，使用下面注册的这些类
//比如，如果@Autowire一个BeanFactory，那么这个BeanFactory实际就是在此处注册的一个对象
//这几项分别是：BeanFactory、ResourceLoader、ApplicationEventPublisher、ApplicationContext
	beanFactory.registerResolvableDependency(BeanFactory.class,beanFactory);
	beanFactory.registerResolvableDependency(ResourceLoader.class,this);
	beanFactory.registerResolvableDependency(ApplicationEventPublisher.class,this);
	beanFactory.registerResolvableDependency(ApplicationContext.class,this);

	//DetectaLoadTimeWeaverandprepareforweaving,iffound.
	//检查是否由LoadTimeWeaver，如果有loadTimeWeaver的bean，就放入一个BeanPostProcessor：LoadTimeWeaverAwareProcessor
	if(beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)){
		beanFactory.addBeanPostProcessor(newLoadTimeWeaverAwareProcessor(beanFactory));
		//SetatemporaryClassLoaderfortypematching.
		beanFactory.setTempClassLoader(newContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
	}
	
	//注册environment，注册成单例
	if(!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)){
		beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME,getEnvironment());
	}
	//注册systemProperties成单例
	if(!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)){
		beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME,getEnvironment().getSystemProperties());
	}
//注册systemEnvironment成单例
	if(!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)){
		beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME,getEnvironment().getSystemEnvironment());
	}
}

4.postProcessBeanFactory

主要负责在BeanFactory准备工作完成之后，beanFactory的后置处理工作；

protectedvoidpostProcessBeanFactory(ConfigurableListableBeanFactorybeanFactory){
}

5.invokeBeanFactoryPostProcessors

protectedvoidinvokeBeanFactoryPostProcessors(ConfigurableListableBeanFactorybeanFactory){
//InvokeBeanDefinitionRegistryPostProcessorsfirst,ifany.

//用于存放已处理过的Bean
SetprocessedBeans=newHashSet();

//如果IOC容器是一个BeanDefinitionRegistry，有了注册BeanDefinition的能力，就可以执行BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry方法
if(beanFactoryinstanceofBeanDefinitionRegistry){

BeanDefinitionRegistryregistry=(BeanDefinitionRegistry)beanFactory;

//regularPostProcessors用于存放普通的BeanFactoryPostProcessor
List
regularPostProcessors=newLinkedList();

//registryPostProcessors用于存放BeanDefinitionRegistryPostProcessor
List
registryPostProcessors=newLinkedList();

//查询通过addBeanFactoryPostProcessor等方法设置进来的的BeanFactoryPostProcessor（不是注册到IOC容器的中）
for(BeanFactoryPostProcessorpostProcessor:getBeanFactoryPostProcessors()){

//如果是BeanDefinitionRegistryPostProcessor，
//就先执行它的postProcessBeanDefinitionRegistry，用于向IOC中注册一些BeanDefinition，
//然后添加到registryPostProcessors队列中
if(postProcessorinstanceofBeanDefinitionRegistryPostProcessor){
BeanDefinitionRegistryPostProcessorregistryPostProcessor=
(BeanDefinitionRegistryPostProcessor)postProcessor;
				
	registryPostProcessor.postProcessBeanDefinitionRegistry(registry);
registryPostProcessors.add(registryPostProcessor);
}
else{
//如果是普通的BeanFactoryPostProcessor，就添加到regularPostProcessors队列中
regularPostProcessors.add(postProcessor);
}
}

//获取IOC容器中注册的BeanDefinitionRegistryPostProcessor，
//放入到registryPostProcessorBeans中，
//并按照Order排序
MapbeanMap=
beanFactory.getBeansOfType(BeanDefinitionRegistryPostProcessor.class,true,false);

ListregistryPostProcessorBeans=
newArrayList(beanMap.values());

OrderComparator.sort(registryPostProcessorBeans);

//先调用registryPostProcessorBeans中的所有postProcessBeanDefinitionRegistry方法
for(BeanDefinitionRegistryPostProcessorpostProcessor:registryPostProcessorBeans){
postProcessor.postProcessBeanDefinitionRegistry(registry);
}
//先调用registryPostProcessors中的postProcessBeanFactory方法
//再调用registryPostProcessorBeans中的postProcessBeanFactory方法
//最后调用regularPostProcessors中的postProcessBeanFactory方法
invokeBeanFactoryPostProcessors(registryPostProcessors,beanFactory);
invokeBeanFactoryPostProcessors(registryPostProcessorBeans,beanFactory);
invokeBeanFactoryPostProcessors(regularPostProcessors,beanFactory);

//对于IOC容器中注册的BeanDefinitionRegistryPostProcessor来说，还要放置到processedBeans中，放置重复调用
processedBeans.addAll(beanMap.keySet());
}
else{
//如果IOC就是一个普通的BeanFacotry，就直接从context中取出所有的BeanFactoryPostProcessor，并调用他们的postProcessBeanFactory方法
//Invokefactoryprocessorsregisteredwiththecontextinstance.
invokeBeanFactoryPostProcessors(getBeanFactoryPostProcessors(),beanFactory);
}
	
//DonotinitializeFactoryBeanshere:Weneedtoleaveallregularbeans
//查询IOC容器中所有的BeanFactoryPostProcessor，有可能上面的BeanDefinitionRegistryPostProcessor刚刚向IOC容器中注册了一些BeanFactoryPostProcessor，所以要在此处全部查出来。
String[]postProcessorNames=
beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class,true,false);

//按照这些BeanFactoryPostProcessor实现的排序接口（PriorityOrdered和Ordered）分成3组
//第一组实现了PriorityOrdered---priorityOrderedPostProcessors
//第二组实现了Ordered---orderedPostProcessorNames
//第三组没有实现排序接口---nonOrderedPostProcessorNames
ListpriorityOrderedPostProcessors=newArrayList();
ListorderedPostProcessorNames=newArrayList();
ListnonOrderedPostProcessorNames=newArrayList();

for(StringppName:postProcessorNames){
//如果已经处理了，就跳过
if(processedBeans.contains(ppName)){
//skip-alreadyprocessedinfirstphaseabove
}
//实现PriorityOrdered接口的
elseif(isTypeMatch(ppName,PriorityOrdered.class)){

priorityOrderedPostProcessors.add(beanFactory.getBean(ppName,BeanFactoryPostProcessor.class));
}
//实现Ordered接口的
elseif(isTypeMatch(ppName,Ordered.class)){
orderedPostProcessorNames.add(ppName);
}
//普通的
else{
nonOrderedPostProcessorNames.add(ppName);
}
}
//然后先执行priorityOrderedPostProcessors中的，再执行orderedPostProcessorNames的，最后执行nonOrderedPostProcessorNames
	
//排序并执行priorityOrderedPostProcessors的
OrderComparator.sort(priorityOrderedPostProcessors);
invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors,beanFactory);

//排序并执行orderedPostProcessors的
ListorderedPostProcessors=newArrayList();
for(StringpostProcessorName:orderedPostProcessorNames){
orderedPostProcessors.add(getBean(postProcessorName,BeanFactoryPostProcessor.class));
}
OrderComparator.sort(orderedPostProcessors);
invokeBeanFactoryPostProcessors(orderedPostProcessors,beanFactory);

//最后执行普通的BeanFactoryPostProcessor的
ListnonOrderedPostProcessors=newArrayList();
for(StringpostProcessorName:nonOrderedPostProcessorNames){
nonOrderedPostProcessors.add(getBean(postProcessorName,BeanFactoryPostProcessor.class));
}
invokeBeanFactoryPostProcessors(nonOrderedPostProcessors,beanFactory);
}

6.registerBeanPostProcessors

protectedvoidregisterBeanPostProcessors(ConfigurableListableBeanFactorybeanFactory){
//获取IOC中注册的BeanPostProcessor
String[]postProcessorNames=beanFactory.getBeanNamesForType(BeanPostProcessor.class,true,false);

//BeanPostProcessorChecker也是一个BeanPostProcessor，用于检查一个Bean应该经过的BeanPostProcessor和

intbeanProcessorTargetCount=beanFactory.getBeanPostProcessorCount()+1+postProcessorNames.length;
beanFactory.addBeanPostProcessor(newBeanPostProcessorChecker(beanFactory,beanProcessorTargetCount));

//按照排序接口分类。
//这里需要注意的是，priorityOrderedPostProcessors里面装的是BeanPostProcessor
//而orderedPostProcessorNames和nonOrderedPostProcessorNames里面装的是BeanPostProcessor的name
//原因是：实例化BeanPostProcessor实现类的时候，也需要调用IOC中已有的BeanPostProcessor，所以Spring这里没有提前实例化Orderd接口和普通的BeanPostProcessor。
//因此，这里有一个有趣的现象，示例化Orderd接口的BeanProcessor的时候，会使用PriorityOrdered的BeanPostProcessor进行处理
//实例化普通的BeanProcessor时，会先后经过PriorityOrdered和Orderd接口的BeanPostProcessor的处理

ListpriorityOrderedPostProcessors=newArrayList();
ListinternalPostProcessors=newArrayList();

ListorderedPostProcessorNames=newArrayList();
ListnonOrderedPostProcessorNames=newArrayList();

//分类
for(StringppName:postProcessorNames){
//PriorityOrdered接口的，先行实例化，并把MergedBeanDefinitionPostProcessor放入到internalPostProcessors中
if(isTypeMatch(ppName,PriorityOrdered.class)){
BeanPostProcessorpp=beanFactory.getBean(ppName,BeanPostProcessor.class);
priorityOrderedPostProcessors.add(pp);
//
if(ppinstanceofMergedBeanDefinitionPostProcessor){
internalPostProcessors.add(pp);
}
}
//Ordered接口的，这里只是把name记录下来。
elseif(isTypeMatch(ppName,Ordered.class)){
//
orderedPostProcessorNames.add(ppName);
}
//普通的，这里只是把name记录下来。
else{
nonOrderedPostProcessorNames.add(ppName);
}
}

//排序并注册PriorityOrdered接口的BeanPostProcessor
OrderComparator.sort(priorityOrderedPostProcessors);
registerBeanPostProcessors(beanFactory,priorityOrderedPostProcessors);

//排序并注册Ordered接口的BeanPostProcessor
ListorderedPostProcessors=newArrayList();
for(StringppName:orderedPostProcessorNames){
//这里才进行实例化，所以会使用实现了PriorityOrdered接口的BeanPostProcessor进行处理
BeanPostProcessorpp=beanFactory.getBean(ppName,BeanPostProcessor.class);
orderedPostProcessors.add(pp);
//把MergedBeanDefinitionPostProcessor放入到internalPostProcessors中
if(ppinstanceofMergedBeanDefinitionPostProcessor){
internalPostProcessors.add(pp);
}
}
OrderComparator.sort(orderedPostProcessors);
registerBeanPostProcessors(beanFactory,orderedPostProcessors);

//注册普通的BeanPostProcessor
ListnonOrderedPostProcessors=newArrayList();
for(StringppName:nonOrderedPostProcessorNames){
//这里才进行实例化，所以会使用实现了PriorityOrdered接口或Orderd的BeanPostProcessor进行处理
BeanPostProcessorpp=beanFactory.getBean(ppName,BeanPostProcessor.class);
nonOrderedPostProcessors.add(pp);
//把MergedBeanDefinitionPostProcessor放入到internalPostProcessors中
//同时注意到，即使在internalPostProcessors中
//BeanPostProcessor的顺序也是按照PriorityOrderd>Orderd>普通的顺序进入的。
if(ppinstanceofMergedBeanDefinitionPostProcessor){
internalPostProcessors.add(pp);
}
}
registerBeanPostProcessors(beanFactory,nonOrderedPostProcessors);

//注册所有的MergedBeanDefinitionPostProcessor
OrderComparator.sort(internalPostProcessors);
registerBeanPostProcessors(beanFactory,internalPostProcessors);
	
//最后，在末尾添加一个ApplicationListenerDetector
beanFactory.addBeanPostProcessor(newApplicationListenerDetector());
}

7.initMessageSource

初始化MessageSource组件（做国际化功能；消息绑定，消息解析）；

获取BeanFactory
判断容器中是否有id为messageSource的，类型是MessageSource的组件；
如果有赋值给messageSource，如果没有自己创建一个DelegatingMessageSource；
MessageSource：取出国际化配置文件中的某个key的值；能按照区域信息获取；
将创建完成的MessageSource注册在容器中，以后获取国际化配置文件的值的时候，可以自动注入MessageSource；

protectedvoidinitMessageSource(){
ConfigurableListableBeanFactorybeanFactory=getBeanFactory();
if(beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)){
this.messageSource=beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME,MessageSource.class);
//MakeMessageSourceawareofparentMessageSource.
//如果已经注册了messageSource&&messageSource是HierarchicalMessageSource&&messageSource没有parent&&此IOC有parent
if(this.parent!=null&&this.messageSourceinstanceofHierarchicalMessageSource){
HierarchicalMessageSourcehms=(HierarchicalMessageSource)this.messageSource;
if(hms.getParentMessageSource()==null){
//OnlysetparentcontextasparentMessageSourceifnoparentMessageSource
//registeredalready.
hms.setParentMessageSource(getInternalParentMessageSource());
}
}
if(logger.isDebugEnabled()){
logger.debug("UsingMessageSource["+this.messageSource+"]");
}
}
//如果没有注册messageSource，就创建一个DelegatingMessageSource,并注册到IOC中
else{
//UseemptyMessageSourcetobeabletoacceptgetMessagecalls.
DelegatingMessageSourcedms=newDelegatingMessageSource();
dms.setParentMessageSource(getInternalParentMessageSource());
this.messageSource=dms;
beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME,this.messageSource);
if(logger.isDebugEnabled()){
logger.debug("UnabletolocateMessageSourcewithname'"+MESSAGE_SOURCE_BEAN_NAME+
"':usingdefault["+this.messageSource+"]");
}
}
}

8.initApplicationEventMulticaster

protectedvoidinitApplicationEventMulticaster(){
ConfigurableListableBeanFactorybeanFactory=getBeanFactory();
//如果有开发自定的applicationEventMulticaster实例bean，则设置IOC的事件广播器为该实例
if(beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)){
this.applicationEventMulticaster=
beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME,ApplicationEventMulticaster.class);
if(logger.isDebugEnabled()){
logger.debug("UsingApplicationEventMulticaster["+this.applicationEventMulticaster+"]");
}
}
//如果没有applicationEventMulticaster，就设置一个SimpleApplicationEventMulticaster
else{
this.applicationEventMulticaster=newSimpleApplicationEventMulticaster(beanFactory);
beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME,this.applicationEventMulticaster);
if(logger.isDebugEnabled()){
logger.debug("UnabletolocateApplicationEventMulticasterwithname'"+
APPLICATION_EVENT_MULTICASTER_BEAN_NAME+
"':usingdefault["+this.applicationEventMulticaster+"]");
}
}
}

9.onRefresh

模板设计模式;该方法属于钩子方法；子类重写该方法并在容器刷新的时候自定义逻辑；

protectedvoidonRefresh()throwsBeansException{
		//Forsubclasses:donothingbydefault.
}

10.registerListeners

注册监听器分为两部分:

向事件分发器注册硬编码设置的applicationListener
向事件分发器注册一个IOC中的事件监听器（并不实例化）

protectedvoidregisterListeners(){
//查出所有通过addApplicationListener方法添加的ApplicationListener，然后注册到事件广播器上
for(ApplicationListenerlistener:getApplicationListeners()){
getApplicationEventMulticaster().addApplicationListener(listener);
}

//查出ioc容器中的所有ApplicationListener，只把他们注册到事件分发器的ApplicationListenerBean上，
//待使用时再进行实例化
String[]listenerBeanNames=getBeanNamesForType(ApplicationListener.class,true,false);
for(StringlistenerBeanName:listenerBeanNames){
getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
}
}

11.finishBeanFactoryInitialization

finishBeanFactoryInitialization主要是负责初始化单实例的bean；该方法是重点方法，bean的生命周期基本调用getBean()方法完成。

protectedvoidfinishBeanFactoryInitialization(ConfigurableListableBeanFactorybeanFactory){
//如果IOC中有conversionService的话，就实例化并设置到IOC中
//conversionService用于类型转换
if(beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME)&&
beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME,ConversionService.class)){
beanFactory.setConversionService(
beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME,ConversionService.class));
}
//如果有LoadTimeWeaverAware，就实例化
String[]weaverAwareNames=beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class,false,false);
for(StringweaverAwareName:weaverAwareNames){
getBean(weaverAwareName);
}
//清理临时的classLoader
beanFactory.setTempClassLoader(null);
//缓存所有beanDefinition的name，以备不时之需
beanFactory.freezeConfiguration();
//实例化所有非non-lazy-init的单例
beanFactory.preInstantiateSingletons();
}

12.finishRefresh

完成bean创建和初始化过程，通知生命周期处理器lifecycleProcessor刷新过程，同时发出ContextRefreshEvent通知。

protectedvoidfinishRefresh(){
//实例化或初始化lifecycleProcessor
initLifecycleProcessor();
//调用lifecycleProcessor的刷新方法
getLifecycleProcessor().onRefresh();
//发布一个ContextRefreshedEvent事件
publishEvent(newContextRefreshedEvent(this));
//注册MBean，用于JMX管理
LiveBeansView.registerApplicationContext(this);
}

参考资料：

解读Spring容器的refresh()
Spring源码深度解析
SpringIoC之ApplicationContext中refresh过程

总结

到此这篇关于Spring教程之refresh()执行逻辑的文章就介绍到这了,更多相关Springrefresh()执行逻辑内容请搜索毛票票以前的文章或继续浏览下面的相关文章希望大家以后多多支持毛票票！

声明：本文内容来源于网络，版权归原作者所有，内容由互联网用户自发贡献自行上传，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任。如果您发现有涉嫌版权的内容，欢迎发送邮件至：czq8825#qq.com（发邮件时，请将#更换为@）进行举报，并提供相关证据，一经查实，本站将立刻删除涉嫌侵权内容。

Spring教程之refresh()执行逻辑浅析

热门推荐

随机推荐