spring boot 啓動原理解析

我們開發任何一個 Spring Boot 項目,都會用到如下的啓動類

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

從上面代碼可以看出,Annotation 定義(@SpringBootApplication)和類定義(SpringApplication.run)最爲耀眼,所以要揭開 SpringBoot 的神祕面紗,我們要從這兩位開始就可以了。

一、SpringBootApplication 背後的祕密

@SpringBootApplication 註解是 Spring Boot 的核心註解,它其實是一個組合註解:

 1 @Target(ElementType.TYPE)
 2 @Retention(RetentionPolicy.RUNTIME)
 3 @Documented
 4 @Inherited
 5 @SpringBootConfiguration
 6 @EnableAutoConfiguration
 7 @ComponentScan(excludeFilters = {
 8         @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
 9         @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
10 public @interface SpringBootApplication {
11 ...
12 }

雖然定義使用了多個 Annotation 進行了原信息標註,但實際上重要的只有三個 Annotation:

即 @SpringBootApplication = (默認屬性)@Configuration + @EnableAutoConfiguration + @ComponentScan。

所以,如果我們使用如下的 SpringBoot 啓動類,整個 SpringBoot 應用依然可以與之前的啓動類功能對等:

1 @Configuration
2 @EnableAutoConfiguration
3 @ComponentScan
4 public class Application {
5     public static void main(String[] args) {
6         SpringApplication.run(Application.class, args);
7     }
8 }

每次寫這 3 個比較累,所以寫一個 @SpringBootApplication 方便點。接下來分別介紹這 3 個 Annotation。

1、@Configuration

     這裏的 @Configuration 對我們來說不陌生,它就是 JavaConfig 形式的 Spring Ioc 容器的配置類使用的那個 @Configuration,SpringBoot 社區推薦使用基於 JavaConfig 的配置形式,所以,這裏的啓動類標註了 @Configuration 之後,本身其實也是一個 IoC 容器的配置類。

舉幾個簡單例子回顧下,XML 跟 config 配置方式的區別:

(1)表達形式層面

基於 XML 配置的方式是這樣:

1 <?xml version="1.0" encoding="UTF-8"?>
2 <beans xmlns="http://www.springframework.org/schema/beans"
3        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd"
5        default-lazy-init="true">
6     <!--bean定義-->
7 </beans>

而基於 JavaConfig 的配置方式是這樣:

1 @Configuration
2 public class MockConfiguration{
3     //bean定義
4 }

任何一個標註了 @Configuration 的 Java 類定義都是一個 JavaConfig 配置類。

(2)註冊 bean 定義層面

基於 XML 的配置形式是這樣:

1 <bean>
2     ...
3 </bean>

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

1 @Configuration
2 public class MockConfiguration{
3     @Bean
4     public MockService mockService(){
5         return new MockServiceImpl();
6     }
7 }

任何一個標註了 @Bean 的方法,其返回值將作爲一個 bean 定義註冊到 Spring 的 IoC 容器,方法名將默認成該 bean 定義的 id。

(3)表達依賴注入關係層面

爲了表達 bean 與 bean 之間的依賴關係,在 XML 形式中一般是這樣:

1 <bean>
2     <propery name ="dependencyService" ref="dependencyService" />
3 </bean>
4 
5 <bean></bean>
而基於JavaConfig的配置形式是這樣的:
 1 @Configuration
 2 public class MockConfiguration{
 3     @Bean
 4     public MockService mockService(){
 5         return new MockServiceImpl(dependencyService());
 6     }
 7     
 8     @Bean
 9     public DependencyService dependencyService(){
10         return new DependencyServiceImpl();
11     }
12 }

如果一個 bean 的定義依賴其他 bean,則直接調用對應的 JavaConfig 類中依賴 bean 的創建方法就可以了。

@Configuration:提到 @Configuration 就要提到他的搭檔 @Bean。使用這兩個註解就可以創建一個簡單的 spring 配置類,可以用來替代相應的 xml 配置文件。

1 <beans> 
2     <bean id = "car" class="com.test.Car"> 
3         <property ></property> 
4     </bean> 
5     <bean id = "wheel" class="com.test.Wheel"></bean> 
6 </beans>

相當於:

 1 @Configuration 
 2 public class Conf { 
 3     @Bean 
 4     public Car car() { 
 5         Car car = new Car(); 
 6         car.setWheel(wheel()); 
 7         return car; 
 8     }
 9     
10     @Bean 
11     public Wheel wheel() { 
12         return new Wheel(); 
13     } 
14 }

@Configuration 的註解類標識這個類可以使用 Spring IoC 容器作爲 bean 定義的來源。

@Bean 註解告訴 Spring,一個帶有 @Bean 的註解方法將返回一個對象,該對象應該被註冊爲在 Spring 應用程序上下文中的 bean。

2、@ComponentScan

     @ComponentScan 這個註解在 Spring 中很重要,它對應 XML 配置中的元素,@ComponentScan 的功能其實就是自動掃描並加載符合條件的組件(比如 @Component 和 @Repository 等)或者 bean 定義,最終將這些 bean 定義加載到 IoC 容器中。

     我們可以通過 basePackages 等屬性來細粒度的定製 @ComponentScan 自動掃描的範圍,如果不指定,則默認 Spring 框架實現會從聲明 @ComponentScan 所在類的 package 進行掃描。

注:所以 SpringBoot 的啓動類最好是放在 root package 下,因爲默認不指定 basePackages。

3、@EnableAutoConfiguration

    個人感覺 @EnableAutoConfiguration 這個 Annotation 最爲重要,所以放在最後來解讀,大家是否還記得 Spring 框架提供的各種名字爲 @Enable 開頭的 Annotation 定義?比如 @EnableScheduling、@EnableCaching、@EnableMBeanExport 等,@EnableAutoConfiguration 的理念和做事方式其實一脈相承,簡單概括一下就是,藉助 @Import 的支持,收集和註冊特定場景相關的 bean 定義。

而 @EnableAutoConfiguration 也是藉助 @Import 的幫助,將所有符合自動配置條件的 bean 定義加載到 IoC 容器,僅此而已!

    @EnableAutoConfiguration 會根據類路徑中的 jar 依賴爲項目進行自動配置,如:添加了 spring-boot-starter-web 依賴,會自動添加 Tomcat 和 Spring MVC 的依賴,Spring Boot 會對 Tomcat 和 Spring MVC 進行自動配置。

 @EnableAutoConfiguration 作爲一個複合 Annotation,其自身定義關鍵信息如下:

 1 @SuppressWarnings("deprecation")
 2 @Target(ElementType.TYPE)
 3 @Retention(RetentionPolicy.RUNTIME)
 4 @Documented
 5 @Inherited
 6 @AutoConfigurationPackage
 7 @Import(EnableAutoConfigurationImportSelector.class)
 8 public @interface EnableAutoConfiguration {
 9     ...
10 }

    其中,最關鍵的要屬 @Import(EnableAutoConfigurationImportSelector.class),藉助 EnableAutoConfigurationImportSelector,@EnableAutoConfiguration 可以幫助 SpringBoot 應用將所有符合條件的 @Configuration 配置都加載到當前 SpringBoot 創建並使用的 IoC 容器。就像一隻 “八爪魚” 一樣,藉助於 Spring 框架原有的一個工具類:SpringFactoriesLoader 的支持,@EnableAutoConfiguration 可以智能的自動配置功效才得以大功告成!

自動配置幕後英雄:SpringFactoriesLoader 詳解

SpringFactoriesLoader 屬於 Spring 框架私有的一種擴展方案,其主要功能就是從指定的配置文件 META-INF/spring.factories 加載配置。

 1 public abstract class SpringFactoriesLoader {
 2     //...
 3     public static <T> List<T> loadFactories(Class<T> factoryClass, ClassLoader classLoader) {
 4         ...
 5     }
 6 
 7 
 8     public static List<String> loadFactoryNames(Class<?> factoryClass, ClassLoader classLoader) {
 9         ....
10     }
11 }

配合 @EnableAutoConfiguration 使用的話,它更多是提供一種配置查找的功能支持,即根據 @EnableAutoConfiguration 的完整類名 org.springframework.boot.autoconfigure.EnableAutoConfiguration 作爲查找的 Key,獲取對應的一組 @Configuration 類。

上圖就是從 SpringBoot 的 autoconfigure 依賴包中的 META-INF/spring.factories 配置文件中摘錄的一段內容,可以很好地說明問題。

所以,@EnableAutoConfiguration 自動配置的魔法騎士就變成了:從 classpath 中搜尋所有的 META-INF/spring.factories 配置文件,並將其中 org.springframework.boot.autoconfigure.EnableutoConfiguration 對應的配置項通過反射(Java Refletion)實例化爲對應的標註了 @Configuration 的 JavaConfig 形式的 IoC 容器配置類,然後彙總爲一個並加載到 IoC 容器。

二、深入探索 SpringApplication 執行流程

SpringApplication 的 run 方法的實現是我們本次旅程的主要線路,該方法的主要流程大體可以歸納如下:

1) 如果我們使用的是 SpringApplication 的靜態 run 方法,那麼,這個方法裏面首先要創建一個 SpringApplication 對象實例,然後調用這個創建好的 SpringApplication 的實例方法。在 SpringApplication 實例初始化的時候,它會提前做幾件事情:

2) SpringApplication 實例初始化完成並且完成設置後,就開始執行 run 方法的邏輯了,方法執行伊始,首先遍歷執行所有通過 SpringFactoriesLoader 可以查找到並加載的 SpringApplicationRunListener。調用它們的 started() 方法,告訴這些 SpringApplicationRunListener,“嘿,SpringBoot 應用要開始執行咯!”。

3) 創建並配置當前 Spring Boot 應用將要使用的 Environment(包括配置要使用的 PropertySource 以及 Profile)。

4) 遍歷調用所有 SpringApplicationRunListener 的 environmentPrepared() 的方法,告訴他們:“當前 SpringBoot 應用使用的 Environment 準備好了咯!”。

5) 如果 SpringApplication 的 showBanner 屬性被設置爲 true,則打印 banner。

6) 根據用戶是否明確設置了 applicationContextClass 類型以及初始化階段的推斷結果,決定該爲當前 SpringBoot 應用創建什麼類型的 ApplicationContext 並創建完成,然後根據條件決定是否添加 ShutdownHook,決定是否使用自定義的 BeanNameGenerator,決定是否使用自定義的 ResourceLoader,當然,最重要的,將之前準備好的 Environment 設置給創建好的 ApplicationContext 使用。

7) ApplicationContext 創建好之後,SpringApplication 會再次藉助 Spring-FactoriesLoader,查找並加載 classpath 中所有可用的 ApplicationContext-Initializer,然後遍歷調用這些 ApplicationContextInitializer 的 initialize(applicationContext)方法來對已經創建好的 ApplicationContext 進行進一步的處理。

8) 遍歷調用所有 SpringApplicationRunListener 的 contextPrepared() 方法。

9) 最核心的一步,將之前通過 @EnableAutoConfiguration 獲取的所有配置以及其他形式的 IoC 容器配置加載到已經準備完畢的 ApplicationContext。

10) 遍歷調用所有 SpringApplicationRunListener 的 contextLoaded() 方法。

11) 調用 ApplicationContext 的 refresh() 方法,完成 IoC 容器可用的最後一道工序。

12) 查找當前 ApplicationContext 中是否註冊有 CommandLineRunner,如果有,則遍歷執行它們。

13) 正常情況下,遍歷執行 SpringApplicationRunListener 的 finished() 方法、(如果整個過程出現異常,則依然調用所有 SpringApplicationRunListener 的 finished() 方法,只不過這種情況下會將異常信息一併傳入處理)

去除事件通知點後,整個流程如下:

本文以調試一個實際的 SpringBoot 啓動程序爲例,參考流程中主要類類圖,來分析其啓動邏輯和自動化配置原理。

總覽:    

    上圖爲 SpringBoot 啓動結構圖,我們發現啓動流程主要分爲三個部分,第一部分進行 SpringApplication 的初始化模塊,配置一些基本的環境變量、資源、構造器、監聽器,第二部分實現了應用具體的啓動方案,包括啓動流程的監聽模塊、加載配置環境模塊、及核心的創建上下文環境模塊,第三部分是自動化配置模塊,該模塊作爲 springboot 自動配置核心,在後面的分析中會詳細討論。在下面的啓動程序中我們會串聯起結構中的主要功能。

啓動:

     每個 SpringBoot 程序都有一個主入口,也就是 main 方法,main 裏面調用 SpringApplication.run() 啓動整個 spring-boot 程序,該方法所在類需要使用 @SpringBootApplication 註解,以及 @ImportResource 註解 (if need),@SpringBootApplication 包括三個註解,功能如下:

@EnableAutoConfiguration:SpringBoot 根據應用所聲明的依賴來對 Spring 框架進行自動配置。

@SpringBootConfiguration(內部爲 @Configuration):被標註的類等於在 spring 的 XML 配置文件中 (applicationContext.xml),裝配所有 bean 事務,提供了一個 spring 的上下文環境。

@ComponentScan:組件掃描,可自動發現和裝配 Bean,默認掃描 SpringApplication 的 run 方法裏的 Booter.class 所在的包路徑下文件,所以最好將該啓動類放到根包路徑下。

SpringBoot 啓動類

首先進入 run 方法

run 方法中去創建了一個 SpringApplication 實例,在該構造方法內,我們可以發現其調用了一個初始化的 initialize 方法

這裏主要是爲 SpringApplication 對象賦一些初值。構造函數執行完畢後,我們回到 run 方法

該方法中實現瞭如下幾個關鍵步驟:

  1. 創建了應用的監聽器 SpringApplicationRunListeners 並開始監聽

  2. 加載 SpringBoot 配置環境 (ConfigurableEnvironment),如果是通過 web 容器發佈,會加載 StandardEnvironment,其最終也是繼承了 ConfigurableEnvironment,類圖如下

可以看出,*Environment 最終都實現了 PropertyResolver 接口,我們平時通過 environment 對象獲取配置文件中指定 Key 對應的 value 方法時,就是調用了 propertyResolver 接口的 getProperty 方法

  1. 配置環境 (Environment) 加入到監聽器對象中(SpringApplicationRunListeners)

  2. 創建 run 方法的返回對象:ConfigurableApplicationContext(應用配置上下文),我們可以看一下創建方法:

方法會先獲取顯式設置的應用上下文 (applicationContextClass),如果不存在,再加載默認的環境配置(通過是否是 web environment 判斷),默認選擇 AnnotationConfigApplicationContext 註解上下文(通過掃描所有註解類來加載 bean),最後通過 BeanUtils 實例化上下文對象,並返回。

ConfigurableApplicationContext 類圖如下:

主要看其繼承的兩個方向:

LifeCycle:生命週期類,定義了 start 啓動、stop 結束、isRunning 是否運行中等生命週期空值方法

ApplicationContext:應用上下文類,其主要繼承了 beanFactory(bean 的工廠類)

  1. 回到 run 方法內,prepareContext 方法將 listeners、environment、applicationArguments、banner 等重要組件與上下文對象關聯

  2. 接下來的 refreshContext(context)方法 (初始化方法如下) 將是實現 spring-boot-starter-*(mybatis、redis 等)自動化配置的關鍵,包括 spring.factories 的加載,bean 的實例化等核心工作。

     配置結束後,Springboot 做了一些基本的收尾工作,返回了應用環境上下文。回顧整體流程,Springboot 的啓動,主要創建了配置環境 (environment)、事件監聽 (listeners)、應用上下文 (applicationContext),並基於以上條件,在容器中開始實例化我們需要的 Bean,至此,通過 SpringBoot 啓動的程序已經構造完成,接下來我們來探討自動化配置是如何實現。

自動化配置:

之前的啓動結構圖中,我們注意到無論是應用初始化還是具體的執行過程,都調用了 SpringBoot 自動配置模塊。

SpringBoot 自動配置模塊

    該配置模塊的主要使用到了 SpringFactoriesLoader,即 Spring 工廠加載器,該對象提供了 loadFactoryNames 方法,入參爲 factoryClass 和 classLoader,即需要傳入上圖中的工廠類名稱和對應的類加載器,方法會根據指定的 classLoader,加載該類加器搜索路徑下的指定文件,即 spring.factories 文件,傳入的工廠類爲接口,而文件中對應的類則是接口的實現類,或最終作爲實現類,所以文件中一般爲如下圖這種一對多的類名集合,獲取到這些實現類的類名後,loadFactoryNames 方法返回類名集合,方法調用方得到這些集合後,再通過反射獲取這些類的類對象、構造方法,最終生成實例。

工廠接口與其若干實現類接口名稱

下圖有助於我們形象理解自動配置流程。

SpringBoot 自動化配置關鍵組件關係圖 

    mybatis-spring-boot-starter、spring-boot-starter-web 等組件的 META-INF 文件下均含有 spring.factories 文件,自動配置模塊中,SpringFactoriesLoader 收集到文件中的類全名並返回一個類全名的數組,返回的類全名通過反射被實例化,就形成了具體的工廠實例,工廠實例來生成組件具體需要的 bean。

之前我們提到了 EnableAutoConfiguration 註解,其類圖如下:

可以發現其最終實現了 ImportSelector(選擇器) 和 BeanClassLoaderAware(bean 類加載器中間件),重點關注一下 AutoConfigurationImportSelector 的 selectImports 方法。

    該方法在 springboot 啓動流程——bean 實例化前被執行,返回要實例化的類信息列表。我們知道,如果獲取到類信息,spring 自然可以通過類加載器將類加載到 jvm 中,現在我們已經通過 spring-boot 的 starter 依賴方式依賴了我們需要的組件,那麼這些組建的類信息在 select 方法中也是可以被獲取到的,不要急我們繼續向下分析。

該方法中的 getCandidateConfigurations 方法,通過方法註釋瞭解到,其返回一個自動配置類的類名列表,方法調用了 loadFactoryNames 方法,查看該方法

    在上面的代碼可以看到自動配置器會根據傳入的 factoryClass.getName() 到項目系統路徑下所有的 spring.factories 文件中找到相應的 key,從而加載裏面的類。我們就選取這個 mybatis-spring-boot-autoconfigure 下的 spring.factories 文件

進入 org.mybatis.spring.boot.autoconfigure.MybatisAutoConfiguration 中,主要看一下類頭:

發現 Spring 的 @Configuration,儼然是一個通過註解標註的 springBean,繼續向下看,

@ConditionalOnClass({SqlSessionFactory.class, SqlSessionFactoryBean.class}) 這個註解的意思是:當存在 SqlSessionFactory.class, SqlSessionFactoryBean.class 這兩個類時才解析 MybatisAutoConfiguration 配置類,否則不解析這一個配置類,make sence,我們需要 mybatis 爲我們返回會話對象,就必須有會話工廠相關類。

@CondtionalOnBean(DataSource.class):只有處理已經被聲明爲 bean 的 dataSource。

@ConditionalOnMissingBean(MapperFactoryBean.class) 這個註解的意思是如果容器中不存在 name 指定的 bean 則創建 bean 注入,否則不執行(該類源碼較長,篇幅限制不全粘貼)

     以上配置可以保證 sqlSessionFactory、sqlSessionTemplate、dataSource 等 mybatis 所需的組件均可被自動配置,@Configuration 註解已經提供了 Spring 的上下文環境,所以以上組件的配置方式與 Spring 啓動時通過 mybatis.xml 文件進行配置起到一個效果。通過分析我們可以發現,只要一個基於 SpringBoot 項目的類路徑下存在 SqlSessionFactory.class, SqlSessionFactoryBean.class,並且容器中已經註冊了 dataSourceBean,就可以觸發自動化配置,意思說我們只要在 maven 的項目中加入了 mybatis 所需要的若干依賴,就可以觸發自動配置,但引入 mybatis 原生依賴的話,每集成一個功能都要去修改其自動化配置類,那就得不到開箱即用的效果了。所以 Spring-boot 爲我們提供了統一的 starter 可以直接配置好相關的類,觸發自動配置所需的依賴 (mybatis) 如下:

這裏是截取的 mybatis-spring-boot-starter 的源碼中 pom.xml 文件中所有依賴:

 因爲 maven 依賴的傳遞性,我們只要依賴 starter 就可以依賴到所有需要自動配置的類,實現開箱即用的功能。也體現出 Springboot 簡化了 Spring 框架帶來的大量 XML 配置以及複雜的依賴管理,讓開發人員可以更加關注業務邏輯的開發。

本文由 Readfog 進行 AMP 轉碼,版權歸原作者所有。
來源https://mp.weixin.qq.com/s/PiG_JN-R-b8DLKOvq2VsfQ