詳解SpringBoot啟動(dòng)代碼和自動(dòng)裝配源碼分析

更新時(shí)間：2022年07月04日 09:10:35 作者：bei_er

這篇文章主要介紹了SpringBoot啟動(dòng)代碼和自動(dòng)裝配源碼分析,使用SpringBoot很簡(jiǎn)單，在主類(lèi)中添加一個(gè)@SpringBootApplication，以及調(diào)用SpringApplication.run()并傳入主類(lèi)，本文通過(guò)示例代碼給大家介紹的非常詳細(xì)，需要的朋友可以參考下

?隨著互聯(lián)網(wǎng)的快速發(fā)展，各種組件層出不窮，需要框架集成的組件越來(lái)越多。每一種組件與Spring容器整合需要實(shí)現(xiàn)相關(guān)代碼。SpringMVC框架配置由于太過(guò)于繁瑣和依賴(lài)XML文件；為了方便快速集成第三方組件和減少對(duì)配置文件的依賴(lài)，SpringBoot應(yīng)運(yùn)而生，其中采用了約定大于配置的理論讓開(kāi)發(fā)者不需要過(guò)多配置即可進(jìn)行開(kāi)發(fā)。SpringBoot底層使用的Spring ，默認(rèn)集成了N多組件的自動(dòng)裝配。使用SpringBoot很簡(jiǎn)單，在主類(lèi)中添加一個(gè)@SpringBootApplication，以及調(diào)用SpringApplication.run()并傳入主類(lèi)。代碼如下

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

由上面的源碼可知，SpringApplication.run(）是SpringBoot的程序入口。本文會(huì)從SpringApplication.run(）和@SpringBootApplication注解兩方面來(lái)分析。

一、SpringBoot啟動(dòng)代碼主線(xiàn)分析

?SpringApplication.run(StartApp.class)的中關(guān)鍵代碼，先創(chuàng)建一個(gè)SpringApplication類(lèi)，再執(zhí)行run方法。代碼如下，

public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) {
   return new SpringApplication(primarySources).run(args);
}

1.SpringApplication的構(gòu)造方法代碼如下

public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
    // 設(shè)置資源加載器
    this.resourceLoader = resourceLoader;
    Assert.notNull(primarySources, "PrimarySources must not be null");
    // 設(shè)置應(yīng)用主配置類(lèi)
    this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
    // 獲取web服務(wù)器類(lèi)型
    this.webApplicationType = WebApplicationType.deduceFromClasspath();
    // 從spring.factories 文件中獲取 ApplicationContextInitializer 的實(shí)現(xiàn)類(lèi)
    setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
    // 從spring.factories 文件中獲取 ApplicationListener 監(jiān)聽(tīng)器的實(shí)現(xiàn)類(lèi)
    setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
    // 設(shè)置main啟動(dòng)類(lèi)
    this.mainApplicationClass = deduceMainApplicationClass();
}

構(gòu)造方法中主要邏輯：

?1.設(shè)置應(yīng)用主配置類(lèi)，后面的run方法中會(huì)用它封裝成 BeanDefinitionHolder 并加載到 context 的 registry 中。

?2.獲取web服務(wù)器類(lèi)型，后面的run方法中會(huì)用它來(lái)創(chuàng)建具體的web服務(wù)類(lèi)型。

?3.從spring.factories 文件中獲取 ApplicationContextInitializer 的實(shí)現(xiàn)類(lèi)，并設(shè)置給SpringApplication實(shí)例

?4.從spring.factories 文件中獲取 ApplicationListener 監(jiān)聽(tīng)器的實(shí)現(xiàn)類(lèi)，并設(shè)置給SpringApplication實(shí)例

?5.設(shè)置main啟動(dòng)類(lèi)

其中g(shù)etSpringFactoriesInstances方法主要邏輯是：從META-INF/spring.factories文件中根據(jù)接口獲取具體實(shí)現(xiàn)類(lèi)字符串，并把字符串成實(shí)例化為對(duì)象。代碼如下，

// 獲取類(lèi)加載器
ClassLoader classLoader = getClassLoader();
// Use names and ensure unique to protect against duplicates
// 根據(jù)type 從META-INF/spring.factories獲取 具體的實(shí)現(xiàn)類(lèi)字符串列表
Set<String> names = new LinkedHashSet<>(SpringFactoriesLoader.loadFactoryNames(type, classLoader));
// 實(shí)例化具體的實(shí)現(xiàn)類(lèi)
List<T> instances = createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names);
// 排序
AnnotationAwareOrderComparator.sort(instances);
return instances;

在META-INF/spring.factories文件中ApplicationContextInitializer.class 對(duì)應(yīng)的實(shí)現(xiàn)類(lèi)字符串為，

org.springframework.boot.context.ConfigurationWarningsApplicationContextInitializer,\
org.springframework.boot.context.ContextIdApplicationContextInitializer,\
org.springframework.boot.context.config.DelegatingApplicationContextInitializer,\
org.springframework.boot.rsocket.context.RSocketPortInfoApplicationContextInitializer,\
org.springframework.boot.web.context.ServerPortInfoApplicationContextInitializer

在META-INF/spring.factories文件中ApplicationListener.class 對(duì)應(yīng)的實(shí)現(xiàn)類(lèi)字符串為，

org.springframework.boot.ClearCachesApplicationListener,\
org.springframework.boot.builder.ParentContextCloserApplicationListener,\
org.springframework.boot.cloud.CloudFoundryVcapEnvironmentPostProcessor,\
org.springframework.boot.context.FileEncodingApplicationListener,\
org.springframework.boot.context.config.AnsiOutputApplicationListener,\
org.springframework.boot.context.config.ConfigFileApplicationListener,\
org.springframework.boot.context.config.DelegatingApplicationListener,\
org.springframework.boot.context.logging.ClasspathLoggingApplicationListener,\
org.springframework.boot.context.logging.LoggingApplicationListener,\
org.springframework.boot.liquibase.LiquibaseServiceLocatorApplicationListener

2.run方法的代碼如下，

StopWatch stopWatch = new StopWatch();
stopWatch.start();
ConfigurableApplicationContext context = null;
Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
// 設(shè)置了一個(gè)名為 java.awt.headless 的系統(tǒng)屬性
// 其實(shí)是想設(shè)計(jì)應(yīng)用程序，即使沒(méi)有檢測(cè)到顯示器，也允許其啟動(dòng)
// 對(duì)于服務(wù)器來(lái)說(shuō)，是不需要顯示器的 ，所以要這樣設(shè)置
configureHeadlessProperty();
// 獲取 SpringApplicationRunListener 加載的是 EventPublishingRunListener
// 獲取啟動(dòng)時(shí)的監(jiān)聽(tīng)器
SpringApplicationRunListeners listeners = getRunListeners(args);
// 觸發(fā)啟動(dòng)事件
listeners.starting();
try {
    // 構(gòu)造一個(gè)應(yīng)用程序的參數(shù)持有類(lèi)
    ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
    // 創(chuàng)建并配置環(huán)境
    ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);
    // 配置需要忽略的BeanInfo信息
    configureIgnoreBeanInfo(environment);
    Banner printedBanner = printBanner(environment);
    // 創(chuàng)建上下文對(duì)象
    context = createApplicationContext();
    // 加載配置的啟動(dòng)異常處理器
    exceptionReporters = getSpringFactoriesInstances(SpringBootExceptionReporter.class,
                                                     new Class[] { ConfigurableApplicationContext.class }, context);
    // 刷新前操作
    prepareContext(context, environment, listeners, applicationArguments, printedBanner);
    // 刷新應(yīng)用上下文 完成 Spring 容器的初始化
    refreshContext(context);
    // 刷新后操作
    afterRefresh(context, applicationArguments);
    stopWatch.stop();
    if (this.logStartupInfo) {
        new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch);
    }
    // 啟動(dòng)完成事件
    listeners.started(context);
    // 執(zhí)行 ApplicationRunner 和 CommandLineRunner 實(shí)現(xiàn)類(lèi)
    callRunners(context, applicationArguments);
}
catch (Throwable ex) {
    // 事件廣播啟動(dòng)出錯(cuò)了
    handleRunFailure(context, ex, exceptionReporters, listeners);
    throw new IllegalStateException(ex);
}

try {
    // 運(yùn)行事件
    listeners.running(context);
}
catch (Throwable ex) {
    handleRunFailure(context, ex, exceptionReporters, null);
    throw new IllegalStateException(ex);
}
return context;

run方法中主要邏輯：

?1. 從spring.factories 文件中獲取 SpringApplicationRunListener 的實(shí)現(xiàn)類(lèi)（監(jiān)聽(tīng)事件發(fā)布器），并在context生命周期中執(zhí)行相關(guān)的事件，比如觸發(fā)啟動(dòng)事件、啟動(dòng)完成事件等。

?2.創(chuàng)建Web應(yīng)用上下文對(duì)象，根據(jù)webApplicationType來(lái)創(chuàng)建具體的web服務(wù)類(lèi)型。

?3.刷新前操作，把主配置類(lèi)資源封裝成 BeanDefinitionHolder 加載到 context 的 registry 中。

?4.刷新應(yīng)用上下文完成 Spring 容器的初始化。

?5.執(zhí)行實(shí)現(xiàn)了 ApplicationRunner 和 CommandLineRunner 接口的類(lèi)。

二、SpringBoot自動(dòng)裝配原理分析

1.自動(dòng)裝配的前置知識(shí)@Import

?@SpringBootApplication注解其中主要是利用@Import 注解，@Import源碼如下:

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Import {
    /**
	 * {@link Configuration @Configuration}, {@link ImportSelector},
	 * {@link ImportBeanDefinitionRegistrar}, or regular component classes to import.
	 */
    Class<?>[] value();
}

@Import在注解一般和@Configuration一起用，Spring容器初始化的過(guò)程中會(huì)進(jìn)行解析@Configuration注解類(lèi)（源碼在org.springframework.context.annotation.ConfigurationClassPostProcessor#processConfigBeanDefinitions中），其過(guò)程會(huì)解析注解類(lèi)的@Import注解的元數(shù)據(jù)，并根據(jù)類(lèi)是否實(shí)現(xiàn)相關(guān)接口進(jìn)行處理。源碼位置：org.springframework.context.annotation.ConfigurationClassParser#processImports；關(guān)鍵代碼如下，

try {
    for (SourceClass candidate : importCandidates) {
        if (candidate.isAssignable(ImportSelector.class)) {
            // Candidate class is an ImportSelector -> delegate to it to determine imports
            Class<?> candidateClass = candidate.loadClass();
            ImportSelector selector = ParserStrategyUtils.instantiateClass(candidateClass, ImportSelector.class,
                                                                           this.environment, this.resourceLoader, this.registry);
            Predicate<String> selectorFilter = selector.getExclusionFilter();
            if (selectorFilter != null) {
                exclusionFilter = exclusionFilter.or(selectorFilter);
            }
            if (selector instanceof DeferredImportSelector) {
                this.deferredImportSelectorHandler.handle(configClass, (DeferredImportSelector) selector);
            }
            else {
                String[] importClassNames = selector.selectImports(currentSourceClass.getMetadata());
                Collection<SourceClass> importSourceClasses = asSourceClasses(importClassNames, exclusionFilter);
                processImports(configClass, currentSourceClass, importSourceClasses, exclusionFilter, false);
            }
        }
        else if (candidate.isAssignable(ImportBeanDefinitionRegistrar.class)) {
            // Candidate class is an ImportBeanDefinitionRegistrar ->
            // delegate to it to register additional bean definitions
            Class<?> candidateClass = candidate.loadClass();
            ImportBeanDefinitionRegistrar registrar =
                ParserStrategyUtils.instantiateClass(candidateClass, ImportBeanDefinitionRegistrar.class,
                                                     this.environment, this.resourceLoader, this.registry);
            configClass.addImportBeanDefinitionRegistrar(registrar, currentSourceClass.getMetadata());
        }
        else {
            // Candidate class not an ImportSelector or ImportBeanDefinitionRegistrar ->
            // process it as an @Configuration class
            this.importStack.registerImport(
                currentSourceClass.getMetadata(), candidate.getMetadata().getClassName());
            processConfigurationClass(candidate.asConfigClass(configClass), exclusionFilter);
        }
    }
}

從上面代碼可知@Import的value類(lèi)使用有三種場(chǎng)景:

?1.實(shí)現(xiàn)了 ImportSelector.class接口的場(chǎng)景；直接調(diào)用實(shí)例selector 的selectImports方法返回要實(shí)例化的Bean對(duì)象的全類(lèi)名列表，并根據(jù)全類(lèi)名字符串列表創(chuàng)建實(shí)例對(duì)象，然后遞歸調(diào)用當(dāng)前的processImports 方法，最終會(huì)添加到configurationClasses的集合中，configurationClasses集合中的對(duì)象會(huì)被注冊(cè)到BeanDefinitionRegistry類(lèi)型的 registry 對(duì)象中。實(shí)現(xiàn)接口ImportSelector這種情況下又?jǐn)U展了 DeferredImportSelector 接口的情況，該接口用來(lái)實(shí)現(xiàn)BeanDefinition的延遲注入功能更。DeferredImportSelector接口擴(kuò)展了ImportSelector接口，并且其中有個(gè)內(nèi)部接口 Group，如果某個(gè)@Import注解的value類(lèi)實(shí)現(xiàn)了DeferredImportSelector接口并且也實(shí)現(xiàn)了該接口的內(nèi)部類(lèi)Group接口，則表面此實(shí)現(xiàn)類(lèi)需要延遲處理。如果是需要延遲處理，則會(huì)把ImportSelector 實(shí)例selector 組裝成 DeferredImportSelectorHolder 對(duì)象添加到 deferredImportSelectors集合中，處理邏輯源碼位置： org.springframework.context.annotation.ConfigurationClassParser.DeferredImportSelectorHandler#handle；關(guān)鍵代碼如下，

public void handle(ConfigurationClass configClass, DeferredImportSelector importSelector) {
    DeferredImportSelectorHolder holder = new DeferredImportSelectorHolder(configClass, importSelector);
    if (this.deferredImportSelectors == null) {
        DeferredImportSelectorGroupingHandler handler = new DeferredImportSelectorGroupingHandler();
        handler.register(holder);
        handler.processGroupImports();
    }
    else {
        this.deferredImportSelectors.add(holder);
    }
}

DeferredImportSelector接口的實(shí)現(xiàn)邏輯會(huì)在org.springframework.context.annotation.ConfigurationClassParser#parse方法中調(diào)用,具體代碼在this.deferredImportSelectorHandler.process()中，關(guān)鍵代碼如下，

public void process() {
    List<DeferredImportSelectorHolder> deferredImports = this.deferredImportSelectors;
    this.deferredImportSelectors = null;
    try {
        if (deferredImports != null) {
            DeferredImportSelectorGroupingHandler handler = new DeferredImportSelectorGroupingHandler();
            deferredImports.sort(DEFERRED_IMPORT_COMPARATOR);
            deferredImports.forEach(handler::register);
            // 具體的執(zhí)行邏輯
            handler.processGroupImports();
        }
    }
    finally {
        this.deferredImportSelectors = new ArrayList<>();
    }
}

在processGroupImports()方法中，先通過(guò)grouping.getImports()拿到需要自動(dòng)裝配的Group.Entry（封裝了全類(lèi)名）對(duì)象集合，然后通過(guò)processImports()方法根據(jù)Entry類(lèi)名字符串進(jìn)行創(chuàng)建SourceClass類(lèi)（該類(lèi)可以通過(guò)asConfigClass()方法轉(zhuǎn)成ConfigurationClass對(duì)象），最終添加到configurationClasses集合中。代碼如下，

public void processGroupImports() {
    for (DeferredImportSelectorGrouping grouping : this.groupings.values()) {
        Predicate<String> exclusionFilter = grouping.getCandidateFilter();
        grouping.getImports().forEach(entry -> {
            ConfigurationClass configurationClass = this.configurationClasses.get(entry.getMetadata());
            try {
                processImports(configurationClass, asSourceClass(configurationClass, exclusionFilter),
                               Collections.singleton(asSourceClass(entry.getImportClassName(), exclusionFilter)),
                               exclusionFilter, false);
            }
            catch (BeanDefinitionStoreException ex) {
                throw ex;
            }
            catch (Throwable ex) {
                throw new BeanDefinitionStoreException(
                    "Failed to process import candidates for configuration class [" +
                    configurationClass.getMetadata().getClassName() + "]", ex);
            }
        });
    }
}

grouping.getImports()方法中主要執(zhí)行具體的實(shí)現(xiàn)類(lèi)的process方法和selectImports()方法（如果是AutoConfigurationImportSelector類(lèi)，則調(diào)用org.springframework.boot.autoconfigure.AutoConfigurationImportSelector.AutoConfigurationGroup#process和org.springframework.boot.autoconfigure.AutoConfigurationImportSelector.AutoConfigurationGroup#selectImports，兩個(gè)方法的具體類(lèi)容請(qǐng)看2.2.2章節(jié)的說(shuō)明），selectImports返回需要自動(dòng)裝配的Group.Entry對(duì)象集合，Entry對(duì)象中保存了全類(lèi)名。代碼如下：

public Iterable<Group.Entry> getImports() {
    for (DeferredImportSelectorHolder deferredImport : this.deferredImports) {
        this.group.process(deferredImport.getConfigurationClass().getMetadata(),
                           deferredImport.getImportSelector());
    }
    return this.group.selectImports();
}

ImportSelector接口代碼代碼如下：

public interface ImportSelector {
	String[] selectImports(AnnotationMetadata importingClassMetadata);
	@Nullable
	default Predicate<String> getExclusionFilter() {
		return null;
	}
}

DeferredImportSelector接口的代碼如下：

public interface DeferredImportSelector extends ImportSelector {

    @Nullable
    default Class<? extends Group> getImportGroup() {
        return null;
    }
    interface Group {
        void process(AnnotationMetadata metadata, DeferredImportSelector selector);
        Iterable<Entry> selectImports();
        class Entry {
			// 省略
        }
    }
}

? 2.實(shí)現(xiàn)了 ImportBeanDefinitionRegistrar.class接口的場(chǎng)景;會(huì)先創(chuàng)建ImportBeanDefinitionRegistrar 實(shí)例類(lèi) registrar，再把 registrar 添加到 configClass 的 importBeanDefinitionRegistrars中，接口的registerBeanDefinitions方法的調(diào)用是在 org.springframework.context.annotation.ConfigurationClassPostProcessor#processConfigBeanDefinitions方法里的this.reader.loadBeanDefinitions(configClasses)代碼中。具體執(zhí)行語(yǔ)句loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());關(guān)鍵代碼如下，

private void loadBeanDefinitionsFromRegistrars(Map<ImportBeanDefinitionRegistrar, AnnotationMetadata> registrars) {
    registrars.forEach((registrar, metadata) ->
                       registrar.registerBeanDefinitions(metadata, this.registry, this.importBeanNameGenerator));
}

ImportBeanDefinitionRegistrar接口代碼如下：

public interface ImportBeanDefinitionRegistrar {

    default void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry,
                                         BeanNameGenerator importBeanNameGenerator) {
        registerBeanDefinitions(importingClassMetadata, registry);
    }

    default void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
    }
}

?3.沒(méi)有實(shí)現(xiàn)以上兩接口的普通類(lèi)，會(huì)直接調(diào)用org.springframework.context.annotation.ConfigurationClassParser#processImports里面的processConfigurationClass方法，把當(dāng)前configClass添加至 configurationClasses 集合中。configurationClasses集合中的對(duì)象最終會(huì)被注冊(cè)到BeanDefinitionRegistry類(lèi)型的 registry 對(duì)象中。

2.@SpringApplication注解分析

?@SpringApplication注解主要包括了@SpringBootConfiguration、@EnableAutoConfiguration、@ComponentScan。代碼如下，

@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) })

2.1@SpringBootConfiguration

?配置注解，包含了@Configuration注解，表明是配置類(lèi)。

2.2@EnableAutoConfiguration

?自動(dòng)裝配注解，主要邏輯是：根據(jù) EnableAutoConfiguration 類(lèi)型從META-INF/spring.factories 文件加載需要自動(dòng)裝配的類(lèi)，并注入到Spring容器中。它包括了@AutoConfigurationPackage注解和一個(gè)@Import(AutoConfigurationImportSelector.class)注解。代碼如下，

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)

2.2.1@AutoConfigurationPackage

?注冊(cè)名為 org.springframework.boot.autoconfigure.AutoConfigurationPackages ，BeanClass為BasePackages.class 的GenericBeanDefinition 到 BeanDefinitionRegistry 中，通過(guò)@Import 注解實(shí)現(xiàn)注入功能，代碼如下，

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@Import(AutoConfigurationPackages.Registrar.class)
public @interface AutoConfigurationPackage {
}

AutoConfigurationPackages.Registrar.class實(shí)現(xiàn)了ImportBeanDefinitionRegistrar接口，所以在Spring容器初始化的過(guò)程中會(huì)調(diào)用它的registerBeanDefinitions方法把PackageImport類(lèi)注入到Spring容器中去。代碼如下，

static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {
    @Override
    public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
        register(registry, new PackageImport(metadata).getPackageName());
    }
    @Override
    public Set<Object> determineImports(AnnotationMetadata metadata) {
        return Collections.singleton(new PackageImport(metadata));
    }
}

2.2.2@Import(AutoConfigurationImportSelector.class)

?自動(dòng)裝配關(guān)鍵邏輯，先從META-INF/spring.factories 文件加載類(lèi)型值為 EnableAutoConfiguration的字符串集合，再通過(guò)過(guò)濾，生成需要自動(dòng)裝配的類(lèi)，最后注入到Spring容器中。AutoConfigurationImportSelector實(shí)現(xiàn)了DeferredImportSelector接口并且內(nèi)部也實(shí)現(xiàn)了DeferredImportSelector.Group接口，所以在Spring容器初始化的過(guò)程中會(huì)調(diào)用

org.springframework.boot.autoconfigure.AutoConfigurationImportSelector.AutoConfigurationGroup#process方法和#selectImports方法，

process()用來(lái)生成需要自動(dòng)裝配的類(lèi)型，方法的代碼如下，

Assert.state(deferredImportSelector instanceof AutoConfigurationImportSelector,
             () -> String.format("Only %s implementations are supported, got %s",
                                 AutoConfigurationImportSelector.class.getSimpleName(),
                                 deferredImportSelector.getClass().getName()));
// 1. getAutoConfigurationMetadata（）
// 從META-INF/spring-autoconfigure-metadata.properties文件中獲取自動(dòng)裝配的元數(shù)據(jù)，
// 里面保存了加載類(lèi)是否自動(dòng)裝配的條件 ，
// org.springframework.boot.autoconfigure.jms.JmsAutoConfiguration.ConditionalOnBean
// =javax.jms.ConnectionFactory
// 2. getAutoConfigurationEntry（）
// 從 META-INF/spring.factories 文件中獲取key為 EnableAutoConfiguration 的配置類(lèi)字符串類(lèi)表 并封裝成 自動(dòng)裝配類(lèi)對(duì)象
AutoConfigurationEntry autoConfigurationEntry = ((AutoConfigurationImportSelector) deferredImportSelector)
    .getAutoConfigurationEntry(getAutoConfigurationMetadata(), annotationMetadata);
this.autoConfigurationEntries.add(autoConfigurationEntry);
// 循環(huán)遍歷 自動(dòng)裝配類(lèi)對(duì)象 的自動(dòng)裝配類(lèi)字符串 ，添加到 this.entries
for (String importClassName : autoConfigurationEntry.getConfigurations()) {
    this.entries.putIfAbsent(importClassName, annotationMetadata);
}

getAutoConfigurationMetadata() 方法主要邏輯是：從META-INF/spring-autoconfigure-metadata.properties文件中獲取自動(dòng)裝配的元數(shù)據(jù)，里面保存了自動(dòng)加載類(lèi)是否符合自動(dòng)裝配的前置條件，比較熟悉的有ConditionalOnClass和ConditionalOnBean，文件相關(guān)內(nèi)容如下：

org.springframework.boot.autoconfigure.data.jpa.JpaRepositoriesAutoConfiguration=
org.springframework.boot.autoconfigure.web.client.RestTemplateAutoConfiguration.AutoConfigureAfter=org.springframework.boot.autoconfigure.http.HttpMessageConvertersAutoConfiguration
org.springframework.boot.autoconfigure.data.cassandra.CassandraReactiveDataAutoConfiguration.ConditionalOnClass=com.datastax.driver.core.Cluster,reactor.core.publisher.Flux,org.springframework.data.cassandra.core.ReactiveCassandraTemplate
org.springframework.boot.autoconfigure.data.solr.SolrRepositoriesAutoConfiguration.ConditionalOnClass=org.apache.solr.client.solrj.SolrClient,org.springframework.data.solr.repository.SolrRepository
org.springframework.boot.autoconfigure.security.oauth2.client.servlet.OAuth2ClientAutoConfiguration.ConditionalOnWebApplication=SERVLET
org.springframework.boot.autoconfigure.web.servlet.error.ErrorMvcAutoConfiguration=
org.springframework.boot.autoconfigure.jersey.JerseyAutoConfiguration.AutoConfigureBefore=org.springframework.boot.autoconfigure.web.servlet.DispatcherServletAutoConfiguration
org.springframework.boot.autoconfigure.jms.artemis.ArtemisXAConnectionFactoryConfiguration=
org.springframework.boot.autoconfigure.web.reactive.HttpHandlerAutoConfiguration.ConditionalOnWebApplication=REACTIVE
org.springframework.boot.autoconfigure.web.reactive.ReactiveWebServerFactoryAutoConfiguration.ConditionalOnWebApplication=REACTIVE
org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchRepositoriesAutoConfiguration=
org.springframework.boot.autoconfigure.security.oauth2.resource.servlet.OAuth2ResourceServerAutoConfiguration.ConditionalOnWebApplication=SERVLET
org.springframework.boot.autoconfigure.web.servlet.MultipartAutoConfiguration.ConditionalOnWebApplication=SERVLET
//省略

getAutoConfigurationEntry()方法主要邏輯是：從spring.factories 文件中獲取key為 EnableAutoConfiguration 的配置類(lèi)字符串列表并封裝成自動(dòng)裝配類(lèi)AutoConfigurationEntry對(duì)象，代碼如下，

protected AutoConfigurationEntry getAutoConfigurationEntry(AutoConfigurationMetadata autoConfigurationMetadata,
                                                           AnnotationMetadata annotationMetadata) {
    if (!isEnabled(annotationMetadata)) {
        return EMPTY_ENTRY;
    }
    // 獲取注解元數(shù)據(jù)的屬性
    AnnotationAttributes attributes = getAttributes(annotationMetadata);
    // 從spring.factories 文件中獲取key為 EnableAutoConfiguration 的配置類(lèi)字符串列表
    List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);
    // 去掉重復(fù)的 自動(dòng)裝配類(lèi)字符串
    configurations = removeDuplicates(configurations);
    // 根據(jù)注解元數(shù)據(jù)獲取 需要排除的類(lèi)名
    Set<String> exclusions = getExclusions(annotationMetadata, attributes);
    // 檢查排除的類(lèi)名
    checkExcludedClasses(configurations, exclusions);
    // 根據(jù)排除的類(lèi)名進(jìn)行排除
    configurations.removeAll(exclusions);
    // 從spring.factories 文件中獲取key為 AutoConfigurationImportFilter 的配置對(duì)象進(jìn)行過(guò)濾
    // 過(guò)濾規(guī)則從 getAutoConfigurationMetadata() 返回類(lèi)的數(shù)據(jù)中獲取
    configurations = filter(configurations, autoConfigurationMetadata);
    // 執(zhí)行導(dǎo)入配置類(lèi)的監(jiān)聽(tīng)事件
    fireAutoConfigurationImportEvents(configurations, exclusions);
    // 返回 AutoConfigurationEntry 對(duì)象
    return new AutoConfigurationEntry(configurations, exclusions);
}

getCandidateConfigurations()方法從spring.factories 文件中獲取類(lèi)型為 EnableAutoConfiguration 的配置類(lèi)字符串列表，代碼如下，

// getSpringFactoriesLoaderFactoryClass()方法返回 EnableAutoConfiguration
List<String> configurations = SpringFactoriesLoader.loadFactoryNames(getSpringFactoriesLoaderFactoryClass(),
				getBeanClassLoader());
		Assert.notEmpty(configurations, "No auto configuration classes found in META-INF/spring.factories. If you "
				+ "are using a custom packaging, make sure that file is correct.");
		return configurations;

在META-INF/spring.factories文件中EnableAutoConfiguration .class 對(duì)應(yīng)的實(shí)現(xiàn)類(lèi)字符串為

# Auto Configure
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\
org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\
org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration,\
org.springframework.boot.autoconfigure.batch.BatchAutoConfiguration,\
org.springframework.boot.autoconfigure.cache.CacheAutoConfiguration,\
// 省略

2.selectImports()方法返回排序后的 Entry(需要自動(dòng)裝配的包裝實(shí)體類(lèi)) 對(duì)象集合，代碼如下，

public Iterable<Entry> selectImports() {
    if (this.autoConfigurationEntries.isEmpty()) {
        return Collections.emptyList();
    }
    Set<String> allExclusions = this.autoConfigurationEntries.stream()
        .map(AutoConfigurationEntry::getExclusions).flatMap(Collection::stream).collect(Collectors.toSet());
    Set<String> processedConfigurations = this.autoConfigurationEntries.stream()
        .map(AutoConfigurationEntry::getConfigurations).flatMap(Collection::stream)
        .collect(Collectors.toCollection(LinkedHashSet::new));
    processedConfigurations.removeAll(allExclusions);
    // 返回排序后的 Entry 集合
    return sortAutoConfigurations(processedConfigurations, getAutoConfigurationMetadata()).stream()
        .map((importClassName) -> new Entry(this.entries.get(importClassName), importClassName))
        .collect(Collectors.toList());
}

注意：@EnableAutoConfiguration 注解的分析過(guò)程需要結(jié)合@Import注解的過(guò)程來(lái)看。