spring之refresh方法分析

一户董

已于 2022-08-26 17:12:48 修改

阅读量1.2k

点赞数 2

分类专栏： spring

于 2021-05-05 15:18:57 首次发布

本文链接：https://blog.csdn.net/wang0907/article/details/116425738

版权

Spring框架初始化过程 bean工厂 bean定义 BeanPostProcessor

关键词由CSDN通过智能技术生成

spring 专栏收录该内容

54 篇文章 0 订阅

订阅专栏

1：方法的定义和实现

该方法的定义是在接口org.springframework.context.ConfigurableApplicationContext中，定义如下：

org.springframework.context.ConfigurableApplicationContext#refresh
void refresh() throws BeansException, IllegalStateException;

具体的实现是在AbstractApplicationContext中，源码如下：

org.springframework.context.support.AbstractApplicationContext#refresh
public void refresh() throws BeansException, IllegalStateException {
	synchronized (this.startupShutdownMonitor) {
		// 设置容器状态，和property source等
		prepareRefresh();
		// 创建bean工厂
		ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
		// bean工厂投入生产前的各种配置，如类加载器，后置处理器等
		prepareBeanFactory(beanFactory);

		try {
			// 默认空实现
			postProcessBeanFactory(beanFactory);
			// 应用BeanFactoryPostProcessor
			invokeBeanFactoryPostProcessors(beanFactory);
			// 实例化和注册BeanPostProcessor
			registerBeanPostProcessors(beanFactory);
			// 初始化MessageSource，辅助i18n
			initMessageSource();
			// 初始化上下文的时间广播器
			initApplicationEventMulticaster();
			// 空实现
			onRefresh();
			// 注册监听器
			registerListeners();
			// 初始化非延迟加载的单例bean
			finishBeanFactoryInitialization(beanFactory);
			// 完成刷新
			finishRefresh();
		}

		catch (BeansException ex) {
			...snip...
			destroyBeans();
			cancelRefresh(ex);
			throw ex;
		}

		finally {
			resetCommonCaches();
		}
	}
}

这里的每一个方法都非常的重要，所以我们来一个一个的进行分析。

2：prepareRefresh

方法是org.springframework.context.support.AbstractApplicationContext#prepareRefresh,源码如下：

org.springframework.context.support.AbstractApplicationContext#prepareRefresh
protected void prepareRefresh() {
	// 设置启动时间（毫秒值）
	this.startupDate = System.currentTimeMillis();
	// 设置容器的关闭状态为false，即未关闭
	this.closed.set(false);
	// 设置容器的激活状态为true，即激活
	this.active.set(true);

	if (logger.isDebugEnabled()) {
		if (logger.isTraceEnabled()) {
			logger.trace("Refreshing " + this);
		}
		else {
			logger.debug("Refreshing " + getDisplayName());
		}
	}
	// 初始化context environment中的占位符的属性来源
	initPropertySources();
	// 验证必须提供的属性是否提供
	getEnvironment().validateRequiredProperties();
	if (this.earlyApplicationListeners == null) {
		this.earlyApplicationListeners = new LinkedHashSet<>(this.applicationListeners);
	}
	else {
		this.applicationListeners.clear();
		this.applicationListeners.addAll(this.earlyApplicationListeners);
	}
	this.earlyApplicationEvents = new LinkedHashSet<>();
}

3：obtainFreshBeanFactory

源码：

org.springframework.context.support.AbstractApplicationContext#obtainFreshBeanFactory
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
	// <20210506 1319>
	refreshBeanFactory();
	// 返回bean工厂
	return getBeanFactory();
}

<20210506 1319>处是创建bean工厂，源码如下:

org.springframework.context.support.AbstractRefreshableApplicationContext#refreshBeanFactory// 该方法执行context的底层bean工厂的真正的刷新操作，停止已存在的bena工厂，并且创建
// 和context生命周期对应的下一阶段的bean工厂
@Override
protected final void refreshBeanFactory() throws BeansException {
	// 若已有，则处理老的
	if (hasBeanFactory()) {
		// 销毁老bean工厂中的单例bean缓存
		destroyBeans();
		// 关闭bean工厂
		closeBeanFactory();
	}
	try {
		// 创建bean工厂，这里创建的是DefaultListableBeanFactory
		DefaultListableBeanFactory beanFactory = createBeanFactory();
		// 设置序列化id，在必要情况下进行序列化和反序列化
		beanFactory.setSerializationId(getId());
		// 自定义beanfactory
		customizeBeanFactory(beanFactory);
		// <20210506 1344>
		// 加载bean definition到bean工厂中
		loadBeanDefinitions(beanFactory);
		// 设置bean工厂引用
		synchronized (this.beanFactoryMonitor) {
			this.beanFactory = beanFactory;
		}
	}
	catch (IOException ex) {
		...snip...
	}
}

<20210506 1344>处是加载bean定义到bean工厂中，具体参考``

3.1：loadBeanDefinitions

详细的加载bean定义的过程可以参考这里。从外部配置中加载bean的配置信息为bean definition，源码如下：

org.springframework.context.support.AbstractXmlApplicationContext#loadBeanDefinitions(org.springframework.beans.factory.support.DefaultListableBeanFactory)
protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
	// 创建bean定义读取器
	XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
	// 设置Environment
	beanDefinitionReader.setEnvironment(this.getEnvironment());
	// 设置资源加载器
	beanDefinitionReader.setResourceLoader(this);
	beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
	// 设置允许子类自定义的读取器的初始化策略，然后按照自定义的策略来加载bean定义
	initBeanDefinitionReader(beanDefinitionReader);
	// <20210506 1353>
	// 真正的加载bean定义
	loadBeanDefinitions(beanDefinitionReader);
}

<20210506 1353>处是真正的加载bean定义，源码如下：

org.springframework.context.support.AbstractXmlApplicationContext#loadBeanDefinitions(org.springframework.beans.factory.xml.XmlBeanDefinitionReader)
protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
	// 获取资源数组
	Resource[] configResources = getConfigResources();
	// 如果是资源数组不为空，则通过配置文件对应的资源数组加载bean definition
	if (configResources != null) {
		reader.loadBeanDefinitions(configResources);
	}
	// 获取配置文件的位置
	String[] configLocations = getConfigLocations();
	// 如果是配置文件位置数组不为空，则根据配置文件加载bean definition
	if (configLocations != null) {
		reader.loadBeanDefinitions(configLocations);
	}
}

4：prepareBeanFactory

本方法是在bean工厂投入生产前设置各种配置，如类加载器，后置处理器等，源码如下：

org.springframework.context.support.AbstractApplicationContext#prepareBeanFactory
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
	// 设置类加载器
	beanFactory.setBeanClassLoader(getClassLoader());
	// <20210506 1647>
	// 设置SpEL的解析器
	beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
	// 设置属性编辑器
	beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

	// 设置处理各种Aware的BeanPostProcessor，用于处理bean实现了Aware时调用对应的setXxx方法
	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);

	...snip...
	beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

	// 增加AspectJ的支持
	if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
		beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
		beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
	}
	// 注册环境相关的默认bean到单例缓存map中
	if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
		beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
	}
	if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
		beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
	}
	if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
		beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
	}
}

<20210506 1647>处是设置解析SpEL的的解析器，关于SpEL可以参考这里。

5：postProcessBeanFactory

目前为空的模板方法。源码如下：

org.springframework.context.support.AbstractApplicationContext#postProcessBeanFactory
// 在通过方法prepareBeanFactory执行了标准的初始化之后来修改内部的bean factory。此时所有的bean definition都已经加载完毕
// ，但是没有任何的bean完成初始化。比如可以通过在子类中重载该方法来注册特殊的BeanPostProcessor
protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
}

6：invokeBeanFactoryPostProcessors

在bean definition加载完毕后，在通过bean definition生成bean之前，调用BeanFactoryPostProcessor，给用户一个修改bean definition的机会，具体可以参考这里，这里，这里,这里,以及这里。接下来看下源码：

org.springframework.context.support.AbstractApplicationContext#invokeBeanFactoryPostProcessors
// 实例化并且调用所有注册的BeanFactoryPostProcessor的bean，注意必须在单例bean实例化之前调用
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
	// <20210506 1739>
	PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
	...snip...
}

<20210506 1739>处源码如下：

org.springframework.context.support.PostProcessorRegistrationDelegate#invokeBeanFactoryPostProcessors(org.springframework.beans.factory.config.ConfigurableListableBeanFactory, java.util.List<org.springframework.beans.factory.config.BeanFactoryPostProcessor>)
public static void invokeBeanFactoryPostProcessors(
			ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
	// 保存所有的BeanFactoryPostProcessor
	Set<String> processedBeans = new HashSet<>();
	// 如果是BeanDefinitionRegistry，这是负责定义bean defintion注册的接口,
	// 可以参考链接：https://blog.csdn.net/wang0907/article/details/116205750
	if (beanFactory instanceof BeanDefinitionRegistry) {
		// 强转为BeanDefinitionRegistry
		BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
		List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
		List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();
		// 循环所有的BeanFactoryPostProcessor
		for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
			// 如果是BeanDefinitionRegistryPostProcessor
			if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
				// 强转
				BeanDefinitionRegistryPostProcessor registryProcessor =
						(BeanDefinitionRegistryPostProcessor) postProcessor;
				// 调用postProcessBeanDefinitionRegistry方法修改bean工厂
				registryProcessor.postProcessBeanDefinitionRegistry(registry);
				// 添加到registryProcessors集合中
				registryProcessors.add(registryProcessor);
			}
			else {
				// 添加到regularePostProcessors集合中
				regularPostProcessors.add(postProcessor);
			}
		}
		// 保存当前处理的BeanDefinitionRegistryPostProcessor
		List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();
	
		// 获取类型为BeanDefinitionRegistryPostProcessor的所有bean的名称的数组
		String[] postProcessorNames =
				beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
		// 处理实现了PriorityOdered接口的
		for (String ppName : postProcessorNames) {
			if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
				// 通过beanFactory#getBean方法获取名称为ppName的bean
				currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
				// 添加到集合，便于后续处理
				processedBeans.add(ppName);
			}
		}
		// 排序
		sortPostProcessors(currentRegistryProcessors, beanFactory);
		// 加入到registryProcessors集合中
		registryProcessors.addAll(currentRegistryProcessors);
		// 调用所有实现了PriorityOrder接口的BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry方法
		invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
		// 清空，后续继续使用
		currentRegistryProcessors.clear();
		
		// 处理实现了Ordered接口的BeanDefinitionRegistryPostProcessor，逻辑同上
		// 这里为什么要重新获取？？？
		postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
		for (String ppName : 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);
		invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
		currentRegistryProcessors.clear();
		
		// 调用剩余的，即没有实现PriorityOrdered接口，也没有实现Ordered的BeanDefinitionRegistryPostProcessor,直到所有的都调用完毕
		boolean reiterate = true;
		while (reiterate) {
			reiterate = false;
			postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
			for (String ppName : 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
		// 注意上面逻辑调用的是BeanDefinitionRegistryPostProcessor#postProcessBeanDefinitionRegistry
		// 调用实现了BeanDefinitionRegitryPostProcessor接口的
		invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
		// 调用没有实现了BeanDefinitionRegitryPostProcessor接口的，即普通的
		invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
	}

	else {
		// 直接循环调用BeanFactoryPostProcessor#postProcessBeanFactory
		invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
	}

	// 按照PriorityOrdered接口，Ordered接口，其他，处理在上一阶段没有处理的BeanFactoryPostProcessor，因为BeanFacotryPostProcessor可以手动注册，可以通过配置文件
	// 注册，所有在一个阶段可能是处理不完的，所以才有了第二阶段的BeanFactoryPostProcessor
	// 的处理
	String[] postProcessorNames =
			beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
	// 实现了PriorityOrdered接口的beanfactorypostprocessor集合
	List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
	// 实现了Ordered接口的beanfactorypostprocessor的bean的名称集合
	List<String> orderedPostProcessorNames = new ArrayList<>();
	// 即没有实现PriorityOrdered也没有实现Ordered接口的beanfactorypostprocessor的
	List<String> nonOrderedPostProcessorNames = new ArrayList<>();
	// 循环所有的beanfactorypostprocessor的名称，分别放到实现了PriorityOrdered接口，
	// Ordered接口，既没有实现PriorityOrederd接口也没有实现Ordered接口的集合中
	for (String ppName : postProcessorNames) {
		if (processedBeans.contains(ppName)) {
		}
		else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
			priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
		}
		else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
			orderedPostProcessorNames.add(ppName);
		}
		else {
			nonOrderedPostProcessorNames.add(ppName);
		}
	}
	// 排序实现了PriorityOrdered接口的BeanFactoryPostProcessor集合
	sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
	// 按照顺序执行实现了priorityOredered接口的BeanFactoryPostProcessor集合
	invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

	// 存储实现了Ordered接口beanfactorypostprocessor的对象集合
	List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>();
	// 循环实现了Ordered接口的beanfactorypostprocessor的bean名称，并从bean工厂中
	// 获取bean实例，添加到集合中
	for (String postProcessorName : orderedPostProcessorNames) {
		orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
	}
	// 排序实现了Oredered接口的BeanFactoryPostProcessor实例
	sortPostProcessors(orderedPostProcessors, beanFactory);
	// 按照顺序执行实现了Ordered接口的BeanFactoryPostProcessor
	invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

	// 存储即没有实现PriorityOrdered接口，也没有实现Oredered接口的BeanFactoryPostProcessor
	List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
	// 循环既没有实现PriorityOrdered，也没有实现Ordered接口的beanfactorypostprocessor的bean
	// 名称，从beanfacotry中获取实例并添加到集合中
	for (String postProcessorName : nonOrderedPostProcessorNames) {
		nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
	}
	// 执行既没有实现PriorityOredered接口，也没有实现Ordered接口的BeanFactoryPostProcessor
	invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
	beanFactory.clearMetadataCache();
}

7：registerBeanPostProcessors

注册BeanPostProcessor，用于拦截bean的创建过程，源码如下：

org.springframework.context.support.AbstractApplicationContext#registerBeanPostProcessors
/*
1：实例化并且注册所有的BeanFactoryPostProcessor的beans。
2：如果是指定了顺序的话，则按照顺序。
3：该方法必须在应用程序的bean实例化之前调用，因为在实例化应用程序bean的时候要应用这些BeanFactoryPostProcessor。
*/
protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
	// <20210507 0545>
	PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
}

<20210507 0545>处源码如下：

org.springframework.context.support.PostProcessorRegistrationDelegate#registerBeanPostProcessors(org.springframework.beans.factory.config.ConfigurableListableBeanFactory, org.springframework.context.support.AbstractApplicationContext)
public static void registerBeanPostProcessors(
			ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
	// 获取所有的BeanPostProcessor类型的bean的名称的数组
	String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);

	// 获取目标bean处理器的数量（为什么要+1？）
	int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
	// 添加BeanPostProcessorChecker，这是BeanPostProcessor的一个子类，执行一些检查
	// 如检测应用程序bean在初始化时所有的BeanPostProcessor是否都已经实例化完毕，没有的话，
	// 则日志记录
	beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));

	// 实现了PriorityOrdered接口的BeanPostProcessor实例集合
	List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
	// 实现了MergedBeanDefinitionPostProcessor接口的BeanPostProcessor实例集合
	List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
	// 实现了Ordered接口的BeanPostProcessor的bean名称集合
	List<String> orderedPostProcessorNames = new ArrayList<>();
	// 即没有实现PriorityOrdered接口，也没有实现Ordered接口的BeanPostProcessor的bean名称集合
	List<String> nonOrderedPostProcessorNames = new ArrayList<>();
	// 填充PriorityOrdered，Ordered，二者均无对应的集合
	for (String ppName : postProcessorNames) {
		if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
			BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
			priorityOrderedPostProcessors.add(pp);
			if (pp instanceof MergedBeanDefinitionPostProcessor) {
				internalPostProcessors.add(pp);
			}
		}
		else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
			orderedPostProcessorNames.add(ppName);
		}
		else {
			nonOrderedPostProcessorNames.add(ppName);
		}
	}
	// 排序实现了PriorityOrdered接口的BeanPostProcessor，并注册到bean工厂
	sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
	// 注册
	registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

	// 从bean容器中获取实现了Ordered接口的BeanPostProcessor并注册到bean工厂中
	List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>();
	for (String ppName : orderedPostProcessorNames) {
		BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
		orderedPostProcessors.add(pp);
		if (pp instanceof MergedBeanDefinitionPostProcessor) {
			internalPostProcessors.add(pp);
		}
	}
	sortPostProcessors(orderedPostProcessors, beanFactory);
	registerBeanPostProcessors(beanFactory, orderedPostProcessors);

	// 获取即没有实现PriorityOrdered接口，也没有实现Ordered接口的BeanPostProcessor，并注册到
	// bean工厂中
	List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
	for (String ppName : nonOrderedPostProcessorNames) {
		BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
		nonOrderedPostProcessors.add(pp);
		if (pp instanceof MergedBeanDefinitionPostProcessor) {
			internalPostProcessors.add(pp);
		}
	}
	registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);

	// 排序实现了MergedBeanDefinitionPostProcessor接口的BeanPostProcessor
	// 并排序，注册到bean工厂中
	sortPostProcessors(internalPostProcessors, beanFactory);
	registerBeanPostProcessors(beanFactory, internalPostProcessors);
	beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}

8：initMessageSource

初始化一个MessageSource接口的实现类，用来处理i18n。源码如下：

org.springframework.context.support.AbstractApplicationContext#initMessageSource
protected void initMessageSource() {
		// 获取底层的bean工厂对象（已在前面步骤创建成功）
		ConfigurableListableBeanFactory beanFactory = getBeanFactory();
		// public static final String MESSAGE_SOURCE_BEAN_NAME = "messageSource";
		// bean工厂中messageSource的bean的名称，如果是包含则使用bean工厂中设置的
		if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
			// 从bean工厂中获取名称为MESSAGE_SOURCE_BEAN_NAME，类型为MessageSource.class
			// 的bean，赋值到this.messageSource
			this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);
			// 如果是有父类，则设置
			if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {
				HierarchicalMessageSource hms = (HierarchicalMessageSource) this.messageSource;
				if (hms.getParentMessageSource() == null) {
					hms.setParentMessageSource(getInternalParentMessageSource());
				}
			}
			if (logger.isTraceEnabled()) {
				logger.trace("Using MessageSource [" + this.messageSource + "]");
			}
		}
		else { // bean工厂中没有名称为MESSAGE_SOURCE_BEAN_NAME = "messageSource"的bean
			// 创建DelegatingMessageSource
			DelegatingMessageSource dms = new DelegatingMessageSource();
			// 设置父messagesource
			dms.setParentMessageSource(getInternalParentMessageSource());
			// 赋值
			this.messageSource = dms;
			// 注册到单例bean单例的一级缓存singletonObjects中，并从二级缓存earlySingletonObjects，
			// 三级缓存singletonFactories中删除
			beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
			if (logger.isTraceEnabled()) {
				logger.trace("No '" + MESSAGE_SOURCE_BEAN_NAME + "' bean, using [" + this.messageSource + "]");
			}
		}
	}

9：initApplicationEventMulticaster

初始化上下文事件广播器，源码如下：

org.springframework.context.support.AbstractApplicationContext#initApplicationEventMulticaster
// 初始化应用程序事件广播器，如果是在工厂中没有定义则使用SimpleApplicationEventMulticaster 
protected void initApplicationEventMulticaster() {
	// 获取bean工厂，在前面流程已经创建完毕
	ConfigurableListableBeanFactory beanFactory = getBeanFactory();
	// public static final String APPLICATION_EVENT_MULTICASTER_BEAN_NAME = "applicationEventMulticaster";
	// 如果是在bean工厂中包含该bean
	if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
		// 从bean工厂中获取bean
		this.applicationEventMulticaster =
				beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
		if (logger.isTraceEnabled()) {
			logger.trace("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
		}
	}
	else { // bean工厂中不包含
		// 使用SimpleApplicationEventMulticaster创建，并赋值
		this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(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() + "]");
		}
	}
}

10：onRefresh

模板方法，留给子类实现，源码如下：

org.springframework.context.support.AbstractApplicationContext#onRefresh
protected void onRefresh() throws BeansException {
	// 留给子类实现，默认什么也不做
}

11：registerListeners

注册监听器到广播器中，源码如下：

org.springframework.context.support.AbstractApplicationContext#registerListeners
protected void registerListeners() {
	for (ApplicationListener<?> listener : getApplicationListeners()) {
		getApplicationEventMulticaster().addApplicationListener(listener);
	}

	String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
	for (String listenerBeanName : listenerBeanNames) {
		getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
	}

	Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
	this.earlyApplicationEvents = null;
	if (earlyEventsToProcess != null) {
		for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
			getApplicationEventMulticaster().multicastEvent(earlyEvent);
		}
	}
}

12：finishBeanFactoryInitialization

注册所有非lazy-init的单例bean，源码如下：

// 初始化剩下的非延迟加载的单例bean，完成context的bean工厂的初始化
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
	// 初始化ConversionService，属性转换API接口
	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(strVal -> getEnvironment().resolvePlaceholders(strVal));
	}

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

	beanFactory.setTempClassLoader(null);

	beanFactory.freezeConfiguration();
	// <20210507 1759>
	// 初始化剩余所有非延迟加载的单例bean
	beanFactory.preInstantiateSingletons();
}

<20210507 1759>处源码如下：

org.springframework.beans.factory.support.DefaultListableBeanFactory#preInstantiateSingletons
public void preInstantiateSingletons() throws BeansException {
	if (logger.isTraceEnabled()) {
		logger.trace("Pre-instantiating singletons in " + this);
	}
	// 获取所有的bean名称
	List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

	// 触发所有非延迟加载的单例bean的初始化
	for (String beanName : beanNames) {
		// 根据bean名称获取bean定义
		RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
		// 非抽象，是单例，非延迟加载
		if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
			// 是工厂bean
			if (isFactoryBean(beanName)) {
				// 获取工厂bean实例
				Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
				// 再次判断为工厂bean
				if (bean instanceof FactoryBean) {
					// 强转工厂bean
					final FactoryBean<?> factory = (FactoryBean<?>) bean;
					boolean isEagerInit;
					if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
						isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)
										((SmartFactoryBean<?>) factory)::isEagerInit,
								getAccessControlContext());
					}
					else {
						isEagerInit = (factory instanceof SmartFactoryBean &&
								((SmartFactoryBean<?>) factory).isEagerInit());
					}
					if (isEagerInit) {
						// 通过getBean方法完成单例bean的初始化
						getBean(beanName);
					}
				}
			}
			else {
				// 通过getBean方法完成单例bean的初始化
				getBean(beanName);
			}
		}
	}
	// 循环处理SmartInitializingSingleton接口的情况，执行单例bean初始化后的方法，又是一个扩展点
	// 不得不说，spring扩展点真的是到处都是
	for (String beanName : beanNames) {
		Object singletonInstance = getSingleton(beanName);
		if (singletonInstance instanceof SmartInitializingSingleton) {
			final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
			if (System.getSecurityManager() != null) {
				AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
					smartSingleton.afterSingletonsInstantiated();
					return null;
				}, getAccessControlContext());
			}
			else {
				smartSingleton.afterSingletonsInstantiated();
			}
		}
	}
}

13：finishRefresh

完成刷新，主要是调用 LifecycleProcessor#onRefresh() ，并且发布事件（ContextRefreshedEvent）。源码如下：

org.springframework.context.support.AbstractApplicationContext#finishRefresh
protected void finishRefresh() {
	clearResourceCaches();
	initLifecycleProcessor();
	getLifecycleProcessor().onRefresh();
	publishEvent(new ContextRefreshedEvent(this));
	LiveBeansView.registerApplicationContext(this);
}