前言
我們知道,spring 的啓動其實就是容器的啓動,而一般情況下,容器指的其實就是上下文 ApplicationContext
。
AbstractApplicationContext
作爲整個 ApplicationContext
體系中最高級的抽象類,爲除了 ComplexWebApplicationContext
和 SimpleWebApplicationContext
這兩個容器外的全部容器,規定好了 refresh
的整體流程,所有的容器在完成一些自己的初始化配置後,都需要調用該 refresh
方法,依次完成指定內容的初始化。
也就是說,讀懂了 AbstractApplicationContext.refresh()
方法,其實就讀懂了容器的啓動流程:
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// ================= 一、上下文的初始化 =================
// 準備上下文
prepareRefresh();
// 通知子類刷新內部工廠
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// 準備bean工廠以便在當前上下文中使用
prepareBeanFactory(beanFactory);
try {
// ================= 二、BeanFactory的初始化 =================
// 對工廠進行默認後置處理
postProcessBeanFactory(beanFactory);
// 使用後置處理器對工廠進行處理
invokeBeanFactoryPostProcessors(beanFactory);
// 註冊Bean後置處理器
registerBeanPostProcessors(beanFactory);
// ================= 三、事件,Bean及其他配置的初始化 =================
// 初始化此上下文的消息源
initMessageSource();
// 爲此上下文初始化事件廣播者
initApplicationEventMulticaster();
// 初始化特定上下文子類中的其他特殊bean
onRefresh();
// 檢查偵聽器bean並註冊
registerListeners();
// 實例化所有非懶加載的剩餘單例
finishBeanFactoryInitialization(beanFactory);
// 完成刷新
finishRefresh();
}
// ================= 異常處理 =================
catch (BeansException ex) {
if (logger.isWarnEnabled()) {
logger.warn("Exception encountered during context initialization - " +
"cancelling refresh attempt: " + ex);
}
// 銷燬已創建的單例
destroyBeans();
// 重置上下文的激活狀態
cancelRefresh(ex);
throw ex;
}
finally {
// 重置內部的一些元數據緩存
resetCommonCaches();
}
}
}
從總體來看,該方法描述的初始化過程大概分爲三步:
筆者將基於 spring 源碼 5.2.x
分支,分別通過五篇文章從源碼分析 spring 容器的初始化過程。
本文是其中的第三篇文章,將介紹上下文中事件,Bean及其他配置的初始化。
相關文章:
一、初始化數據源
調用 AbstarctApplicationContext.initMessageSource()
用於初始化上下文所使用的數據源對象 MessageSource
,這個配置用於支持國際化的信息處理,一般情況下比較少會直接去配置它:
protected void initMessageSource() {
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
// 如果當前上下文否存在名爲“messageSource”的Bean
if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);
// Make MessageSource aware of parent MessageSource.
if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {
// 若父容器沒有MessageSource,就把它設置爲父容器的MessageSource
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.isTraceEnabled()) {
logger.trace("Using MessageSource [" + this.messageSource + "]");
}
}
else {
// 不存在就嘗試獲取父容器的MessageSource
DelegatingMessageSource dms = new DelegatingMessageSource();
dms.setParentMessageSource(getInternalParentMessageSource());
this.messageSource = dms;
beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
if (logger.isTraceEnabled()) {
logger.trace("No '" + MESSAGE_SOURCE_BEAN_NAME + "' bean, using [" + this.messageSource + "]");
}
}
}
二、初始化事件廣播者
調用 AbstarctApplicationContext.initApplicationEventMulticaster()
是初始化 spring 事件機制的第一步,它的作用很簡單:
如果當前 BeanFactory
有名爲 “applicationEventMulticaster”
的 ApplicationEventMulticaster
,就把它設置爲當前上下文的事件廣播器,否則就創建並在 BeanFactory
中註冊一個SimpleApplicationEventMulticaster
實例作爲當前上下文的事件廣播器。
protected void initApplicationEventMulticaster() {
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
// 是否存在“applicationEventMulticaster”這個Bean
if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
// 如果存在就把它設置爲當前上下文的事件廣播器
this.applicationEventMulticaster =
beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
if (logger.isTraceEnabled()) {
logger.trace("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
}
}
else {
// 沒有就創建一個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() + "]");
}
}
}
三、初始化特殊Bean
AbstarctApplicationContext.onRefresh()
用於在完成上下文與 BeanFactory
初始化後去初始化一些特殊的 Bean
,其實從方法名就可以看出來,這個方法主要是作爲上下文初步刷新完畢後的回調使用。
在 AbstarctApplicationContext
中只提供了空實現,實際上也只有很少的實現類會去重新實現這個方法,至少在 5.2.x
裏面,關於這個方法的有用實現只有:
UiApplicationContextUtils.initThemeSource(this)
該代碼用於初始化一些 spring 的“主題資源”,一般用於配合消息國際化進行一些處理。
四、註冊事件監聽器
當消息和事件相關的內容都準備就緒後,上下文會調用 AbstarctApplicationContext.registerListeners
方法以註冊事件監聽器 ApplicationListener
。
這一步代碼不動,實際上邏輯也很簡單:
- 向事件廣播器註冊已經被註冊的上下文中的監聽器;
- 向事件廣播器註冊還沒有被實例化的監聽器的
BeanName
; - 發佈一些早期事件;
protected void registerListeners() {
// 向事件廣播器註冊已經被註冊的上下文中的監聽器
for (ApplicationListener<?> listener : getApplicationListeners()) {
getApplicationEventMulticaster().addApplicationListener(listener);
}
// 向事件廣播器註冊指定的監聽器,不過這裏只註冊BeanName,
// 因爲有些監聽器Bean是由FactoryBean生產的,而在這裏FactoryBean實際上還沒被生成出來
String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
for (String listenerBeanName : listenerBeanNames) {
getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
}
// 發佈一些早期事件
Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
this.earlyApplicationEvents = null;
if (!CollectionUtils.isEmpty(earlyEventsToProcess)) {
for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
getApplicationEventMulticaster().multicastEvent(earlyEvent);
}
}
}
這裏有兩個比較有意思的地方:
getApplicationListeners
獲取的監聽器實際上也是通過一個名爲EventListenerMethodProcessor
的BeanFactoryPostProcessor
註冊到上下文的;- 註冊
BeanName
而不是直接註冊Bean
這一點是爲了遷就FactoryBean
。實際上在初始化BeanFactory
的時候,調用BeanFactoryPostProcessor
和註冊BeanPostProcessor
也都專門對此進行了處理;
五、實例化工廠中的Bean
當調用 AbstarctApplicationContext.finishBeanFactoryInitialization()
的時候,spring 會根據 BeanFactory
中已經註冊的 BeanDefinition
實例化所有非懶加載的單例 Bean
:
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
// 爲BeanFactory設置ConversionService
// 該接口爲spring轉換器體系的入口
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));
}
// 註冊一個StringValueResolver,沒有就從上下文的環境對象中獲取
// 該解析器用於解析配置文件中的一些佔位符以及SpEL表達式
if (!beanFactory.hasEmbeddedValueResolver()) {
beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
}
// 若存在AOP使用的支持類加載時織入切面邏輯的類加載器,則優先將該Bean初始化
String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
for (String weaverAwareName : weaverAwareNames) {
getBean(weaverAwareName);
}
// 由於類加載器已經初始化完成,所以可以停用臨時的類加載器了
beanFactory.setTempClassLoader(null);
// 鎖定當前工廠的配置
beanFactory.freezeConfiguration();
// 初始化剩餘未初始化的非懶加載單例Bean
beanFactory.preInstantiateSingletons();
}
這個方法總共幹了五件事:
- 爲
BeanFactory
設置類型轉換服務ConversionService
; - 爲
BeanFactory
設置佔位符轉換器StringValueResolver
; - 禁用臨時的類加載器,若有則啓用支持類加載時織入切面邏輯的類加載器;
- 鎖定當前
BeanFactory
的配置; - 初始化剩餘未初始化的非懶加載單例
Bean
;
這裏我們重點關注 BeanFactory.preInstantiateSingletons()
方法,此處是實際上完成 Bean
初始化的代碼:
public void preInstantiateSingletons() throws BeansException {
if (logger.isTraceEnabled()) {
logger.trace("Pre-instantiating singletons in " + this);
}
// Iterate over a copy to allow for init methods which in turn register new bean definitions.
// While this may not be part of the regular factory bootstrap, it does otherwise work fine.
List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
// 遍歷beanName,若BeanName是可以實例化的非懶加載單例Bean,則將其實例化
for (String beanName : beanNames) {
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
// 如果是FactoryBean
if (isFactoryBean(beanName)) {
Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
if (bean instanceof FactoryBean) {
FactoryBean<?> factory = (FactoryBean<?>) bean;
boolean isEagerInit;
// 類型爲SmartFactoryBean,則是否立刻實例化由SmartFactoryBean.isEagerInit()決定
if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
isEagerInit = AccessController.doPrivileged(
(PrivilegedAction<Boolean>) ((SmartFactoryBean<?>) factory)::isEagerInit,
getAccessControlContext());
}
else {
// 類型不爲SmartFactoryBean,則不立刻實例化
isEagerInit = (factory instanceof SmartFactoryBean &&
((SmartFactoryBean<?>) factory).isEagerInit());
}
if (isEagerInit) {
getBean(beanName);
}
}
}
else {
// 實例化bean
getBean(beanName);
}
}
}
// 獲取所有實現了SmartInitializingSingleton接口的Bean,調用Bean初始化後回調afterSingletonsInstantiated
for (String beanName : beanNames) {
Object singletonInstance = getSingleton(beanName);
if (singletonInstance instanceof SmartInitializingSingleton) {
SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
smartSingleton.afterSingletonsInstantiated();
return null;
}, getAccessControlContext());
}
else {
smartSingleton.afterSingletonsInstantiated();
}
}
}
}
這一步主要乾了兩件事:
- 如果是允許實例化的非懶加載普通
Bean
,就直接初始化; - 如果是允許實例化的非懶加載
FactoryBean
,則判斷它是否是SmartFactoryBean
:- 如果不是,則放棄直接初始化;
- 如果是,則根據
SmartFactoryBean.isEagerInit()
判斷是否要直接初始化;
- 初始化所有可初始化的
Bean
後,如果這些Bean
實現了SmartInitializingSingleton
接口,則調用該接口提供的回調函數;
這裏需要注意兩點:
BeanFactory.getBean()
實際纔是最終完成BeanFactory
創建Bean
實例操作的方法,在這個方法中將根據BeanDefinition
完成各自依賴的自動裝配、Bean
的後置處理等操作,三級緩存也是在這個時候使用的,這部分的內容將會在後續另起一篇文章分析;- 此處僅預加載了
FactoryBean
,而沒有懶加載FactoryBean
裏面的Bean
,因此FactoryBean
提供的Bean
總是懶加載的; SmartInitializingSingleton
接口用於提供BeanFactory
在初始化全部非懶加載Bean
時調用的回調函數;
至此,BeanFactory
中所有可以預先初始化的 Bean
都完成的初始化,我們已經可以通過 BeanFactory
正常的去獲取 Bean
了。
六、完成刷新
AbstractApplicationContext.finishRefresh()
是完成容器刷新的最後一步,它跟 AbstractApplicationContext.onRefresh()
一樣是一個鉤子方法。
protected void finishRefresh() {
// 清空資源緩存
clearResourceCaches();
// 初始化上下文的生命週期處理器
initLifecycleProcessor();
// 調用上下文的生命週期處理器
getLifecycleProcessor().onRefresh();
// 發佈上下文刷新完畢事件
publishEvent(new ContextRefreshedEvent(this));
// 註冊用於支持通過JMX管理spring的組件,這裏不過多分析,
// 關於JMX具體可以參考這篇文章:https://www.wdbyte.com/java/jmx.html#_3-2-%E8%B5%84%E6%BA%90%E4%BB%A3%E7%90%86-mbean-server
LiveBeansView.registerApplicationContext(this);
}
1、清空上下文資源緩存
public void clearResourceCaches() {
this.resourceCaches.clear();
}
2、初始化上下文的生命週期處理器
protected void initLifecycleProcessor() {
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
// 若存在名爲“lifecycleProcessor”的bean,則設置爲生命週期處理器
if (beanFactory.containsLocalBean(LIFECYCLE_PROCESSOR_BEAN_NAME)) {
this.lifecycleProcessor =
beanFactory.getBean(LIFECYCLE_PROCESSOR_BEAN_NAME, LifecycleProcessor.class);
if (logger.isTraceEnabled()) {
logger.trace("Using LifecycleProcessor [" + this.lifecycleProcessor + "]");
}
}
// 若不存在名爲“lifecycleProcessor”的bean,則創建一個DefaultLifecycleProcessor並設置爲生命週期處理器
else {
DefaultLifecycleProcessor defaultProcessor = new DefaultLifecycleProcessor();
defaultProcessor.setBeanFactory(beanFactory);
this.lifecycleProcessor = defaultProcessor;
beanFactory.registerSingleton(LIFECYCLE_PROCESSOR_BEAN_NAME, this.lifecycleProcessor);
if (logger.isTraceEnabled()) {
logger.trace("No '" + LIFECYCLE_PROCESSOR_BEAN_NAME + "' bean, using " +
"[" + this.lifecycleProcessor.getClass().getSimpleName() + "]");
}
}
}
3、生命週期處理
這裏需要着重研究一下生命週期處理器的調用。
在 getLifecycleProcessor().onRefresh()
這一步,將會獲取上一步設置到上下文中的 LifecycleProcessor
然後調用:
// AbstraceApplicationContext.getLifecycleProcessor()
LifecycleProcessor getLifecycleProcessor() throws IllegalStateException {
if (this.lifecycleProcessor == null) {
throw new IllegalStateException("LifecycleProcessor not initialized - " +
"call 'refresh' before invoking lifecycle methods via the context: " + this);
}
return this.lifecycleProcessor;
}
這裏我們以默認的生命週期處理器 DefaultLifecycleProcessor
爲例:
@Override
public void onRefresh() {
startBeans(true);
this.running = true;
}
private void startBeans(boolean autoStartupOnly) {
// 獲取所有實現了Lifecycle接口的Bean,並按階段分組裝到不同的LifecycleGroup裏
Map<String, Lifecycle> lifecycleBeans = getLifecycleBeans();
Map<Integer, LifecycleGroup> phases = new HashMap<>();
lifecycleBeans.forEach((beanName, bean) -> {
// 同時滿足下述條件的Bean不會被處理
// 1.入參的autoStartupOnly爲true
// 2.bean實現了SmartLifecycle接口
// 3.SmartLifecycle.isAutoStartup()方法返回false
if (!autoStartupOnly || (bean instanceof SmartLifecycle && ((SmartLifecycle) bean).isAutoStartup())) {
// 若實現了SmartLifecycle接口,則返回SmartLifecycle.getPhase(),否則默認返回0
int phase = getPhase(bean);
LifecycleGroup group = phases.get(phase);
if (group == null) {
group = new LifecycleGroup(phase, this.timeoutPerShutdownPhase, lifecycleBeans, autoStartupOnly);
phases.put(phase, group);
}
group.add(beanName, bean);
}
});
// 按階段從小到大排序,依次處理
if (!phases.isEmpty()) {
List<Integer> keys = new ArrayList<>(phases.keySet());
Collections.sort(keys);
for (Integer key : keys) {
phases.get(key).start();
}
}
}
可以看到,這裏針對 SmartLifecycle
接口的實現類做了很多特殊化的處理,默認情況下:
- 實現了
SmartLifecycle
接口的Bean
,需要保證SmartLifecycle.isAutoStartup
返回true
纔會被處理; - 沒實現
SmartLifecycle
接口,但是實現了Lifecycle
接口的Bean
會被直接處理;
並且,在處理 Bean
的時候,還會根據聲明週期“階段”按順序從小到大排序:
- 實現了
SmartLifecycle
接口的Bean
,按照SmartLifecycle.getPhase
返回值排序從小到大執行; - 沒實現
SmartLifecycle
接口,但是實現了Lifecycle
接口的Bean
,“階段”視爲 0,會被最先處理;
4、發佈上下文刷新完畢事件
這個操作其實也很簡單,其實就是調用時間廣播器推送一個 ContextRefreshedEvent
事件:
public class ContextRefreshedEvent extends ApplicationContextEvent {
public ContextRefreshedEvent(ApplicationContext source) {
super(source);
}
}
這個事件裏唯一一個參數就是上下文本身。
這一部分主要邏輯在事件推送上,後續會在專門的文章分析 spring 提供的事件機制,這裏就不過多展開。
總結
本文內容比較零散,主要幹三件事:
- 初始化消息源相關組件:
initMessageSource
:初始化上下文使用的消息源;onRefresh
:上下文刷新時的回調函數,但是一般只用於加載ThemeSource
;
- 初始化事件相關組件:
initApplicationEventMulticaster
:初始化事件廣播器;registerListeners
:註冊容器中的事件監聽器ApplicationListener
;
- 初始化
BeanFactory
中所有非抽象的非懶加載Bean
; - 完成刷新:
- 清空上下文中的資源緩存;
- 初始化並調用
Bean
生命週期處理器; - 發佈上下文刷新時間;
- 註冊並初始化用於支持 JMX 的組件;