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