最棒 Spring Boot 乾貨總結（超詳細，建議收藏）

前言：本文非常長，建議先mark後看，也許是最後一次寫這麼長的文章

說明：前面有4個小節關於Spring的基礎知識

分別是：IOC容器、JavaConfig、事件監聽、SpringFactoriesLoader詳解

它們佔據了本文的大部分內容：

雖然它們之間可能沒有太多的聯絡，但這些知識對於理解Spring Boot的核心原理至關重要，如果你對Spring框架爛熟於心，完全可以跳過這4個小節。正是因為這個系列的文章是由這些看似不相關的知識點組成，因此取名知識清單。

在過去兩三年的Spring生態圈，最讓人興奮的莫過於Spring Boot框架。或許從命名上就能看出這個框架的設計初衷：快速的啟動Spring應用。因而Spring Boot應用本質上就是一個基於Spring框架的應用，它是Spring對“約定優先於配置”理念的最佳實踐產物，它能夠幫助開發者更快速高效地構建基於Spring生態圈的應用。

那Spring Boot有何魔法？

自動配置、起步依賴、Actuator、命令列介面(CLI) 是Spring Boot最重要的4大核心特性，其中CLI是Spring Boot的可選特性，雖然它功能強大，但也引入了一套不太常規的開發模型，因而這個系列的文章僅關注其它3種特性。如文章標題，本文是這個系列的第一部分，將為你開啟Spring Boot的大門，重點為你剖析其啟動流程以及自動配置實現原理。要掌握這部分核心內容，理解一些Spring框架的基礎知識，將會讓你事半功倍。

我把 Spring Boot 相關的文章整理成了 PDF，關注公眾號 Java後端 並回復 666 下載。

一、拋磚引玉：探索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底層是如何工作的：

// 預設容器實現
 DefaultListableBeanFactory beanRegistry = new DefaultListableBeanFactory();
 // 根據業務物件構造相應的BeanDefinition
 AbstractBeanDefinition definition = new RootBeanDefinition(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容器的整個工作流程大致可以分為兩個階段：

①、容器啟動階段

容器啟動時，會通過某種途徑載入Configuration MetaData。除了程式碼方式比較直接外，在大部分情況下，容器需要依賴某些工具類，比如：BeanDefinitionReader，BeanDefinitionReader會對載入的Configuration MetaData進行解析和分析，並將分析後的資訊組裝為相應的BeanDefinition，最後把這些儲存了bean定義的BeanDefinition，註冊到相應的BeanDefinitionRegistry，這樣容器的啟動工作就完成了。

這個階段主要完成一些準備性工作，更側重於bean物件管理資訊的收集，當然一些驗證性或者輔助性的工作也在這一階段完成。

來看一個簡單的例子吧，過往，所有的bean都定義在XML配置檔案中，下面的程式碼將模擬

BeanFactory如何從配置檔案中載入bean的定義以及依賴關係：

// 通常為BeanDefinitionRegistry的實現類，這裡以DeFaultListabeBeanFactory為例
 BeanDefinitionRegistry beanRegistry = new DefaultListableBeanFactory();
  // XmlBeanDefinitionReader實現了BeanDefinitionReader介面，用於解析XML檔案
 XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReaderImpl(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定義了兩個介面：

// 通常為BeanDefinitionRegistry的實現類，這裡以DeFaultListabeBeanFactory為例
 BeanDefinitionRegistry beanRegistry = new DefaultListableBeanFactory();
  // XmlBeanDefinitionReader實現了BeanDefinitionReader介面，用於解析XML檔案
 XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReaderImpl(beanRegistry);
 // 載入配置檔案 beanDefinitionReader.loadBeanDefinitions("classpath:spring-bean.xml");
  // 從容器中獲取bean例項
 BeanFactory container = (BeanFactory)beanRegistry;
 Business business = (Business)container.getBean("beanName");

為了理解這兩個方法執行的時機，簡單的瞭解下bean的整個生命週期：

 

Bean的例項化過程（來自：Spring揭祕）

postProcessBeforeInitialization()方法與postProcessAfterInitialization()分別對應圖中前置處理和後置處理兩個步驟將執行的方法。這兩個方法中都傳入了bean物件例項的引用，為擴充套件容器的物件例項化過程提供了很大便利，在這兒幾乎可以對傳入的例項執行任何操作。

註解、AOP等功能的實現均大量使用了BeanPostProcessor，比如有一個自定義註解，你完全可以實現BeanPostProcessor的介面，在其中判斷bean物件的腦袋上是否有該註解，如果有，你可以對這個bean例項執行任何操作，想想是不是非常的簡單？

再來看一個更常見的例子，在Spring中經常能夠看到各種各樣的Aware介面，其作用就是在物件例項化完成以後將Aware介面定義中規定的依賴注入到當前例項中。

比如最常見的ApplicationContextAware介面，實現了這個介面的類都可以獲取到一個ApplicationContext物件。當容器中每個物件的例項化過程走到BeanPostProcessor前置處理這一步時，容器會檢測到之前註冊到容器的ApplicationContextAwareProcessor，然後就會呼叫其postProcessBeforeInitialization()方法，檢查並設定Aware相關依賴。

看看程式碼吧，是不是很簡單：

// 程式碼來自：org.springframework.context.support.ApplicationContextAwareProcessor
 // 其postProcessBeforeInitialization方法呼叫了invokeAwareInterfaces方法
 private void invokeAwareInterfaces(Object bean){
     if (bean instanceof EnvironmentAware){
         ((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());
     }
     if (bean instanceof ApplicationContextAware){
         ((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);
     }
     // ......
}

最後總結一下，本小節內容和你一起回顧了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的定義：

<bean id="bookService" class="cn.moondev.service.BookServiceImpl"></bean>

而基於JavaConfig的配置形式是這樣的：

@Configuration
 public class
 MoonBookConfiguration
 {
      // 任何標誌了@Bean的方法，其返回值將作為一個bean註冊到Spring的IOC容器中
     // 方法名預設成為該bean定義的id
     @Bean
     public BookService bookService() {
         return new BookServiceImpl();
     }
 }

如果兩個bean之間有依賴關係的話，在XML配置中應該是這樣：

<bean id="bookService" class="cn.moondev.service.BookServiceImpl">
     <property name="dependencyService" ref="dependencyService"/>
 </bean>

  <bean id="otherService" class="cn.moondev.service.OtherServiceImpl">
     <property name="dependencyService" ref="dependencyService"/>
 </bean>

  <bean id="dependencyService" class="DependencyServiceImpl"/>

而在JavaConfig中則是這樣：

@Configuration
 public class MoonBookConfiguration {
      // 如果一個bean依賴另一個bean，則直接呼叫對應JavaConfig類中依賴bean的建立方法即可
     // 這裡直接呼叫dependencyService()
     @Bean
     public BookService bookService() {
         return new BookServiceImpl(dependencyService());
     }
      @Bean
     public OtherService otherService() {
         return new OtherServiceImpl(dependencyService());
     }
      @Bean
     public DependencyService dependencyService() {
         return new DependencyServiceImpl();
     }
 }

你可能注意到這個示例中，有兩個bean都依賴於dependencyService，也就是說當初始化bookService時會呼叫dependencyService()，在初始化otherService時也會呼叫dependencyService()，那麼問題來了？

這時候IOC容器中是有一個dependencyService例項還是兩個？這個問題留著大家思考吧，這裡不再贅述。

2.2、@ComponentScan

@ComponentScan註解對應XML配置形式中的元素表示啟用元件掃描，Spring會自動掃描所有通過註解配置的bean，然後將其註冊到IOC容器中。

我們可以通過basePackages等屬性來指定@ComponentScan自動掃描的範圍，如果不指定，預設從宣告@ComponentScan所在類的package進行掃描。正因為如此，SpringBoot的啟動類都預設在src/main/java下。

2.3、@Import

@Import註解用於匯入配置類，舉個簡單的例子：

@Configuration
 public class MoonBookConfiguration{
     @Bean
     public BookService bookService() {
         return new BookServiceImpl();
     }
 }

現在有另外一個配置類，比如：MoonUserConfiguration，這個配置類中有一個bean依賴於MoonBookConfiguration中的bookService，如何將這兩個bean組合在一起？

藉助@Import即可：

@Configuration
 // 可以同時匯入多個配置類，比如：@Import({A.class,B.class})
 @Import(MoonBookConfiguration.class)
 public class MoonUserConfiguration
 {
     @Bean
     public UserService userService(BookService bookService) {
         return new BookServiceImpl(bookService);
     }
 }

需要注意的是，在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類時才生效:

public class JdbcTemplateCondition implements Condition {

      @Override
     public boolean matches(ConditionContext
 conditionContext, AnnotatedTypeMetadata annotatedTypeMetadata) {
         try {
         conditionContext.getClassLoader().loadClass("org.springframework.jdbc.core.JdbcTemplate");
             return true;
         }
 catch (ClassNotFoundException e) {
             e.printStackTrace();
         }
         return false;
     }
 }

當你用Java來宣告bean的時候，可以使用這個自定義條件類：

@Conditional(JdbcTemplateCondition.class) @Service public MyService service() { ...... }

這個例子中只有當JdbcTemplateCondition類的條件成立時才會建立MyService這個bean。

也就是說MyService這bean的建立條件是classpath裡面包含JdbcTemplate，否則這個bean的宣告就會被忽略掉。

Spring Boot定義了很多有趣的條件，並把他們運用到了配置類上，這些配置類構成了Spring Boot的自動配置的基礎。

Spring Boot運用條件化配置的方法是：定義多個特殊的條件化註解，並將它們用到配置類上。

下面列出了Spring Boot提供的部分條件化註解：

 

2.5、@ConfigurationProperties與@EnableConfigurationProperties

當某些屬性的值需要配置的時候，我們一般會在application.properties檔案中新建配置項，然後在bean中使用@Value註解來獲取配置的值，比如下面配置資料來源的程式碼。

// jdbc config
 jdbc.mysql.url=jdbc:mysql://localhost:3306/sampledb
 jdbc.mysql.username=root
 jdbc.mysql.password=123456
 ......

  // 配置資料來源
 @Configuration
 public class HikariDataSourceConfiguration {

      @Value("jdbc.mysql.url")
     public String url;
     @Value("jdbc.mysql.username")
     public String user;
     @Value("jdbc.mysql.password")
     public String password;

          @Bean
     public HikariDataSource dataSource() {
         HikariConfig hikariConfig = new HikariConfig();
         hikariConfig.setJdbcUrl(url);
         hikariConfig.setUsername(user);
         hikariConfig.setPassword(password);
         // 省略部分程式碼
         return new HikariDataSource(hikariConfig);
     }
 }

使用@Value註解注入的屬性通常都比較簡單，如果同一個配置在多個地方使用，也存在不方便維護的問題（考慮下，如果有幾十個地方在使用某個配置，而現在你想改下名字，你改怎麼做？）

對於更為複雜的配置，Spring Boot提供了更優雅的實現方式,那就是@ConfigurationProperties註解。

我們可以通過下面的方式來改寫上面的程式碼：

@Component
 // 還可以通過@PropertySource("classpath:jdbc.properties")來指定配置檔案
 @ConfigurationProperties("jdbc.mysql")
 // 字首=jdbc.mysql，會在配置檔案中尋找jdbc.mysql.*的配置項
 pulic class JdbcConfig {
     public String url;
     public String username;
     public String password;
 }
  @Configuration
 public class HikariDataSourceConfiguration {

      @AutoWired
     public JdbcConfig config;

          @Bean
     public HikariDataSource dataSource() {
         HikariConfig hikariConfig = new HikariConfig();
         hikariConfig.setJdbcUrl(config.url);
         hikariConfig.setUsername(config.username);
         hikariConfig.setPassword(config.password);
         // 省略部分程式碼
         return new HikariDataSource(hikariConfig);
   }
 }

@ConfigurationProperties對於更為複雜的配置，處理起來也是得心應手，比如有如下配置檔案：

#App
 app.menus[0].title=Home
 app.menus[0].name=Home
 app.menus[0].path=/
 app.menus[1].title=Login
 app.menus[1].name=Login
 app.menus[1].path=/login

  app.compiler.timeout=5
 app.compiler.output-folder=/temp/

  app.error=/error/

可以定義如下配置類來接收這些屬性：

@Component
 @ConfigurationProperties("app")
 public class AppProperties {

      public String error;
     public List<Menu> menus = new ArrayList<>();
     public Compiler compiler = new Compiler();

      public static class Menu {
         public String name;
         public String path;
         public String title;
     }
      public static class Compiler {
         public String timeout;
         public String outputFolder;
     }
 }

@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的原始碼，對雙親委派模型會有更直觀的認識：

protected Class<?> loadClass(String name, boolean resolve) {
     synchronized (getClassLoadingLock(name)) {
     // 首先，檢查該類是否已經被載入，如果從JVM快取中找到該類，則直接返回
     Class<?> c = findLoadedClass(name);
     if (c == null) {
         try {
             // 遵循雙親委派的模型，首先會通過遞迴從父載入器開始找，
             // 直到父類載入器是BootstrapClassLoader為止
             if (parent != null) {
                 c = parent.loadClass(name, false);
             } else {
                 c = findBootstrapClassOrNull(name);
             }
        } catch (ClassNotFoundException e) {}
         if (c == null) {
             // 如果還找不到，嘗試通過findClass方法去尋找
             // findClass是留給開發者自己實現的，也就是說
             // 自定義類載入器時，重寫此方法即可
            c = findClass(name);
         }
     }
     if (resolve) {
        resolveClass(c);
     }
     return c;
     }
 }

但雙親委派模型並不能解決所有的類載入器問題，比如，Java 提供了很多服務提供者介面(Service Provider Interface，SPI)，允許第三方為這些介面提供實現。

常見的 SPI 有 JDBC、JNDI、JAXP 等，這些SPI的介面由核心類庫提供，卻由第三方實現這樣就存在一個問題：SPI 的介面是 Java 核心庫的一部分，是由BootstrapClassLoader載入的；SPI實現的Java類一般是由AppClassLoader來載入的。BootstrapClassLoader是無法找到 SPI 的實現類的，因為它只載入Java的核心庫。它也不能代理給AppClassLoader，因為它是最頂層的類載入器。也就是說，雙親委派模型並不能解決這個問題。

執行緒上下文類載入器(ContextClassLoader)正好解決了這個問題。

從名稱上看，可能會誤解為它是一種新的類載入器，實際上，它僅僅是Thread類的一個變數而已，可以通過setContextClassLoader(ClassLoader cl)和getContextClassLoader()來設定和獲取該物件。

如果不做任何的設定，Java應用的執行緒的上下文類載入器預設就是AppClassLoader。

在核心類庫使用SPI介面時，傳遞的類載入器使用執行緒上下文類載入器，就可以成功的載入到SPI實現的類。

 

執行緒上下文類載入器在很多SPI的實現中都會用到。但在JDBC中，你可能會看到一種更直接的實現方式，比如，JDBC驅動管理java.sql.Driver中的loadInitialDrivers()方法中

你可以直接看到JDK是如何載入驅動的：

for (String aDriver : driversList) {
     try {
         // 直接使用AppClassLoader
         Class.forName(aDriver, true, ClassLoader.getSystemClassLoader());
     } catch (Exception ex) {
         println("DriverManager.Initialize: load failed: " + ex);
      }
   }

其實講解執行緒上下文類載入器，最主要是讓大家在看到：

Thread.currentThread().getClassLoader()Thread.currentThread().getContextClassLoader()

時不會一臉懵逼.

這兩者除了在許多底層框架中取得的ClassLoader可能會有所不同外，其他大多數業務場景下都是一樣的，大家只要知道它是為了解決什麼問題而存在的即可。

類載入器除了載入class外，還有一個非常重要功能，就是載入資源，它可以從jar包中讀取任何資原始檔，比如，ClassLoader.getResources(String name)方法就是用於讀取jar包中的資原始檔，其程式碼如下：

public Enumeration<URL> getResources(String name) throws IOException {
     Enumeration<URL>[] tmp = (Enumeration<URL>[]) new Enumeration<?>[2];
     if (parent != null) {
         tmp[0] = parent.getResources(name);
     } else {
         tmp[0] = getBootstrapResources(name);
     }
     tmp[1] = findResources(name);
     return new CompoundEnumeration<>(tmp);
 }

是不是覺得有點眼熟，不錯，它的邏輯其實跟類載入的邏輯是一樣的,首先判斷父類載入器是否為空，不為空則委託父類載入器執行資源查詢任務, 直到BootstrapClassLoader，最後才輪到自己查詢。

而不同的類載入器負責掃描不同路徑下的jar包，就如同載入class一樣，最後會掃描所有的jar包，找到符合條件的資原始檔。

類載入器的findResources(name)方法會遍歷其負責載入的所有jar包，找到jar包中名稱為name的資原始檔，這裡的資源可以是任何檔案，甚至是.class檔案，比如下面的示例，用於查詢Array.class檔案：

// 尋找Array.class檔案
 public static void main(String[] args) throws Exception{
     // Array.class的完整路徑
     String name = "java/sql/Array.class";
     Enumeration<URL> urls = Thread.currentThread().getContextClassLoader().getResources(name);
     while (urls.hasMoreElements()) {
         URL url = urls.nextElement();
         System.out.println(url.toString());
     }
 }

執行後可以得到如下結果：

$JAVA_HOME/jre/lib/rt.jar!/java/sql/Array.class

根據資原始檔的URL，可以構造相應的檔案來讀取資源內容。

看到這裡，你可能會感到挺奇怪的，你不是要詳解SpringFactoriesLoader嗎？

上來講了一ClassLoader是幾個意思？看下它的原始碼你就知道了：

public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";
 // spring.factories檔案的格式為：key=value1,value2,value3
 // 從所有的jar包中找到META-INF/spring.factories檔案
 // 然後從檔案中解析出key=factoryClass類名稱的所有value值
 public static List<String> loadFactoryNames(Class<?> factoryClass, ClassLoader classLoader) {
     String factoryClassName = factoryClass.getName();
     // 取得資原始檔的URL
     Enumeration<URL> urls = (classLoader != null ? classLoader.getResources(FACTORIES_RESOURCE_LOCATION) : ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));
     List<String> result = new ArrayList<String>();
     // 遍歷所有的URL
     while (urls.hasMoreElements()) {
         URL url = urls.nextElement();
         // 根據資原始檔URL解析properties檔案
         Properties properties = PropertiesLoaderUtils.loadProperties(new UrlResource(url));
         String factoryClassNames = properties.getProperty(factoryClassName);
         // 組裝資料，並返回
         result.addAll(Arrays.asList(StringUtils.commaDelimitedListToStringArray(factoryClassNames)));
     }
     return result;
 }

有了前面關於ClassLoader的知識，再來理解這段程式碼，是不是感覺豁然開朗：

從CLASSPATH下的每個Jar包中搜尋所有META-INF/spring.factories配置檔案，然後將解析properties檔案，找到指定名稱的配置後返回。

需要注意的是，其實這裡不僅僅是會去ClassPath路徑下查詢，會掃描所有路徑下的Jar包，只不過這個檔案只會在Classpath下的jar包中。

來簡單看下spring.factories檔案的內容吧：

// 來自 org.springframework.boot.autoconfigure下的META-INF/spring.factories
 // EnableAutoConfiguration後文會講到，它用於開啟Spring Boot自動配置功能
 org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
 org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\
 org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\
 org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration\

執行loadFactoryNames(EnableAutoConfiguration.class, classLoader)後，得到對應的一組@Configuration類，我們就可以通過反射例項化這些類然後注入到IOC容器中，最後容器裡就有了一系列標註了@Configuration的JavaConfig形式的配置類。

這就是SpringFactoriesLoader，它本質上屬於Spring框架私有的一種擴充套件方案，類似於SPI，Spring Boot在Spring基礎上的很多核心功能都是基於此，希望大家可以理解。

四、另一件武器：Spring容器的事件監聽機制

過去，事件監聽機制多用於圖形介面程式設計，比如：點選按鈕、在文字框輸入內容等操作被稱為事件，而當事件觸發時，應用程式作出一定的響應則表示應用監聽了這個事件，而在伺服器端，事件的監聽機制更多的用於非同步通知以及監控和異常處理。

Java提供了實現事件監聽機制的兩個基礎類：自定義事件型別擴充套件自java.util.EventObject、事件的監聽器擴充套件自java.util.EventListener。

來看一個簡單的例項：簡單的監控一個方法的耗時。

首先定義事件型別，通常的做法是擴充套件EventObject，隨著事件的發生，相應的狀態通常都封裝在此類中：

public class MethodMonitorEvent extends EventObject {
     // 時間戳，用於記錄方法開始執行的時間
     public long timestamp;

      public MethodMonitorEvent(Object source) {
         super(source);
     }
 }

事件釋出之後，相應的監聽器即可對該型別的事件進行處理，我們可以在方法開始執行之前釋出一個begin事件.

在方法執行結束之後釋出一個end事件，相應地，事件監聽器需要提供方法對這兩種情況下接收到的事件進行處理：

// 1、定義事件監聽介面
 public interface MethodMonitorEventListener extends EventListener {
     // 處理方法執行之前釋出的事件
     public void onMethodBegin(MethodMonitorEvent event);
     // 處理方法結束時釋出的事件
     public void onMethodEnd(MethodMonitorEvent event);
 }
 // 2、事件監聽介面的實現：如何處理
 public class AbstractMethodMonitorEventListener implements MethodMonitorEventListener {
      @Override
     public void onMethodBegin(MethodMonitorEvent event) {
         // 記錄方法開始執行時的時間
         event.timestamp = System.currentTimeMillis();
     }
      @Override
     public void onMethodEnd(MethodMonitorEvent event) {
         // 計算方法耗時
         long duration = System.currentTimeMillis() - event.timestamp;
         System.out.println("耗時：" + duration);
     }
 }

事件監聽器介面針對不同的事件釋出實際提供相應的處理方法定義，最重要的是，其方法只接收MethodMonitorEvent引數，說明這個監聽器類只負責監聽器對應的事件並進行處理。

有了事件和監聽器，剩下的就是釋出事件，然後讓相應的監聽器監聽並處理。

通常情況，我們會有一個事件釋出者，它本身作為事件源，在合適的時機，將相應的事件釋出給對應的事件監聽器：

public class MethodMonitorEventPublisher {

      private List<MethodMonitorEventListener> listeners = new ArrayList<MethodMonitorEventListener>();

      public void methodMonitor() {
         MethodMonitorEvent eventObject = new MethodMonitorEvent(this);
         publishEvent("begin",eventObject);
         // 模擬方法執行：休眠5秒鐘
         TimeUnit.SECONDS.sleep(5);
         publishEvent("end",eventObject);
      }

      private void publishEvent(String status,MethodMonitorEvent event) {
         // 避免在事件處理期間，監聽器被移除，這裡為了安全做一個複製操作
         List<MethodMonitorEventListener> copyListeners = ➥ new ArrayList<MethodMonitorEventListener>(listeners);
         for (MethodMonitorEventListener listener : copyListeners) {
             if ("begin".equals(status)) {
                 listener.onMethodBegin(event);
             } else {
                 listener.onMethodEnd(event);
             }
         }
     }
         public static void main(String[] args) {
         MethodMonitorEventPublisher publisher = new MethodMonitorEventPublisher();
         publisher.addEventListener(new AbstractMethodMonitorEventListener());
         publisher.methodMonitor();
     }
     // 省略實現
     public void addEventListener(MethodMonitorEventListener listener) {}
     public void removeEventListener(MethodMonitorEventListener listener) {}
     public void removeAllListeners() {}

對於事件釋出者（事件源）通常需要關注兩點：

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介面，該介面提供了void publishEvent(ApplicationEvent event)方法定義，不難看出，ApplicationContext容器擔當的就是事件釋出者的角色。

如果有興趣可以檢視AbstractApplicationContext.publishEvent(ApplicationEvent event)方法的原始碼：ApplicationContext將事件的釋出以及監聽器的管理工作委託給 ApplicationEventMulticaster介面的實現類。

在容器啟動時，會檢查容器內是否存在名為applicationEventMulticaster的 ApplicationEventMulticaster物件例項。

如果有就使用其提供的實現，沒有就預設初始化一個SimpleApplicationEventMulticaster作為實現。

最後，如果我們業務需要在容器內部發布事件，只需要為其注入ApplicationEventPublisher 依賴即可：實現ApplicationEventPublisherAware介面或者ApplicationContextAware介面.

五、出神入化：揭祕自動配置原理

典型的Spring Boot應用的啟動類一般均位於src/main/java根路徑下

比如MoonApplication類：

@SpringBootApplication
 public class MoonApplication {
      public static void main(String[] args) {
         SpringApplication.run(MoonApplication.class, args);
     }
 }

其中@SpringBootApplication開啟元件掃描和自動配置，而SpringApplication.run則負責啟動引導應用程式。

@SpringBootApplication是一個複合Annotation，它將三個有用的註解組合在一起：

@Target(ElementType.TYPE)
 @Retention(RetentionPolicy.RUNTIME)
@Documented @Inherited
 @SpringBootConfiguration
 @EnableAutoConfiguration
 @ComponentScan(excludeFilters = {
        @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
         @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
 public @interface SpringBootApplication {
     // ......
 }

@SpringBootConfiguration就是@Configuration，它是Spring框架的註解，標明該類是一個JavaConfig配置類。

而@ComponentScan啟用元件掃描，前文已經詳細講解過，這裡著重關注@EnableAutoConfiguration。@EnableAutoConfiguration註解表示開啟Spring Boot自動配置功能，Spring Boot會根據應用的依賴、自定義的bean、classpath下有沒有某個類 等等因素來猜測你需要的bean，

然後註冊到IOC容器中。

那@EnableAutoConfiguration是如何推算出你的需求？

首先看下它的定義：

@Target(ElementType.TYPE)
 @Retention(RetentionPolicy.RUNTIME)
 @Documented
 @Inherited
 @AutoConfigurationPackage
 @Import(EnableAutoConfigurationImportSelector.class)
 public @interface EnableAutoConfiguration {
     // ......
 }

你的關注點應該在@Import(EnableAutoConfigurationImportSelector.class)上了，前文說過，@Import註解用於匯入類，並將這個類作為一個bean的定義註冊到容器中，這裡將把EnableAutoConfigurationImportSelector作為bean注入到容器中，而這個類會將所有符合條件的@Configuration配置都載入到容器中，看看它的程式碼：

public String[] selectImports(AnnotationMetadata annotationMetadata) {
     // 省略了大部分程式碼，保留一句核心程式碼
     // 注意：SpringBoot最近版本中，這句程式碼被封裝在一個單獨的方法中
     // SpringFactoriesLoader相關知識請參考前文
     List<String> factories = new ArrayList<String>(new LinkedHashSet<String>(
           SpringFactoriesLoader.loadFactoryNames(EnableAutoConfiguration.class, this.beanClassLoader)));
 }

這個類會掃描所有的jar包，將所有符合條件的@Configuration配置類注入的容器中何為符合條件，看看META-INF/spring.factories的檔案內容：

// 來自 org.springframework.boot.autoconfigure下的META-INF/spring.factories
 // 配置的key = EnableAutoConfiguration，與程式碼中一致
 org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
 org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration,\
 org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\
 org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration\
 .....

以DataSourceAutoConfiguration為例，看看Spring Boot是如何自動配置的：

@Configuration
 @ConditionalOnClass({ DataSource.class, EmbeddedDatabaseType.class })
 @EnableConfigurationProperties(DataSourceProperties.class)
 @Import({ Registrar.class, DataSourcePoolMetadataProvidersConfiguration.class })
 public class DataSourceAutoConfiguration {
 }

分別說一說：

@ConditionalOnClass({ DataSource.class, EmbeddedDatabaseType.class })：當Classpath中存在DataSource或者EmbeddedDatabaseType類時才啟用這個配置，否則這個配置將被忽略。

@EnableConfigurationProperties(DataSourceProperties.class)：將DataSource的預設配置類注入到IOC容器中，DataSourceproperties定義為：

// 提供對datasource配置資訊的支援，所有的配置字首為：spring.datasource
 @ConfigurationProperties(prefix = "spring.datasource")
 public class DataSourceProperties {
     private ClassLoader classLoader;
     private Environment environment;
     private String name = "testdb";
     ......
 }

@Import({ Registrar.class, DataSourcePoolMetadataProvidersConfiguration.class })：匯入其他額外的配置，就以DataSourcePoolMetadataProvidersConfiguration為例吧。

@Configuration
 public class DataSourcePoolMetadataProvidersConfiguration {

      @Configuration
     @ConditionalOnClass(org.apache.tomcat.jdbc.pool.DataSource.class)
     static class TomcatDataSourcePoolMetadataProviderConfiguration {
         @Bean
         public DataSourcePoolMetadataProvider tomcatPoolDataSourceMetadataProvider() {
             .....
         }
     }
   ......
 }

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)方法，其程式碼如下:

private void initialize(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> 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容器啟動的基礎上做了大量的擴充套件，按照這個思路來看看

原始碼：

public ConfigurableApplicationContext run(String... args) {
         StopWatch stopWatch = new StopWatch();
         stopWatch.start();
         ConfigurableApplicationContext context = null;
         FailureAnalyzers analyzers = null;
         configureHeadlessProperty();
         // ①
         SpringApplicationRunListeners listeners = getRunListeners(args);
         listeners.starting();
         try {
             // ②
ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
             ConfigurableEnvironment environment = prepareEnvironment(listeners,applicationArguments);
             // ③
             Banner printedBanner = printBanner(environment);
             // ④
             context = createApplicationContext();
             // ⑤
             analyzers = new FailureAnalyzers(context);
             // ⑥
             prepareContext(context, environment, listeners, applicationArguments,printedBanner);
             // ⑦
              refreshContext(context);
             // ⑧
             afterRefresh(context, applicationArguments);
             // ⑨
             listeners.finished(context, null);
             stopWatch.stop();
             return context;
        }
         catch (Throwable ex) {
             handleRunFailure(context, listeners, analyzers, ex);
             throw new IllegalStateException(ex);
         }
     }

① 通過SpringFactoriesLoader查詢並載入所有的SpringApplicationRunListeners通過呼叫starting()方法通知所有的SpringApplicationRunListeners：應用開始啟動了。

SpringApplicationRunListeners其本質上就是一個事件釋出者，它在SpringBoot應用啟動的不同時間點發布不同應用事件型別(ApplicationEvent)，如果有哪些事件監聽者(ApplicationListener)對這些事件感興趣，則可以接收並且處理。

還記得初始化流程中，SpringApplication載入了一系列ApplicationListener嗎？這個啟動流程中沒有發現有釋出事件的程式碼，其實都已經在SpringApplicationRunListeners這兒實現了。

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

public interface SpringApplicationRunListener {

      // 執行run方法時立即呼叫此方法，可以使用者非常早期的初始化工作
     void starting();

          // Environment準備好後，並且ApplicationContext建立之前呼叫
     void environmentPrepared(ConfigurableEnvironment environment);

      // ApplicationContext建立好後立即呼叫
     void contextPrepared(ConfigurableApplicationContext context);

      // ApplicationContext載入完成，在refresh之前呼叫
     void contextLoaded(ConfigurableApplicationContext context);

      // 當run方法結束之前呼叫
     void finished(ConfigurableApplicationContext
 context, Throwable exception);
  }

 

SpringApplicationRunListener只有一個實現類：EventPublishingRunListener。

①處的程式碼只會獲取到一個EventPublishingRunListener的例項

我們來看看starting()方法的內容：

public void starting() {
     // 釋出一個ApplicationStartedEvent
     this.initialMulticaster.multicastEvent(new ApplicationStartedEvent(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);

看看這個方法的實現：

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
     PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
     ......
 }

獲取到所有的BeanFactoryPostProcessor來對容器做一些額外的操作。

BeanFactoryPostProcessor允許我們在容器例項化相應物件之前，對註冊到容器的BeanDefinition所儲存的資訊做一些額外的操作。

這裡的getBeanFactoryPostProcessors()方法可以獲取到3個Processor：

ConfigurationWarningsApplicationContextInitializer$ConfigurationWarningsPostProcessor
 SharedMetadataReaderFactoryContextInitializer$CachingMetadataReaderFactoryPostProcessor
 ConfigFileApplicationListener$PropertySourceOrderingPostProcessor

不是有那麼多BeanFactoryPostProcessor的實現類，為什麼這兒只有這3個？

因為在初始化流程獲取到的各種ApplicationContextInitializer和ApplicationListener中，只有上文3個做了類似於如下操作：

public void initialize(ConfigurableApplicationContext context) {
     context.addBeanFactoryPostProcessor(new ConfigurationWarningsPostProcessor(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啟動流程就不在話下了。

作者：CHEN川
連結：http://www.jianshu.com/p/83693d3d0a65