源碼深度解析之 Spring IOC
大家好，我是樓仔！
這篇文章主要講解 IOC 容器的創建過程，讓你對整體有一個全局的認識，文章沒有複雜嵌套的 debug 流程，相對來說比較簡單。
不 BB，上文章目錄。
1. 基礎知識
1.1 什麼是 Spring IOC ？
IOC 不是一種技術，只是一種思想，一個重要的面向對象編程的法則，它能指導我們如何設計出松耦合、更優良的程序。
傳統應用程序都是由我們在類內部主動創建依賴對象，從而導致類與類之間高耦合，難於測試。
有了 IOC 容器後，把創建和查找依賴對象的控制權交給了容器，由容器進行注入組合對象，所以對象與對象之間是鬆散耦合，便於測試和功能複用，整個體系結構更加靈活。
理解 IOC 的關鍵是要明確 “誰控制誰，控制什麼，爲何是反轉（有反轉就應該有正轉了），哪些方面反轉了”，我們淺析一下：
-
誰控制誰，控制什麼：
-
傳統 Java SE 程序設計，我們直接在對象內部通過 new 進行創建對象，是程序主動去創建依賴對象；
-
IOC 是有專門一個容器來創建這些對象，即由 IOC 容器來控制對象的創建；
-
誰控制誰？當然是 IOC 容器控制了對象；
-
控制什麼？主要控制了外部資源獲取。
-
爲何反轉，哪些方面反轉：
-
傳統應用程序是由我們自己在對象中主動控制去直接獲取依賴對象，也就是正轉；
-
反轉則是由容器來幫忙創建及注入依賴對象；
-
爲何是反轉？因爲由容器幫我們查找及注入依賴對象，對象只是被動的接受依賴對象，所以是反轉；
-
哪些方面反轉了？依賴對象的獲取被反轉了。
1.2 容器創建過程
在看源碼之前，首先搞清楚 Spring IOC 容器的創建過程，然後再深入源碼。
IOC 容器如婚姻介紹所：
-
男人 A 要求需要一個女人，中介從婚姻介紹所根據男人 A 給他介紹瞭如花；
-
男人 B 要求介紹一個膚白貌美大長腿，中介從婚姻介紹所根據男人 B 給他介紹了女神。
從婚姻介紹所的例子可以大概知道 Spring IOC 是存儲、定製、管理等功能的各種定製化的 bean 對象容器，下圖是 Spring IOC 容器創建基本流程。
2. 核心知識
2.1 相關對象
2.1.1 ApplicationContext
ApplicationContext 接口是 BeanFactory 的子接口，也被稱爲 Spring 上下文，與 BeanFactory 一樣，可以加載配置文件中定義的 bean，並進行管理。
它還加強了企業所需要的功能，如從屬性文件中解析文本信息和將事件傳遞給所有指定的監視器，下圖是 ApplicationContext 接口的繼承關係。
ApplicationContext 接口主要的 5 個作用如表所示：
2.1.2 BeanDefinitionReader
// 示例
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");配置文件解析器，如將配置文件中的 bean 信息解析成對應的 BeanDefinition 對象。
xml 文件解析使用是就是 BeanDefinitionReader 實現類 XmlBeanDefinitionReader。
2.1.3 BeanFactoryPostProcessor
可以修改 Spring 上下文中 BeanDefinition 信息。
如下圖 BeanFactoryPostProcessor 的子類 PropertySourcesPlaceholderConfigurer 的作用可以爲數據庫連接池 ${} 佔位符賦值等等。
2.1.4 BeanFactory
是所有 Bean 容器的根接口，定義了 spring 容器基本方法。
如使用 getBean(beanName,Class) 獲取對象。
2.2 源碼核心流程
容器初始化的核心源碼，都在 refresh() 方法中：
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
//1:準備刷新上下文環境
prepareRefresh();
//2:獲取初始化Bean工廠
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
//3:對bean工廠進行填充屬性
prepareBeanFactory(beanFactory);
try {
//4:Spring開放接口 留給子類去實現該接口
postProcessBeanFactory(beanFactory);
//5:調用我們的bean工廠的後置處理器
invokeBeanFactoryPostProcessors(beanFactory);
//6:註冊我們bean後置處理器
registerBeanPostProcessors(beanFactory);
//7:初始化國際化資源處理器
initMessageSource();
//8:初始化事件多播器
initApplicationEventMulticaster();
//9:這個方法同樣也是留個子類實現,其中springboot也是從這個方法進行tomcat的啓動
onRefresh();
//10:把我們的事件監聽器註冊到多播器上
registerListeners();
//11:實例化所有的非懶加載的單實例bean
finishBeanFactoryInitialization(beanFactory);
//12:最後刷新容器 發佈刷新事件(Spring cloud eureka也是從這裏啓動的)
finishRefresh();
}
catch (BeansException ex) {
if (logger.isWarnEnabled()) {
logger.warn("Exception encountered during context initialization - " +
"cancelling refresh attempt: " + ex);
}
// Destroy already created singletons to avoid dangling resources.
destroyBeans();
// Reset 'active' flag.
cancelRefresh(ex);
// Propagate exception to caller.
throw ex;
}
finally {
// Reset common introspection caches in Spring's core, since we
// might not ever need metadata for singleton beans anymore...
resetCommonCaches();
}
}
}什麼，內容不夠精煉？那我再給大家上一個牛逼的思維導圖：
3. 源碼解析
下面主要對 refresh() 的 12 個流程進行講解。
3.1 prepareRefresh()
準備刷新上下文環境：
protected void prepareRefresh() {
// Switch to active.
this.startupDate = System.currentTimeMillis();
this.closed.set(false);
this.active.set(true);
if (logger.isInfoEnabled()) {
logger.info("Refreshing " + this);
}
/**
* 初始化上下文環境
*/
initPropertySources();
/**
* 用來校驗我們容器啓動必須依賴的環境變量的值
*/
getEnvironment().validateRequiredProperties();
/**
* 創建一個早期事件監聽器對象
*/
if (this.earlyApplicationListeners == null) {
this.earlyApplicationListeners = new LinkedHashSet<>(this.applicationListeners);
}
else {
// Reset local application listeners to pre-refresh state.
this.applicationListeners.clear();
this.applicationListeners.addAll(this.earlyApplicationListeners);
}
/**
* 創建一個容器用於保存早期待發布的事件集合 什麼是早期事件了?
* 就是我們的事件監聽器還沒有註冊到事件多播器上的時候都稱爲早期事件
*/
this.earlyApplicationEvents = new LinkedHashSet<>();
}3.2 ConfigurableListableBeanFactory()
獲取初始化的 Bean 的工廠：
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
//刷新bean工廠()
refreshBeanFactory();
//返回之前容器準備工作的時候創建的的bean工廠也就是DefaultListableBeanFactory（很重要）
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
if (logger.isDebugEnabled()) {
logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
}
return beanFactory;
}protected final void refreshBeanFactory() throws IllegalStateException {
//由於BeanFactory只能刷新一次，多線程情況下可能導致線程安全問題，所有使用cas原子操作來保證
if (!this.refreshed.compareAndSet(false, true)) {
throw new IllegalStateException(
"GenericApplicationContext does not support multiple refresh attempts: just call 'refresh' once");
}
//指定Bean工廠的序列化Id
this.beanFactory.setSerializationId(getId());
}3.3 prepareBeanFactory()
對 Bean 工廠進行填充屬性：
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
//設置bean工廠的類加載器爲當前application應用上下文的加載器
beanFactory.setBeanClassLoader(getClassLoader());
//爲bean工廠設置SPEL表達式解析器對象StandardBeanExpressionResolver
beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
//爲我們的bean工廠設置了一個propertyEditor屬性資源編輯器對象(用於後面的給bean對象賦值使用)
beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
//註冊ApplicationContextAwareProcessor後置處理器用來處理ApplicationContextAware接口的回調方法
beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
/**
* 當Spring將ApplicationContextAwareProcessor註冊後，那麼在invokeAwarelnterfaces方法中調用的Aware類已經不是普通的bean了 ，
* 如ResourceLoaderAware、ApplicationEventPublisherAware、ApplicationContextAware等，那麼當然需要在Spring做bean的依賴注入的時候忽略它們。
* 這個就是ignoreDependencyInterface的作用
*/
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.class的解析依賴後，
* 當bean的屬性注入的時候，一旦檢測到屬性爲BeanFactory類型便會將beanFactory的實例注入進去。
*/
beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
beanFactory.registerResolvableDependency(ResourceLoader.class, this);
beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
beanFactory.registerResolvableDependency(ApplicationContext.class, this);
//註冊了一個事件監聽器探測器後置處理器接口
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
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()));
}
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());
}
}3.4 postProcessBeanFactory()
Spring 開放接口留給子類去實現該接口，主要用來改變 BeanFactory。
比如給 BeanFactory 添加一些自己的 BeanPostProcessor（Bean 的後置處理器）
3.5 invokeBeanFactoryPostProcessors()
調用我們的 bean 工廠的後置處理器，裏面邏輯非常複雜，需要的同學可以和我聯繫，有詳細講解，就不擴展了。
3.6 registerBeanPostProcessors()
註冊我們 bean 後置處理器：
/**
* 往容器中註冊了我們的bean的後置處理器
* bean的後置處理器在什麼時候進行調用？在bean的生命週期中
* @param beanFactory
* @param applicationContext
*/
public static void registerBeanPostProcessors(
ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
//去容器中獲取所有的BeanPostProcessor的bean名稱
String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
/**
* beanFactory.getBeanPostProcessorCount()獲取的是已經添加在beanFactory的beanPostProcessors集合中的
* postProcessorNames.length beanFactory工廠中BeanPostProcessor個數 +1 又註冊了BeanPostProcessorChecker的後置處理器
*/
int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
/**
* 按照BeanPostProcessor實現的優先級接口來分離我們的後置處理器
*/
//保存實現了priorityOrdered接口的
List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
//容器內部的
List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
//實現了我們ordered接口的
List<String> orderedPostProcessorNames = new ArrayList<>();
//實現了我們任何優先級的
List<String> nonOrderedPostProcessorNames = new ArrayList<>();
//循環我們的bean定義(BeanPostProcessor)
for (String ppName : postProcessorNames) {
//若實現了PriorityOrdered接口的
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
//顯示的調用getBean流程創建bean的後置處理器
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
//加入到集合中
priorityOrderedPostProcessors.add(pp);
//判斷是否實現了MergedBeanDefinitionPostProcessor
if (pp instanceof MergedBeanDefinitionPostProcessor) {
//加入到集合中
internalPostProcessors.add(pp);
}
}
//判斷是否實現了Ordered
else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessorNames.add(ppName);
}
else {
nonOrderedPostProcessorNames.add(ppName);
}
}
//把實現了priorityOrdered註冊到容器中
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
//處理實現Ordered的bean後置處理器
List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>();
for (String ppName : orderedPostProcessorNames) {
//顯示調用getBean方法
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
//加入到集合中
orderedPostProcessors.add(pp);
//判斷是否實現了MergedBeanDefinitionPostProcessor
if (pp instanceof MergedBeanDefinitionPostProcessor) {
//加入到集合中
internalPostProcessors.add(pp);
}
}
//排序並且註冊我們實現了Order接口的後置處理器
sortPostProcessors(orderedPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, orderedPostProcessors);
// 實例化我們所有的非排序接口的
List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
for (String ppName : nonOrderedPostProcessorNames) {
//顯示調用
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
nonOrderedPostProcessors.add(pp);
//判斷是否實現了MergedBeanDefinitionPostProcessor
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
//註冊我們普通的沒有實現任何排序接口的
registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);
//註冊MergedBeanDefinitionPostProcessor類型的後置處理器
sortPostProcessors(internalPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, internalPostProcessors);
//註冊ApplicationListenerDetector應用監聽器探測器的後置處理器
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}3.7 initMessageSource()
初始化國際化資源處理器：
/**
* Initialize the MessageSource.
* Use parent's if none defined in this context.
*/
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.isDebugEnabled()) {
logger.debug("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.isDebugEnabled()) {
logger.debug("Unable to locate MessageSource with name '" + MESSAGE_SOURCE_BEAN_NAME +
"': using default [" + this.messageSource + "]");
}
}
}3.8 initApplicationEventMulticaster()
初始化事件多播器：
/**
* 從bean工廠中獲取或者直接顯示的new一個事件多播器賦值給applicatoinContext對象的applicationEventMulticaster屬性
* 事件多播器採用典型的設計模式就是觀察者模式 多播器作爲的是一個被觀察者
* @see org.springframework.context.event.SimpleApplicationEventMulticaster
*/
protected void initApplicationEventMulticaster() {
//獲取我們的bean工廠對象
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
//判斷容器中是否包含了applicationEventMulticaster事件多播器組件
if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
//直接顯示的調用我們的getBean獲取出來賦值給我們的applicationContext對象
this.applicationEventMulticaster =
beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
if (logger.isDebugEnabled()) {
logger.debug("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
}
}
//容器中沒有的話
else {
//直接new一個
this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
//並且注入到容器中
beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
if (logger.isDebugEnabled()) {
logger.debug("Unable to locate ApplicationEventMulticaster with name '" +
APPLICATION_EVENT_MULTICASTER_BEAN_NAME +
"': using default [" + this.applicationEventMulticaster + "]");
}
}
}3.9 onRefresh()
這個方法很重要，同樣也是留個子類實現，其中 Spring Boot 就是從這個方法進行 tomcat 的啓動。
3.10 registerListeners()
把我們的事件監聽器註冊到事件多播器上：
protected void registerListeners() {
//獲取容器中所有的監聽器對象
for (ApplicationListener<?> listener : getApplicationListeners()) {
//把監聽器挨個的註冊到我們的事件多播器上去
getApplicationEventMulticaster().addApplicationListener(listener);
}
//獲取bean定義中的監聽器對象
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);
}
}
}如何發佈事件，通過事件多播器方法：multicastEvent()，進入方法。
@Override
public void multicastEvent(ApplicationEvent event) {
multicastEvent(event, resolveDefaultEventType(event));
}@Override
public void multicastEvent(final ApplicationEvent event, @Nullable ResolvableType eventType) {
ResolvableType type = (eventType != null ? eventType : resolveDefaultEventType(event));
//從事件多播器中獲取出所有的監聽器
for (final ApplicationListener<?> listener : getApplicationListeners(event, type)) {
//判斷多播器中是否支持異步多播的
Executor executor = getTaskExecutor();
if (executor != null) {
//異步播發事件
executor.execute(() -> invokeListener(listener, event));
}
else {//同步播發
invokeListener(listener, event);
}
}
}/**
* Invoke the given listener with the given event.
* @param listener the ApplicationListener to invoke
* @param event the current event to propagate
* @since 4.1
*/
protected void invokeListener(ApplicationListener<?> listener, ApplicationEvent event) {
ErrorHandler errorHandler = getErrorHandler();
if (errorHandler != null) {
try {
doInvokeListener(listener, event);
}
catch (Throwable err) {
errorHandler.handleError(err);
}
}
else {
doInvokeListener(listener, event);
}
}doInvokeListener() 方法，Spring 有一個特點，涉及到以 do 開頭的方法都是真正幹活的。
@SuppressWarnings({"rawtypes", "unchecked"})
private void doInvokeListener(ApplicationListener listener, ApplicationEvent event) {
try {
listener.onApplicationEvent(event);
}
catch (ClassCastException ex) {
String msg = ex.getMessage();
if (msg == null || matchesClassCastMessage(msg, event.getClass())) {
// Possibly a lambda-defined listener which we could not resolve the generic event type for
// -> let's suppress the exception and just log a debug message.
Log logger = LogFactory.getLog(getClass());
if (logger.isTraceEnabled()) {
logger.trace("Non-matching event type for listener: " + listener, ex);
}
}
else {
throw ex;
}
}
}3.11 finishBeanFactoryInitialization()
實例化所有的非懶加載的單實例 bean，我們前幾篇源碼，其實都是講的裏面的方法，最重要的就是 getBean()。
這個方法必須掌握，可以查看我的前幾篇源碼系列文章。
3.12 finishRefresh()
最後刷新容器發佈刷新事件（Spring cloud eureka 也是從這裏啓動的）。
protected void finishRefresh() {
//初始化生命週期處理器
initLifecycleProcessor();
//調用生命週期處理器的onRefresh方法
getLifecycleProcessor().onRefresh();
//發佈ContextRefreshedEvent事件
publishEvent(new ContextRefreshedEvent(this));
// Participate in LiveBeansView MBean, if active.
LiveBeansView.registerApplicationContext(this);
}(1) 初始化生命週期處理器：initLifecycleProcessor() 方法。
protected void initLifecycleProcessor() {
//獲取beanFactory工廠
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
//判斷容器中是否有lifecycleProcessor，有就直接從容器中拿
if (beanFactory.containsLocalBean(LIFECYCLE_PROCESSOR_BEAN_NAME)) {
this.lifecycleProcessor =
beanFactory.getBean(LIFECYCLE_PROCESSOR_BEAN_NAME, LifecycleProcessor.class);
if (logger.isDebugEnabled()) {
logger.debug("Using LifecycleProcessor [" + this.lifecycleProcessor + "]");
}
}
//沒有創建一個DefaultLifecycleProcessor，然後註冊到容器中
else {
DefaultLifecycleProcessor defaultProcessor = new DefaultLifecycleProcessor();
defaultProcessor.setBeanFactory(beanFactory);
this.lifecycleProcessor = defaultProcessor;
beanFactory.registerSingleton(LIFECYCLE_PROCESSOR_BEAN_NAME, this.lifecycleProcessor);
if (logger.isDebugEnabled()) {
logger.debug("Unable to locate LifecycleProcessor with name '" +
LIFECYCLE_PROCESSOR_BEAN_NAME +
"': using default [" + this.lifecycleProcessor + "]");
}
}
}(2) 調用生命週期處理器的 getLifecycleProcessor().onRefresh() 方法。
@Override
public void onRefresh() {
startBeans(true);
this.running = true;
}startBeans(true) 方法，主要的功能是找到 Spring 容器的 Lifecycle 類型的 Bean，然後調用 start() 去啓動。
private void startBeans(boolean autoStartupOnly) {
Map<String, Lifecycle> lifecycleBeans = getLifecycleBeans();
Map<Integer, LifecycleGroup> phases = new HashMap<Integer, LifecycleGroup>();
for (Map.Entry<String, ? extends Lifecycle> entry : lifecycleBeans.entrySet()) {
Lifecycle bean = entry.getValue();
if (!autoStartupOnly || (bean instanceof SmartLifecycle && ((SmartLifecycle) bean).isAutoStartup())) {
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(entry.getKey(), bean);
}
}
if (!phases.isEmpty()) {
List<Integer> keys = new ArrayList<Integer>(phases.keySet());
Collections.sort(keys);
for (Integer key : keys) {
phases.get(key).start();
}
}
}phases.get(key).start() 方法。
public void start() {
if (this.members.isEmpty()) {
return;
}
if (logger.isDebugEnabled()) {
logger.debug("Starting beans in phase " + this.phase);
}
Collections.sort(this.members);
for (LifecycleGroupMember member : this.members) {
doStart(this.lifecycleBeans, member.name, this.autoStartupOnly);
}
}private void doStart(Map<String, ? extends Lifecycle> lifecycleBeans, String beanName, boolean autoStartupOnly) {
Lifecycle bean = lifecycleBeans.remove(beanName);
if (bean != null && bean != this) {
String[] dependenciesForBean = getBeanFactory().getDependenciesForBean(beanName);
for (String dependency : dependenciesForBean) {
doStart(lifecycleBeans, dependency, autoStartupOnly);
}
//bean不在運行中並且(autoStartupOnly=false 或者 不是SmartLifecycle類型 或者 isAutoStartup() = true)
if (!bean.isRunning() &&
(!autoStartupOnly || !(bean instanceof SmartLifecycle) || ((SmartLifecycle) bean).isAutoStartup())) {
if (logger.isDebugEnabled()) {
logger.debug("Starting bean '" + beanName + "' of type [" + bean.getClass().getName() + "]");
}
try {
//調用生命週期Lifecycle Bean的start()方法
bean.start();
}
catch (Throwable ex) {
throw new ApplicationContextException("Failed to start bean '" + beanName + "'", ex);
}
if (logger.isDebugEnabled()) {
logger.debug("Successfully started bean '" + beanName + "'");
}
}
}
}(3) 發佈 ContextRefreshedEvent 事件：主要就是調用前面第八步創建的事件多播器的發佈事件方法。
protected void publishEvent(Object event, ResolvableType eventType) {
Assert.notNull(event, "Event must not be null");
if (logger.isTraceEnabled()) {
logger.trace("Publishing event in " + getDisplayName() + ": " + event);
}
// Decorate event as an ApplicationEvent if necessary
ApplicationEvent applicationEvent;
if (event instanceof ApplicationEvent) {
applicationEvent = (ApplicationEvent) event;
}
else {
applicationEvent = new PayloadApplicationEvent<Object>(this, event);
if (eventType == null) {
eventType = ((PayloadApplicationEvent) applicationEvent).getResolvableType();
}
}
// Multicast right now if possible - or lazily once the multicaster is initialized
if (this.earlyApplicationEvents != null) {
this.earlyApplicationEvents.add(applicationEvent);
}
else {
getApplicationEventMulticaster().multicastEvent(applicationEvent, eventType);
}
// Publish event via parent context as well...
if (this.parent != null) {
if (this.parent instanceof AbstractApplicationContext) {
((AbstractApplicationContext) this.parent).publishEvent(event, eventType);
}
else {
this.parent.publishEvent(event);
}
}
}4. 總結
總結一下本文內容：
-
講述了 IOC 的基礎知識，並通過婚介所的示例，講解容器的創建過程；
-
介紹容器創建的 4 個相關對象，以及 refresh() 的主流程；
-
給出 refresh() 的 12 個主流程的核心源碼，並附上詳細註釋。
大家主要掌握 IOC 容器創建的思想和過程，以及 refresh() 的 12 個主流程即可，至於裏面每一步流程，如果深究下去，其實內容非常多，建議後續如果需要，再深入學習。
本文由 Readfog 進行 AMP 轉碼，版權歸原作者所有。
來源：https://mp.weixin.qq.com/s/29xlEK2N_Wptl4TBMg1ZPQ