??上一篇??我們從 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<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);
configurations = removeDuplicates(configurations);
Set<String> exclusions = getExclusions(annotationMetadata, attributes);
checkExcludedClasses(configurations, exclusions);
// 這里會刪除我們手動關閉的自動配置項
configurations.removeAll(exclusions);
// 過濾掉不需要自動配置的項
configurations = getConfigurationClassFilter().filter(configurations);
fireAutoConfigurationImportEvents(configurations, exclusions);
return new AutoConfigurationEntry(configurations, exclusions);
}
protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
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;
}
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<String> 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<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
......
try {
// 讀取 spring.factories 文件
Enumeration<URL> 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<AnnotationAttributes> 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<BeanDefinitionHolder> 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<? extends BeanDefinitionReader> 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<SourceClass> importCandidates, Predicate<String> exclusionFilter,
boolean checkForCircularImports) {
......
if (checkForCircularImports && isChainedImportOnStack(configClass)) {
......
}
else {
this.importStack.push(configClass);
try {
for (SourceClass candidate : importCandidates) {
// 處理 ImportSelector
if (candidate.isAssignable(ImportSelector.class)) {
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)) {
......
}
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. SpringApplication
1. run()
2. refreshContext()
3. refresh()
2. AbstractApplicationContext
1. refresh()
2. invokeBeanFactoryPostProcessors()
3. PostProcessorRegistrationDelegate
1. invokeBeanFactoryPostProcessors()
4. ConfigurationClassPostProcessor
1. postProcessBeanDefinitionRegistry()
2. processConfigBeanDefinitions()
5. ConfigurationClassParser
1. parse()
6. ConfigurationClassParser.DeferredImportSelectorHandler
1. process()
7. ConfigurationClassParser.DeferredImportSelectorGroupingHandler
1. processGroupImports()
8. ConfigurationClassParser.DeferredImportSelectorGrouping
1. getImports()
9. AutoConfigurationImportSelector.AutoConfigurationGroup
1. process()
10. AutoConfigurationImportSelector
1. 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 的衍生注解，見表 8-1：
注解 | 說明 |
@ConditionalOnBean | 當容器里有指定 Bean 時 |
@ConditionalOnMissingBean | 當容器里沒有指定 Bean 時 |
@ConditionalOnClass | classpath 里有指定的類時 |
@ConditionalOnMissingClass | classpath 里沒有指定的類時 |
@ConditionalOnExpression | 給定的 Spring Expression Language（SpEL）表達式計算結果為 true 時 |
@ConditionalOnJava | JVM 的版本匹配特定值或者一個范圍時 |
@ConditionalOnJndi | 參數中給定的 JNDI 位置至少存在一個時（如果沒有給參數，則要有 JNDI InitialContext） |
@ConditionalOnProperty | 指定的屬性為指定的值時 |
@ConditionalOnResource | classpath 里有指定的資源時 |
@ConditionalOnWebApplication | 當前應用是 Web 應用時 |
@ConditionalOnNotWebApplication | 當前應用不是 Web 應用時 |
這些注解都是基于 @Conditional，可以覆蓋到我們大多數的使用場景，如果以上情況不能滿足你的需求，還可以通過自己實現 Condition 接口來完成自定義的需求。
