EnableAutoConfiguration 注解的原理

December 1, 2024 by walter

Table of Contents

在 Spring Boot 中，@EnableAutoConfiguration 是一个核心注解，它实现了自动配置的功能。它的作用是根据项目中依赖的库以及应用上下文中的配置，自动配置 Spring 应用程序的上下文。以下是它的原理和运行机制：

1. @EnableAutoConfiguration 的定义

@EnableAutoConfiguration 注解本质上是一个复合注解，其源码如下：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {
    Class<?>[] exclude() default {};
    String[] excludeName() default {};
}

主要包括以下两部分：

•   @AutoConfigurationPackage: 自动将当前类所在包及其子包中的所有组件注册到 Spring 容器。
•   @Import(AutoConfigurationImportSelector.class): 导入了 AutoConfigurationImportSelector，用来加载所有可用的自动配置类。

2. 自动配置的核心机制

2.1 自动配置类的定义

自动配置类通过 spring.factories 文件定义，这个文件通常位于 META-INF 目录下。例如：

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.boot.autoconfigure.web.servlet.WebMvcAutoConfiguration,\
org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration

•   每个类都是一个自动配置类，Spring Boot 会在应用启动时加载这些类。
•   自动配置类本质上是普通的 @Configuration 类，包含若干个条件注解（如 @ConditionalOnClass）。

2.2 条件注解 (@Conditional 系列)

@EnableAutoConfiguration 的核心是基于条件的配置，它通过一系列的条件注解决定是否加载某个配置类，例如：

•   @ConditionalOnClass: 检查某个类是否在类路径中（例如某个依赖是否存在）。
•   @ConditionalOnMissingBean: 检查某个 bean 是否已经存在，如果不存在，则加载配置。
•   @ConditionalOnProperty: 检查某个配置属性是否存在以及是否匹配特定值。

示例（简化的自动配置类）：

@Configuration
@ConditionalOnClass(DataSource.class)
public class DataSourceAutoConfiguration {
    @Bean
    public DataSource dataSource() {
        return new HikariDataSource();
    }
}

•   当类路径中存在 DataSource 类时，自动配置一个数据源 Bean。

3. 自动配置加载的过程

3.1 加载 spring.factories 文件

Spring Boot 启动时，通过 SpringFactoriesLoader 加载 spring.factories 文件中定义的自动配置类。

3.2 调用 AutoConfigurationImportSelector

@Import(AutoConfigurationImportSelector.class) 的作用是动态筛选并加载符合条件的自动配置类。

•   步骤 1: 读取所有的自动配置类。
•   步骤 2: 通过条件注解筛选符合条件的配置类。
•   步骤 3: 将符合条件的配置类导入到 Spring 容器中。

3.3 注册自动配置的 Bean

Spring 容器会根据自动配置类中定义的 @Bean 方法，将所需的 Bean 注册到容器中。

4. 自定义自动配置行为

4.1 排除某些自动配置类

可以使用 exclude 或 excludeName 参数排除特定的自动配置类：

@EnableAutoConfiguration(exclude = {DataSourceAutoConfiguration.class})

4.2 自定义配置优先级

通过设置 application.properties 文件中的属性，可以控制自动配置行为。例如：

spring.main.allow-bean-definition-overriding=true

5. 典型的工作流程

1.  启动 Spring Boot 应用时，@EnableAutoConfiguration 启用自动配置。
2.  Spring Boot 通过 SpringFactoriesLoader 加载所有自动配置类。
3.  AutoConfigurationImportSelector 筛选出符合条件的自动配置类。
4.  Spring 容器将自动配置类中的 Bean 注册到上下文。

6. 注解处理器逻辑

@EnableAutoConfiguration 的逻辑主要依赖于 AutoConfigurationImportSelector 来完成自动配置类的加载和注册。以下是简要描述其源码实现的流程：

@EnableAutoConfiguration 的核心逻辑

@EnableAutoConfiguration 注解通过 @Import(AutoConfigurationImportSelector.class) 将自动配置的选择器引入到 Spring 容器中。

AutoConfigurationImportSelector 的逻辑

AutoConfigurationImportSelector 是自动配置功能的核心，它的主要职责是加载、筛选和注册自动配置类。

关键方法实现

1.  selectImports 方法

这是自动配置类选择的入口方法：

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

•   调用 getAutoConfigurationEntry 获取符合条件的自动配置类列表。
•   返回配置类名称数组。

2.  getAutoConfigurationEntry 方法

负责加载和筛选自动配置类：

protected AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) {
    if (!isEnabled(annotationMetadata)) {
        return EMPTY_ENTRY;
    }
    List<String> configurations = loadAutoConfigurations();
    configurations = filter(configurations);
    return new AutoConfigurationEntry(configurations);
}

•   isEnabled: 检查自动配置是否启用（可以通过属性 spring.boot.enableautoconfiguration 控制）。
•   loadAutoConfigurations: 加载 META-INF/spring.factories 中定义的所有自动配置类。
•   filter: 通过条件注解筛选出当前环境有效的配置类。

3.  loadAutoConfigurations 方法

使用 SpringFactoriesLoader 从 spring.factories 中加载自动配置类：

private List<String> loadAutoConfigurations() {
    return SpringFactoriesLoader.loadFactoryNames(
            EnableAutoConfiguration.class, getClass().getClassLoader());
}

•   读取 META-INF/spring.factories 文件中 EnableAutoConfiguration 对应的自动配置类列表。

4.  筛选逻辑

自动配置类在注册之前，会根据以下条件进行筛选：
• @ConditionalOnClass: 检查类路径中是否存在某些依赖。
• @ConditionalOnMissingBean: 检查容器中是否已经存在特定的 Bean。
• @ConditionalOnProperty: 检查配置文件中的属性是否满足条件。
• @Conditional: 自定义的条件判断逻辑。

自动配置类的注册

经过筛选后，符合条件的自动配置类会被返回到 ConfigurationClassPostProcessor 中，由 Spring 容器解析并注册为配置类。

•   核心流程:
•   自动配置类被解析为 @Configuration 配置类。
•   通过 @Bean 定义的 Bean 方法被调用，Bean 被注册到 Spring 容器中。
•   这些自动配置类为项目提供了开箱即用的功能，如数据源、事务管理器等。

代码执行的整体流程
1. 启动时，@EnableAutoConfiguration 激活。
2. AutoConfigurationImportSelector 被执行。
3. 通过 SpringFactoriesLoader 加载所有自动配置类。
4. 结合环境条件筛选出符合条件的配置类。
5. 将符合条件的自动配置类导入 Spring 容器。
6. Spring 容器根据自动配置类创建相关的 Bean 并完成初始化。
小结

• 核心组件:
• @Import(AutoConfigurationImportSelector.class) 是入口。
• SpringFactoriesLoader 加载配置类。
• @Conditional 系列注解决定配置类是否生效。
• 优点:
• 自动配置通过条件判断，避免加载不必要的组件。
• 使用了 spring.factories 和模块化设计，方便扩展和自定义。
• 源码流程图:
```
@EnableAutoConfiguration
   ↓
@Import(AutoConfigurationImportSelector)
   ↓
AutoConfigurationImportSelector.selectImports()
   ↓
SpringFactoriesLoader.loadFactoryNames()
   ↓
筛选符合条件的自动配置类
   ↓
注册 Bean 到 Spring 容器
```

7. 相关源码

@EnableAutoConfiguration 和相关的自动配置逻辑的源代码主要位于 Spring Boot 的以下几个模块中：

@EnableAutoConfiguration 的定义

• 位置: spring-boot-autoconfigure 模块
• 类路径:

org.springframework.boot.autoconfigure.EnableAutoConfiguration

•   源码:

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {
    Class<?>[] exclude() default {};
    String[] excludeName() default {};
}

自动配置类的加载器

AutoConfigurationImportSelector

•   位置: spring-boot-autoconfigure 模块
•   类路径:

org.springframework.boot.autoconfigure.AutoConfigurationImportSelector

•   关键源码片段:

public class AutoConfigurationImportSelector implements DeferredImportSelector, BeanClassLoaderAware, EnvironmentAware, ResourceLoaderAware {
    @Override
    public String[] selectImports(AnnotationMetadata annotationMetadata) {
        AutoConfigurationEntry autoConfigurationEntry = getAutoConfigurationEntry(annotationMetadata);
        return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
    }

    protected AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) {
        if (!isEnabled(annotationMetadata)) {
            return EMPTY_ENTRY;
        }
        List<String> configurations = loadAutoConfigurations();
        configurations = filter(configurations);
        return new AutoConfigurationEntry(configurations);
    }

    private List<String> loadAutoConfigurations() {
        return SpringFactoriesLoader.loadFactoryNames(EnableAutoConfiguration.class, getClass().getClassLoader());
    }
}

加载 spring.factories 文件

SpringFactoriesLoader

•   位置: spring-core 模块
•   类路径:

org.springframework.core.io.support.SpringFactoriesLoader

•   关键源码片段:

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

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

    try {
        Enumeration<URL> urls = (classLoader != null ?
                classLoader.getResources(FACTORIES_RESOURCE_LOCATION) :
                ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));
        // Load and parse META-INF/spring.factories
    }
}

•   spring.factories 文件路径:

META-INF/spring.factories

该文件中定义了所有自动配置类：

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.boot.autoconfigure.web.servlet.WebMvcAutoConfiguration,\
org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration

自动配置类的示例

Spring Boot 提供了大量的自动配置类，例如：

•   Web 自动配置:

org.springframework.boot.autoconfigure.web.servlet.WebMvcAutoConfiguration

•   JPA 自动配置:

org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration

这些类也在 spring-boot-autoconfigure 模块中，路径通常为：

org.springframework.boot.autoconfigure.[module].[ClassName]

如何查看源码

1.  通过 IDE 查看源码:
•   导入 Spring Boot 的依赖。
•   按住 Ctrl（或 Cmd）点击注解，如 @EnableAutoConfiguration 或 AutoConfigurationImportSelector。
2.  从 GitHub 浏览源码:
•   Spring Boot GitHub 仓库:

https://github.com/spring-projects/spring-boot
• 关键目录：
• spring-boot-project/spring-boot-autoconfigure
• spring-boot-project/spring-core

Maven 本地缓存:
如果使用 Maven/Gradle 构建项目，可以从本地仓库中找到源码 jar 文件：

~/.m2/repository/org/springframework/boot/spring-boot-autoconfigure/<version>/spring-boot-autoconfigure-<version>-sources.jar

源码之间的调用关系

1.  @EnableAutoConfiguration 导入 AutoConfigurationImportSelector。
2.  AutoConfigurationImportSelector 调用 SpringFactoriesLoader 读取 spring.factories 文件。
3.  spring.factories 文件中定义的自动配置类按条件注解生效。

你可以从这些模块和类中完整了解 @EnableAutoConfiguration 的实现细节。

8. 小结

•   @EnableAutoConfiguration 是 Spring Boot 自动配置的核心，结合 spring.factories 和条件注解实现自动化配置。
•   通过 @Conditional 系列注解，自动配置类根据运行时环境动态生效。
•   开发者可以通过 exclude 或自定义配置文件，调整或禁用某些自动配置。

通过这种机制，Spring Boot 提供了高度灵活的自动化能力，让开发者专注于业务逻辑开发而不必关心繁杂的基础配置。

Comments |0|

Cancel

Legend *) Required fields are marked
**) You may use these HTML tags and attributes:

<a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <s> <strike> <strong>

Category: 似水流年

老范的自言自语 Walter's Solo