Spring Boot 自动配置基于约定优于配置理念，通过@EnableAutoConfiguration 注解和 Spring Factories 机制实现。核心原理涉及 AutoConfigurationImportSelector 扫描 META-INF/spring.factories 文件加载配置类。实战包括项目创建、配置文件管理（yml/properties）、自定义自动配置类及条件注解使用。高级应用涵盖条件注解深度用法、配置优先级解决冲突及常见依赖冲突处理方案。
在 Java 开发的广阔天地中，Spring Boot 已然成为一颗璀璨的明星，占据着极为重要的地位。它就像是一位贴心的助手，为开发者们带来了前所未有的便捷性和高效性。
Spring Boot 的诞生，是为了简化 Spring 应用的初始搭建以及开发过程。在它出现之前，传统的 Spring 开发就像是一场繁琐的配置马拉松。开发者们需要花费大量的时间和精力，去配置各种 XML 文件，定义 bean、数据源、事务管理器等等。一个简单的 Web 应用，可能就需要几十行甚至上百行的配置代码，这不仅耗费了开发者的心血，还容易出现各种配置错误。
而 Spring Boot 则打破了这种局面，它采用了约定优于配置的理念。这意味着，许多默认配置已经预先设定好了，只要开发者按照一定的命名规范和目录结构组织代码，就可以轻松地启动一个应用。比如，在创建一个 Spring Boot 项目时，我们只需在 pom.xml 文件中引入相关的依赖，Spring Boot 就能自动帮我们配置好所需的组件，无需手动编写大量的配置代码。就如同搭建积木一样，我们只需要将各种功能模块的积木（依赖）拼接起来，Spring Boot 就会自动帮我们构建出一个完整的应用框架。
Spring Boot 的自动配置，是其核心特性之一，也是约定优于配置理念的集中体现。简单来说，自动配置就是 Spring Boot 能够根据项目中引入的依赖和配置，自动为应用程序提供默认的配置。
当我们在项目中引入 spring-boot-starter-web 依赖时，Spring Boot 会自动配置 Tomcat 服务器、Spring MVC 框架等。它就像是一个智能的配置大师，能够根据我们的需求线索（引入的依赖），自动推断出我们想要的配置，并帮我们完成这些配置。这样一来，开发者无需手动编写大量的配置代码，就可以快速搭建起一个可运行的应用程序，大大提高了开发效率。
为了更直观地感受自动配置的重要性，我们来对比一下传统 Spring 开发和 Spring Boot 开发。
在传统的 Spring 开发中，以搭建一个简单的 Web 应用为例。我们需要在 web.xml 文件中配置 DispatcherServlet，指定其初始化参数和映射路径；在 Spring 的配置文件（如 spring-mvc.xml）中，配置视图解析器、组件扫描等。同时，还需要手动管理各种依赖的版本，确保它们之间的兼容性。这一系列的操作繁琐且容易出错，一个不小心，就可能因为版本冲突或者配置错误导致应用无法正常运行。
而在 Spring Boot 开发中，我们只需要在 pom.xml 文件中引入 spring-boot-starter-web 依赖，然后创建一个主启动类，并在类上添加 @SpringBootApplication 注解。这样，Spring Boot 就会自动帮我们完成 Tomcat 服务器的配置、DispatcherServlet 的注册、视图解析器的配置以及静态资源的映射等。我们只需要专注于编写业务逻辑代码，无需再为繁琐的配置工作烦恼。
通过这种对比，可以明显看出自动配置在提高开发效率、降低出错率方面的重要作用。它让开发者能够从繁琐的配置工作中解脱出来，将更多的时间和精力投入到业务逻辑的实现上，从而大大加快了项目的开发进度，提高了项目的质量。
在 Spring Boot 的自动配置体系中，@EnableAutoConfiguration 注解堪称核心中的核心，它就像是开启自动配置大门的一把神奇钥匙。当我们在 Spring Boot 应用的主类上添加 @SpringBootApplication 注解时，其实就已经间接引入了 @EnableAutoConfiguration 注解。因为 @SpringBootApplication 是一个组合注解，它包含了 @SpringBootConfiguration、@EnableAutoConfiguration 和 @ComponentScan 这三个重要注解。
@EnableAutoConfiguration 注解的主要作用，是告诉 Spring Boot 去自动配置应用程序。它通过触发 Spring 的 ImportSelector 机制，扫描并加载类路径下的自动配置类。具体来说，这个注解内部通过 @Import(AutoConfigurationImportSelector.class) 导入了 AutoConfigurationImportSelector 类，而这个类正是自动配置的核心处理器。
我们可以通过一个简单的代码示例来更直观地理解它的作用。首先，创建一个 Spring Boot 项目，并在主类上添加 @SpringBootApplication 注解：
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class MySpringBootApp {
public static void main(String[] args) {
SpringApplication.run(MySpringBootApp.class, args);
}
}
在这个例子中，@SpringBootApplication 注解中的 @EnableAutoConfiguration 发挥了关键作用。当 Spring Boot 应用启动时，它会根据 @EnableAutoConfiguration 注解的指示，去寻找并加载一系列的自动配置类。这些自动配置类会根据项目中引入的依赖和配置，为应用程序提供默认的配置。例如，如果项目中引入了 spring-boot-starter-web 依赖，那么 @EnableAutoConfiguration 会触发 Spring Boot 去加载与 Web 开发相关的自动配置类，如 WebMvcAutoConfiguration，从而自动配置 Spring MVC 的相关组件，包括请求映射处理器、视图解析器等。
AutoConfigurationImportSelector 类在 Spring Boot 的自动配置过程中扮演着至关重要的角色，它就像是一个智能的配置筛选器。该类实现了 DeferredImportSelector 接口，这使得它能够在 Spring 容器初始化过程中延迟导入配置类。
AutoConfigurationImportSelector 的核心方法是 selectImports()，它通过 SpringFactoriesLoader 加载 META-INF/spring.factories 中注册的自动配置类。具体步骤如下：
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\
org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\
org.springframework.boot.autoconfigure.batch.BatchAutoConfiguration
Spring Factories 机制是 Spring Boot 自动配置的重要基础，它就像一个配置仓库，帮助 Spring Boot 找到并加载所有的自动配置类。
Spring Boot 在启动时，会通过 SpringFactoriesLoader 读取 META-INF/spring.factories 文件。这个文件本质上是一个属性文件，其中包含了一组或多组键值对（key=value）。其中，key 的取值为接口的完全限定名，value 的取值为接口实现类的完全限定名，一个接口可以设置多个实现类，不同实现类之间使用','隔开。例如：
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration,\
org.springframework.boot.autoconfigure.web.servlet.WebMvcAutoConfiguration
在这个例子中，org.springframework.boot.autoconfigure.EnableAutoConfiguration 是键，后面的 org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration 和 org.springframework.boot.autoconfigure.web.servlet.WebMvcAutoConfiguration 是值，表示这两个类是与自动配置相关的类。
SpringFactoriesLoader 类会扫描所有 Jar 包类路径下的 META-INF/spring.factories 文件，并获取指定接口的配置。它提供了两个对外的方法：loadFactories(Class factoryType, @Nullable ClassLoader classLoader) 和 loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader)。前者用于根据接口获取其实现类的实例，返回的是实现类对象列表；后者用于根据接口获取其实现类的名称，返回的是实现类的类名列表。
通过 Spring Factories 机制，Spring Boot 能够轻松地找到并加载所有需要的自动配置类，为应用程序提供丰富的默认配置，从而实现约定优于配置的理念。
在开始实战之前，我们需要先创建一个 Spring Boot 项目。这里我们分别介绍使用 Maven 和 Gradle 两种方式来创建项目。
使用 Maven 创建 Spring Boot 项目
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.7.5</version>
<relativePath/>
</parent>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
在上述依赖中，spring-boot-starter-parent 是 Spring Boot 项目的父依赖，它定义了很多默认的依赖版本和插件配置；spring-boot-starter-web 依赖则包含了开发 Web 应用所需的 Spring MVC、Tomcat 等组件。
使用 Gradle 创建 Spring Boot 项目
plugins {
id 'org.springframework.boot' version '2.7.5'
id 'io.spring.dependency-management' version '1.0.11.RELEASE'
id 'java'
}
group = 'com.example'
version = '1.0.0'
sourceCompatibility = '11'
repositories {
mavenCentral()
}
dependencies {
implementation 'org.springframework.boot:spring-boot-starter-web'
testImplementation 'org.springframework.boot:spring-boot-starter-test'
}
这里的 org.springframework.boot 插件用于支持 Spring Boot 项目的构建，spring-boot-starter-web 依赖与 Maven 中的作用相同。
Spring Boot 的配置文件主要有 application.yml 和 application.properties 两种格式，它们的作用是相同的，只是语法格式不同。这里以 application.yml 为例进行介绍。
配置文件的作用 配置文件主要用于定义和管理应用的各种配置项，如数据库连接、日志设置、服务器端口、Spring Boot 的自动配置选项等。通过配置文件，我们可以轻松地对应用进行定制化，而无需修改代码。
常见配置项
server:
port: 8081
这样，应用启动时就会使用 8081 端口，而不是默认的 8080 端口。
spring:
datasource:
url: jdbc:mysql://localhost:3306/mydb?useSSL=false&serverTimezone=UTC
username: root
password: 123456
driver-class-name: com.mysql.cj.jdbc.Driver
这里配置了数据库的连接 URL、用户名、密码以及驱动类名。Spring Boot 会根据这些配置自动创建数据源，并进行数据库连接。
logging:
level:
org.springframework: INFO
com.example: DEBUG
file:
name: app.log
上述配置中，org.springframework 包下的日志级别设置为 INFO，com.example 包下的日志级别设置为 DEBUG，日志输出到 app.log 文件中。
在实际开发中，Spring Boot 的默认自动配置可能无法满足所有需求，这时我们就需要进行自定义自动配置。下面通过一个实例来演示如何创建自定义的自动配置类。
import org.springframework.boot.context.properties.ConfigurationProperties;
@ConfigurationProperties(prefix = "my.custom")
public class MyProperties {
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
在这个类中，使用 @ConfigurationProperties 注解，并指定 prefix = "my.custom"，表示从配置文件中读取以 my.custom 开头的属性。例如，在 application.yml 文件中可以这样配置：
my.custom:
name: "张三"
age: 25
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
@ConditionalOnClass(MyService.class)
@EnableConfigurationProperties(MyProperties.class)
public class MyAutoConfiguration {
@Autowired
private MyProperties myProperties;
@Bean
@ConditionalOnProperty(name = "my.custom.enabled", havingValue = "true")
public MyService myService() {
return new MyService(myProperties.getName(), myProperties.getAge());
}
}
在这个自动配置类中：
public class MyService {
private String name;
private int age;
public MyService(String name, int age) {
this.name = name;
this.age = age;
}
public void sayHello() {
System.out.println("大家好，我叫 " + name + "，今年 " + age + " 岁。");
}
}
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class SpringBootAutoConfigDemoApplication implements CommandLineRunner {
@Autowired
private MyService myService;
public static void main(String[] args) {
SpringApplication.run(SpringBootAutoConfigDemoApplication.class, args);
}
@Override
public void run(String... args) throws Exception {
myService.sayHello();
}
}
运行 Spring Boot 应用，如果配置正确，控制台会输出：'大家好，我叫 张三，今年 25 岁。'，这表明自定义自动配置生效了。
在 Spring Boot 中，@Conditional 系列注解为我们提供了根据不同条件进行灵活配置的强大功能。除了前面提到的基本用法，它们还有许多高级应用场景，能够满足各种复杂的业务需求。
@ConditionalOnClass 注解用于判断类路径中是否存在指定类，只有当指定类存在时，被注解的配置类或 Bean 才会生效。在实际开发中，我们可以利用它来实现对第三方库的灵活依赖管理。
假设我们的项目中可能会使用到 Jackson 库来处理 JSON 数据，但并非所有模块都需要这个功能。我们可以创建一个配置类，只有当 Jackson 库在类路径中存在时，才配置相关的 JSON 处理 Bean。
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
@ConditionalOnClass(ObjectMapper.class)
public class JsonConfig {
@Bean
public ObjectMapper objectMapper() {
return new ObjectMapper();
}
}
在这个例子中，@ConditionalOnClass(ObjectMapper.class) 确保只有当 ObjectMapper 类（Jackson 库的核心类之一）存在于类路径中时，JsonConfig 配置类才会生效，其中定义的 objectMapper Bean 才会被创建。这样，当我们在某些模块中不需要 Jackson 库时，只需不引入相关依赖，就不会创建这些与 Jackson 相关的 Bean，从而减少不必要的资源消耗。
@ConditionalOnProperty 注解允许根据配置文件中的属性值来决定是否加载某个 Bean 或配置类。除了基本的属性匹配，它还支持设置多个属性以及使用 SpEL 表达式来实现更复杂的条件判断。
我们可以通过设置多个属性来控制一个配置类的生效条件。假设我们有一个支付功能的配置类，只有当 feature.payment.enable 属性为 true 且 feature.payment.type 属性为 "online" 时，这个配置类才生效。
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
@ConditionalOnProperty(prefix = "feature.payment", name = {"enable", "type"}, havingValue = "true", matchIfMissing = false)
public class PaymentConfig {
@Bean
public PaymentService paymentService() {
return new PaymentService();
}
}
在这个例子中，@ConditionalOnProperty 注解指定了多个属性，只有当 feature.payment.enable 为 true 且 feature.payment.type 为 "online" 时，PaymentConfig 配置类才会生效，paymentService Bean 才会被创建。
此外，@ConditionalOnProperty 还可以结合 SpEL 表达式来实现更灵活的条件判断。比如，我们可以根据配置文件中的属性值来决定是否启用某个功能模块。
import org.springframework.boot.autoconfigure.condition.ConditionalOnExpression;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
@ConditionalOnExpression("${feature.new-feature.enabled} and ${feature.new-feature.version > 1.0}")
public class NewFeatureConfig {
@Bean
public NewFeatureService newFeatureService() {
return new NewFeatureService();
}
}
在这个例子中，@ConditionalOnExpression 注解使用了 SpEL 表达式，只有当 feature.new-feature.enabled 为 true 且 feature.new-feature.version 大于 1.0 时，NewFeatureConfig 配置类才会生效，newFeatureService Bean 才会被创建。
在 Spring Boot 应用中，配置文件的加载优先级是一个非常重要的概念。了解不同配置文件的加载顺序以及如何利用优先级解决配置冲突问题，对于确保应用的正确运行和灵活配置至关重要。
Spring Boot 加载配置文件的优先级从高到低依次为：
在实际开发中，可能会出现不同配置文件中存在相同配置项但值不同的情况，这就需要利用配置文件的加载优先级来解决配置冲突问题。
假设我们的项目中有一个 application.properties 文件，其中配置了 server.port=8080，同时在 application-dev.yml 文件中也配置了 server.port=8081。如果我们在启动应用时没有指定任何命令行参数或其他高优先级的配置，那么最终生效的端口号将是 8081，因为 application-dev.yml 文件的优先级高于 application.properties 文件。
但是，如果我们在启动应用时使用命令行参数--server.port=8082，那么最终生效的端口号将是 8082，因为命令行参数的优先级最高，会覆盖其他所有配置源中的 server.port 配置。
通过合理利用配置文件的加载优先级，我们可以在不同环境下灵活地配置应用，同时避免配置冲突带来的问题。例如，在开发环境中，我们可以在 application-dev.yml 文件中配置一些开发专用的参数，如数据库连接信息、日志级别等；而在生产环境中，我们可以通过命令行参数或环境变量来覆盖这些配置，以确保应用在生产环境中的安全性和性能。
在使用 Spring Boot 自动配置的过程中，可能会遇到各种问题，下面列举一些常见问题及对应的解决方案。
问题描述：由于项目中使用了多个起步依赖，这些依赖可能包含相同库的不同版本，从而引发依赖冲突。比如，某个依赖需要 A 库的 1.0 版本，而另一个依赖需要 A 库的 2.0 版本，这就会造成类加载错误或运行时异常。
解决方案：
<dependency>
<groupId>com.example</groupId>
<artifactId>example-library</artifactId>
<version>1.0.0</version>
<exclusions>
<exclusion>
<groupId>conflicting-group</groupId>
<artifactId>conflicting-artifact</artifactId>
</exclusion>
</exclusions>
</dependency>
问题描述：配置文件中的某些配置项没有生效，导致应用的行为不符合预期。例如，修改了 application.yml 文件中的 server.port 配置，但应用启动时仍然使用默认端口。
解决方案：
本文深入探讨了 Spring Boot 自动配置这一核心特性。首先介绍了 Spring Boot 在 Java 开发中的重要地位，以及自动配置的概念和重要性，它通过约定优于配置的理念，大大简化了开发过程，提高了开发效率。
在核心原理部分，我们剖析了 @EnableAutoConfiguration 注解作为自动配置的核心触发点，它借助 AutoConfigurationImportSelector 类和 Spring Factories 机制，实现了自动配置类的加载和条件评估。AutoConfigurationImportSelector 通过读取 META-INF/spring.factories 文件，筛选出符合条件的自动配置类，并将其导入到 Spring 上下文中。
实战演练环节，我们通过创建 Spring Boot 项目，详细讲解了配置文件的作用、常见配置项以及自定义自动配置的实现方法。配置文件用于管理应用的各种配置，而自定义自动配置则让我们能够根据实际需求对默认配置进行定制化。
在高级应用与问题解决部分，我们深入探讨了条件注解的高级使用，如 @ConditionalOnClass 和 @ConditionalOnProperty 的深度应用，以及配置文件加载优先级和常见自动配置问题的解决方案，这些知识对于解决复杂的开发场景和问题非常关键。
Spring Boot 自动配置在微服务架构中发挥着重要作用。它与 Spring Cloud 等微服务框架结合，能够实现服务的自动配置、注册与发现、负载均衡等功能。例如，在基于 Spring Cloud 的微服务项目中，Spring Boot 的自动配置可以帮助我们快速搭建 Eureka 服务注册中心、Ribbon 客户端负载均衡器等组件，使得微服务之间的通信和协作更加便捷。
在云原生开发领域，Spring Boot 自动配置也有广阔的应用前景。它可以与容器编排工具（如 Kubernetes）、云服务提供商（如 AWS、Azure、阿里云）的服务相结合，实现应用的自动化部署、弹性伸缩和配置管理。通过自动配置，我们可以轻松地将 Spring Boot 应用部署到容器中，并利用云原生技术的优势，提高应用的性能和可靠性。
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 zeeklog
查找任何按下的键的javascript键代码、代码、位置和修饰符。 在线工具，Keycode 信息在线工具，online
JavaScript 字符串转义/反转义；Java 风格 \uXXXX（Native2Ascii）编码与解码。 在线工具，Escape 与 Native 编解码在线工具，online
使用 Prettier 在浏览器内格式化 JavaScript 或 HTML 片段。 在线工具，JavaScript / HTML 格式化在线工具，online
Terser 压缩、变量名混淆，或 javascript-obfuscator 高强度混淆（体积会增大）。 在线工具，JavaScript 压缩与混淆在线工具，online
将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具，Base64 字符串编码/解码在线工具，online
将字符串、文件或图像转换为其 Base64 表示形式。 在线工具，Base64 文件转换器在线工具，online