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:
-
@Configuration(@SpringBootConfiguration 點開查看發現裏面還是應用了 @Configuration)
-
@EnableAutoConfiguration
-
@ComponentScan
即 @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 定義。
-
@EnableScheduling 是通過 @Import 將 Spring 調度框架相關的 bean 定義都加載到 IoC 容器。
-
@EnableMBeanExport 是通過 @Import 將 JMX 相關的 bean 定義加載到 IoC 容器。
而 @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 實例初始化的時候,它會提前做幾件事情:
-
根據 classpath 裏面是否存在某個特徵類(org.springframework.web.context.ConfigurableWebApplicationContext)來決定是否應該創建一個爲 Web 應用使用的 ApplicationContext 類型。
-
使用 SpringFactoriesLoader 在應用的 classpath 中查找並加載所有可用的 ApplicationContextInitializer。
-
使用 SpringFactoriesLoader 在應用的 classpath 中查找並加載所有可用的 ApplicationListener。
-
推斷並設置 main 方法的定義類。
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 方法
該方法中實現瞭如下幾個關鍵步驟:
-
創建了應用的監聽器 SpringApplicationRunListeners 並開始監聽
-
加載 SpringBoot 配置環境 (ConfigurableEnvironment),如果是通過 web 容器發佈,會加載 StandardEnvironment,其最終也是繼承了 ConfigurableEnvironment,類圖如下
可以看出,*Environment 最終都實現了 PropertyResolver 接口,我們平時通過 environment 對象獲取配置文件中指定 Key 對應的 value 方法時,就是調用了 propertyResolver 接口的 getProperty 方法
-
配置環境 (Environment) 加入到監聽器對象中(SpringApplicationRunListeners)
-
創建 run 方法的返回對象:ConfigurableApplicationContext(應用配置上下文),我們可以看一下創建方法:
方法會先獲取顯式設置的應用上下文 (applicationContextClass),如果不存在,再加載默認的環境配置(通過是否是 web environment 判斷),默認選擇 AnnotationConfigApplicationContext 註解上下文(通過掃描所有註解類來加載 bean),最後通過 BeanUtils 實例化上下文對象,並返回。
ConfigurableApplicationContext 類圖如下:
主要看其繼承的兩個方向:
LifeCycle:生命週期類,定義了 start 啓動、stop 結束、isRunning 是否運行中等生命週期空值方法
ApplicationContext:應用上下文類,其主要繼承了 beanFactory(bean 的工廠類)
-
回到 run 方法內,prepareContext 方法將 listeners、environment、applicationArguments、banner 等重要組件與上下文對象關聯
-
接下來的 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