SpringBoot 自动配置原理

Spring Boot 的自动配置（Auto-Configuration）是其核心特性之一，它通过条件化配置和约定优于配置的原则，极大地简化了 Spring 应用的开发。下面我们从源码角度详细分析 Spring Boot 自动配置的原理，重点讲解关键点和核心流程。

---

1. 自动配置的核心原理

Spring Boot 的自动配置是通过 @EnableAutoConfiguration 注解和 spring.factories 文件实现的。其核心思想是：

1. 条件化配置：根据项目的依赖和配置，动态决定哪些 Bean 需要被加载。
2. 约定优于配置：通过默认配置减少开发者的手动配置。

---

2. 自动配置的入口：@EnableAutoConfiguration

@EnableAutoConfiguration 是 Spring Boot 自动配置的入口注解。它位于 @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 {
    // ...
}

• @EnableAutoConfiguration：启用自动配置。
• @ComponentScan：扫描当前包及其子包下的组件。

---

3. 自动配置的核心类：AutoConfigurationImportSelector

@EnableAutoConfiguration 注解的核心逻辑由 AutoConfigurationImportSelector 类实现。它负责加载自动配置类。

3.1 AutoConfigurationImportSelector 的源码分析

AutoConfigurationImportSelector 实现了 DeferredImportSelector 接口，其核心方法是 selectImports：

@Override
public String[] selectImports(AnnotationMetadata annotationMetadata) {
    if (!isEnabled(annotationMetadata)) {
        return NO_IMPORTS;
    }
    AutoConfigurationEntry autoConfigurationEntry = getAutoConfigurationEntry(annotationMetadata);
    return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
}

• getAutoConfigurationEntry()：获取自动配置类的列表。

3.2 getAutoConfigurationEntry() 的源码分析

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

• getCandidateConfigurations()：加载所有候选的自动配置类。
• removeDuplicates()：去重。
• getExclusions()：获取需要排除的配置类。
• filter()：根据条件过滤不需要的配置类。

---

4. 加载自动配置类

getCandidateConfigurations 方法通过 SpringFactoriesLoader 加载 META-INF/spring.factories 文件中的自动配置类。

springboot 3.x 已经变更了，不再加载 META-INF/spring.factories，而是改为加载 META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports.imports

public static ImportCandidates load(Class<?> annotation, ClassLoader classLoader) {
    Assert.notNull(annotation, "'annotation' must not be null");
    ClassLoader classLoaderToUse = decideClassloader(classLoader);
    String location = String.format("META-INF/spring/%s.imports", annotation.getName());
    Enumeration<URL> urls = findUrlsInClasspath(classLoaderToUse, location);
    List<String> importCandidates = new ArrayList();

    while(urls.hasMoreElements()) {
        URL url = (URL)urls.nextElement();
        importCandidates.addAll(readCandidateConfigurations(url));
    }

    return new ImportCandidates(importCandidates);
}

4.1 spring.factories 文件

spring.factories 文件位于 spring-boot-autoconfigure 模块的 META-INF 目录下，内容如下：

# 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,\
# ...

• EnableAutoConfiguration：键名，表示自动配置类。
• 值：逗号分隔的自动配置类列表。

4.2 org.springframework.boot.autoconfigure.AutoConfiguration.imports 文件

org.springframework.boot.autoconfigure.AutoConfiguration.imports 文件位于 spring-boot-autoconfigure 模块的 META-INF/spring 目录下，内容如下：

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
...

4.3 SpringFactoriesLoader.loadFactoryNames() 的源码分析

SpringFactoriesLoader 是 Spring 提供的工具类，用于加载 spring.factories 文件中的配置：

public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
    String factoryTypeName = factoryType.getName();
    return loadSpringFactories(classLoader).getOrDefault(factoryTypeName, Collections.emptyList());
}

• loadSpringFactories()：加载 spring.factories 文件并解析为 Map。
• getOrDefault()：获取指定键（如 EnableAutoConfiguration）对应的值（自动配置类列表）。

---

5. 条件化配置：@Conditional

自动配置类的加载是通过条件化配置（@Conditional）实现的。Spring Boot 提供了多种条件注解，用于控制 Bean 的加载。

5.1 常用的条件注解

• @ConditionalOnClass：当类路径中存在指定类时生效。
• @ConditionalOnMissingBean：当容器中不存在指定 Bean 时生效。
• @ConditionalOnProperty：当配置文件中存在指定属性时生效。
• @ConditionalOnWebApplication：当应用是 Web 应用时生效。

5.2 示例：DataSourceAutoConfiguration

DataSourceAutoConfiguration 是 Spring Boot 中数据源自动配置的核心类：

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

• @ConditionalOnClass：当类路径中存在 DataSource 和 EmbeddedDatabaseType 时生效。
• @ConditionalOnMissingBean：当容器中不存在 ConnectionFactory Bean 时生效。
• @EnableConfigurationProperties：启用 DataSourceProperties 配置绑定。

---

6. 自动配置的执行流程

1. 启动应用：

   • Spring Boot 启动时，@SpringBootApplication 注解会触发 @EnableAutoConfiguration。

2. 加载自动配置类：

   • AutoConfigurationImportSelector 通过 spring.factories 加载所有候选的自动配置类。

3. 条件化过滤：

   • 根据条件注解（如 @ConditionalOnClass）过滤不需要的配置类。

4. 注册 Bean：

   • 符合条件的自动配置类会向容器中注册 Bean。

5. 应用配置：

   • 自动配置的 Bean 会根据配置文件（如 application.properties）进行初始化。

---

7. 总结

Spring Boot 的自动配置原理可以概括为以下步骤：

1. 入口：@EnableAutoConfiguration 注解启用自动配置。
2. 加载：通过 spring.factories 文件加载所有候选的自动配置类。
3. 过滤：根据条件注解（如 @ConditionalOnClass）过滤不需要的配置类。
4. 注册：符合条件的配置类会向容器中注册 Bean。
5. 应用：自动配置的 Bean 会根据配置文件进行初始化。

通过这种方式，Spring Boot 实现了“约定优于配置”的理念，极大地简化了 Spring 应用的开发。希望这个详细的源码分析能帮助你更好地理解 Spring Boot 的自动配置原理！