Spring Boot 自动配置实现原理

于 2025-05-08 09:26:58 发布
阅读量1.3k 收藏 29
点赞数 22
CC 4.0 BY-SA版权
分类专栏： spring spring boot java 文章标签： spring boot java 后端 spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/a1256afafaafr/article/details/147767992

Spring Boot 3.x 与 Spring Boot 2.x 自动配置实现原理 分析。

🧠 一、Spring Boot 2.x 自动配置原理（基于 spring.factories）

✅ 1. 自动配置入口：@EnableAutoConfiguration

Spring Boot 2.x 的自动配置通过 @EnableAutoConfiguration 注解触发：

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

✅ 2. 自动配置类加载机制：SpringFactoriesLoader

Spring Boot 2.x 使用 SpringFactoriesLoader 从 META-INF/spring.factories 文件中加载自动配置类：

public final class SpringFactoriesLoader {
    public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
        String factoryTypeName = factoryType.getName();
        ClassLoader classLoaderToUse = classLoader != null ? classLoader : ClassLoader.getSystemClassLoader();
        Enumeration<URL> urls = classLoaderToUse.getResources(FACTORIES_RESOURCE_LOCATION); // 即 "META-INF/spring.factories"
        List<String> result = new ArrayList<>();
        while (urls.hasMoreElements()) {
            URL url = urls.nextElement();
            Properties properties = PropertiesLoaderUtils.loadProperties(new UrlResource(url));
            String factoryClassNames = properties.getProperty(factoryTypeName);
            if (factoryClassNames != null) {
                result.addAll(Arrays.asList(StringUtils.commaDelimitedListToStringArray(factoryClassNames)));
            }
        }
        return result;
    }
}

✅ 3. 自动配置类的筛选机制

Spring Boot 会加载所有 spring.factories 中的自动配置类，并通过 @Conditional 系列注解（如 @ConditionalOnClass、@ConditionalOnMissingBean）筛选是否生效。

public class AutoConfigurationImportSelector implements DeferredImportSelector, BeanClassLoaderAware, ResourceLoaderAware {
    @Override
    public String[] selectImports(AnnotationMetadata annotationMetadata) {
        List<String> configurations = getCandidateConfigurations(annotationMetadata, null);
        configurations = removeDuplicates(configurations);
        Set<String> autoConfigurationGroup = getAutoConfigurationGroup(annotationMetadata, configurations);
        return StringUtils.toStringArray(autoConfigurationGroup);
    }

    protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
        // 通过 SpringFactoriesLoader 加载 spring.factories 中的自动配置类
        List<String> configurations = SpringFactoriesLoader.loadFactoryNames(getSpringFactoriesLoaderFactoryClass(), getBeanClassLoader());
        Assert.notEmpty(configurations, "No auto configuration classes found in META-INF/spring.factories");
        return configurations;
    }
}

✅ 4. spring.factories 示例

# META-INF/spring.factories
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.example.autoconfig.MyAutoConfiguration

✅ 5. 自动配置类示例

@Configuration
@ConditionalOnClass(MyService.class)
@ConditionalOnMissingBean
public class MyAutoConfiguration {
    @Bean
    public MyService myService() {
        return new MyService();
    }
}

🔄 二、Spring Boot 3.x 自动配置原理（基于 AutoConfiguration.imports）

✅ 1. 移除 spring.factories，使用 AutoConfiguration.imports

Spring Boot 3.x 不再依赖 spring.factories，而是使用新的配置方式 META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports。

✅ 示例文件路径：
src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports
✅ 文件内容（每行一个自动配置类）：
com.example.autoconfig.MyAutoConfiguration

✅ 2. 自动配置类加载机制：AutoConfigurationImportSelector 改进

Spring Boot 3.x 中，AutoConfigurationImportSelector 内部逻辑发生变化，改为直接读取 AutoConfiguration.imports 文件。

public class AutoConfigurationImportSelector implements DeferredImportSelector, BeanClassLoaderAware, ResourceLoaderAware {
    @Override
    public String[] selectImports(AnnotationMetadata annotationMetadata) {
        List<String> configurations = getCandidateConfigurations(annotationMetadata, null);
        configurations = removeDuplicates(configurations);
        Set<String> autoConfigurationGroup = getAutoConfigurationGroup(annotationMetadata, configurations);
        return StringUtils.toStringArray(autoConfigurationGroup);
    }

    protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
        List<String> configurations = new ArrayList<>();
        try {
            // 新版：直接读取 AutoConfiguration.imports 文件
            Enumeration<URL> urls = getClass().getClassLoader().getResources("META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports");
            while (urls.hasMoreElements()) {
                URL url = urls.nextElement();
                Properties properties = new Properties();
                properties.load(url.openStream());
                properties.forEach((key, value) -> configurations.add((String) key));
            }
        } catch (IOException ex) {
            throw new IllegalStateException("Failed to load auto-configuration imports", ex);
        }
        return configurations;
    }
}

✅ 3. 条件注解机制保持不变

Spring Boot 3.x 依然使用 @Conditional 系列注解进行条件装配：

@Configuration
@ConditionalOnClass(MyService.class)
@ConditionalOnMissingBean
public class MyAutoConfiguration {
    @Bean
    public MyService myService() {
        return new MyService();
    }
}

✅ 4. 支持 Java 17 的新特性（如 getDeclaredConstructors()）

Spring Boot 3.x 要求使用 JDK 17 或更高版本，因此内部反射调用方式有所变化：

// Spring Boot 2.x（JDK 8 兼容）
Method method = clazz.getDeclaredMethod("someMethod");

// Spring Boot 3.x（JDK 17+）
Constructor<?> constructor = clazz.getDeclaredConstructors()[0];

📦 三、Spring Boot 3.x 自动配置的完整流程

✅ 1. 启动类：@SpringBootApplication

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

✅ 2. @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：扫描组件
  • @SpringBootConfiguration：标记为配置类

✅ 3. @EnableAutoConfiguration 的实现

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {
}
  • @Import(AutoConfigurationImportSelector.class)：导入自动配置选择器

✅ 4. AutoConfigurationImportSelector 的改进（Spring Boot 3.x）

public class AutoConfigurationImportSelector implements DeferredImportSelector, BeanClassLoaderAware, ResourceLoaderAware {
    @Override
    public String[] selectImports(AnnotationMetadata annotationMetadata) {
        List<String> configurations = getCandidateConfigurations(annotationMetadata, null);
        configurations = removeDuplicates(configurations);
        Set<String> autoConfigurationGroup = getAutoConfigurationGroup(annotationMetadata, configurations);
        return StringUtils.toStringArray(autoConfigurationGroup);
    }

    protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
        List<String> configurations = new ArrayList<>();
        try {
            // 新版：读取 AutoConfiguration.imports 文件
            Enumeration<URL> urls = getClass().getClassLoader().getResources("META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports");
            while (urls.hasMoreElements()) {
                URL url = urls.nextElement();
                Properties properties = new Properties();
                properties.load(url.openStream());
                properties.forEach((key, value) -> configurations.add((String) key));
            }
        } catch (IOException ex) {
            throw new IllegalStateException("Failed to load auto-configuration imports", ex);
        }
        return configurations;
    }
}

✅ 5. AutoConfiguration.imports 文件格式（Spring Boot 3.x）

# META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports
com.example.autoconfig.MyAutoConfiguration

🧱 四、Spring Boot 2.x 与 3.x 自动配置的核心差异

特性Spring Boot 2.xSpring Boot 3.x
自动配置文件META-INF/spring.factoriesMETA-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports
配置加载方式SpringFactoriesLoaderProperties.load() 直接读取
支持的 JDK 版本JDK 8 ~ 17（兼容旧版本）JDK 17+（不兼容 JDK 8）
自动配置类加载方式通过 SpringFactoriesLoader 加载通过 Properties 文件直接读取
性能优化无显著优化避免多次加载 spring.factories，提升启动速度
模块化支持不支持 JPMS（Java Platform Module System）支持 JPMS，兼容模块化项目
反射 API 使用使用 getDeclaredMethod()使用 getDeclaredConstructors()（适配 JDK 17）

🔄 五、Spring Boot 3.x 自动配置的源码执行流程（简化版）

@SpringBootApplication
 └── @EnableAutoConfiguration
      └── @Import(AutoConfigurationImportSelector.class)
           └── AutoConfigurationImportSelector.selectImports()
                └── getCandidateConfigurations()
                     └── 读取 META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports 文件
                          └── 加载自动配置类（如 MyAutoConfiguration）
                └── 过滤重复配置
                └── 按条件筛选（@ConditionalOnClass、@ConditionalOnMissingBean 筃
                └── 注册为 BeanDefinition 并注册到容器

🧩 六、Spring Boot 3.x 自动配置的源码关键类

类名作用
AutoConfigurationImportSelectorSpring Boot 自动配置的核心类，负责加载自动配置类
AutoConfiguration.importsSpring Boot 3.x 的自动配置类配置文件
SpringFactoriesLoaderSpring Boot 2.x 使用的自动配置类加载器
AutoConfigurationGroup负责按条件筛选自动配置类
ConditionEvaluator评估 @Conditional 注解是否满足条件

🧱 七、Spring Boot 3.x 自动配置的性能优化

✅ 1. 避免重复加载 spring.factories

Spring Boot 3.x 使用 AutoConfiguration.imports 替代 spring.factories，避免了多个 spring.factories 文件的合并和去重操作，提升加载效率。

✅ 2. 支持模块化项目（JPMS）

Spring Boot 3.x 完全支持 Java 9+ 的模块化系统（JPMS），自动配置类可以在模块中声明，无需手动配置。

✅ 3. JDK 17 兼容性优化

Spring Boot 3.x 使用 JDK 17 的新特性，如 getDeclaredConstructors() 替代 getDeclaredMethods()，提高反射性能。

📦 八、Spring Boot 3.x 自动配置迁移指南

✅ 1. 从 Spring Boot 2.x 迁移到 3.x

步骤 1：修改自动配置类的注册方式

Spring Boot 2.x：

# META-INF/spring.factories
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.example.autoconfig.MyAutoConfiguration

Spring Boot 3.x：

# META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports
com.example.autoconfig.MyAutoConfiguration
步骤 2：更新依赖版本

确保所有依赖库已升级到支持 Spring Boot 3.x 的版本（如 Spring Boot 3.0+、Spring Framework 6.0+、Jakarta EE 9+）。

步骤 3：适配 JDK 17+
  • 使用 getDeclaredConstructors() 替代 getDeclaredMethods()
  • 替换 javax.* 为 jakarta.*
  • 使用新的模块化方式构建项目（如 module-info.java）
步骤 4：测试自动配置行为
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        ApplicationContext context = SpringApplication.run(Application.class, args);
        MyService service = context.getBean(MyService.class);
        service.doSomething(); // 验证自动配置是否生效
    }
}

🧪 九、完整示例：Spring Boot 3.x 自动配置实现

1. 自动配置类定义

@Configuration
@ConditionalOnClass(MyService.class)
@ConditionalOnMissingBean
public class MyAutoConfiguration {
    @Bean
    public MyService myService() {
        return new MyService();
    }
}

2. 配置文件（Spring Boot 3.x）

# META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports
com.example.autoconfig.MyAutoConfiguration

3. 使用自动配置类

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        ApplicationContext context = SpringApplication.run(Application.class, args);
        MyService service = context.getBean(MyService.class);
        service.doSomething(); // 自动配置生效
    }
}

✅ 十、总结

特性Spring Boot 2.xSpring Boot 3.x
自动配置文件spring.factoriesAutoConfiguration.imports
自动配置类加载方式SpringFactoriesLoaderProperties.load() 直接读取
JDK 支持JDK 8 ~ 17JDK 17+
模块化支持不支持 JPMS支持 JPMS
反射 API 改进使用 getDeclaredMethod()使用 getDeclaredConstructors()
性能优化无显著优化避免多次加载 spring.factories
条件注解机制保持一致保持一致

🧩 十一、扩展

  • Spring Boot 3.x 自动配置的源码路径：

    • org.springframework.boot.autoconfigure.AutoConfigurationImportSelector
    • org.springframework.boot.autoconfigure.AutoConfigurationGroup

  • Spring Boot 3.x 的官方迁移指南：

  • Spring Boot 3.x 的模块化支持：

    • 支持 Java 9+ 模块化项目，自动配置类可以定义在模块中

  • Spring Boot 3.x 与 Jakarta EE 9+ 的兼容性：

    • 所有 javax.* 包名替换为 jakarta.*
Spring Boot 自动配置实现原理与自定义开发指南
记录学习的过程
05-06 1063
Configuration(proxyBeanMethods = false) // 优化配置类代理@AutoConfigureAfter(DataSourceAutoConfiguration.class) // 在数据源配置后加载@ConditionalOnClass(MyService.class) // 类路径存在MyService时生效@EnableConfigurationProperties(MyProperties.class) // 启用配置属性@Bean。
Spring Boot 自动配置实现原理（源码分析）
weixin_42118323的博客
07-01 1617
这里我们只简单贴出两个重点方法，process 方法和 selectImports 方法，我们在 process 方法中看到了 AutoConfigurationImportSelector#getAutoConfigurationEntry 方法，这个方法在项目启动时候是调用了的，因此我们可以进一步猜测，项目启动的时候是调用了 AutoConfigurationImportSelector.AutoConfigurationGroup#process 方法。下面我们从源码层面去剖析。
springboot核心基础之spring.factories机制
Javaesandyou的博客
12-08 1514
引言 在java spring cloud项目中，我们常常会在子模块中创建公共方法，那么在另外一个子模块中，需要加载配置文件的时候，往往Spring Boot 自动扫描包的时候，只会扫描自己模块下的类。这个是springboot约定俗成的内容。 抛出问题 如果想要被Spring容器管理的Bean的路径不再Spring Boot 的包扫描路径下，怎么办呢？也就是如何去加载第三方的Bean 呢？ 目前较通用的方式有2种，一是使用注解进行实例化，而是使用spring.factories机制。 这里我们使
【SpringBoot 二】spring.factories加载时机分析
石臻臻的杂货铺(szzdzhp001)
08-18 5414
spring.factories作用 这个类似于Java中的SPI功能,SpringBoot启动的时候会读取所有jar包下面的META-INF/spring.factories文件; 并且将文件中的 接口/抽象类 对应的实现类都对应起来,并在需要的时候可以实例化对应的实现类 下面我们来分析一下源码看看spring.factories的使用场景 源码解析 启动SpringApplication,看看构造方法 public SpringApplication(ResourceLoader resour
【Spring面试全家桶】SpringBoot中的spring.factories文件有什么作用？
我是Java程序员廖志伟，感谢朋友们的支持！不定期贡献一篇高品质、过万文字、图文并茂且附有视频解说、满载代码示例注释的良心之作，坚决杜绝粗制乱造。
06-30 3480
这样就能够快速地自动配置相关的组件和功能，简化了Spring Boot的配置过程。总的来说，Spring Boot中的自动配置原理主要是基于SPI机制的，通过读取classpath下的spring.factories文件，来自动加载对应的自动配置类，并按照一定的规则进行配置。@EnableAutoConfiguration注解是Spring Boot自动配置的核心注解之一，其底层实现原理是使用@Import注解来导入一个或多个自动配置类，Spring Boot会根据其顺序进行配置，并自动加载依赖的配置类。
SpringBoot启动类默认自动扫描包范围 + spring.factories理解
Java后端技术栈
04-19 1万+
SpringBoot应用启动时，默认会自动扫描与启动类在同个包以及子包下的Bean。 所以当启动类的包名与项目子模块等的包名不同时，可以在启动类上添加包扫描注解： package com.xxx.app.bff.service; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.sprin
springboot 3.X spring.factories文件配置变化
01-15 115
spring.factories
Spring Boot面试杀手锏————自动配置原理
热门推荐
Morty的技术乐园
11-07 19万+
引言 不论在工作中，亦或是求职面试，Spring Boot已经成为我们必知必会的技能项。除了某些老旧的政府项目或金融项目持有观望态度外，如今的各行各业都在飞速的拥抱这个已经不是很新的Spring启动框架。 当然，作为Spring Boot的精髓，自动配置原理的工作过程往往只有在“面试”的时候才能用得上，但是如果在工作中你能够深入的理解Spring Boot的自动配置原理，将无往不利。 Spr...
Spring Boot 自动配置原理及过程
yuanchun的知识整理
08-06 3266
Spring Boot 自动配置原理及过程
Spring Boot自动配置实现原理
你好，我们在哪里见过啊！
08-24 1万+
我们在使用Spring Boot构建Java Web项目的时候，实现起来非常的简单，那么SpringBoot是如何做到看似简单，却能够实现我们之前使用SSM或者SSH结合复杂配置实现的功能的呢？ 我们在看Spring Boot的介绍的时候，常看到下面一段话：Spring Boot 是由 Pivotal 团队提供的全新框架，其设计目的是用来简化新 Spring 应用的初始搭建以及开发过程。该框架使...
浅谈spring.factories文件的作用
chinaherolts2008的博客
08-01 100
spring.factories文件是Spring Boot自动配置的核心文件之一，它的作用是将各种自动配置类与对应的配置类集中在一起，方便Spring Boot自动装配。该文件的格式为键值对，键是自动配置类的全限定名，值是该自动配置类所对应的配置类的全限定名。本文主要介绍了浅谈spring.factories文件的作用,spring.factories文件是Spring Boot自动配置的核心文件之一,它的作用是将各种自动配置类与对应的配置类集中在一起,下面就来介绍一下如何使用,感兴趣的可以了解一下。
Spring Boot 3.x 与 2.x 版本的主要区别与改进
最新发布
嗨，欢迎来到我的 优快云 博客小天地！一名深耕多年的技术发烧友。在这里，我将把日常工作中积累的宝贵经验，从复杂架构设计的精妙之处，到代码优化的实战技巧，毫无保留地分享给大家。
04-20 6880
Spring Boot 3.x 与 2.x 版本的主要区别与改进
Spring Boot 3.x：自动配置类加载机制的变化
weixin_54574094的博客
12-17 1331
Spring Boot 3.x 对自动配置类加载机制的变化，主要是将自动配置类的注册方式从。
SpringBoot自动配置的8个宝藏技巧！
Java架构师之路的博客
01-02 560
作为开发者，我们也可以创建自定义的自动配置类，以便在特定条件下自动配置特定的 Bean。创建自动配置类：使用 @Configuration 和适当的 @Conditional 注解。@Bean在 spring.factories 中注册发布 Starter：将自动配置类打包在一个 Starter 中，供其他项目引入使用。通过上面 3个核心步骤，当我们在启动SpringBoot容器时，自定义的类就会被自动配置，实现我们要达到的预期。
为什么 SpringBoot 宁可挨骂也要干掉 spring.factories ？
m0_46995061的博客
03-27 1173
从SpringBoot 3.0开始，引入了基于imports文件的新机制，作为的替代方案。这些文件位于// 自定义扩展点加载器示例// 迁移到新机制// 或者实现自己的imports文件加载逻辑// ...// 1. 创建配置属性类// getter和setter方法// ...// 2. 创建自动配置类@AutoConfiguration// 注意这里使用了@AutoConfiguration而非@Configuration@Bean// 根据属性创建服务。
springboot2.0自动注入文件spring.factories如何加载详解
竹林幽深
10-25 1675
https://www.jianshu.com/p/5ac61de70ce6 1.首先看下启动类： @SpringBootApplication public class Application { public static void main(String[] args) { SpringApplication.run(Application.class); } } ...
SPRINGBOOT启动原理（基于2.x版本）（二）-SpringFactoriesLoader
盖丽男
03-11 518
目录版本SpringFactoriesLoader引入介绍代码 版本 版本：2.5.5 上一篇：SPRINGBOOT启动原理（基于2.x版本）（一） SpringFactoriesLoader 引入 从上一篇可以看到，代码中频繁地使用到了SpringFactoriesLoader这个类，大致能看出来是为了拿类的，今天我们详细的研究一下。 介绍 看一下官网的介绍： General purpose factory loading mechanism for internal use within the fr
SpringBoot 2.x SpringFactoriesLoader工厂加载机制解析
Java持续实践
06-13 563
文章目录SpringFactoriesLoader 作用介绍源码解析 SpringFactoriesLoader 作用介绍 其源码注释如下 General purpose factory loading mechanism for internal use within the framework. SpringFactoriesLoader loads and instantiates factories of a given type from "META-INF/spring.factories"
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值