Spring启动流程refresh()源码深入解析

2023-07-17 13:03:03 70

一、Spring容器的refresh()

spring version:4.3.12 ，尚硅谷Spring注解驱动开发—源码部分

//refresh():543,AbstractApplicationContext(org.springframework.context.support)
publicvoidrefresh()throwsBeansException,IllegalStateException{
synchronized(this.startupShutdownMonitor){
//1刷新前的预处理
prepareRefresh();
//2获取BeanFactory；刚创建的默认DefaultListableBeanFactory
ConfigurableListableBeanFactorybeanFactory=obtainFreshBeanFactory();
//3BeanFactory的预准备工作（BeanFactory进行一些设置）
prepareBeanFactory(beanFactory);

try{
//4BeanFactory准备工作完成后进行的后置处理工作；
//4.1）、抽象的方法，当前未做处理。子类通过重写这个方法来在BeanFactory创建并预准备完成以后做进一步的设置
postProcessBeanFactory(beanFactory);
/**************************以上是BeanFactory的创建及预准备工作****************/

//5执行BeanFactoryPostProcessor的方法；
//BeanFactoryPostProcessor：BeanFactory的后置处理器。在BeanFactory标准初始化之后执行的；
//他的重要两个接口：BeanFactoryPostProcessor、BeanDefinitionRegistryPostProcessor
invokeBeanFactoryPostProcessors(beanFactory);

//6注册BeanPostProcessor（Bean的后置处理器）
registerBeanPostProcessors(beanFactory);

//7initMessageSource();初始化MessageSource组件（做国际化功能；消息绑定，消息解析）；
initMessageSource();

//8初始化事件派发器
initApplicationEventMulticaster();

//9子类重写这个方法，在容器刷新的时候可以自定义逻辑；
onRefresh();

//10给容器中将所有项目里面的ApplicationListener注册进来

registerListeners();


//11.初始化所有剩下的单实例bean；
finishBeanFactoryInitialization(beanFactory);

//12.完成BeanFactory的初始化创建工作；IOC容器就创建完成；
finishRefresh();
}

catch(BeansExceptionex){
if(logger.isWarnEnabled()){
logger.warn("Exceptionencounteredduringcontextinitialization-"+
"cancellingrefreshattempt:"+ex);
}

//Destroyalreadycreatedsingletonstoavoiddanglingresources.
destroyBeans();

//Reset'active'flag.
cancelRefresh(ex);

//Propagateexceptiontocaller.
throwex;
}

finally{
//ResetcommonintrospectioncachesinSpring'score,sincewe
//mightnoteverneedmetadataforsingletonbeansanymore...
resetCommonCaches();
}
}
}

1、prepareRefresh()刷新前的预处理;

//刷新前的预处理;
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

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

3、BeanFactory的预准备工作

protectedvoidprepareBeanFactory(ConfigurableListableBeanFactorybeanFactory){
//1）、设置BeanFactory的类加载器
beanFactory.setBeanClassLoader(getClassLoader());
//1）、设置支持表达式解析器
beanFactory.setBeanExpressionResolver(newStandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
beanFactory.addPropertyEditorRegistrar(newResourceEditorRegistrar(this,getEnvironment()));

//2）、添加部分BeanPostProcessor【ApplicationContextAwareProcessor】
beanFactory.addBeanPostProcessor(newApplicationContextAwareProcessor(this));
//3）、设置忽略的自动装配的接口EnvironmentAware、EmbeddedValueResolverAware、xxx；
//这些接口的实现类不能通过类型来自动注入
beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);

//4）、注册可以解析的自动装配；我们能直接在任何组件中自动注入：
//BeanFactory、ResourceLoader、ApplicationEventPublisher、ApplicationContext
/*其他组件中可以通过下面方式直接注册使用
@autowired
BeanFactorybeanFactory*/
beanFactory.registerResolvableDependency(BeanFactory.class,beanFactory);
beanFactory.registerResolvableDependency(ResourceLoader.class,this);
beanFactory.registerResolvableDependency(ApplicationEventPublisher.class,this);
beanFactory.registerResolvableDependency(ApplicationContext.class,this);

//5）、添加BeanPostProcessor【ApplicationListenerDetector】后置处理器，在bean初始化前后的一些工作
beanFactory.addBeanPostProcessor(newApplicationListenerDetector(this));

//6）、添加编译时的AspectJ；
if(beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)){
beanFactory.addBeanPostProcessor(newLoadTimeWeaverAwareProcessor(beanFactory));
//SetatemporaryClassLoaderfortypematching.
beanFactory.setTempClassLoader(newContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}

//7）、给BeanFactory中注册一些能用的组件；
if(!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)){
//环境信息ConfigurableEnvironment
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());
}
}

5执行BeanFactoryPostProcessor的后置处理器方法（BeanFactory）；

protectedvoidinvokeBeanFactoryPostProcessors(ConfigurableListableBeanFactorybeanFactory){
//执行BeanFactoryPostProcessor的方法
PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory,getBeanFactoryPostProcessors());

//DetectaLoadTimeWeaverandprepareforweaving,iffoundinthemeantime
//(e.g.throughan@BeanmethodregisteredbyConfigurationClassPostProcessor)
if(beanFactory.getTempClassLoader()==null&&beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)){
beanFactory.addBeanPostProcessor(newLoadTimeWeaverAwareProcessor(beanFactory));
beanFactory.setTempClassLoader(newContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}
}

5.1 执行invokeBeanFactoryPostProcessors

publicstaticvoidinvokeBeanFactoryPostProcessors(
ConfigurableListableBeanFactorybeanFactory,ListbeanFactoryPostProcessors){

//InvokeBeanDefinitionRegistryPostProcessorsfirst,ifany.
SetprocessedBeans=newHashSet();
//判断beanFatory类型
if(beanFactoryinstanceofBeanDefinitionRegistry){
BeanDefinitionRegistryregistry=(BeanDefinitionRegistry)beanFactory;
ListregularPostProcessors=newLinkedList();
ListregistryProcessors=newLinkedList();
//得到所有的BeanFactoryPostProcessor遍历
for(BeanFactoryPostProcessorpostProcessor:beanFactoryPostProcessors){
if(postProcessorinstanceofBeanDefinitionRegistryPostProcessor){
BeanDefinitionRegistryPostProcessorregistryProcessor=
(BeanDefinitionRegistryPostProcessor)postProcessor;
registryProcessor.postProcessBeanDefinitionRegistry(registry);
registryProcessors.add(registryProcessor);
}
else{
regularPostProcessors.add(postProcessor);
}
}

//DonotinitializeFactoryBeanshere:Weneedtoleaveallregularbeans
//uninitializedtoletthebeanfactorypost-processorsapplytothem!
//SeparatebetweenBeanDefinitionRegistryPostProcessorsthatimplement
//PriorityOrdered,Ordered,andtherest.
ListcurrentRegistryProcessors=newArrayList();


//从容器中获取所有的BeanDefinitionRegistryPostProcessor，
String[]postProcessorNames=
beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class,true,false);
//第一步，先执行实现了PriorityOrdered接口的BeanDefinitionRegistryPostProcessor
for(StringppName:postProcessorNames){
if(beanFactory.isTypeMatch(ppName,PriorityOrdered.class)){
currentRegistryProcessors.add(beanFactory.getBean(ppName,BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
}
}
//排序
sortPostProcessors(currentRegistryProcessors,beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
//执行BeanDefinitionRegistryPostProcessor的postProcessor.postProcessBeanDefinitionRegistry(registry)
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors,registry);
currentRegistryProcessors.clear();

//在执行实现了Ordered顺序接口的BeanDefinitionRegistryPostProcessor；
postProcessorNames=beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class,true,false);
for(StringppName:postProcessorNames){
if(!processedBeans.contains(ppName)&&beanFactory.isTypeMatch(ppName,Ordered.class)){
currentRegistryProcessors.add(beanFactory.getBean(ppName,BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
}
}
//排序
sortPostProcessors(currentRegistryProcessors,beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
//执行postProcessor.postProcessBeanDefinitionRegistry(registry)
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors,registry);
currentRegistryProcessors.clear();

//最后执行没有实现任何优先级或者是顺序接口的BeanDefinitionRegistryPostProcessors；
booleanreiterate=true;
while(reiterate){
reiterate=false;
postProcessorNames=beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class,true,false);
for(StringppName:postProcessorNames){
if(!processedBeans.contains(ppName)){
currentRegistryProcessors.add(beanFactory.getBean(ppName,BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
reiterate=true;
}
}
sortPostProcessors(currentRegistryProcessors,beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors,registry);
currentRegistryProcessors.clear();
}

//现在执行BeanFactoryPostProcessor的postProcessBeanFactory()方法
invokeBeanFactoryPostProcessors(registryProcessors,beanFactory);
invokeBeanFactoryPostProcessors(regularPostProcessors,beanFactory);
}

else{
//Invokefactoryprocessorsregisteredwiththecontextinstance.
invokeBeanFactoryPostProcessors(beanFactoryPostProcessors,beanFactory);
}

//再执行BeanFactoryPostProcessor的方法
//1）、获取所有的BeanFactoryPostProcessor和执行BeanDefinitionRegistryPostProcessors的接口逻辑一样
String[]postProcessorNames=
beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class,true,false);


ListpriorityOrderedPostProcessors=newArrayList();
ListorderedPostProcessorNames=newArrayList();
ListnonOrderedPostProcessorNames=newArrayList();
//把BeanFactoryPostProcessor分类
for(StringppName:postProcessorNames){
if(processedBeans.contains(ppName)){
//skip-alreadyprocessedinfirstphaseabove
}
elseif(beanFactory.isTypeMatch(ppName,PriorityOrdered.class)){
priorityOrderedPostProcessors.add(beanFactory.getBean(ppName,BeanFactoryPostProcessor.class));
}
elseif(beanFactory.isTypeMatch(ppName,Ordered.class)){
orderedPostProcessorNames.add(ppName);
}
else{
nonOrderedPostProcessorNames.add(ppName);
}
}

//2）、看先执行实现了PriorityOrdered优先级接口的BeanFactoryPostProcessor、
sortPostProcessors(priorityOrderedPostProcessors,beanFactory);
invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors,beanFactory);

//3）、在执行实现了Ordered顺序接口的BeanFactoryPostProcessor；
ListorderedPostProcessors=newArrayList();
for(StringpostProcessorName:orderedPostProcessorNames){
orderedPostProcessors.add(beanFactory.getBean(postProcessorName,BeanFactoryPostProcessor.class));
}
sortPostProcessors(orderedPostProcessors,beanFactory);
invokeBeanFactoryPostProcessors(orderedPostProcessors,beanFactory);

//4）、最后执行没有实现任何优先级或者是顺序接口的BeanFactoryPostProcessor；
ListnonOrderedPostProcessors=newArrayList();
for(StringpostProcessorName:nonOrderedPostProcessorNames){
nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName,BeanFactoryPostProcessor.class));
}
invokeBeanFactoryPostProcessors(nonOrderedPostProcessors,beanFactory);
beanFactory.clearMetadataCache();
}

6、注册BeanPostProcessor（Bean的后置处理器）

bean的创建拦截器

不同接口类型的BeanPostProcessor；在Bean创建前后的执行时机是不一样的

BeanPostProcessor、
DestructionAwareBeanPostProcessor、
InstantiationAwareBeanPostProcessor、在createBean()方法中处理的，bean创建之前调用的
SmartInstantiationAwareBeanPostProcessor、
MergedBeanDefinitionPostProcessor【internalPostProcessors】（bean创建完成后调用，11章节中）

registerBeanPostProcessors(beanFactory);


publicstaticvoidregisterBeanPostProcessors(
ConfigurableListableBeanFactorybeanFactory,AbstractApplicationContextapplicationContext){
//1）、获取所有的BeanPostProcessor;后置处理器都默认可以通过PriorityOrdered、Ordered接口来执行优先级
String[]postProcessorNames=beanFactory.getBeanNamesForType(BeanPostProcessor.class,true,false);

//检查器，检查所有的BeanPostProcessor
intbeanProcessorTargetCount=beanFactory.getBeanPostProcessorCount()+1+postProcessorNames.length;
beanFactory.addBeanPostProcessor(newBeanPostProcessorChecker(beanFactory,beanProcessorTargetCount));

//SeparatebetweenBeanPostProcessorsthatimplementPriorityOrdered,
//Ordered,andtherest.
ListpriorityOrderedPostProcessors=newArrayList();
ListinternalPostProcessors=newArrayList();
ListorderedPostProcessorNames=newArrayList();
ListnonOrderedPostProcessorNames=newArrayList();
for(StringppName:postProcessorNames){
if(beanFactory.isTypeMatch(ppName,PriorityOrdered.class)){
BeanPostProcessorpp=beanFactory.getBean(ppName,BeanPostProcessor.class);
priorityOrderedPostProcessors.add(pp);
if(ppinstanceofMergedBeanDefinitionPostProcessor){
internalPostProcessors.add(pp);
}
}
elseif(beanFactory.isTypeMatch(ppName,Ordered.class)){
orderedPostProcessorNames.add(ppName);
}
else{
nonOrderedPostProcessorNames.add(ppName);
}
}

/*2）、先注册PriorityOrdered优先级接口的BeanPostProcessor；
把每一个BeanPostProcessor；添加到BeanFactory中
beanFactory.addBeanPostProcessor(postProcessor);*/
sortPostProcessors(priorityOrderedPostProcessors,beanFactory);
registerBeanPostProcessors(beanFactory,priorityOrderedPostProcessors);

//3）、再注册Ordered接口的
ListorderedPostProcessors=newArrayList();
for(StringppName:orderedPostProcessorNames){
BeanPostProcessorpp=beanFactory.getBean(ppName,BeanPostProcessor.class);
orderedPostProcessors.add(pp);
if(ppinstanceofMergedBeanDefinitionPostProcessor){
internalPostProcessors.add(pp);
}
}
sortPostProcessors(orderedPostProcessors,beanFactory);
registerBeanPostProcessors(beanFactory,orderedPostProcessors);

//4）、最后注册没有实现任何优先级接口的
ListnonOrderedPostProcessors=newArrayList();
for(StringppName:nonOrderedPostProcessorNames){
BeanPostProcessorpp=beanFactory.getBean(ppName,BeanPostProcessor.class);
nonOrderedPostProcessors.add(pp);
if(ppinstanceofMergedBeanDefinitionPostProcessor){
internalPostProcessors.add(pp);
}
}
registerBeanPostProcessors(beanFactory,nonOrderedPostProcessors);

//5）、最终注册MergedBeanDefinitionPostProcessor；
sortPostProcessors(internalPostProcessors,beanFactory);
registerBeanPostProcessors(beanFactory,internalPostProcessors);

//6）、注册一个ApplicationListenerDetector；判断创建完成的bean是否监听器
/*在Bean创建完成后ApplicationListenerDetector.postProcessAfterInitialization()中检查是否是ApplicationListener类型，如果是applicationContext.addApplicationListener((ApplicationListener)bean);如果是添加到容器中*/
beanFactory.addBeanPostProcessor(newApplicationListenerDetector(applicationContext));
}

7、initMessageSource();国际化

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


protectedvoidinitMessageSource(){
//1）、获取BeanFactory
ConfigurableListableBeanFactorybeanFactory=getBeanFactory();
/*
2）、看容器中是否有id为messageSource的，类型是MessageSource的组件
如果有赋值给messageSource，如果没有自己创建一个DelegatingMessageSource；
MessageSource作用：取出国际化配置文件中的某个key的值；能按照区域信息获取；
*/
if(beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)){
this.messageSource=beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME,MessageSource.class);
//MakeMessageSourceawareofparentMessageSource.
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+"]");
}
}
else{
//如果没有自己创建一个DelegatingMessageSource；
DelegatingMessageSourcedms=newDelegatingMessageSource();
dms.setParentMessageSource(getInternalParentMessageSource());
this.messageSource=dms;
//把创建好的messageSource注册到容器中，以后获取国际化配置文件的值的时候，可以自动注入MessageSource；
//注入后通过这个方法使用MessageSource.getMessage(Stringcode,Object[]args,StringdefaultMessage,Localelocale);
beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME,this.messageSource);
if(logger.isDebugEnabled()){
logger.debug("UnabletolocateMessageSourcewithname'"+MESSAGE_SOURCE_BEAN_NAME+
"':usingdefault["+this.messageSource+"]");
}
}
}

8、初始化事件派发器initApplicationEventMulticaster()


protectedvoidinitApplicationEventMulticaster(){
//1）、获取BeanFactory
ConfigurableListableBeanFactorybeanFactory=getBeanFactory();
//判断容器中是否有applicationEventMulticaster的这个bean,如果有获取，没有创建
if(beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)){
//2）、从BeanFactory中获取applicationEventMulticaster的ApplicationEventMulticaster；
this.applicationEventMulticaster=
beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME,ApplicationEventMulticaster.class);
if(logger.isDebugEnabled()){
logger.debug("UsingApplicationEventMulticaster["+this.applicationEventMulticaster+"]");
}
}
else{
//3)个SimpleApplicationEventMulticaster类型的applicationEventMulticaster
this.applicationEventMulticaster=newSimpleApplicationEventMulticaster(beanFactory);
//4）、将创建的ApplicationEventMulticaster添加到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();留给子容器（子类）

1、子类重写AbstractApplicationContext.onRefresh()这个方法，在容器刷新的时候可以自定义逻辑；

10、registerListeners();检查和注册Listener

将所有项目里面的ApplicationListener注册到容器中；


protectedvoidregisterListeners(){
//1、从容器中拿到所有的ApplicationListener
for(ApplicationListenerlistener:getApplicationListeners()){
//2、将每个监听器添加到事件派发器中；
getApplicationEventMulticaster().addApplicationListener(listener);
}


//1.获取所有的ApplicationListener
String[]listenerBeanNames=getBeanNamesForType(ApplicationListener.class,true,false);
for(StringlistenerBeanName:listenerBeanNames){
//2、将每个监听器添加到事件派发器中；
getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
}

//earlyApplicationEvents中保存之前的事件，
SetearlyEventsToProcess=this.earlyApplicationEvents;
this.earlyApplicationEvents=null;
if(earlyEventsToProcess!=null){
for(ApplicationEventearlyEvent:earlyEventsToProcess){
//3、派发之前步骤产生的事件；
getApplicationEventMulticaster().multicastEvent(earlyEvent);
}
}
}

11、初始化所有剩下的单实例bean；finishBeanFactoryInitialization(beanFactory);

protectedvoidfinishBeanFactoryInitialization(ConfigurableListableBeanFactorybeanFactory){
//类型装换器
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));
}

//值解析器
if(!beanFactory.hasEmbeddedValueResolver()){
beanFactory.addEmbeddedValueResolver(newStringValueResolver(){
@Override
publicStringresolveStringValue(StringstrVal){
returngetEnvironment().resolvePlaceholders(strVal);
}
});
}

//InitializeLoadTimeWeaverAwarebeansearlytoallowforregisteringtheirtransformersearly.
String[]weaverAwareNames=beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class,false,false);
for(StringweaverAwareName:weaverAwareNames){
getBean(weaverAwareName);
}

//StopusingthetemporaryClassLoaderfortypematching.
beanFactory.setTempClassLoader(null);

//Allowforcachingallbeandefinitionmetadata,notexpectingfurtherchanges.
beanFactory.freezeConfiguration();

//初始化剩下的单实例bean
beanFactory.preInstantiateSingletons();
}

11.1beanFactory.preInstantiateSingletons()初始化剩下的单实例bean

//preInstantiateSingletons():781,DefaultListableBeanFactory
publicvoidpreInstantiateSingletons()throwsBeansException{
if(this.logger.isDebugEnabled()){
this.logger.debug("Pre-instantiatingsingletonsin"+this);
}
//1）、获取容器中的所有Bean，依次进行初始化和创建对象
ListbeanNames=newArrayList(this.beanDefinitionNames);
for(StringbeanName:beanNames){
//2）、获取Bean的定义信息；RootBeanDefinition
RootBeanDefinitionbd=getMergedLocalBeanDefinition(beanName);
//3）、Bean不是抽象的，是单实例的，不是懒加载；
if(!bd.isAbstract()&&bd.isSingleton()&&!bd.isLazyInit()){
//3.1）、判断是否是FactoryBean；是否是实现FactoryBean接口的Bean；
if(isFactoryBean(beanName)){
finalFactoryBeanfactory=(FactoryBean)getBean(FACTORY_BEAN_PREFIX+beanName);
booleanisEagerInit;
if(System.getSecurityManager()!=null&&factoryinstanceofSmartFactoryBean){
isEagerInit=AccessController.doPrivileged(newPrivilegedAction(){
@Override
publicBooleanrun(){
return((SmartFactoryBean)factory).isEagerInit();
}
},getAccessControlContext());
}
else{
isEagerInit=(factoryinstanceofSmartFactoryBean&&
((SmartFactoryBean)factory).isEagerInit());
}
if(isEagerInit){
getBean(beanName);
}
}
else{//3.2）、不是工厂Bean。利用getBean(beanName);创建对象
getBean(beanName);//详情请见（11.1.3.2创建bean->doGetBean）章节
}
}
}

//循环所有的bean
for(StringbeanName:beanNames){
ObjectsingletonInstance=getSingleton(beanName);
//判断bean是否实现了SmartInitializingSingleton接口如果是；就执行afterSingletonsInstantiated()；
if(singletonInstanceinstanceofSmartInitializingSingleton){
finalSmartInitializingSingletonsmartSingleton=(SmartInitializingSingleton)singletonInstance;
if(System.getSecurityManager()!=null){
AccessController.doPrivileged(newPrivilegedAction

Spring启动流程refresh()源码深入解析

热门推荐

随机推荐