預警：本文非常長，建議先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 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定義了兩個接口：

public?interface?BeanPostProcessor?{//?前置處理Object?postProcessBeforeInitialization(Object?bean,?String?beanName)?throws?BeansException;//?后置處理Object?postProcessAfterInitialization(Object?bean,?String?beanName)?throws?BeansException; }

為了理解這兩個方法執行的時機，簡單的了解下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@Beanpublic?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()@Beanpublic?BookService?bookService()?{return?new?BookServiceImpl(dependencyService());}@Beanpublic?OtherService?otherService()?{return?new?OtherServiceImpl(dependencyService());}@Beanpublic?DependencyService?dependencyService()?{return?new?DependencyServiceImpl();} }

你可能注意到這個示例中，有兩個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注解用于導入配置類，舉個簡單的例子：

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

現在有另外一個配置類，比如：MoonUserConfiguration，這個配置類中有一個bean依賴于MoonBookConfiguration中的bookService，如何將這兩個bean組合在一起？借助@Import即可：

@Configuration //?可以同時導入多個配置類，比如：@Import({A.class,B.class}) @Import(MoonBookConfiguration.class) public?class?MoonUserConfiguration?{@Beanpublic?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?{@Overridepublic?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提供的部分條件化注解：

條件化注解配置生效條件

@ConditionalOnBean	配置了某個特定bean
@ConditionalOnMissingBean	沒有配置特定的bean
@ConditionalOnClass	Classpath里有指定的類
@ConditionalOnMissingClass	Classpath里沒有指定的類
@ConditionalOnExpression	給定的Spring Expression Language表達式計算結果為true
@ConditionalOnJava	Java的版本匹配特定指或者一個范圍值
@ConditionalOnProperty	指定的配置屬性要有一個明確的值
@ConditionalOnResource	Classpath里有指定的資源
@ConditionalOnWebApplication	這是一個Web應用程序
@ConditionalOnNotWebApplication	這不是一個Web應用程序

2.5、@ConfigurationProperties與@EnableConfigurationProperties

當某些屬性的值需要配置的時候，我們一般會在application.properties文件中新建配置項，然后在bean中使用@Value注解來獲取配置的值，比如下面配置數據源的代碼。

使用@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?{@AutoWiredpublic?JdbcConfig?config;@Beanpublic?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=/loginapp.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?{//?直接使用AppClassLoaderClass.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();//?取得資源文件的URLEnumeration<URL>?urls?=?(classLoader?!=?null???classLoader.getResources(FACTORIES_RESOURCE_LOCATION)?:?ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));List<String>?result?=?new?ArrayList<String>();//?遍歷所有的URLwhile?(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 Boot 知识清单（上）的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。