給你一份超詳細 Spring Boot 知識清單

作者：CHEN川
https://www.jianshu.com/p/83693d3d0a65

在過去兩三年的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的注冊以及管理作業，它們之間的關系就如下圖：

BeanFactory、BeanDefinitionRegistry關系圖（來自：Spring揭秘）

DefaultListableBeanFactory作為一個比較通用的BeanFactory實作，它同時也實作了BeanDefinitionRegistry介面，因此它就承擔了Bean的注冊管理作業，從圖中也可以看出，BeanFactory介面中主要包含getBean、containBean、getType、getAliases等管理bean的方法，而BeanDefinitionRegistry介面則包含registerBeanDefinition、removeBeanDefinition、getBeanDefinition等注冊管理BeanDefinition的方法，

下面通過一段簡單的代碼來模擬BeanFactory底層是如何作業的：

這段代碼僅為了說明BeanFactory底層的大致作業流程，實際情況會更加復雜，比如bean之間的依賴關系可能定義在外部組態檔(XML/Properties)中、也可能是注解方式，Spring IoC容器的整個作業流程大致可以分為兩個階段：

①、容器啟動階段

容器啟動時，會通過某種途徑加載 ConfigurationMetaData，除了代碼方式比較直接外，在大部分情況下，容器需要依賴某些工具類，比如： BeanDefinitionReader，BeanDefinitionReader會對加載的 ConfigurationMetaData進行決議和分析，并將分析后的資訊組裝為相應的BeanDefinition，最后把這些保存了bean定義的BeanDefinition，注冊到相應的BeanDefinitionRegistry，這樣容器的啟動作業就完成了，這個階段主要完成一些準備性作業，更側重于bean物件管理資訊的收集，當然一些驗證性或者輔助性的作業也在這一階段完成，

來看一個簡單的例子吧，過往，所有的bean都定義在XML組態檔中，下面的代碼將模擬BeanFactory如何從組態檔中加載bean的定義以及依賴關系：

②、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的整個生命周期：

Bean的實體化程序（來自：Spring揭秘）

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中非常核心的概念，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注解，《Spring Boot 配置加載順序詳解》了解一下，

三、削鐵如泥：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檔案：

運行后可以得到如下結果：

根據資源檔案的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引數，說明這個監聽器類只負責監聽器對應的事件并進行處理，有了事件和監聽器，剩下的就是發布事件，然后讓相應的監聽器監聽并處理，通常情況，我們會有一個事件發布者，它本身作為事件源，在合適的時機，將相應的事件發布給對應的事件監聽器：

對于事件發布者（事件源）通常需要關注兩點：

1. 在合適的時機發布事件，此例中的methodMonitor()方法是事件發布的源頭，其在方法執行之前和結束之后兩個時間點發布MethodMonitorEvent事件，每個時間點發布的事件都會傳給相應的監聽器進行處理，在具體實作時需要注意的是，事件發布是順序執行，為了不影響處理性能，事件監聽器的處理邏輯應盡量簡單，

2. 事件監聽器的管理，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)方法，其代碼如下：

初始化流程中最重要的就是通過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>listeners)兩個方法來添加一個或者多個自定義監聽器

• 既然SpringApplication的初始化流程中已經從 spring.factories中獲取到 ApplicationListener的實作類，那么我們直接在自己的jar包的 META-INF/spring.factories檔案中新增配置即可：

關于SpringApplication的初始化，我們就說這么多，

6.2 Spring Boot啟動流程

Spring Boot應用的整個啟動流程都封裝在SpringApplication.run方法中，其整個流程真的是太長太長了，但本質上就是在Spring容器啟動的基礎上做了大量的擴展，按照這個思路來看看原始碼：

① 通過SpringFactoriesLoader查找并加載所有的 SpringApplicationRunListeners，通過呼叫starting()方法通知所有的SpringApplicationRunListeners：應用開始啟動了，SpringApplicationRunListeners其本質上就是一個事件發布者，它在SpringBoot應用啟動的不同時間點發布不同應用事件型別(ApplicationEvent)，如果有哪些事件監聽者(ApplicationListener)對這些事件感興趣，則可以接收并且處理，還記得初始化流程中，SpringApplication加載了一系列ApplicationListener嗎？這個啟動流程中沒有發現有發布事件的代碼，其實都已經在SpringApplicationRunListeners這兒實作了，

簡單的分析一下其實作流程，首先看下SpringApplicationRunListener的原始碼：

SpringApplicationRunListener只有一個實作類： EventPublishingRunListener，①處的代碼只會獲取到一個EventPublishingRunListener的實體，我們來看看starting()方法的內容：

順著這個邏輯，你可以在②處的 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應用在啟動時會輸出這樣的東西：

如果想把這個東西改成自己的涂鴉，你可以研究以下Banner的實作，這個任務就留給你們吧，

④、根據是否是web專案，來創建不同的ApplicationContext容器，

⑤、創建一系列 FailureAnalyzer，創建流程依然是通過SpringFactoriesLoader獲取到所有實作FailureAnalyzer介面的class，然后在創建對應的實體，FailureAnalyzer用于分析故障并提供相關診斷資訊，

⑥、初始化ApplicationContext，主要完成以下作業：

• 將準備好的Environment設定給ApplicationContext

• 遍歷呼叫所有的ApplicationContextInitializer的 initialize()方法來對已經創建好的ApplicationContext進行進一步的處理

• 呼叫SpringApplicationRunListener的 contextPrepared()方法，通知所有的監聽者：ApplicationContext已經準備完畢

• 將所有的bean加載到容器中

• 呼叫SpringApplicationRunListener的 contextLoaded()方法，通知所有的監聽者：ApplicationContext已經裝載完畢

⑦、呼叫ApplicationContext的 refresh()方法，完成IoC容器可用的最后一道工序，從名字上理解為重繪容器，那何為重繪？就是插手容器的啟動，聯系一下第一小節的內容，那如何重繪呢？且看下面代碼：

看看這個方法的實作：

獲取到所有的 BeanFactoryPostProcessor來對容器做一些額外的操作，BeanFactoryPostProcessor允許我們在容器實體化相應物件之前，對注冊到容器的BeanDefinition所保存的資訊做一些額外的操作，這里的getBeanFactoryPostProcessors()方法可以獲取到3個Processor：

不是有那么多BeanFactoryPostProcessor的實作類，為什么這兒只有這3個？因為在初始化流程獲取到的各種ApplicationContextInitializer和ApplicationListener中，只有上文3個做了類似于如下操作：

然后你就可以進入到 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啟動流程就不在話下了，

推薦去我的博客閱讀更多：

1.Java JVM、集合、多執行緒、新特性系列教程

2.Spring MVC、Spring Boot、Spring Cloud 系列教程

3.Maven、Git、Eclipse、Intellij IDEA 系列工具教程

4.Java、后端、架構、阿里巴巴等大廠最新面試題

覺得不錯，別忘了點贊+轉發哦！

標籤：Java

上一篇：Spring+SpringMVC+Mybatis組態檔

下一篇：idea為代碼添加標簽清除標簽