這章我們分析 spring 核心方法refresh(), Spring容器的創建刷新過程。 這個方法在 spring 中有着很重要的功能處理下面我們來分析：
AbstractApplicationContext # refresh() 方法分析
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// 1、準備刷新上下文。
prepareRefresh();
// 2、獲取Bean工廠。
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// 3、Bean工廠準備。
prepareBeanFactory(beanFactory);
try {
// 4、後置處理 Bean工廠。 (由子類具體實現)
postProcessBeanFactory(beanFactory);
// 5、執行 BeanFactoryPostProcessor 處理 Bean工廠
invokeBeanFactoryPostProcessors(beanFactory);
// 6、通過當前上下文獲取 BeanPostProcessor 註冊給當前 Bean工廠
registerBeanPostProcessors(beanFactory);
// 7、初始化消息資源器
initMessageSource();
// 8、初始化應用事件廣播 (SimpleApplicationEventMulticaster)
initApplicationEventMulticaster();
// 9、留給子類重寫, 初始化主題資源. 主要用於如何定位相應的主題資源文件 (ThemeSource)
onRefresh();
// 10、向廣播器中心註冊應用監聽器, (ApplicationEventMulticaster) 添加(ApplicationListener)
registerListeners();
// 11、完成BeanFactory初始化. 1)設置轉換服務. 2)關閉對BeanDefinition操作. 3)實例化(非延遲初始化)單例
finishBeanFactoryInitialization(beanFactory);
// 12、完成刷新 (a、清空資源緩存 b、初始化 LifecycleProcessor 生命週期處理器並調用 onRefresh() d、發佈 ContextRefreshedEvent 上下文刷新事件 )
finishRefresh();
}
catch (BeansException ex) {
if (logger.isWarnEnabled()) {
logger.warn("Exception encountered during context initialization - " +
"cancelling refresh attempt: " + ex);
}
// a\如果異常, 則銷燬已經創建的單例，以避免懸空資源。 b\並重置“活躍”的旗幟爲false
destroyBeans();
cancelRefresh(ex);
// Propagate exception to caller.
throw ex;
}
finally {
// 13、清除緩存. 重置Spring內核中的常見自省緩存，因爲我們可能再也不需要單例bean的元數據了……
resetCommonCaches();
}
}
}
1、prepareRefresh() 刷新前準備
protected void prepareRefresh() {
this.startupDate = System.currentTimeMillis();
this.closed.set(false);
this.active.set(true);
if (logger.isDebugEnabled()) {
if (logger.isTraceEnabled()) {
logger.trace("Refreshing " + this);
}
else {
logger.debug("Refreshing " + getDisplayName());
}
}
// Initialize any placeholder property sources in the context environment
// 在上下文環境中初始化任何佔位符屬性源 空實現
initPropertySources();
// Validate that all properties marked as required are resolvable
// see ConfigurablePropertyResolver#setRequiredProperties
//獲取上下文中的環境效驗請求屬性
getEnvironment().validateRequiredProperties();
// Allow for the collection of early ApplicationEvents,
// to be published once the multicaster is available...
//創建應用事件Set集合, 用於提前公佈
this.earlyApplicationEvents = new LinkedHashSet<>();
}
2、obtainFreshBeanFactory() 獲取BeanFactory
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
refreshBeanFactory(); //抽象方法
return getBeanFactory();
}
protected final void refreshBeanFactory() throws BeansException {
if (hasBeanFactory()) { //判斷是否存在，如存在就銷燬,關閉
destroyBeans();
closeBeanFactory();
}
try {
DefaultListableBeanFactory beanFactory = createBeanFactory(); //初始化 DefaultListableBeanFactory
beanFactory.setSerializationId(getId());
//定製 BeanFactory (設置是否允許 BeanDefinition 覆蓋, 是否允許循環引用)
customizeBeanFactory(beanFactory);
//創建 XmlBeanDefinitionReader 對象用來解析xml, 並加載bean
loadBeanDefinitions(beanFactory);
synchronized (this.beanFactoryMonitor) {
this.beanFactory = beanFactory;
}
}
catch (IOException ex) {
throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
}
}
3、prepareBeanFactory(beanFactory) BeanFactory的準備工作
/**
* 配置工廠的標準上下文特徵，例如上下文的類加載器和後處理器。
* 一、配置類加載器
* 二、配置表達式分解器
* 三、添加屬性編輯註冊器
* 四、添加後置處理器
* 五、忽視依賴接口
* 六、註冊分解器依賴
* 七、註冊單列
*/
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
// 設置Bean的類加載器
beanFactory.setBeanClassLoader(getClassLoader());
// 設置Bean表達式分解器
beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
// 給BeanFactory添加屬性編輯註冊器
beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
// Configure the bean factory with context callbacks.
// 添加Bean後置處理器
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); //應用上下文裝配
// BeanFactory interface not registered as resolvable type in a plain factory.
// MessageSource registered (and found for autowiring) as a bean.
// 註冊可用於分解的依賴
beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory); //BeanFactory
beanFactory.registerResolvableDependency(ResourceLoader.class, this);
beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
beanFactory.registerResolvableDependency(ApplicationContext.class, this);
// Register early post-processor for detecting inner beans as ApplicationListeners.
// 添加Bean後置處理器 ApplicationListenerDetector
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
// Detect a LoadTimeWeaver and prepare for weaving, if found.
if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
// Set a temporary ClassLoader for type matching.
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}
// Register default environment beans.
// 註冊默認環境bean 單列
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());
}
}
4、postProcessBeanFactory(beanFactory) BeanFactory後置處理 留給子類重寫
protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
}
// 子類重寫 AbstractRefreshableWebApplicationContext
protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
beanFactory.addBeanPostProcessor(new ServletContextAwareProcessor(this.servletContext, this.servletConfig));
beanFactory.ignoreDependencyInterface(ServletContextAware.class);
beanFactory.ignoreDependencyInterface(ServletConfigAware.class);
WebApplicationContextUtils.registerWebApplicationScopes(beanFactory, this.servletContext);
WebApplicationContextUtils.registerEnvironmentBeans(beanFactory, this.servletContext, this.servletConfig);
}
5、invokeBeanFactoryPostProcessors(beanFactory) 執行BeanFactory後置方法
/**
* 實例化和調用所有已註冊的BeanFactoryPostProcessor bean，如果給定了顯式順序，則尊重顯式順序。
* 一、處理器註冊代理處理所有的BeanFactory處理器
* 二、給BeanFactory添加處理器
* 三、設置臨時類加載器
*/
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
// Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime
// (e.g. through an @Bean method registered by ConfigurationClassPostProcessor)
if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}
}
6、registerBeanPostProcessors(beanFactory) 註冊bean的後置處理器
/**
* 實例化和調用所有已註冊的BeanPostProcessor bean，如果給定了顯式順序，則尊重顯式順序。
*/
protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
}
7、initMessageSource() 初始化MessageSource組件
/**
* 初始化MessageSource
*/
protected void initMessageSource() {
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);
// Make MessageSource aware of parent MessageSource.
if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {
HierarchicalMessageSource hms = (HierarchicalMessageSource) this.messageSource;
if (hms.getParentMessageSource() == null) {
// Only set parent context as parent MessageSource if no parent MessageSource
// registered already.
hms.setParentMessageSource(getInternalParentMessageSource());
}
}
if (logger.isTraceEnabled()) {
logger.trace("Using MessageSource [" + this.messageSource + "]");
}
}
else {
// Use empty MessageSource to be able to accept getMessage calls.
DelegatingMessageSource dms = new DelegatingMessageSource();
dms.setParentMessageSource(getInternalParentMessageSource());
this.messageSource = dms;
beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
if (logger.isTraceEnabled()) {
logger.trace("No '" + MESSAGE_SOURCE_BEAN_NAME + "' bean, using [" + this.messageSource + "]");
}
}
}
8、initApplicationEventMulticaster() 初始化事件廣播器
/**
* 初始化ApplicationEventMulticaster 事件廣播器
*/
protected void initApplicationEventMulticaster() {
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
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() + "]");
}
}
}
9、onRefresh() 留給子類重寫
/**
* 模板方法，該方法可被重寫以添加特定於上下文的刷新工作。
* 在實例化單例之前對特殊bean進行初始化時調用。
*/
protected void onRefresh() throws BeansException {
// For subclasses: do nothing by default.
}
// 子類實現 AbstractRefreshableWebApplicationContext
protected void onRefresh() {
this.themeSource = UiApplicationContextUtils.initThemeSource(this);
}
10、registerListeners() 註冊事件監聽器
/**
* 添加實現ApplicationListener爲偵聽器的bean。不影響其他偵聽器，這些偵聽器可以在不使用bean的情況下添加。
* 一、遍歷監聽器集合, 添加一個偵聽器來接收所有事件的通知。
* 二、根據class 得到所有的實現類的名稱, 並添加一個偵聽器bean來接收所有事件的通知。
* 三、發佈早期的應用程序事件, 將給定的應用程序事件多播到適當的偵聽器
*/
protected void registerListeners() {
// Register statically specified listeners first.
// 遍歷監聽器集合
for (ApplicationListener<?> listener : getApplicationListeners()) {
// 添加一個偵聽器來接收所有事件的通知。
getApplicationEventMulticaster().addApplicationListener(listener);
}
// Do not initialize FactoryBeans here: We need to leave all regular beans
// uninitialized to let post-processors apply to them!
// 根據class 得到所有的實現類的名稱
String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
for (String listenerBeanName : listenerBeanNames) {
// 添加一個偵聽器bean來接收所有事件的通知。
getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
}
// Publish early application events now that we finally have a multicaster...
// 發佈早期的應用程序事件
Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
this.earlyApplicationEvents = null;
if (earlyEventsToProcess != null) {
for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
// 將給定的應用程序事件多播到適當的偵聽器
getApplicationEventMulticaster().multicastEvent(earlyEvent);
}
}
}
11、finishBeanFactoryInitialization(beanFactory) 初始化所有剩下的單實例bean
/**
* 結束此上下文的bean工廠的初始化，初始化所有剩餘的單例bean。
*/
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
// Initialize conversion service for this context.
// 是否包含conversionService
if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) && beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
// 設置轉換服務
beanFactory.setConversionService(beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
}
// 如果沒有bean後處理器，則註冊默認的嵌入式值解析器
if (!beanFactory.hasEmbeddedValueResolver()) {
beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
}
// 儘早初始化LoadTimeWeaverAware bean，以便儘早註冊它們的轉換器。
String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
for (String weaverAwareName : weaverAwareNames) {
getBean(weaverAwareName);
}
// 停止使用臨時類裝入器進行類型匹配。
beanFactory.setTempClassLoader(null);
// 凍結所有BeanDefinition
beanFactory.freezeConfiguration();
// Instantiate all remaining (non-lazy-init) singletons.
// 實例化所有剩餘的(非延遲初始化)單例。
beanFactory.preInstantiateSingletons();
}
12、finishRefresh() 容器創建完成
/**
* 完成此上下文的刷新，調用LifecycleProcessor的onRefresh()方法併發布
* {@link org.springframework.context.event.ContextRefreshedEvent}.
*/
protected void finishRefresh() {
// Clear context-level resource caches (such as ASM metadata from scanning).
//清空資源緩存
clearResourceCaches();
// Initialize lifecycle processor for this context.
// 初始化生命週期處理器
initLifecycleProcessor();
// 首先將刷新傳播到生命週期處理器。
getLifecycleProcessor().onRefresh();
// 發佈最終事件。
publishEvent(new ContextRefreshedEvent(this));
// 註冊應用上下文
LiveBeansView.registerApplicationContext(this);
}