上一篇我们从 run() 方法切入，分析了 Spring 容器的启动流程。今天我们拿 @SpringBootApplication 注解开刀，我们来看看这个注解为我们做了什么。先看它的源码：

@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) })
public @interface SpringBootApplication {......
}

可以看到，@SpringBootApplication 是一个组合注解。除了最上面的几个元注解以以外，还有三个 Spring 的注解：

• @SpringBootConfiguration，表示被注解的元素为一个 Spring Boot 配置类
• @EnableAutoConfiguration，负责开启自动配置的注解
• @ComponentScan，用于配置扫描的包路径

自动配置原理

关键点

我们重点关注 @EnableAutoConfiguration，我们继续深入源码：

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

@Import 注解和 AutoConfigurationImportSelector 类是我们需要特别关注的。先剧透一下结论：自动配置的工作就是在 AutoConfigurationImportSelector 类中完成的。通过 getAutoConfigurationEntry 方法得到一个需要自动配置的列表：

protected AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) {if (!isEnabled(annotationMetadata)) {return EMPTY_ENTRY;}AnnotationAttributes attributes = getAttributes(annotationMetadata);// 得到一个包含一百多个元素的列表List configurations = getCandidateConfigurations(annotationMetadata, attributes);configurations = removeDuplicates(configurations);Set exclusions = getExclusions(annotationMetadata, attributes);checkExcludedClasses(configurations, exclusions);// 这里会删除我们手动关闭的自动配置项configurations.removeAll(exclusions);// 过滤掉不需要自动配置的项configurations = getConfigurationClassFilter().filter(configurations);fireAutoConfigurationImportEvents(configurations, exclusions);return new AutoConfigurationEntry(configurations, exclusions);
}protected List getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {List 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;
}protected Class getSpringFactoriesLoaderFactoryClass() {return EnableAutoConfiguration.class;
}

getCandidateConfigurations 方法会获取到 Spring 预设的自动配置列表，一共有一百多项（具体的数量不同版本可能会有差别），这个列表的名单就放在 spring-boot-autoconfigure-x.x.x.RELEASE.jar 包中的 /META-INF/spring.factories 文件中。如果我们指定了需要关闭的自动配置项，那么会通过 configurations.removeAll(exclusions) 将其从列表中移除。最后通过 filter 方法过滤掉不需要自动配置的项，最终会得到一个包含所有需要自动配置项的列表。

层层深入

获取预设自动配置列表

AutoConfigurationImportSelector 类（在 getCandidateConfigurations() 方法中）通过调用 SpringFactoriesLoader 的 loadFactoryNames() 方法来读取 spring.factories 文件中的 key（org.springframework.boot.autoconfigure.EnableAutoConfiguration）来加载 Spring 预设的自动配置列表。

读取 spring.factories 文件的源码示例：

public final class SpringFactoriesLoader {// spring.factories 文件路径public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";......public static List loadFactoryNames(Class factoryType, @Nullable ClassLoader classLoader) {ClassLoader classLoaderToUse = classLoader;if (classLoaderToUse == null) {classLoaderToUse = SpringFactoriesLoader.class.getClassLoader();}String factoryTypeName = factoryType.getName();// 调用真正读取 spring.factories 文件的方法return loadSpringFactories(classLoaderToUse).getOrDefault(factoryTypeName, Collections.emptyList());}private static Map> loadSpringFactories(@Nullable ClassLoader classLoader) {......try {// 读取 spring.factories 文件Enumeration urls = classLoader.getResources(FACTORIES_RESOURCE_LOCATION);......}......}......
}

处理 @Import

分析完 AutoConfigurationImportSelector 类，下面来分析 @Import 注解。正是因为这个注解，ImportSelector 才能处理自动配置的逻辑。@Import 的处理逻辑是由 ConfigurationClassParser 类完成的，入口是 doProcessConfigurationClass() 方法：

class ConfigurationClassParser {......protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass)throws IOException {......// 处理 @PropertySource 注解for (AnnotationAttributes propertySource : AnnotationConfigUtils.attributesForRepeatable(sourceClass.getMetadata(), PropertySources.class,org.springframework.context.annotation.PropertySource.class)) {......}// 处理 @ComponentScan 注解Set componentScans = AnnotationConfigUtils.attributesForRepeatable(sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class);if (!componentScans.isEmpty() &&!this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) {for (AnnotationAttributes componentScan : componentScans) {Set scannedBeanDefinitions =this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());......}}// 处理 @Import 注解processImports(configClass, sourceClass, getImports(sourceClass), filter, true);// 处理 @ImportResource 注解AnnotationAttributes importResource =AnnotationConfigUtils.attributesFor(sourceClass.getMetadata(), ImportResource.class);if (importResource != null) {String[] resources = importResource.getStringArray("locations");Class readerClass = importResource.getClass("reader");for (String resource : resources) {String resolvedResource = this.environment.resolveRequiredPlaceholders(resource);configClass.addImportedResource(resolvedResource, readerClass);}}......}......private void processImports(ConfigurationClass configClass, SourceClass currentSourceClass,Collection importCandidates, Predicate exclusionFilter,boolean checkForCircularImports) {......if (checkForCircularImports && isChainedImportOnStack(configClass)) {......}else {this.importStack.push(configClass);try {for (SourceClass candidate : importCandidates) {// 处理 ImportSelectorif (candidate.isAssignable(ImportSelector.class)) {Class candidateClass = candidate.loadClass();ImportSelector selector = ParserStrategyUtils.instantiateClass(candidateClass, ImportSelector.class,this.environment, this.resourceLoader, this.registry);Predicate 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 importSourceClasses = asSourceClasses(importClassNames, exclusionFilter);// 递归调用processImports(configClass, currentSourceClass, importSourceClasses, exclusionFilter, false);}}else if (candidate.isAssignable(ImportBeanDefinitionRegistrar.class)) {......}else {this.importStack.registerImport(currentSourceClass.getMetadata(), candidate.getMetadata().getClassName());processConfigurationClass(candidate.asConfigClass(configClass), exclusionFilter);}}}......}}    
}

doProcessConfigurationClass() 方法调用 processImports() 方法来处理 @Import 注解。processImports() 方法中又分情况对 @Import 注解中的值执行了不同的处理逻辑。当值为 ImportSelector.class 及其子接口/实现类（AutoConfigurationImportSelector 是 ImportSelector 的实现类 ） 时，还会通过递归再次调用自己。

这段逻辑相对比较复杂，不仅有自我递归，还有多个方法间的“串联递归”。上面代码中，进入最后一个 else 下面的 processConfigurationClass() 方法，你会看到它里面还有对 doProcessConfigurationClass() 方法的调用，这样就形成了一个调用环： doProcessConfigurationClass() -> processImports() -> processConfigurationClass() -> doProcessConfigurationClass() 。

调用链

下面是我整理的一份从 Spring 容器启动一直到自动配置功能完成的方法调用链，可以在看源码或者 Debug 的时候作为参考：

1. SpringApplication1. run()2. refreshContext()3. refresh()
2. AbstractApplicationContext1. refresh()2. invokeBeanFactoryPostProcessors()
3. PostProcessorRegistrationDelegate1. invokeBeanFactoryPostProcessors()
4. ConfigurationClassPostProcessor1. postProcessBeanDefinitionRegistry()2. processConfigBeanDefinitions()
5. ConfigurationClassParser1. parse()
6. ConfigurationClassParser.DeferredImportSelectorHandler1. process()
7. ConfigurationClassParser.DeferredImportSelectorGroupingHandler1. processGroupImports()
8. ConfigurationClassParser.DeferredImportSelectorGrouping1. getImports()
9. AutoConfigurationImportSelector.AutoConfigurationGroup1. process()
10. AutoConfigurationImportSelector1. getAutoConfigurationEntry()

第一层级为类，其中还有几个是内部类，用“.”和主类隔开了，第二层级为该类下的方法。从上到下按顺序依次调用。

大致的调用关系就是这样，可以当做一个参考，不能保证完全严谨正确，需要注意不同版本可能有些许的出入，如果发现上述顺序有误，欢迎与我交流。

注意

如果你在网上搜索 Spring Boot 自动配置，你会发现很多文章的入手点是 AutoConfigurationImportSelector.selectImports()。那么他的文章是基于 Spring Boot 2.1.0 之前的版本。

之所以有这样的结论是因为在 2.1.0 之后的版本中 ConfigurationClassParser.processImports() 的代码如下：

if (selector instanceof DeferredImportSelector) {this.deferredImportSelectorHandler.handle(configClass, (DeferredImportSelector) selector);
}
else {String[] importClassNames = selector.selectImports(currentSourceClass.getMetadata());......
}

而 AutoConfigurationImportSelector 就是 DeferredImportSelector 的实现类，所以根本不会走 else 中的逻辑。

按需配置

Spring Boot 的自动配置再一次践行了约定优于配置的原则。它的自动配置并不是一股脑的将所有预设列表全部加载进来，而是非常智能的“按需配置”。能做到这一点要归功于 @Conditional 注解和 Condition 接口。它们使得各种配置只有在符合一定的条件时才会被加载。

在讲自动配置原理的时候，我们了解到 AutoConfigurationImportSelector.getAutoConfigurationEntry() 方法中 configurations = getConfigurationClassFilter().filter(configurations) 就是用来过滤那些不符合条件配置的。

我们以 DataSourceAutoConfiguration 为例来具体分析一下，先来看一下源码：

@Configuration(proxyBeanMethods = false)
@ConditionalOnClass({ DataSource.class, EmbeddedDatabaseType.class })
@ConditionalOnMissingBean(type = "io.r2dbc.spi.ConnectionFactory")
@EnableConfigurationProperties(DataSourceProperties.class)
@Import({ DataSourcePoolMetadataProvidersConfiguration.class,DataSourceInitializationConfiguration.InitializationSpecificCredentialsDataSourceInitializationConfiguration.class,DataSourceInitializationConfiguration.SharedCredentialsDataSourceInitializationConfiguration.class })
public class DataSourceAutoConfiguration {......
}

DataSourceAutoConfiguration 通过 @ConditionalOnClass({ DataSource.class, EmbeddedDatabaseType.class }) 告诉 Spring，只有当 classpath 下存在 DataSource.class 或 EmbeddedDatabaseType.class 时，DataSourceAutoConfiguration 才会被加载。

@ConditionalOnClass 是 @Conditional 的衍生注解，由 @Conditional 和 OnClassCondition 类组成，源码如下：

@Target({ ElementType.TYPE, ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Conditional(OnClassCondition.class)
public @interface ConditionalOnClass {......
}

内置条件注解

OnClassCondition 是一个实现了 Condition 接口的类，@ConditionalOnClass 表示 classpath 里有指定的类时加载配置。它是 @Conditional 众多衍生注解中的一个，Spring Boot 提供了一些基于 @Conditional 的衍生注解，见下表：

这些注解都是基于 @Conditional，可以覆盖到我们大多数的使用场景，如果以上情况不能满足你的需求，还可以通过自己实现 Condition 接口来完成自定义的需求。

更多独家精彩内容尽在我的新书《Spring Boot趣味实战课》中。