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

2. 說明：前面有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的整個生命週期：

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配置形式中的<context:component-scan>元素，表示啟用元件掃描，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註解來獲取配置的值，比如下面配置資料來源的程式碼。

使用@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基礎上的很多核心功能都是基於此，希望大家可以理解。