Spring教程之refresh()执行逻辑浅析-eolink官网

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

前言

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

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

概览

refresh

该方法是 Spring Bean 加载的核心，它是 ClassPathXmlApplicationContext 的父类 AbstractApplicationContext 的一个方法，顾名思义，用于刷新整个Spring 上下文信息，定义了整个 Spring 上下文加载的流程。

先看下refresh()方法总体：

@Override

public void refresh() throws BeansException, IllegalStateException {

synchronized (this.startupShutdownMonitor) {

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

this.prepareRefresh();

// **告诉子类去刷新bean工厂，此方法解析配置文件并将bean信息存储到beanDefinition中，注册到BeanFactory（但是未被初始化，仅将信息写到了beanDefination的map中）**重点方法，下面的操作都基于这个beanFactory进行的

ConfigurableListableBeanFactory beanFactory = 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();

//** 初始化所有singleton bean；**重点方法

this.finishBeanFactoryInitialization(beanhttp://Factory);

// 广播事件：ApplicationContext初始化完成

this.finishRefresh();

} catch (BeansException ex) {

if (logger.isWarnEnabled()) {

logger.warn("Exception encountered during context initialization - " + "cancelling refresh attempt: " + ex);

}

// 销毁bean

this.destroyBeans();

// 重置 'active' 标志.

this.cancelRefresh(ex);

throw ex;

}

明细

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

1.prepareRefresh

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

initPropertySources():初始化一些属性设置;子类自定义个性化的属性设置方法；

getEnvironment().validateRequiredProperties():检验属性的合法等;

earlyApplicationEvents= new LinkedHashSet():保存容器中的一些早期的事件;

//刷新前的预处理;

protected void prepareRefresh() {

this.startupDate = System.currentTimeMillis();

this.closed.set(false);

this.active.set(true);

if (logger.isInfoEnabled()) {

logger.info("Refreshing " + this);

}

// 初始化一些属性设置;子类自定义个性化的属性设置方法；

initPropertySources();

// 校验配置文件的属性，合法性

getEnvironment().validateRequiredProperties();

//保存容器中的一些事件

this.earlyApplicationEvents = new LinkedHashSet();

}

2.obtainFreshBeanFactory

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

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {

refreshBeanFactory(); //创建了一个this.beanFactory = new DefaultListableBeanFactory();设置了序列化的ID

//返回刚才创建的DefaultListableBeanFactory

ConfigurableListableBeanFactory beanFactory = getBeanFactory();

if (logger.isDebugEnabled()) {

logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);

}

return beanFactory;

}

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】

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {

// Tell the internal bean factory to use the context's class loader etc.

//设置类加载器

beanFactory.setBeanClassLoader(getClassLoader());

//设置bean表达式解析器，详解见下文

beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver());

//资源编辑注册器

beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

//添加一个BeanPostProcessor：ApplicationContextAwareProcessor，用于向实现类ApplitionContextAware中，调用setApplicationContext方法，并将ApplicationContext作为参数。

beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(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);

// Detect a LoadTimeWeaver and prepare for weaving, if found.

//检查是否由LoadTimeWeaver，如果有loadTimeWeaver的bean，就放入一个BeanPostProcessor：LoadTimeWeaverAwareProcessor

if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {

beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));

// Set a temporary ClassLoader for type matching.

beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLohttp://ader()));

}

// 注册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的后置处理工作；

protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {

}

5. invokeBeanFactoryPostProcessors

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {

// Invoke BeanDefinitionRegistryPostProcessors first, if any.

//用于存放已处理过的Bean

Set processedBeans = new HashSet();

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

if (beanFactory instanceof BeanDefinitionRegistry) {

BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;

//regularPostProcessors用于存放普通的BeanFactoryPostProcessor

List

regularPostProcessors = new LinkedList();

//registryPostProcessors用于存放 BeanDefinitionRegistryPostProcessor

List

registryPostProcessors = new LinkedList();

//查询通过addBeanFactoryPostProcessor等方法设置进来的的BeanFactoryPostProcessor（不是注册到IOC容器的中）

for (BeanFactoryPostProcessor postProcessor : getBeanFactoryPostProcessors()) {

//如果是 BeanDefinitionRegistryPostProcessor ，

//就先执行它的postProcessBeanDefinitionRegistry，用于向IOC中注册一些BeanDefinition，

//然后添加到registryPostProcessors队列中

if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {

BeanDefinitionRegistryPostProcessor registryPostProcessor =

(BeanDefinitionRegistryPostProcessor) postProcessor;

registryPostProcessor.postProcessBeanDefinitionRegistry(registry);

registryPostProcessors.add(registryPostProcessor);

}

else {

//如果是普通的BeanFactoryPostProcessor，就添加到regularPostProcessors队列中

regularPostProcessors.add(postProcessor);

}

//获取IOC容器中注册的BeanDefinitionRegistryPostProcessor，

//放入到registryPostProcessorBeans中，

//并按照Order排序

Map beanMap =

beanFactory.getBeansOfType(BeanDefinitionRegistryPostProcessor.class, true, false);

List registryPostProcessorBeans =

new ArrayList(beanMap.values());

OrderComparator.sort(registryPostProcessorBeans);

//先调用registryPostProcessorBeans中的所有postProcessBeanDefinitionRegistry方法

for (BeanDefinitionRegistryPostProcessor postProcessor : 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方法

// Invoke factory processors registered with the context instance.

invokeBeanFactoryPostProcessors(getBeanFactoryPostProcessors(), beanFactory);

}

// Do not initialize FactoryBeans here: We need to leave all regular beans

// 查询IOC容器中所有的BeanFactoryPostProcessor，有可能上面的BeanDefinitionRegistryPostProcessor刚刚向IOC容器中注册了一些BeanFactoryPostProcessor，所以要在此处全部查出来。

String[] postProcessorNames =

beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

// 按照这些BeanFactoryPostProcessor实现的排序接口（ PriorityOrdered 和 Ordered）分成3组

//第一组实现了PriorityOrdered --- priorityOrderedPostProcessors

//第二组实现了Ordered --- orderedPostProcessorNames

//第三组没有实现排序接口 --- nonOrderedPostProcessorNames

List priorityOrderedPostProcessors = new ArrayList();

List orderedPostProcessorNames = new ArrayList();

List nonOrderedPostProcessorNames = new ArrayList();

for (String ppName : postProcessorNames) {

//如果已经处理了，就跳过

if (processedBeans.contains(ppName)) {

// skip - already processed in first phase above

}

//实现PriorityOrdered 接口的

else if (isTypeMatch(ppName, PriorityOrdered.class)) {

priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));

}

// 实现Ordered 接口的

else if (isTypeMatch(ppName, Ordered.class)) {

orderedPostProcessorNames.add(ppName);

}

//普通的

else {

nonOrderedPostProcessorNames.add(ppName);

}

//然后先执行priorityOrderedPostProcessors中的，再执行orderedPostProcessorNames的，最后执行nonOrderedPostProcessorNames

//排序并执行priorityOrderedPostProcessors的

OrderComparator.sort(priorityOrderedPostProcessors);

invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

// 排序并执行orderedPostProcessors的

List orderedPostProcessors = new ArrayList();

for (String postProcessorName : orderedPostProcessorNames) {

orderedPostProcessors.add(getBean(postProcessorName, BeanFactoryPostProcessor.class));

}

OrderComparator.sort(orderedPostProcessors);

invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

// 最后执行普通的BeanFactoryPostProcessor的

List nonOrderedPostProcessors = new ArrayList();

for (String postProcessorName : nonOrderedPostProcessorNames) {

nonOrderedPostProcessors.add(getBean(postProcessorName, BeanFactoryPostProcessor.class));

}

invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);

}

6.registerBeanPostProcessors

protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {

// 获取IOC中注册的 BeanPostProcessor

String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);

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

int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;

beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));

//按照排序接口分类。

//这里需要注意的是，priorityOrderedPostProcessors里面装的是BeanPostProcessor

//而orderedPostProcessorNames和nonOrderedPostProcessorNames里面装的是BeanPostProcessor的name

//原因是：实例化BeanPostProcessor实现类的时候，也需要调用IOC中已有的BeanPostProcessor，所以Spring这里没有提前实例化Orderd接口和普通的BeanPostProcessor。

//因此，这里有一个有趣的现象，示例化Orderd接口的BeanProcessor的时候，会使用PriorityOrdered的BeanPostProcessor进行处理

//实例化普通的BeanProcessor时，会先后经过PriorityOrdered和Orderd接口的BeanPostProcessor的处理

List priorityOrderedPostProcessors = new ArrayList();

List internalPostProcessors = new ArrayList();

List orderedPostProcessorNames = new ArrayList();

List nonOrderedPostProcessorNames = new ArrayList();

//分类

for (String ppName : postProcessorNames) {

//PriorityOrdered接口的，先行实例化，并把MergedBeanDefinitionPostProcessor放入到internalPostProcessors中

if (isTypeMatch(ppName, PriorityOrdered.class)) {

BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);

priorityOrderedPostProcessors.add(pp);

if (pp instanceof MergedBeanDefinitionPostProcessor) {

internalPostProcessors.add(pp);

}

//Ordered接口的，这里只是把name记录下来。

else if (isTypeMatch(ppName, Ordered.class)) {

orderedPostProcessorNames.add(ppName);

}

//普通的，这里只是把name记录下来。

else {

nonOrderedPostProcessorNames.add(ppName);

}

//排序并注册PriorityOrdered接口的BeanPostProcessor

OrderComparator.sort(priorityOrderedPostProcessors);

registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

//排序并注册Ordered接口的BeanPostProcessor

List orderedPostProcessors = new ArrayList();

for (String ppName : orderedPostProcessorNames) {

//这里才进行实例化，所以会使用实现了PriorityOrdered接口的BeanPostProcessor进行处理

BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);

orderedPostProcessors.add(pp);

//把MergedBeanDefinitionPostProcessor放入到internalPostProcessors中

if (pp instanceof MergedBeanDefinitionPostProcessor) {

internalPostProcessors.add(pp);

}

OrderComparator.sort(orderedPostProcessors);

registerBeanPostProcessors(beanFactory, orderedPostProcessors);

// 注册普通的BeanPostProcessor

List nonOrderedPostProcessors = new ArrayList();

for (String ppName : nonOrderedPostProcessorNames) {

//这里才进行实例化，所以会使用实现了PriorityOrdered接口或Orderd的BeanPostProcessor进行处理

BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);

nonOrderedPostProcessors.add(pp);

//把 MergedBeanDefinitionPostProcessor 放入到internalPostProcessors中

//同时注意到，即使在internalPostProcessors中

//BeanPostProcessor的顺序也是按照 PriorityOrderd > Orderd > 普通的顺序进入的。

if (pp instanceof MergedBeanDefinitionPostProcessor) {

internalPostProcessors.add(pp);

}

registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);

//注册所有的MergedBeanDefinitionPostProcessor

OrderComparator.sort(internalPostProcessors);

registerBeanPostProcessors(beanFactory, internalPostProcessors);

//最后，在末尾添加一个ApplicationListenerDetector

beanFactory.addBeanPostProcessor(new ApplicationListenerDetector());

}

7.initMessageSource

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

获取BeanFactory

判断容器中是否有id为messageSource的，类型是MessageSource的组件；

如果有赋值给messageSource，如果没有自己创建一个DelegatingMessageSource；

MessageSource：取出国际化配置文件中的某个key的值；能按照区域信息获取；

将创建完成的MessageSource注册在容器中，以后获取国际化配置文件的值的时候，可以自动注入MessageSource；

protected void initMessageSource() {

ConfigurableListableBeanFactory beanFactory = getBeanFactory();

if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {

this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);

// Make MessageSource aware of parent MessageSource.

//如果已经注册了 messageSource && messageSource是HierarchicalMessageSource && messageSource没有parent && 此IOC有parent

if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {

HierarchicalMessageSource hms = (HierarchicalMessageSource) this.messageSource;

if (hms.getParentMessageSource() == null) {

// Only set parent context as parent MessageSource if no parent MessageSource

// registered already.

hms.setParentMessageSource(getInternalParentMessageSource());

}

if (logger.isDebugEnabled()) {

logger.debug("Using MessageSource [" + this.messageSource + "]");

}

//如果没有注册messageSource，就创建一个DelegatingMessageSource,并注册到IOC中

else {

// Use empty MessageSource to be able to accept getMessage calls.

DelegatingMessageSource dms = new DelegatingMessageSource();

dms.setParentMessageSource(getInternalParentMessageSource());

this.messageSource = dms;

beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);

if (logger.isDebugEnabled()) {

logger.debug("Unable to locate MessageSource with name '" + MESSAGE_SOURCE_BEAN_NAME +

"': using default [" + this.messageSource + "]");

}

8.initApplicationEventMulticaster

protected void initApplicationEventMulticaster() {

ConfigurableListableBeanFactory beanFactory = 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("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");

}

//如果没有applicationEventMulticaster，就设置一个SimpleApplicationEventMulticaster

else {

this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);

beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);

if (logger.isDebugEnabled()) {

logger.debug("Unable to locate ApplicationEventMulticaster with name '" +

APPLICATION_EVENT_MULTICASTER_BEAN_NAME +

"': using default [" + this.applicationEventMulticaster + "]");

}

9.onRefresh

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

protected void onRefresh() throws BeansException {

// For subclasses: do nothing by default.

}

10.registerListeners

注册监听器分为两部分:

向事件分发器注册硬编码设置的applicationListener

向事件分发器注册一个IOC中的事件监听器（并不实例化）

protected voidaaysqs registerListeners() {

// 查出所有通过addApplicationListener方法添加的ApplicationListener，然后注册到事件广播器上

for (ApplicationListener> listener : getApplicationListeners()) {

getApplicationEventMulticaster().addApplicationListener(listener);

}

// 查出ioc容器中的所有ApplicationListener，只把他们注册到事件分发器的ApplicationListenerBean上，

// 待使用时再进行实例化

String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);

for (String listenerBeanName : listenerBeanNames) {

getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);

}

11.finishBeanFactoryInitialization

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

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {

//如果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 (String weaverAwareName : weaverAwareNames) {

getBean(weaverAwareName);

}

// 清理临时的classLoader

beanFactory.setTempClassLoader(null);

// 缓存所有beanDefinition的name，以备不时之需

beanFactory.freezeConfiguration();

// 实例化所有非non-lazy-init的单例

beanFactory.preInstantiateSingletons();

}

12.finishRefresh

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

protected void finishRefresh() {

// 实例化或初始化lifecycleProcessor

initLifecycleProcessor();

// 调用lifecycleProcessor的刷新方法

getLifecycleProcessor().onRefresh();

//发布一个ContextRefreshedEvent事件

publishEvent(new ContextRefreshedEvent(this));

// 注册MBean，用于JMX管理

LiveBeansView.registerApplicationContext(this);

}

参考资料：

解读Spring容器的refresh()

Spring 源码深度解析

Spring IoC之ApplicationContext中refresh过程

总结

Flask接口签名sign原理与实例代码浅析

223 2022-11-24

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

多平台统一管理软件接口，如何实现多平台统一管理软件接口

Flask接口签名sign原理与实例代码浅析

java中的接口是类吗

推荐文章

接口调用是什么意思？几种常用接口调用方式

接口设计原则

8款在线 API 接口文档管理工具

api管理系统是什么？

什么是接口调试？接口调试的步骤有哪些？

api 接口管理系统有哪些？

接口测试有几种测试方法

API文档生成工具有哪些？

微服务和api网关区别

交换机配置步骤

最近发表

热评文章

在线接口文档管理工具推荐，支持在线测试，HTTP接口

开源的在线接口文档wiki工具Mindoc的介绍与使

如何优雅的进行接口设计？接口设计的六大原则是什么？

什么是API测试,api检测公司

软件接口设计怎么做？前后端分离软件接口设计思路

接口管理平台推荐，几大接口管理平台总有一款适合你！