Spring Boot 的自动配置原理-优快云博客

Spring Boot 的自动配置是其 "约定大于配置" 理念的核心实现，它能自动配置 Spring 应用所需的各种组件，大幅减少手动配置。下面从核心注解、加载流程、条件过滤等方面详细讲解其原理，并结合关键源码说明。

一、自动配置的入口：@SpringBootApplication 注解

Spring Boot 应用的启动类通常标注@SpringBootApplication，这个注解是自动配置的起点，它是一个 "复合注解"，包含三个核心注解：

@SpringBootConfiguration：本质是@Configuration，标识当前类是配置类
@ComponentScan：扫描当前包及子包的组件（如@Component、@Service等）
@EnableAutoConfiguration：启用自动配置的核心注解

源码：@SpringBootApplication

java运行

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration // 等同于@Configuration
@ComponentScan(excludeFilters = { // 扫描组件
    @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
    @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class)
})
@EnableAutoConfiguration // 关键：启用自动配置
public @interface SpringBootApplication {
    // 排除指定的自动配置类
    Class<?>[] exclude() default {};
    String[] excludeName() default {};
    // ... 其他属性
}

二、@EnableAutoConfiguration：自动配置的开关

@EnableAutoConfiguration的核心作用是触发 Spring 容器自动导入符合条件的配置类，其实现依赖@Import注解导入AutoConfigurationImportSelector类。

源码：@EnableAutoConfiguration

java运行

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage // 自动注册当前包为基础包（用于扫描@Entity等）
@Import(AutoConfigurationImportSelector.class) // 关键：导入选择器
public @interface EnableAutoConfiguration {
    String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";
    // 排除不需要的自动配置类
    Class<?>[] exclude() default {};
    String[] excludeName() default {};
}

三、AutoConfigurationImportSelector：自动配置类的 "导入器"

AutoConfigurationImportSelector是自动配置的核心类，它通过selectImports方法筛选并导入符合条件的自动配置类，流程如下：

1. 核心方法：selectImports

该方法返回需要导入的自动配置类全类名数组，核心逻辑是获取候选配置类并过滤。

java运行

public class AutoConfigurationImportSelector implements DeferredImportSelector, BeanClassLoaderAware, etc. {

    @Override
    public String[] selectImports(AnnotationMetadata annotationMetadata) {
        if (!isEnabled(annotationMetadata)) { // 检查是否启用自动配置（默认启用）
            return NO_IMPORTS;
        }
        // 1. 加载自动配置的元数据（条件注解等信息）
        AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader
            .loadMetadata(this.beanClassLoader);
        // 2. 获取所有候选的自动配置类
        AutoConfigurationEntry autoConfigurationEntry = getAutoConfigurationEntry(
            autoConfigurationMetadata, annotationMetadata);
        return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
    }

    // 关键：获取自动配置入口（筛选候选类）
    protected AutoConfigurationEntry getAutoConfigurationEntry(
        AutoConfigurationMetadata autoConfigurationMetadata, AnnotationMetadata annotationMetadata) {
        // ... 检查是否启用（省略）

        // 1. 获取所有候选的自动配置类（从spring.factories加载）
        List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);
        // 2. 去重
        configurations = removeDuplicates(configurations);
        // 3. 排除用户指定的自动配置类（通过exclude属性）
        Set<String> exclusions = getExclusions(annotationMetadata, attributes);
        checkExcludedClasses(configurations, exclusions);
        configurations.removeAll(exclusions);
        // 4. 基于条件注解过滤（核心：只保留符合条件的配置类）
        configurations = filter(configurations, autoConfigurationMetadata);
        // ... 其他处理（发布事件等）
        return new AutoConfigurationEntry(configurations, exclusions);
    }
}

2. 加载候选配置类：getCandidateConfigurations

getCandidateConfigurations通过SpringFactoriesLoader从类路径下的META-INF/spring.factories文件中加载自动配置类。

java运行

protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
    // 从spring.factories中加载key为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;
}

// 指定加载的类型为EnableAutoConfiguration
protected Class<?> getSpringFactoriesLoaderFactoryClass() {
    return EnableAutoConfiguration.class;
}

四、SpringFactoriesLoader：SPI 机制的实现

SpringFactoriesLoader是 Spring 的一种 SPI（Service Provider Interface）实现，用于从类路径的META-INF/spring.factories文件中加载指定类型的实现类。

源码：SpringFactoriesLoader.loadFactoryNames

java运行

public final class SpringFactoriesLoader {
    public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";

    public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
        String factoryTypeName = factoryType.getName();
        // 加载所有spring.factories文件，返回key为接口名、value为实现类列表的Map
        return loadSpringFactories(classLoader).getOrDefault(factoryTypeName, Collections.emptyList());
    }

    private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
        MultiValueMap<String, String> result = cache.get(classLoader);
        if (result != null) {
            return result;
        }

        try {
            // 查找类路径下所有META-INF/spring.factories文件
            Enumeration<URL> urls = (classLoader != null ?
                classLoader.getResources(FACTORIES_RESOURCE_LOCATION) :
                ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));
            result = new LinkedMultiValueMap<>();
            while (urls.hasMoreElements()) {
                URL url = urls.nextElement();
                UrlResource resource = new UrlResource(url);
                // 解析文件为Properties（key=接口全类名，value=实现类全类名逗号分隔）
                Properties properties = PropertiesLoaderUtils.loadProperties(resource);
                for (Map.Entry<?, ?> entry : properties.entrySet()) {
                    String factoryTypeName = ((String) entry.getKey()).trim();
                    for (String factoryImplementationName : StringUtils.commaDelimitedListToStringArray((String) entry.getValue())) {
                        result.add(factoryTypeName, factoryImplementationName.trim());
                    }
                }
            }
            cache.put(classLoader, result);
            return result;
        }
        catch (IOException ex) {
            throw new IllegalArgumentException("Unable to load factories from location [" +
                                               FACTORIES_RESOURCE_LOCATION + "]", ex);
        }
    }
}

spring.factories 文件示例

Spring Boot 的spring-boot-autoconfigure包中包含META-INF/spring.factories，其中定义了大量自动配置类：

properties

# Auto Configure
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.boot.autoconfigure.web.servlet.DispatcherServletAutoConfiguration,\
org.springframework.boot.autoconfigure.web.servlet.ServletWebServerFactoryAutoConfiguration,\
org.springframework.boot.autoconfigure.data.jpa.JpaRepositoriesAutoConfiguration,\
# ... 其他数百个自动配置类

五、条件注解：过滤生效的自动配置类

从spring.factories加载的候选配置类并非全部生效，Spring Boot 通过条件注解（@Conditional系列）筛选符合当前环境的配置类。

常见条件注解：

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

示例：DispatcherServletAutoConfiguration

Spring MVC 的 DispatcherServlet 自动配置类，通过条件注解控制生效时机：

java运行

@Configuration(proxyBeanMethods = false)
@ConditionalOnWebApplication(type = Type.SERVLET) // 仅在Servlet Web应用中生效
@ConditionalOnClass(DispatcherServlet.class) // 类路径存在DispatcherServlet时生效
@AutoConfigureAfter(ServletWebServerFactoryAutoConfiguration.class) // 在指定配置类之后加载
public class DispatcherServletAutoConfiguration {

    // 定义DispatcherServlet的Bean
    @Bean(name = DEFAULT_DISPATCHER_SERVLET_BEAN_NAME)
    @ConditionalOnMissingBean(DispatcherServlet.class) // 容器中没有DispatcherServlet时才创建
    public DispatcherServlet dispatcherServlet(WebMvcProperties webMvcProperties) {
        DispatcherServlet dispatcherServlet = new DispatcherServlet();
        dispatcherServlet.setDispatchOptionsRequest(webMvcProperties.isDispatchOptionsRequest());
        // ... 配置其他属性
        return dispatcherServlet;
    }
}

六、自动配置的完整流程总结

启动触发：@SpringBootApplication包含@EnableAutoConfiguration，开启自动配置。
导入选择器：@EnableAutoConfiguration通过@Import导入AutoConfigurationImportSelector。
加载候选类：AutoConfigurationImportSelector通过SpringFactoriesLoader从META-INF/spring.factories加载所有EnableAutoConfiguration对应的自动配置类。
过滤配置类：
- 排除用户指定的类（exclude属性）。
- 通过条件注解（如@ConditionalOnClass）筛选符合当前环境的配置类。
注册 Bean：生效的自动配置类（@Configuration）通过@Bean向容器注册组件，完成自动配置。