漲薪必備｜給你一份超詳細Spring Boot知識清單
在過去兩三年的 Spring 生態圈，最讓人興奮的莫過於 Spring Boot 框架。或許從命名上就能看出這個框架的設計初衷：快速的啟動 Spring 應用。因而 Spring Boot 應用本質上就是一個基於 Spring 框架的應用，它是 Spring 對“約定優先於配置”理念的最佳實踐產物，它能夠幫助開發者更快速高效地構建基於 Spring 生態圈的應用。
那 Spring Boot 有何魔法？ 自動配置 、 起步依賴 、 Actuator 、 命令列介面(CLI) 是 Spring Boot 最重要的 4 大核心特性，其中 CLI 是 Spring Boot 的可選特性，雖然它功能強大，但也引入了一套不太常規的開發模型，因而這個系列的文章僅關注其它 3 種特性。
如文章標題，本文是這個系列的第一部分，將為你開啟 Spring Boot 的大門，重點為你剖析其啟動流程以及自動配置實現原理。要掌握這部分核心內容，理解一些 Spring 框架的基礎知識，將會讓你事半功倍。
一、拋磚引玉：探索Spring IoC容器
如果有看過 SpringApplication.run()方法的原始碼，Spring Boot 冗長無比的啟動流程一定會讓你抓狂，透過現象看本質，SpringApplication 只是將一個典型的 Spring 應用的啟動流程進行了擴充套件，因此，透徹理解 Spring 容器是開啟 Spring Boot 大門的一把鑰匙。
1.1、Spring IoC容器
可以把 Spring IoC 容器比作一間餐館，當你來到餐館，通常會直接招呼服務員：點菜！至於菜的原料是什麼？如何用原料把菜做出來？可能你根本就不關心。IoC 容器也是一樣，你只需要告訴它需要某個bean，它就把對應的例項（instance）扔給你，至於這個bean是否依賴其他元件，怎樣完成它的初始化，根本就不需要你關心。
作為餐館，想要做出菜餚，得知道菜的原料和菜譜，同樣地，IoC 容器想要管理各個業務物件以及它們之間的依賴關係，需要通過某種途徑來記錄和管理這些資訊。 BeanDefinition物件就承擔了這個責任：容器中的每一個 bean 都會有一個對應的 BeanDefinition 例項，該例項負責儲存bean物件的所有必要資訊，包括 bean 物件的 class 型別、是否是抽象類、構造方法和引數、其它屬性等等。當客戶端向容器請求相應物件時，容器就會通過這些資訊為客戶端返回一個完整可用的 bean 例項。
原材料已經準備好（把 BeanDefinition 看著原料），開始做菜吧，等等，你還需要一份菜譜， BeanDefinitionRegistry和 BeanFactory就是這份菜譜，BeanDefinitionRegistry 抽象出 bean 的註冊邏輯，而 BeanFactory 則抽象出了 bean 的管理邏輯，而各個 BeanFactory 的實現類就具體承擔了 bean 的註冊以及管理工作。它們之間的關係就如下圖：
DefaultListableBeanFactory作為一個比較通用的 BeanFactory 實現，它同時也實現了 BeanDefinitionRegistry 介面，因此它就承擔了 Bean 的註冊管理工作。從圖中也可以看出，BeanFactory 介面中主要包含 getBean、containBean、getType、getAliases 等管理 bean 的方法，而 BeanDefinitionRegistry 介面則包含 registerBeanDefinition、removeBeanDefinition、getBeanDefinition 等註冊管理 BeanDefinition 的方法。
下面通過一段簡單的程式碼來模擬 BeanFactory 底層是如何工作的：
// 預設容器實現DefaultListableBeanFactory beanRegistry=newDefaultListableBeanFactory();// 根據業務物件構造相應的BeanDefinitionAbstractBeanDefinition definition=newRootBeanDefinition(Business.class,true);// 將bean定義註冊到容器中beanRegistry.registerBeanDefinition("beanName",definition);// 如果有多個bean，還可以指定各個bean之間的依賴關係// ........// 然後可以從容器中獲取這個bean的例項// 注意：這裡的beanRegistry其實實現了BeanFactory介面，所以可以強轉，// 單純的BeanDefinitionRegistry是無法強制轉換到BeanFactory型別的BeanFactory container=(BeanFactory)beanRegistry;Business business=(Business)container.getBean("beanName");
這段程式碼僅為了說明 BeanFactory 底層的大致工作流程，實際情況會更加複雜，比如 bean 之間的依賴關係可能定義在外部配置檔案(XML/Properties)中、也可能是註解方式。Spring IoC 容器的整個工作流程大致可以分為兩個階段：
①、容器啟動階段
容器啟動時，會通過某種途徑載入 ConfigurationMetaData。除了程式碼方式比較直接外，在大部分情況下，容器需要依賴某些工具類，比如： BeanDefinitionReader，BeanDefinitionReader 會對載入的 ConfigurationMetaData進行解析和分析，並將分析後的資訊組裝為相應的 BeanDefinition，最後把這些儲存了 bean 定義的 BeanDefinition，註冊到相應的 BeanDefinitionRegistry，這樣容器的啟動工作就完成了。這個階段主要完成一些準備性工作，更側重於 bean 物件管理資訊的收集，當然一些驗證性或者輔助性的工作也在這一階段完成。
來看一個簡單的例子吧，過往，所有的 bean 都定義在 XML 配置檔案中，下面的程式碼將模擬 BeanFactory 如何從配置檔案中載入 bean 的定義以及依賴關係：
// 通常為BeanDefinitionRegistry的實現類，這裡以DeFaultListabeBeanFactory為例BeanDefinitionRegistry beanRegistry=newDefaultListableBeanFactory();// XmlBeanDefinitionReader實現了BeanDefinitionReader介面，用於解析XML檔案XmlBeanDefinitionReader beanDefinitionReader=newXmlBeanDefinitionReaderImpl(beanRegistry);// 載入配置檔案beanDefinitionReader.loadBeanDefinitions("classpath:spring-bean.xml");// 從容器中獲取bean例項BeanFactory container=(BeanFactory)beanRegistry;Business business=(Business)container.getBean("beanName");
②、Bean的例項化階段
經過第一階段，所有 bean 定義都通過 BeanDefinition 的方式註冊到 BeanDefinitionRegistry 中，當某個請求通過容器的 getBean 方法請求某個物件，或者因為依賴關係容器需要隱式的呼叫 getBean 時，就會觸發第二階段的活動：容器會首先檢查所請求的物件之前是否已經例項化完成。如果沒有，則會根據註冊的 BeanDefinition 所提供的資訊例項化被請求物件，併為其注入依賴。當該物件裝配完畢後，容器會立即將其返回給請求方法使用。
BeanFactory 只是 Spring IoC 容器的一種實現，如果沒有特殊指定，它採用採用延遲初始化策略：只有當訪問容器中的某個物件時，才對該物件進行初始化和依賴注入操作。而在實際場景下，我們更多的使用另外一種型別的容器： ApplicationContext，它構建在 BeanFactory 之上，屬於更高階的容器，除了具有 BeanFactory 的所有能力之外，還提供對事件監聽機制以及國際化的支援等。它管理的 bean，在容器啟動時全部完成初始化和依賴注入操作。
1.2、Spring容器擴充套件機制
IoC 容器負責管理容器中所有bean的生命週期，而在 bean 生命週期的不同階段，Spring 提供了不同的擴充套件點來改變 bean 的命運。在容器的啟動階段， BeanFactoryPostProcessor允許我們在容器例項化相應物件之前，對註冊到容器的 BeanDefinition 所儲存的資訊做一些額外的操作，比如修改 bean 定義的某些屬性或者增加其他資訊等。
如果要自定義擴充套件類，通常需要實現 org.springframework.beans.factory.config.BeanFactoryPostProcessor介面，與此同時，因為容器中可能有多個BeanFactoryPostProcessor，可能還需要實現org.springframework.core.Ordered介面，以保證BeanFactoryPostProcessor按照順序執行。Spring提供了為數不多的BeanFactoryPostProcessor實現，我們以 PropertyPlaceholderConfigurer來說明其大致的工作流程。
在Spring專案的XML配置檔案中，經常可以看到許多配置項的值使用佔位符，而將佔位符所代表的值單獨配置到獨立的properties檔案，這樣可以將散落在不同XML檔案中的配置集中管理，而且也方便運維根據不同的環境進行配置不同的值。這個非常實用的功能就是由PropertyPlaceholderConfigurer負責實現的。
根據前文，當BeanFactory在第一階段載入完所有配置資訊時，BeanFactory中儲存的物件的屬性還是以佔位符方式存在的，比如 ${jdbc.mysql.url}。當PropertyPlaceholderConfigurer作為BeanFactoryPostProcessor被應用時，它會使用properties配置檔案中的值來替換相應的BeanDefinition中佔位符所表示的屬性值。當需要例項化bean時，bean定義中的屬性值就已經被替換成我們配置的值。當然其實現比上面描述的要複雜一些，這裡僅說明其大致工作原理，更詳細的實現可以參考其原始碼。
與之相似的，還有 BeanPostProcessor，其存在於物件例項化階段。跟BeanFactoryPostProcessor類似，它會處理容器內所有符合條件並且已經例項化後的物件。簡單的對比，BeanFactoryPostProcessor處理bean的定義，而BeanPostProcessor則處理bean完成例項化後的物件。BeanPostProcessor定義了兩個介面：
為了理解這兩個方法執行的時機，簡單的瞭解下bean的整個生命週期：
postProcessBeforeInitialization()方法與 postProcessAfterInitialization()分別對應圖中前置處理和後置處理兩個步驟將執行的方法。這兩個方法中都傳入了bean物件例項的引用，為擴充套件容器的物件例項化過程提供了很大便利，在這兒幾乎可以對傳入的例項執行任何操作。註解、AOP等功能的實現均大量使用了 BeanPostProcessor，比如有一個自定義註解，你完全可以實現BeanPostProcessor的介面，在其中判斷bean物件的腦袋上是否有該註解，如果有，你可以對這個bean例項執行任何操作，想想是不是非常的簡單？
再來看一個更常見的例子，在Spring中經常能夠看到各種各樣的Aware介面，其作用就是在物件例項化完成以後將Aware介面定義中規定的依賴注入到當前例項中。比如最常見的 ApplicationContextAware介面，實現了這個介面的類都可以獲取到一個ApplicationContext物件。當容器中每個物件的例項化過程走到BeanPostProcessor前置處理這一步時，容器會檢測到之前註冊到容器的ApplicationContextAwareProcessor，然後就會呼叫其postProcessBeforeInitialization()方法，檢查並設定Aware相關依賴。看看程式碼吧，是不是很簡單：
最後總結一下，本小節內容和你一起回顧了Spring容器的部分核心內容，限於篇幅不能寫更多，但理解這部分內容，足以讓您輕鬆理解Spring Boot的啟動原理，如果在後續的學習過程中遇到一些晦澀難懂的知識，再回過頭來看看Spring的核心知識，也許有意想不到的效果。也許Spring Boot的中文資料很少，但Spring的中文資料和書籍有太多太多，總有東西能給你啟發。
二、夯實基礎：JavaConfig與常見Annotation
2.1、JavaConfig
我們知道 bean是Spring IOC/">IOC中非常核心的概念，Spring容器負責bean的生命週期的管理。在最初，Spring使用XML配置檔案的方式來描述bean的定義以及相互間的依賴關係，但隨著Spring的發展，越來越多的人對這種方式表示不滿，因為Spring專案的所有業務類均以bean的形式配置在XML檔案中，造成了大量的XML檔案，使專案變得複雜且難以管理。
後來，基於純Java Annotation依賴注入框架 Guice出世，其效能明顯優於採用XML方式的Spring，甚至有部分人認為， Guice可以完全取代Spring（ Guice僅是一個輕量級IOC框架，取代Spring還差的挺遠）。正是這樣的危機感，促使Spring及社群推出並持續完善了 JavaConfig子專案，它基於Java程式碼和Annotation註解來描述bean之間的依賴繫結關係。比如，下面是使用XML配置方式來描述bean的定義：
而基於JavaConfig的配置形式是這樣的：
如果兩個bean之間有依賴關係的話，在XML配置中應該是這樣：
而在JavaConfig中則是這樣：
你可能注意到這個示例中，有兩個bean都依賴於dependencyService，也就是說當初始化bookService時會呼叫 dependencyService()，在初始化otherService時也會呼叫dependencyService()，那麼問題來了？這時候IOC容器中是有一個dependencyService例項還是兩個？這個問題留著大家思考吧，這裡不再贅述。
2.2、@ComponentScan
@ComponentScan註解對應XML配置形式中的 <context:component-scan>元素，表示啟用元件掃描，Spring會自動掃描所有通過註解配置的bean，然後將其註冊到IOC容器中。我們可以通過 basePackages等屬性來指定 @ComponentScan自動掃描的範圍，如果不指定，預設從宣告 @ComponentScan所在類的 package進行掃描。正因為如此，SpringBoot的啟動類都預設在 src/main/java下。
2.3、@Import
@Import註解用於匯入配置類，舉個簡單的例子：
現在有另外一個配置類，比如： MoonUserConfiguration，這個配置類中有一個bean依賴於 MoonBookConfiguration中的bookService，如何將這兩個bean組合在一起？藉助 @Import即可：
需要注意的是，在4.2之前， @Import註解只支援匯入配置類，但是在4.2之後，它支援匯入普通類，並將這個類作為一個bean的定義註冊到IOC容器中。
2.4、@Conditional
@Conditional註解表示在滿足某種條件後才初始化一個bean或者啟用某些配置。它一般用在由 @Component、 @Service、 @Configuration等註解標識的類上面，或者由 @Bean標記的方法上。如果一個 @Configuration類標記了 @Conditional，則該類中所有標識了 @Bean的方法和 @Import註解匯入的相關類將遵從這些條件。
在Spring裡可以很方便的編寫你自己的條件類，所要做的就是實現 Condition介面，並覆蓋它的 matches()方法。舉個例子，下面的簡單條件類表示只有在 Classpath裡存在 JdbcTemplate類時才生效：
當你用Java來宣告bean的時候，可以使用這個自定義條件類：
這個例子中只有當 JdbcTemplateCondition類的條件成立時才會建立MyService這個bean。也就是說MyService這bean的建立條件是 classpath裡面包含 JdbcTemplate，否則這個bean的宣告就會被忽略掉。
SpringBoot定義了很多有趣的條件，並把他們運用到了配置類上，這些配置類構成了 SpringBoot的自動配置的基礎。 SpringBoot運用條件化配置的方法是：定義多個特殊的條件化註解，並將它們用到配置類上。下面列出了 SpringBoot提供的部分條件化註解：
2.5、@ConfigurationProperties與@EnableConfigurationProperties
當某些屬性的值需要配置的時候，我們一般會在 application.properties檔案中新建配置項，然後在bean中使用 @Value註解來獲取配置的值，比如下面配置資料來源的程式碼。
使用 @Value註解注入的屬性通常都比較簡單，如果同一個配置在多個地方使用，也存在不方便維護的問題（考慮下，如果有幾十個地方在使用某個配置，而現在你想改下名字，你改怎麼做？）。對於更為複雜的配置，Spring Boot提供了更優雅的實現方式，那就是 @ConfigurationProperties註解。我們可以通過下面的方式來改寫上面的程式碼：
@ConfigurationProperties對於更為複雜的配置，處理起來也是得心應手，比如有如下配置檔案：
可以定義如下配置類來接收這些屬性
@EnableConfigurationProperties註解表示對 @ConfigurationProperties的內嵌支援，預設會將對應Properties Class作為bean注入的IOC容器中，即在相應的Properties類上不用加 @Component註解。
三、削鐵如泥：SpringFactoriesLoader詳解
JVM提供了3種類載入器： BootstrapClassLoader、 ExtClassLoader、 AppClassLoader分別載入Java核心類庫、擴充套件類庫以及應用的類路徑( CLASSPATH)下的類庫。JVM通過雙親委派模型進行類的載入，我們也可以通過繼承 java.lang.classloader實現自己的類載入器。
何為雙親委派模型？當一個類載入器收到類載入任務時，會先交給自己的父載入器去完成，因此最終載入任務都會傳遞到最頂層的BootstrapClassLoader，只有當父載入器無法完成載入任務時，才會嘗試自己來載入。
採用雙親委派模型的一個好處是保證使用不同類載入器最終得到的都是同一個物件，這樣就可以保證Java 核心庫的型別安全，比如，載入位於rt.jar包中的 java.lang.Object類，不管是哪個載入器載入這個類，最終都是委託給頂層的BootstrapClassLoader來載入的，這樣就可以保證任何的類載入器最終得到的都是同樣一個Object物件。檢視ClassLoader的原始碼，對雙親委派模型會有更直觀的認識：
但雙親委派模型並不能解決所有的類載入器問題，比如，Java 提供了很多服務提供者介面( ServiceProviderInterface，SPI)，允許第三方為這些介面提供實現。常見的 SPI 有 JDBC、JNDI、JAXP 等，這些SPI的介面由核心類庫提供，卻由第三方實現，這樣就存在一個問題：SPI 的介面是 Java 核心庫的一部分，是由BootstrapClassLoader載入的；SPI實現的Java類一般是由AppClassLoader來載入的。BootstrapClassLoader是無法找到 SPI 的實現類的，因為它只加載Java的核心庫。它也不能代理給AppClassLoader，因為它是最頂層的類載入器。也就是說，雙親委派模型並不能解決這個問題。
執行緒上下文類載入器( ContextClassLoader)正好解決了這個問題。從名稱上看，可能會誤解為它是一種新的類載入器，實際上，它僅僅是Thread類的一個變數而已，可以通過 setContextClassLoader(ClassLoadercl)和 getContextClassLoader()來設定和獲取該物件。如果不做任何的設定，Java應用的執行緒的上下文類載入器預設就是AppClassLoader。在核心類庫使用SPI介面時，傳遞的類載入器使用執行緒上下文類載入器，就可以成功的載入到SPI實現的類。執行緒上下文類載入器在很多SPI的實現中都會用到。但在JDBC中，你可能會看到一種更直接的實現方式，比如，JDBC驅動管理 java.sql.Driver中的 loadInitialDrivers()方法中，你可以直接看到JDK是如何載入驅動的：
其實講解執行緒上下文類載入器，最主要是讓大家在看到 Thread.currentThread().getClassLoader()和 Thread.currentThread().getContextClassLoader()時不會一臉懵逼，這兩者除了在許多底層框架中取得的ClassLoader可能會有所不同外，其他大多數業務場景下都是一樣的，大家只要知道它是為了解決什麼問題而存在的即可。
類載入器除了載入class外，還有一個非常重要功能，就是載入資源，它可以從jar包中讀取任何資原始檔，比如， ClassLoader.getResources(Stringname)方法就是用於讀取jar包中的資原始檔，其程式碼如下：
是不是覺得有點眼熟，不錯，它的邏輯其實跟類載入的邏輯是一樣的，首先判斷父類載入器是否為空，不為空則委託父類載入器執行資源查詢任務，直到BootstrapClassLoader，最後才輪到自己查詢。而不同的類載入器負責掃描不同路徑下的jar包，就如同載入class一樣，最後會掃描所有的jar包，找到符合條件的資原始檔。
類載入器的 findResources(name)方法會遍歷其負責載入的所有jar包，找到jar包中名稱為name的資原始檔，這裡的資源可以是任何檔案，甚至是.class檔案，比如下面的示例，用於查詢Array.class檔案：
執行後可以得到如下結果：
$JAVA_HOME/jre/lib/rt.jar!/java/sql/Array.class
根據資原始檔的URL，可以構造相應的檔案來讀取資源內容。
看到這裡，你可能會感到挺奇怪的，你不是要詳解 SpringFactoriesLoader嗎？上來講了一堆ClassLoader是幾個意思？看下它的原始碼你就知道了：
有了前面關於ClassLoader的知識，再來理解這段程式碼，是不是感覺豁然開朗：從 CLASSPATH下的每個Jar包中搜尋所有 META-INF/spring.factories配置檔案，然後將解析properties檔案，找到指定名稱的配置後返回。需要注意的是，其實這裡不僅僅是會去ClassPath路徑下查詢，會掃描所有路徑下的Jar包，只不過這個檔案只會在Classpath下的jar包中。來簡單看下 spring.factories檔案的內容吧：
執行 loadFactoryNames(EnableAutoConfiguration.class,classLoader)後，得到對應的一組 @Configuration類，
我們就可以通過反射例項化這些類然後注入到IOC容器中，最後容器裡就有了一系列標註了 @Configuration的JavaConfig形式的配置類。
這就是 SpringFactoriesLoader，它本質上屬於Spring框架私有的一種擴充套件方案，類似於SPI，Spring Boot在Spring基礎上的很多核心功能都是基於此，希望大家可以理解。
四、另一件武器：Spring容器的事件監聽機制
過去，事件監聽機制多用於圖形介面程式設計，比如： 點選 按鈕、在文字框 輸入 內容等操作被稱為事件，而當事件觸發時，應用程式作出一定的響應則表示應用監聽了這個事件，而在伺服器端，事件的監聽機制更多的用於非同步通知以及監控和異常處理。Java提供了實現事件監聽機制的兩個基礎類：自定義事件型別擴充套件自java.util.EventObject、事件的監聽器擴充套件自 java.util.EventListener。來看一個簡單的例項：簡單的監控一個方法的耗時。
首先定義事件型別，通常的做法是擴充套件EventObject，隨著事件的發生，相應的狀態通常都封裝在此類中：
事件釋出之後，相應的監聽器即可對該型別的事件進行處理，我們可以在方法開始執行之前釋出一個begin事件，在方法執行結束之後釋出一個end事件，相應地，事件監聽器需要提供方法對這兩種情況下接收到的事件進行處理：
事件監聽器介面針對不同的事件釋出實際提供相應的處理方法定義，最重要的是，其方法只接收MethodMonitorEvent引數，說明這個監聽器類只負責監聽器對應的事件並進行處理。有了事件和監聽器，剩下的就是釋出事件，然後讓相應的監聽器監聽並處理。通常情況，我們會有一個事件釋出者，它本身作為事件源，在合適的時機，將相應的事件釋出給對應的事件監聽器：
對於事件釋出者（事件源）通常需要關注兩點：
在合適的時機發布事件。此例中的methodMonitor()方法是事件釋出的源頭，其在方法執行之前和結束之後兩個時間點發布MethodMonitorEvent事件，每個時間點發布的事件都會傳給相應的監聽器進行處理。在具體實現時需要注意的是，事件釋出是順序執行，為了不影響處理效能，事件監聽器的處理邏輯應儘量簡單。
事件監聽器的管理。publisher類中提供了事件監聽器的註冊與移除方法，這樣客戶端可以根據實際情況決定是否需要註冊新的監聽器或者移除某個監聽器。如果這裡沒有提供remove方法，那麼註冊的監聽器示例將一直被MethodMonitorEventPublisher引用，即使已經廢棄不用了，也依然在釋出者的監聽器列表中，這會導致隱性的記憶體洩漏。
Spring容器內的事件監聽機制
Spring的ApplicationContext容器內部中的所有事件型別均繼承自 org.springframework.context.AppliationEvent，容器中的所有監聽器都實現 org.springframework.context.ApplicationListener介面，並且以bean的形式註冊在容器中。一旦在容器內釋出ApplicationEvent及其子型別的事件，註冊到容器的ApplicationListener就會對這些事件進行處理。
你應該已經猜到是怎麼回事了。
ApplicationEvent繼承自EventObject，Spring提供了一些預設的實現，比如： ContextClosedEvent表示容器在即將關閉時釋出的事件型別， ContextRefreshedEvent表示容器在初始化或者重新整理的時候釋出的事件型別......
容器內部使用ApplicationListener作為事件監聽器介面定義，它繼承自EventListener。ApplicationContext容器在啟動時，會自動識別並載入EventListener型別的bean，一旦容器內有事件釋出，將通知這些註冊到容器的EventListener。
ApplicationContext介面繼承了ApplicationEventPublisher介面，該介面提供了 voidpublishEvent(ApplicationEventevent)方法定義，不難看出，ApplicationContext容器擔當的就是事件釋出者的角色。如果有興趣可以檢視 AbstractApplicationContext.publishEvent(ApplicationEventevent)方法的原始碼：ApplicationContext將事件的釋出以及監聽器的管理工作委託給 ApplicationEventMulticaster介面的實現類。在容器啟動時，會檢查容器內是否存在名為applicationEventMulticaster的ApplicationEventMulticaster物件例項。如果有就使用其提供的實現，沒有就預設初始化一個SimpleApplicationEventMulticaster作為實現。
最後，如果我們業務需要在容器內部發布事件，只需要為其注入ApplicationEventPublisher依賴即可：實現ApplicationEventPublisherAware介面或者ApplicationContextAware介面(Aware介面相關內容請回顧上文)。
五、出神入化：揭祕自動配置原理
典型的Spring Boot應用的啟動類一般均位於 src/main/java根路徑下，比如 MoonApplication類：
其中 @SpringBootApplication開啟元件掃描和自動配置，而 SpringApplication.run則負責啟動引導應用程式。 @SpringBootApplication是一個複合 Annotation，它將三個有用的註解組合在一起：
@SpringBootConfiguration就是 @Configuration，它是Spring框架的註解，標明該類是一個 JavaConfig配置類。而 @ComponentScan啟用元件掃描，前文已經詳細講解過，這裡著重關注 @EnableAutoConfiguration。
@EnableAutoConfiguration註解表示開啟Spring Boot自動配置功能，Spring Boot會根據應用的依賴、自定義的bean、classpath下有沒有某個類 等等因素來猜測你需要的bean，然後註冊到IOC容器中。那 @EnableAutoConfiguration是如何推算出你的需求？首先看下它的定義：
你的關注點應該在 @Import(EnableAutoConfigurationImportSelector.class)上了，前文說過， @Import註解用於匯入類，並將這個類作為一個bean的定義註冊到容器中，這裡它將把 EnableAutoConfigurationImportSelector作為bean注入到容器中，而這個類會將所有符合條件的@Configuration配置都載入到容器中，看看它的程式碼：
這個類會掃描所有的jar包，將所有符合條件的@Configuration配置類注入的容器中，何為符合條件，看看 META-INF/spring.factories的檔案內容：
以 DataSourceAutoConfiguration為例，看看Spring Boot是如何自動配置的：
分別說一說：
@ConditionalOnClass({DataSource.class,EmbeddedDatabaseType.class})：當Classpath中存在DataSource或者EmbeddedDatabaseType類時才啟用這個配置，否則這個配置將被忽略。
@EnableConfigurationProperties(DataSourceProperties.class)：將DataSource的預設配置類注入到IOC容器中，DataSourceproperties定義為：
@Import({Registrar.class,DataSourcePoolMetadataProvidersConfiguration.class})：匯入其他額外的配置，就以 DataSourcePoolMetadataProvidersConfiguration為例吧。
DataSourcePoolMetadataProvidersConfiguration是資料庫連線池提供者的一個配置類，即Classpath中存在 org.apache.tomcat.jdbc.pool.DataSource.class，則使用tomcat-jdbc連線池，如果Classpath中存在 HikariDataSource.class則使用Hikari連線池。
這裡僅描述了DataSourceAutoConfiguration的冰山一角，但足以說明Spring Boot如何利用條件話配置來實現自動配置的。回顧一下， @EnableAutoConfiguration中匯入了EnableAutoConfigurationImportSelector類，而這個類的 selectImports()通過SpringFactoriesLoader得到了大量的配置類，而每一個配置類則根據條件化配置來做出決策，以實現自動配置。
整個流程很清晰，但漏了一個大問題： EnableAutoConfigurationImportSelector.selectImports()是何時執行的？其實這個方法會在容器啟動過程中執行： AbstractApplicationContext.refresh()，更多的細節在下一小節中說明。
六、啟動引導：Spring Boot應用啟動的祕密
6.1 SpringApplication初始化
SpringBoot整個啟動流程分為兩個步驟：初始化一個SpringApplication物件、執行該物件的run方法。看下SpringApplication的初始化流程，SpringApplication的構造方法中呼叫initialize(Object[] sources)方法，其程式碼如下：
privatevoidinitialize(Object[]sources){if(sources!=null&&sources.length>0){this.sources.addAll(Arrays.asList(sources));}// 判斷是否是Web專案this.webEnvironment=deduceWebEnvironment();setInitializers((Collection)getSpringFactoriesInstances(ApplicationContextInitializer.class));setListeners((Collection)getSpringFactoriesInstances(ApplicationListener.class));// 找到入口類this.mainApplicationClass=deduceMainApplicationClass();}
初始化流程中最重要的就是通過SpringFactoriesLoader找到 spring.factories檔案中配置的 ApplicationContextInitializer和 ApplicationListener兩個介面的實現類名稱，以便後期構造相應的例項。ApplicationContextInitializer的主要目的是在 ConfigurableApplicationContext做refresh之前，對ConfigurableApplicationContext例項做進一步的設定或處理。ConfigurableApplicationContext繼承自ApplicationContext，其主要提供了對ApplicationContext進行設定的能力。
實現一個ApplicationContextInitializer非常簡單，因為它只有一個方法，但大多數情況下我們沒有必要自定義一個ApplicationContextInitializer，即便是Spring Boot框架，它預設也只是註冊了兩個實現，畢竟Spring的容器已經非常成熟和穩定，你沒有必要來改變它。
而 ApplicationListener的目的就沒什麼好說的了，它是Spring框架對Java事件監聽機制的一種框架實現，具體內容在前文Spring事件監聽機制這個小節有詳細講解。這裡主要說說，如果你想為Spring Boot應用新增監聽器，該如何實現？
Spring Boot提供兩種方式來新增自定義監聽器：
通過SpringApplication.addListeners(ApplicationListener<?>...listeners)或者SpringApplication.setListeners(Collection<?extendsApplicationListener<?>>listeners)兩個方法來新增一個或者多個自定義監聽器
既然SpringApplication的初始化流程中已經從spring.factories中獲取到ApplicationListener的實現類，那麼我們直接在自己的jar包的META-INF/spring.factories檔案中新增配置即可：
org.springframework.context.ApplicationListener=\
cn.moondev.listeners.xxxxListener\
關於SpringApplication的初始化，我們就說這麼多。
6.2 Spring Boot啟動流程
Spring Boot應用的整個啟動流程都封裝在SpringApplication.run方法中，其整個流程真的是太長太長了，但本質上就是在Spring容器啟動的基礎上做了大量的擴充套件，按照這個思路來看看原始碼：
publicConfigurableApplicationContextrun(String...args){StopWatch stopWatch=newStopWatch();stopWatch.start();ConfigurableApplicationContext context=null;FailureAnalyzers analyzers=null;configureHeadlessProperty();// ①SpringApplicationRunListeners listeners=getRunListeners(args);listeners.starting();try{// ②ApplicationArguments applicationArguments=newDefaultApplicationArguments(args);ConfigurableEnvironment environment=prepareEnvironment(listeners,applicationArguments);// ③Banner printedBanner=printBanner(environment);// ④context=createApplicationContext();// ⑤analyzers=newFailureAnalyzers(context);// ⑥prepareContext(context,environment,listeners,applicationArguments,printedBanner);// ⑦ refreshContext(context);// ⑧afterRefresh(context,applicationArguments);// ⑨listeners.finished(context,null);stopWatch.stop();returncontext;}catch(Throwableex){handleRunFailure(context,listeners,analyzers,ex);thrownewIllegalStateException(ex);}}
① 通過SpringFactoriesLoader查詢並載入所有的 SpringApplicationRunListeners，通過呼叫starting()方法通知所有的SpringApplicationRunListeners：應用開始啟動了。SpringApplicationRunListeners其本質上就是一個事件釋出者，它在SpringBoot應用啟動的不同時間點發布不同應用事件型別(ApplicationEvent)，如果有哪些事件監聽者(ApplicationListener)對這些事件感興趣，則可以接收並且處理。還記得初始化流程中，SpringApplication載入了一系列ApplicationListener嗎？這個啟動流程中沒有發現有釋出事件的程式碼，其實都已經在SpringApplicationRunListeners這兒實現了。
簡單的分析一下其實現流程，首先看下SpringApplicationRunListener的原始碼：
publicinterfaceSpringApplicationRunListener{// 執行run方法時立即呼叫此方法，可以使用者非常早期的初始化工作voidstarting();// Environment準備好後，並且ApplicationContext建立之前呼叫voidenvironmentPrepared(ConfigurableEnvironment environment);// ApplicationContext建立好後立即呼叫voidcontextPrepared(ConfigurableApplicationContext context);// ApplicationContext載入完成，在refresh之前呼叫voidcontextLoaded(ConfigurableApplicationContext context);// 當run方法結束之前呼叫voidfinished(ConfigurableApplicationContext context,Throwable exception);}
SpringApplicationRunListener只有一個實現類： EventPublishingRunListener。①處的程式碼只會獲取到一個EventPublishingRunListener的例項，我們來看看starting()方法的內容：
publicvoidstarting(){// 釋出一個ApplicationStartedEventthis.initialMulticaster.multicastEvent(newApplicationStartedEvent(this.application,this.args));}
順著這個邏輯，你可以在②處的 prepareEnvironment()方法的原始碼中找到 listeners.environmentPrepared(environment);即SpringApplicationRunListener介面的第二個方法，那不出你所料， environmentPrepared()又釋出了另外一個事件 ApplicationEnvironmentPreparedEvent。接下來會發生什麼，就不用我多說了吧。
② 建立並配置當前應用將要使用的 Environment，Environment用於描述應用程式當前的執行環境，其抽象了兩個方面的內容：配置檔案(profile)和屬性(properties)，開發經驗豐富的同學對這兩個東西一定不會陌生：不同的環境(eg：生產環境、預釋出環境)可以使用不同的配置檔案，而屬性則可以從配置檔案、環境變數、命令列引數等來源獲取。因此，當Environment準備好後，在整個應用的任何時候，都可以從Environment中獲取資源。
總結起來，②處的兩句程式碼，主要完成以下幾件事：
判斷Environment是否存在，不存在就建立（如果是web專案就建立StandardServletEnvironment，否則建立StandardEnvironment）
配置Environment：配置profile以及properties
呼叫SpringApplicationRunListener的environmentPrepared()方法，通知事件監聽者：應用的Environment已經準備好
③、SpringBoot應用在啟動時會輸出這樣的東西：
. ____ _ __ _ _
/\\ / ___'_ __ _ _(_)_ __ __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
\\/ ___)| |_)| | | | | || (_| | ) ) ) )
' |____| .__|_| |_|_| |_\__, | / / / /
=========|_|==============|___/=/_/_/_/
:: Spring Boot :: (v1.5.6.RELEASE)
如果想把這個東西改成自己的塗鴉，你可以研究以下Banner的實現，這個任務就留給你們吧。
④、根據是否是web專案，來建立不同的ApplicationContext容器。
⑤、建立一系列 FailureAnalyzer，建立流程依然是通過SpringFactoriesLoader獲取到所有實現FailureAnalyzer介面的class，然後在建立對應的例項。FailureAnalyzer用於分析故障並提供相關診斷資訊。
⑥、初始化ApplicationContext，主要完成以下工作：
將準備好的Environment設定給ApplicationContext
遍歷呼叫所有的ApplicationContextInitializer的initialize()方法來對已經建立好的ApplicationContext進行進一步的處理
呼叫SpringApplicationRunListener的contextPrepared()方法，通知所有的監聽者：ApplicationContext已經準備完畢
將所有的bean載入到容器中
呼叫SpringApplicationRunListener的contextLoaded()方法，通知所有的監聽者：ApplicationContext已經裝載完畢
⑦、呼叫ApplicationContext的 refresh()方法，完成IoC容器可用的最後一道工序。從名字上理解為重新整理容器，那何為重新整理？就是插手容器的啟動，聯絡一下第一小節的內容。那如何重新整理呢？且看下面程式碼：
// 摘自refresh()方法中一句程式碼invokeBeanFactoryPostProcessors(beanFactory);
看看這個方法的實現：
protectedvoidinvokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory){PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory,getBeanFactoryPostProcessors());......}
獲取到所有的 BeanFactoryPostProcessor來對容器做一些額外的操作。BeanFactoryPostProcessor允許我們在容器例項化相應物件之前，對註冊到容器的BeanDefinition所儲存的資訊做一些額外的操作。這裡的getBeanFactoryPostProcessors()方法可以獲取到3個Processor：
ConfigurationWarningsApplicationContextInitializer$ConfigurationWarningsPostProcessor
SharedMetadataReaderFactoryContextInitializer$CachingMetadataReaderFactoryPostProcessor
ConfigFileApplicationListener$PropertySourceOrderingPostProcessor
不是有那麼多BeanFactoryPostProcessor的實現類，為什麼這兒只有這3個？因為在初始化流程獲取到的各種ApplicationContextInitializer和ApplicationListener中，只有上文3個做了類似於如下操作：
publicvoidinitialize(ConfigurableApplicationContext context){context.addBeanFactoryPostProcessor(newConfigurationWarningsPostProcessor(getChecks()));}
然後你就可以進入到 PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors()方法了，這個方法除了會遍歷上面的3個BeanFactoryPostProcessor處理外，還會獲取型別為 BeanDefinitionRegistryPostProcessor的bean： org.springframework.context.annotation.internalConfigurationAnnotationProcessor，對應的Class為 ConfigurationClassPostProcessor。 ConfigurationClassPostProcessor用於解析處理各種註解，包括：@Configuration、@ComponentScan、@Import、@PropertySource、@ImportResource、@Bean。當處理 @import註解的時候，就會呼叫<自動配置>這一小節中的 EnableAutoConfigurationImportSelector.selectImports()來完成自動配置功能。其他的這裡不再多講，如果你有興趣，可以查閱參考資料6。
⑧、查詢當前context中是否註冊有CommandLineRunner和ApplicationRunner，如果有則遍歷執行它們。
⑨、執行所有SpringApplicationRunListener的finished()方法。
這就是Spring Boot的整個啟動流程，其核心就是在Spring容器初始化並啟動的基礎上加入各種擴充套件點，這些擴充套件點包括：ApplicationContextInitializer、ApplicationListener以及各種BeanFactoryPostProcessor等等。你對整個流程的細節不必太過關注，甚至沒弄明白也沒有關係，你只要理解這些擴充套件點是在何時如何工作的，能讓它們為你所用即可。
整個啟動流程確實非常複雜，可以查詢參考資料中的部分章節和內容，對照著原始碼，多看看，我想最終你都能弄清楚的。言而總之，Spring才是核心，理解清楚Spring容器的啟動流程，那Spring Boot啟動流程就不在話下了。
歡迎工作一到五年的Java工程師朋友們加入Java填坑之路：860113481
群內提供免費的Java架構學習資料（裡面有高可用、高併發、高效能及分散式、Jvm效能調優、Spring原始碼，MyBatis，Netty,Redis,Kafka,Mysql,Zookeeper,Tomcat,Docker,Dubbo,Nginx等多個知識點的架構資料）合理利用自己每一分每一秒的時間來學習提升自己，不要再用"沒有時間“來掩飾自己思想上的懶惰！趁年輕，使勁拼，給未來的自己一個交代！