<think>
我们正在讨论
Spring Boot的三个核心问题：
自动配置原理、自定义Starter方法、以及@
SpringBootApplication
注解的组成。下面我将逐一详细解释。
### 1.
Spring Boot
自动配置原理
Spring Boot的
自动配置（Auto-configuration）是其核心特性之一，它基于条件化配置（Conditional Configuration）实现，主要依赖`
spring-boot-autoconfigure`模块。其工作原理可分为以下
几个步骤：
#### (1) 条件
注解驱动
Spring Boot定义了一系列`@Conditional`派生
注解（如`@ConditionalOnClass`, `@ConditionalOnBean`, `@ConditionalOnProperty`等），用于判断是否满足特定条件。例如：
```
java
@Configuration
@ConditionalOnClass(DataSource.class) // 当类路径存在DataSource类时生效
public class DataSourceAutoConfiguration {
//
自动配置逻辑
}
```
#### (2) 配置加载机制
- **
自动配置声明文件**：在`META-INF/
spring.factories`中通过`org.
springframework.boot.autoconfigure.EnableAutoConfiguration`键列出所有
自动配置类：
```properties
org.
springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.
springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration,\
org.
springframework.boot.autoconfigure.web.servlet.WebMvcAutoConfiguration
```
#### (3) 配置
优先级
自动配置的
优先级低于用户显式配置（如`@Bean`方法），遵循**覆盖原则**。
#### (4) 执行流程
1.
Spring Boot启动时加载`
spring.factories`中的
自动配置类
2. 根据条件
注解筛选有效的配置类
3. 按顺序加载符合条件的配置类（使用`@AutoConfigureOrder`控制顺序）
> **关键点**：
自动配置的本质是**标准
Spring配置类的条件化加载**[^1]。
### 2. 自定义
Spring Boot Starter方法
创建自定义Starter包含以下步骤：
#### (1) 命名规范
- 官方Starter命名：`
spring-boot-starter-{name}`
- 自定义Starter命名：`{name}-
spring-boot-starter`
#### (2) 项目结构
```
my-starter
├── src/main/
java
│ ├── com/example/autoconfigure
│ │ ├── MyServiceAutoConfiguration.
java //
自动配置类
│ │ └── MyServiceProperties.
java // 配置属性类
├── src/main/resources
│ ├── META-INF
│ │ └──
spring.factories //
自动配置注册文件
```
#### (3) 核心代码实现
- **定义配置属性类**（绑定application.properties中的参数）：
```
java
@ConfigurationProperties(prefix = "my.service")
public class MyServiceProperties {
private String apiKey;
private int timeout = 5000;
// getters & setters
}
```
- **
自动配置类**：
```
java
@Configuration
@EnableConfigurationProperties(MyServiceProperties.class)
@ConditionalOnClass(MyService.class)
public class MyServiceAutoConfiguration {
@Bean
@ConditionalOnMissingBean
public MyService myService(MyServiceProperties properties) {
return new MyService(properties.getApiKey(), properties.getTimeout());
}
}
```
- **注册
自动配置**（`src/main/resources/META-INF/
spring.factories`）：
```properties
org.
springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.example.autoconfigure.MyServiceAutoConfiguration
```
#### (4) 使用Starter
用户引入依赖后，可直接
注入`MyService`：
```
java
@Service
public class UserService {
private final MyService myService;
public UserService(MyService myService) {
this.myService = myService;
}
}
```
并在`application.properties`中配置参数：
```properties
my.service.api-key=123abc
my.service.timeout=3000
```
### 3. `@
SpringBootApplication`
注解解析
`@
SpringBootApplication`是一个组合
注解，包含三个核心
注解：
```
java
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@
SpringBootConfiguration // 继承自@Configuration，标识该类为配置类
@EnableAutoConfiguration // 启用
自动配置功能
@ComponentScan( // 包扫描路径（默认当前类所在包及其子包）
excludeFilters = @Filter(
type = FilterType.CUSTOM,
classes = TypeExcludeFilter.class
)
)
public @interface
SpringBootApplication {
// 属性可覆盖@ComponentScan的basePackages等参数
}
```
####
注解层级关系：
$$
\begin{array}{c}
\text{@
SpringBootApplication} \\
\downarrow \\
\begin{array}{c}
\text{@
SpringBootConfiguration} \\
\downarrow \\
\text{@Configuration} \\
\end{array} \\
+ \\
\begin{array}{c}
\text{@EnableAutoConfiguration} \\
\end{array} \\
+ \\
\begin{array}{c}
\text{@ComponentScan} \\
\end{array}
\end{array}
$$
#### 功能详解：
1. **@
SpringBootConfiguration**
表明该类是
Spring Boot的配置类，允许注册额外的Bean或导入其他配置类。
2. **@EnableAutoConfiguration**
激活
Spring Boot的
自动配置机制，根据依赖
自动配置
Spring应用。
3. **@ComponentScan**
自动扫描当前包及其子包下的组件（`@Component`, `@Service`, `@Repository`, `@Controller`等）。
> **最佳实践**：主配置类应放在项目的根包（root package）下，确保扫描范围覆盖所有组件[^1]。
---
### 总结
- **
自动配置**：基于条件
注解和`
spring.factories`的
自动化
Spring配置加载
- **自定义Starter**：通过
自动配置类+属性绑定+`
spring.factories`注册实现即插即用
- **`@
SpringBootApplication`**：三大核心
注解的合成体，简化启动类配置
§§相关问题§§
1. 如果想自定义
Spring Boot
自动配置的条件判断规则，应该如何扩展？
2. 如何在自定义Starter中实现健康检查（HealthIndicator）？
3. `@
SpringBootApplication`中的`exclude`属性有什么具体用途？
4. 如何解决多个Starter间的
自动配置冲突问题？
</think>
###
Spring Boot
自动配置原理、自定义 Starter 方法及 `@
SpringBootApplication`
注解详解
---
#### **一、
Spring Boot
自动配置原理**
Spring Boot
自动配置基于 **条件化装配（Conditional Beans）** 和 **约定优于配置（Convention over Configuration）** 实现，核心流程如下：
1. **扫描
自动配置类**
启动时通过 `
spring-boot-autoconfigure` 模块的 `META-INF/
spring.factories` 文件加载所有预定义的
自动配置类：
```properties
#
spring.factories 示例
org.
springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.
springframework.boot.autoconfigure.web.servlet.WebMvcAutoConfiguration,\
org.
springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration
```
2. **条件
注解驱动装配**
自动配置类使用 **条件
注解** 判断是否生效：
```
java
@Configuration
@ConditionalOnClass(DataSource.class) // 类路径存在DataSource时生效
@ConditionalOnProperty(prefix="
spring.datasource") // 配置属性存在时生效
public class DataSourceAutoConfiguration {
@Bean
@ConditionalOnMissingBean // 当容器无DataSource时创建
public DataSource dataSource() {
return new HikariDataSource();
}
}
```
- `@ConditionalOnClass`：依赖类存在时触发配置
- `@ConditionalOnProperty`：配置参数匹配时触发
- `@ConditionalOnMissingBean`：容器无此Bean时创建[^1]
3. **
优先级控制**
用户自定义配置（如 `@Bean`）
优先级 **高于**
自动配置（通过 `@ConditionalOnMissingBean` 实现覆盖）。
---
#### **二、自定义
Spring Boot Starter 方法**
创建 Starter 需实现 **
自动配置模块** + **依赖管理**：
##### **步骤 1：项目结构**
```
my-starter
├── src/main/
java
│ ├── com/example/mystarter
│ │ ├── MyService.
java // 核心服务类
│ │ ├── MyAutoConfiguration.
java //
自动配置类
│ │ └── MyProperties.
java // 配置属性类
├── src/main/resources
│ ├── META-INF
│ │ └──
spring.factories // 注册
自动配置类
```
##### **步骤 2：关键代码实现**
1. **定义配置属性类**（绑定 `application.yml`）：
```
java
@ConfigurationProperties(prefix = "my.service")
public class MyProperties {
private String apiKey;
private int timeout = 3000;
// getters & setters
}
```
2. **
自动配置类**：
```
java
@Configuration
@EnableConfigurationProperties(MyProperties.class) // 启用属性绑定
@ConditionalOnClass(MyService.class)
public class MyAutoConfiguration {
@Bean
@ConditionalOnMissingBean
public MyService myService(MyProperties properties) {
return new MyService(properties.getApiKey(), properties.getTimeout());
}
}
```
3. **注册配置类**（`resources/META-INF/
spring.factories`）：
```properties
org.
springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.example.mystarter.MyAutoConfiguration
```
##### **步骤 3：使用自定义 Starter**
1. 其他项目引入依赖：
```xml
<dependency>
<groupId>com.example</groupId>
<artifactId>my-starter</artifactId>
<version>1.0.0</version>
</dependency>
```
2. 在 `application.yml` 中配置参数：
```yaml
my.service:
api-key: "123456"
timeout: 5000
```
---
#### **三、`@
SpringBootApplication`
注解解析**
该
注解是合成
注解（Composed Annotation），包含三个核心
注解：
```
java
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@
SpringBootConfiguration // ← 继承自 @Configuration
@EnableAutoConfiguration // ← 启用
自动配置
@ComponentScan( // ← 包扫描
excludeFilters = @Filter(
type = FilterType.CUSTOM,
classes = TypeExcludeFilter.class
)
)
public @interface
SpringBootApplication {}
```
1. **`@
SpringBootConfiguration`**
- 继承自 `@Configuration`，标识该类为 **配置类**（可定义 `@Bean` 方法）。
2. **`@EnableAutoConfiguration`**
- 激活
Spring Boot 的
自动配置机制，根据依赖
自动装配 Bean。
- 内部通过 `@Import(AutoConfigurationImportSelector.class)` 加载 `
spring.factories` 中的配置类。
3. **`@ComponentScan`**
- 默认扫描**当前包及其子包**下的组件（`@Component`, `@Service`, `@Controller` 等）。
- 可通过 `scanBasePackages` 属性自定义扫描路径：
```
java
@
SpringBootApplication(scanBasePackages = "com.example.app")
```
---
### **总结**
| 机制 | 实现要点 |
|---------------------|--------------------------------------------------------------------------|
| **
自动配置** | 基于 `
spring.factories` + 条件
注解（`@ConditionalOnClass` 等） |
| **自定义 Starter** |
自动配置类 + `@ConfigurationProperties` + `META-INF/
spring.factories` 注册 |
| **`@
SpringBootApplication`** | 三大核心
注解：配置声明 +
自动装配 + 组件扫描 |
> **最佳实践**：主启动类应放在项目**根包**（Root Package）下，确保 `@ComponentScan` 能覆盖所有组件[^1]。
---
本文详细阐述了在Spring框架中，@Resource、@Autowired、@Qualifier和@Primary四个注解的注入优先级。当接口只有一个实现类时，@Resource和@Autowired效果相同，@Primary的使用影响不大。而在存在多个实现类的情况下，@Qualifier优先级高于@Primary，而@Resource的优先级最高。总结了在不同场景下如何选择和组合这些注解以实现准确的依赖注入。
扫一扫
168万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
