spring之refresh方法分析

快来打我* 2022-10-21 14:52 271阅读 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定义的过程可以参考[这里][Link 1]。从外部配置中加载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可以参考[这里][Link 2]。

## 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的机会，具体可以参考[这里][Link 3]，[这里][Link 4]，[这里][Link 5],[这里][Link 6],以及[这里][Link 7]。接下来看下源码：

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);
    }

[Link 1]: https://blog.csdn.net/wang0907/article/details/114016448
[Link 2]: https://blog.csdn.net/wang0907/article/details/116453128
[Link 3]: https://blog.csdn.net/wang0907/article/details/115440135
[Link 4]: https://blog.csdn.net/wang0907/article/details/115443697
[Link 5]: https://blog.csdn.net/wang0907/article/details/115483144
[Link 6]: https://blog.csdn.net/wang0907/article/details/115488263
[Link 7]: https://blog.csdn.net/wang0907/article/details/115506565