丰收连山

172. SpringBoot 配置详解

一、SpringBoot 配置基础

SpringBoot 配置概述

什么是 SpringBoot 配置

SpringBoot 配置是指通过特定的方式（如配置文件、环境变量、命令行参数等）来定义应用程序的行为和属性。SpringBoot 提供了灵活的配置机制，允许开发者在不修改代码的情况下调整应用程序的运行参数。

主要配置方式

application.properties 或 application.yml
SpringBoot 默认支持这两种配置文件格式，通常放在 src/main/resources 目录下。
- .properties 格式示例：
```
server.port=8080
spring.datasource.url=jdbc:mysql://localhost:3306/mydb
```
- .yml 格式示例：
```
server:
  port: 8080
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mydb
```
环境变量
可以通过操作系统环境变量覆盖配置，例如：
```
export SERVER_PORT=9090
```
命令行参数
在启动时通过 -- 传递参数：
```
java -jar myapp.jar --server.port=9090
```

@ConfigurationProperties
用于将配置文件中的属性绑定到 Java Bean 上：

@ConfigurationProperties(prefix = "myapp")
public class MyAppConfig {
    private String name;
    private int version;
    // getters and setters
}

配置加载顺序

SpringBoot 按照以下优先级加载配置（从高到低）：

命令行参数
环境变量
application-{profile}.properties 或 application-{profile}.yml
默认的 application.properties 或 application.yml

多环境配置

SpringBoot 支持通过 spring.profiles.active 指定运行环境：

spring:
  profiles:
    active: dev

并可以定义不同环境的配置文件，如 application-dev.yml 和 application-prod.yml。

常见配置项

服务器配置

server:
  port: 8080
  servlet:
    context-path: /api

数据库配置

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mydb
    username: root
    password: password
    driver-class-name: com.mysql.cj.jdbc.Driver

日志配置

logging:
  level:
    root: INFO
    org.springframework.web: DEBUG

注意事项

配置优先级：命令行参数 > 环境变量 > Profile 配置 > 默认配置。
YAML 缩进：YAML 文件必须严格使用空格缩进，不能用 Tab 键。
属性覆盖：高优先级的配置会覆盖低优先级的配置。
配置加密：敏感信息（如数据库密码）建议使用加密工具（如 Jasypt）。

示例代码

读取配置

@Value("${server.port}")
private int port;

自定义配置类

@Configuration
@ConfigurationProperties(prefix = "app")
public class AppConfig {
    private String name;
    private List<String> servers;
    // getters and setters
}

配置文件类型（properties/yml）

概念定义

SpringBoot 支持两种主要的配置文件格式：

Properties 文件（.properties）
传统的键值对格式，使用 key=value 的形式存储配置，支持 ISO-8859-1 编码。
YAML 文件（.yml 或 .yaml）
基于缩进的层次化格式，支持 UTF-8 编码，通过缩进和冒号表示层级关系。

使用场景

Properties 文件的适用场景
- 简单的扁平化配置（无复杂嵌套结构）。
- 需要兼容旧项目或工具（如某些 Java 库仅支持 .properties）。
- 对可读性要求不高但需要快速编辑的场景。
YAML 文件的适用场景
- 需要多层嵌套的复杂配置（如 Spring Cloud、数据库连接池配置）。
- 追求高可读性和结构化表达（如列表、对象等）。
- 需要支持多行字符串或特殊字符（如 \n）。

示例代码对比

Properties 示例

# 数据库配置
spring.datasource.url=jdbc:mysql://localhost:3306/test
spring.datasource.username=root
spring.datasource.password=123456

# 列表配置（需特殊处理）
server.ports=8080,8081,8082

YAML 示例

# 数据库配置
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/test
    username: root
    password: "123456"  # 字符串可加引号

# 列表配置（原生支持）
server:
  ports:
    - 8080
    - 8081
    - 8082

常见误区与注意事项

编码问题
- Properties 文件默认使用 ISO-8859-1，若包含中文需转义（如 \u4E2D\u6587）。
- YAML 文件推荐使用 UTF-8，可直接写入中文。
优先级与覆盖规则
- 若同时存在 application.properties 和 application.yml，Properties 的优先级更高。
- 可通过 spring.config.name 和 spring.config.location 自定义文件路径。
YAML 的语法陷阱
- 缩进必须使用空格（不能使用 Tab）。
- 冒号后需加空格（如 key: value）。
- 特殊字符需引号包裹（如 password: "123@456"）。
类型转换差异
- Properties 中所有值均为字符串，需手动转换（如 server.port=8080 实际是字符串 “8080”）。
- YAML 支持自动类型推断（如 port: 8080 会被识别为整数）。

高级特性

多环境配置
- 两种格式均支持 application-{profile}.properties/yml（如 application-dev.yml）。
- YAML 可通过 --- 分隔符在同一文件内定义多环境配置。
占位符与表达式
- 均支持 ${} 占位符（如 ${spring.datasource.url}）。
- YAML 额外支持 SpEL 表达式（如 random.int(1,100)）。

配置文件加载顺序

SpringBoot 支持多种配置文件格式（如 application.properties、application.yml），并且遵循特定的加载顺序。理解加载顺序有助于解决配置冲突和覆盖问题。

默认加载顺序

SpringBoot 会按照以下顺序加载配置文件（后加载的配置会覆盖先加载的配置）：

application.properties 或 application.yml（项目根目录）
- 项目根目录下的配置文件优先级最低。
- 示例：src/main/resources/application.yml
application-{profile}.properties 或 application-{profile}.yml（项目根目录）
- 根据激活的 Profile 加载对应的配置文件。
- 示例：src/main/resources/application-dev.yml（当 spring.profiles.active=dev 时加载）
外部配置文件（config/ 目录）
- 项目根目录下的 config/ 文件夹中的配置文件。
- 示例：src/main/resources/config/application.yml
外部配置文件（config/ 子目录）
- 项目根目录的子目录 config/ 中的配置文件。
- 示例：./config/application.yml（打包后的 JAR 文件同级目录）
命令行参数
- 通过 -- 传递的参数优先级最高。
- 示例：java -jar app.jar --server.port=8081
系统环境变量
- 操作系统环境变量中的配置。
- 示例：export SERVER_PORT=8082
Java 系统属性（-D 参数）
- 通过 -D 设置的 JVM 参数。
- 示例：java -Dserver.port=8083 -jar app.jar

示例代码

1. 多环境配置示例

# application.yml（默认配置）
server:
  port: 8080
spring:
  profiles:
    active: dev  # 激活 dev 环境

# application-dev.yml（开发环境）
server:
  port: 8081

# application-prod.yml（生产环境）
server:
  port: 80

2. 外部配置文件覆盖示例

项目打包后，在 JAR 文件同级目录创建 config/application.yml：

server:
  port: 9090

运行时，实际端口为 9090（覆盖默认配置）。

注意事项

Profile 优先级
application-{profile}.yml 会覆盖 application.yml 中的相同配置。
文件格式优先级
.properties 和 .yml 的优先级相同，后加载的会覆盖先加载的。
命令行参数最高优先级
例如：java -jar app.jar --server.port=7070 会覆盖所有文件配置。
避免配置冲突
如果多个配置文件定义了相同的属性，确保理解覆盖逻辑，避免意外行为。
调试配置加载
启动时添加 --debug 参数可以查看详细的配置加载日志：
```
java -jar app.jar --debug
```

SpringBoot 配置优先级规则

SpringBoot 提供了多种配置来源，这些配置来源之间存在优先级关系，优先级高的配置会覆盖优先级低的配置。了解这些优先级规则对于正确管理和覆盖配置非常重要。

配置来源及优先级（从高到低）

命令行参数
通过 java -jar 启动时传递的参数，例如：
```
java -jar app.jar --server.port=8081
```
- 使用 -- 前缀指定参数。
- 优先级最高，会覆盖其他所有配置。
Java 系统属性（System.getProperties()）
通过 -D 参数设置，例如：
```
java -Dserver.port=8082 -jar app.jar
```
操作系统环境变量
直接在操作系统中设置的变量，例如：
```
export SERVER_PORT=8083
```
- SpringBoot 会自动将 SERVER_PORT 转换为 server.port。
外部配置文件（application-{profile}.properties 或 application-{profile}.yml）
例如 application-prod.yml 或 application-prod.properties，优先级高于默认配置文件。
默认配置文件（application.properties 或 application.yml）
项目中的 application.properties 或 application.yml。

@Configuration 类上的 @PropertySource 注解
例如：

@Configuration
@PropertySource("classpath:custom.properties")
public class AppConfig { }

SpringBoot 默认配置
内置的默认值（如 server.port 默认为 8080）。

示例验证

假设有以下配置来源：

命令行参数：--server.port=9000
application.properties：server.port=8080
application-prod.properties：server.port=9090

最终生效的端口是 9000，因为命令行参数优先级最高。

注意事项

多环境配置
- 使用 spring.profiles.active 指定激活的配置文件，例如：
```
spring.profiles.active=prod
```
- 激活的 application-prod.properties 会覆盖默认的 application.properties。
YAML 和 Properties 文件的优先级
- 如果同时存在 application.yml 和 application.properties，properties 文件的优先级更高。
配置覆盖的陷阱
- 低优先级的配置可能被高优先级的配置完全覆盖，需注意检查是否有冲突。
自定义配置文件的加载顺序
- 通过 spring.config.location 可以指定额外的配置文件路径，例如：
```
java -jar app.jar --spring.config.location=file:/path/to/custom-config/
```
- 这些文件的优先级高于默认的 application.properties。

代码示例

以下是一个测试配置优先级的示例：

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

    @RestController
    class ConfigController {
        @Value("${server.port}")
        private String port;

        @GetMapping("/port")
        public String getPort() {
            return "Server port: " + port;
        }
    }
}

通过访问 /port 可以查看最终生效的 server.port 值。

通过理解这些优先级规则，可以更灵活地管理 SpringBoot 应用的不同环境配置。

环境变量配置

什么是环境变量配置

环境变量配置是指在SpringBoot应用中，通过操作系统或外部配置文件设置的环境变量来动态调整应用行为的一种方式。这些变量通常用于存储与部署环境相关的配置，如数据库连接、API密钥、服务端口等。

使用场景

多环境部署：开发、测试、生产环境使用不同的配置
敏感信息管理：避免将密码、密钥等敏感信息硬编码在代码中
容器化部署：在Docker、Kubernetes等容器环境中传递配置
云平台集成：与AWS、Azure等云服务的环境变量系统集成

配置方式

1. 系统环境变量

# Linux/Mac
export DB_URL=jdbc:mysql://localhost:3306/mydb

# Windows
set DB_URL=jdbc:mysql://localhost:3306/mydb

2. SpringBoot配置文件

在application.properties或application.yml中引用环境变量：

# application.properties
db.url=${DB_URL}

# application.yml
db:
  url: ${DB_URL}

3. 启动参数

java -jar myapp.jar --spring.datasource.url=jdbc:mysql://localhost:3306/mydb

优先级顺序

SpringBoot加载环境变量的优先级从高到低：

命令行参数
JNDI属性
Java系统属性(System.getProperties())
操作系统环境变量
随机属性(random.*)
应用配置文件(application-{profile}.properties/yml)
默认应用配置文件(application.properties/yml)

代码中获取环境变量

@RestController
public class EnvController {
    
    @Value("${db.url}")
    private String dbUrl;
    
    @Autowired
    private Environment env;
    
    @GetMapping("/dbinfo")
    public String getDbInfo() {
        // 方式1：通过@Value注解
        String url1 = dbUrl;
        
        // 方式2：通过Environment接口
        String url2 = env.getProperty("db.url");
        
        return "DB URL: " + url1 + " / " + url2;
    }
}

最佳实践

命名规范：使用大写字母和下划线(如DB_URL)，避免特殊字符
默认值设置：${VARIABLE_NAME:default_value}
敏感信息：不要将敏感信息提交到版本控制系统
环境隔离：使用不同的profile管理不同环境的配置
文档记录：维护环境变量清单文档

常见问题

变量未生效：检查变量名拼写、作用域和优先级
特殊字符处理：URL中的特殊字符需要编码
IDE配置：开发时需要在IDE运行配置中添加环境变量
容器环境：Docker中需要通过-e参数传递环境变量

示例：多环境配置

# application-dev.yml
db:
  url: jdbc:mysql://dev-server:3306/mydb
  
# application-prod.yml  
db:
  url: ${PROD_DB_URL}

启动时指定profile：

java -jar myapp.jar --spring.profiles.active=prod

命令行参数配置

概念定义

命令行参数配置是指在启动SpringBoot应用时，通过命令行直接传递参数来覆盖或设置应用的配置项。这些参数通常以--开头，后面跟随配置属性名称和值。

使用场景

临时覆盖配置：在测试或生产环境中临时修改某些配置项
环境差异化配置：在不同部署环境中使用不同的配置
敏感信息传递：避免将敏感信息写入配置文件
快速调试：在开发过程中快速测试不同配置

常见格式

java -jar your-application.jar --server.port=8081 --spring.datasource.url=jdbc:mysql://localhost:3306/mydb

参数类型

标准Spring属性：如--server.port=8080
自定义属性：如--app.feature.enabled=true
系统属性：使用-D前缀，如-Dspring.profiles.active=dev

示例代码

@SpringBootApplication
public class MyApp {
    public static void main(String[] args) {
        SpringApplication.run(MyApp.class, args);
    }
    
    @Value("${custom.message:Default Message}")
    private String message;
    
    @PostConstruct
    public void init() {
        System.out.println("Message from command line: " + message);
    }
}

启动命令：

java -jar app.jar --custom.message="Hello from command line"

参数优先级

在SpringBoot中，命令行参数的优先级非常高：

命令行参数
JNDI属性
Java系统属性
操作系统环境变量
配置文件中的属性

注意事项

参数格式：必须使用--前缀，否则会被当作普通JVM参数
布尔值处理：--feature.enabled=true可以简写为--feature.enabled
空格处理：包含空格的参数值需要用引号包裹
特殊字符：某些特殊字符可能需要转义
安全性：敏感信息通过命令行传递可能在进程列表中可见

高级用法

参数分组：使用@ConfigurationProperties绑定多个相关参数

@ConfigurationProperties("app")
public class AppProperties {
    private String name;
    private int version;
    // getters and setters
}

参数验证：结合JSR-303验证

@Validated
@ConfigurationProperties("app")
public class AppProperties {
    @NotNull
    private String name;
    @Min(1)
    private int version;
}

多环境参数：结合profile使用

java -jar app.jar --spring.profiles.active=prod --db.host=prod-db.example.com

替代方案

对于复杂的参数配置，可以考虑：

使用外部配置文件
使用环境变量
使用配置服务器

调试技巧

查看生效的配置：
```
java -jar app.jar --debug
```

检查特定属性值：

@Autowired
private Environment env;

public void checkProperty() {
    System.out.println(env.getProperty("custom.message"));
}

配置属性来源

SpringBoot 提供了多种配置属性的来源，允许开发者灵活地管理和覆盖配置。以下是常见的配置属性来源及其优先级（从高到低）：

1. 命令行参数

通过 java -jar 启动应用时，使用 -- 前缀传递参数。
示例：

java -jar app.jar --server.port=8081

特点：

优先级最高，运行时动态覆盖其他配置。
适用于临时调整参数（如端口、日志级别）。

2. Java 系统属性（System.getProperties()）

通过 -D 参数设置。
示例：

java -Dserver.port=8082 -jar app.jar

注意：

需在启动命令中显式声明。

3. 操作系统环境变量

直接通过操作系统环境变量配置，SpringBoot 会自动转换为小写并替换 . 为 _。
示例：

export SERVER_PORT=8083

适用场景：

容器化部署（如 Docker、Kubernetes）。

4. 配置文件（application-{profile}.properties/yml）

默认文件：application.properties 或 application.yml。
Profile 专属文件：如 application-dev.yml。
YAML 示例：

server:
  port: 8084

优先级规则：

Profile 专属配置 > 默认配置。
.properties 文件优先级高于 .yml（同目录下）。

5. @Configuration 类中的 @PropertySource

通过注解显式加载自定义配置文件。
示例：

@Configuration
@PropertySource("classpath:custom.properties")
public class AppConfig {}

限制：

不支持 YAML 文件，仅适用于 .properties。

6. 默认属性（SpringApplication.setDefaultProperties）

通过代码设置默认值。
示例：

SpringApplication app = new SpringApplication(MyApp.class);
app.setDefaultProperties(Collections.singletonMap("server.port", "8085"));
app.run(args);

常见误区

优先级混淆：误以为 application.yml 总是覆盖系统环境变量。
环境变量格式错误：未将 server.port 转为 SERVER_PORT。
Profile 未激活：配置了 application-dev.yml 但未通过 --spring.profiles.active=dev 启用。

最佳实践

敏感信息：使用环境变量或 Vault 存储密码。
多环境管理：通过 spring.profiles.active 切换配置。
调试技巧：通过 /actuator/env 端点查看最终生效的配置。

配置属性继承

概念定义

配置属性继承是 SpringBoot 中一种允许子配置类或子配置文件继承父配置类或父配置文件属性的机制。通过继承，可以避免重复定义相同的属性，提高配置的复用性和可维护性。

使用场景

多环境配置：在开发、测试、生产等不同环境中，大部分配置相同，只有少数配置需要覆盖。
模块化配置：多个模块共享相同的基类配置，子模块只需覆盖特定属性。
简化配置：减少重复配置，提高代码的可读性和可维护性。

实现方式

基于 @ConfigurationProperties 的继承

@ConfigurationProperties(prefix = "parent")
public class ParentProperties {
    private String commonProperty;
    // getters and setters
}

@ConfigurationProperties(prefix = "child")
public class ChildProperties extends ParentProperties {
    private String specificProperty;
    // getters and setters
}

基于配置文件的继承
- 在 application.yml 或 application.properties 中定义父配置：
```
parent:
  commonProperty: value
```
- 在子配置文件中（如 application-dev.yml）继承并覆盖：
```
parent:
  commonProperty: overridden-value
```

使用 spring.config.import 导入父配置

spring:
  config:
    import: classpath:parent-config.yml

常见误区与注意事项

前缀冲突：如果子类和父类使用相同的 prefix，可能会导致属性覆盖或冲突。
属性覆盖顺序：SpringBoot 的属性加载顺序会影响继承属性的最终值，通常后加载的配置会覆盖先加载的配置。
类型安全：继承时需确保子类和父类的属性类型一致，否则可能导致类型转换异常。
配置文件优先级：Profile 特定的配置文件（如 application-dev.yml）会覆盖通用配置文件（application.yml）中的属性。

示例代码

基于类的继承

@Configuration
@ConfigurationProperties(prefix = "base")
public class BaseConfig {
    private String url;
    private int timeout;
    // getters and setters
}

@Configuration
@ConfigurationProperties(prefix = "extended")
public class ExtendedConfig extends BaseConfig {
    private boolean enabled;
    // getters and setters
}

基于配置文件的继承

application.yml（父配置）：

shared:
  database:
    url: jdbc:mysql://localhost:3306/parent
    username: root

application-dev.yml（子配置）：

shared:
  database:
    url: jdbc:mysql://dev-server:3306/child

最佳实践

明确继承层次：设计清晰的继承关系，避免过度嵌套。
使用 Profile：利用 Spring Profiles 管理不同环境的配置覆盖。
文档化：为继承的配置属性添加清晰的文档说明，避免后续维护时的混淆。

配置属性覆盖

概念定义

配置属性覆盖（Configuration Property Override）是指在 SpringBoot 应用中，通过不同的配置源（如配置文件、环境变量、命令行参数等）对同一属性进行多次定义时，SpringBoot 会根据优先级规则选择最终的属性值。这种机制允许开发者在不同环境中灵活地覆盖默认配置。

配置源优先级

SpringBoot 按照以下优先级顺序加载配置属性（从高到低）：

命令行参数（--property=value）
JNDI 属性（来自 java:comp/env）
Java 系统属性（System.getProperties()）
操作系统环境变量
application-{profile}.properties 或 application-{profile}.yml 文件（带 Profile 的配置文件）
application.properties 或 application.yml 文件（默认配置文件）
@PropertySource 注解指定的属性文件
SpringBoot 默认属性（通过 SpringApplication.setDefaultProperties 设置）

使用场景

环境差异化配置：例如，在开发环境使用本地数据库，而在生产环境使用云数据库。
敏感信息保护：通过环境变量覆盖配置文件中的密码等敏感信息。
临时调试：通过命令行参数临时修改配置，无需修改配置文件。

示例代码

1. 通过命令行参数覆盖

java -jar myapp.jar --server.port=8081

2. 通过环境变量覆盖

export SPRING_DATASOURCE_URL=jdbc:mysql://production-db:3306/mydb
java -jar myapp.jar

3. 多配置文件覆盖

application.properties（默认配置）：

server.port=8080
spring.datasource.url=jdbc:mysql://localhost:3306/mydb

application-prod.properties（生产环境配置）：

spring.datasource.url=jdbc:mysql://prod-db:3306/mydb

启动时激活 prod Profile：

java -jar myapp.jar --spring.profiles.active=prod

常见误区与注意事项

属性名格式：
- 环境变量需转换为大写并用下划线分隔（如 spring.datasource.url 对应 SPRING_DATASOURCE_URL）。
- YAML 文件中的属性层级需用缩进表示。
Profile 文件未生效：
- 确保文件名格式为 application-{profile}.properties/yml。
- 检查是否通过 spring.profiles.active 正确激活 Profile。
属性覆盖失败：
- 检查属性名拼写是否一致（包括大小写）。
- 确保高优先级配置源已正确设置（如环境变量是否导出）。
YAML 与 Properties 混用：
- 避免同时使用 application.yml 和 application.properties，可能导致优先级混乱。

高级用法

1. 使用 `@TestPropertySource` 覆盖测试配置

@SpringBootTest
@TestPropertySource(properties = {"server.port=0", "spring.datasource.url=jdbc:h2:mem:test"})
public class MyTest {
    // 测试代码
}

2. 动态覆盖属性

通过 SpringApplication.setDefaultProperties：

public static void main(String[] args) {
    SpringApplication app = new SpringApplication(MyApp.class);
    Properties props = new Properties();
    props.setProperty("server.port", "8082");
    app.setDefaultProperties(props);
    app.run(args);
}

配置属性占位符

概念定义

配置属性占位符（Property Placeholder）是 Spring/SpringBoot 中用于动态替换配置文件内容的语法，格式为 ${key:defaultValue}。

${key} 表示引用配置文件中定义的属性值
:defaultValue 为可选部分，当 key 不存在时使用默认值

核心作用

解耦硬编码：将变量从代码中抽离到配置文件
环境适配：不同环境（dev/test/prod）使用不同配置
动态注入：运行时动态替换值

使用场景

1. 基础用法（application.properties）

# 定义属性
app.name=MyApp
app.version=${APP_VERSION:1.0.0}  # 带默认值

# 引用属性
welcome.message=Welcome to ${app.name}!

2. YAML 配置（application.yml）

server:
  port: ${SERVER_PORT:8080}  # 优先取环境变量，不存在则用8080

3. Java 代码中使用

@Value("${app.name}")
private String appName;

@Value("${undefined.key:default}") 
private String withDefault;

4. @ConfigurationProperties 绑定

@ConfigurationProperties(prefix = "mail")
public class MailConfig {
    private String host;  // 自动绑定 mail.host
}

执行优先级

SpringBoot 按以下顺序解析占位符：

JVM 系统属性（-D 参数）
操作系统环境变量
application.properties/yml
@PropertySource 指定文件

高级特性

嵌套占位符

base.path=/opt/app
log.path=${base.path}/logs  # -> /opt/app/logs

随机值生成

secret.key=${random.uuid}
server.port=${random.int(8000,9000)}

常见问题

占位符未解析
- 检查属性文件是否被正确加载
- 确保没有拼写错误（区分大小写）
循环引用
```
a=${b}
b=${a}  # 会导致启动失败
```
默认值失效
- ${key:-default} 冒号后不能有空格
- 错误写法：${key : default}

特殊字符处理

# 需用单引号包裹特殊字符
regex.pattern=${'^[a-z]+$'}

最佳实践

敏感信息（如密码）应使用 @ConfigurationProperties 而非 @Value
生产环境推荐通过环境变量覆盖配置
使用 spring.config.import 替代已弃用的 spring.config.location

示例：多环境配置

# application-dev.yml
db:
  url: jdbc:mysql://localhost:3306/dev

# application-prod.yml
db:
  url: ${DB_URL:jdbc:mysql://prod-server:3306/prod}

# 启动时激活环境
java -jar app.jar --spring.profiles.active=prod

配置属性引用

概念定义

配置属性引用（Property Reference）是 SpringBoot 中一种允许在配置文件中动态引用其他配置值的机制。通过 ${property.name} 语法，可以在 application.properties 或 application.yml 中引用已定义的属性值，实现配置的复用和动态组合。

使用场景

避免重复配置：多个配置项需要相同值时，只需定义一次，其他地方通过引用复用。
动态组合配置：如拼接文件路径、构造 URL 等。
环境差异化配置：通过引用环境变量或命令行参数，实现不同环境的配置切换。

语法示例

在 `application.properties` 中

# 定义基础属性
app.name=MyApp
app.version=1.0.0

# 引用属性
app.info=${app.name}@${app.version}  # 结果为 "[email protected]"

在 `application.yml` 中

app:
  name: MyApp
  version: 1.0.0
  info: "${app.name}@${app.version}"  # 结果为 "[email protected]"

支持的功能

嵌套引用：属性值中可以包含多层引用。

database.url=jdbc:mysql://${db.host}:${db.port}/${db.name}
db.host=localhost
db.port=3306
db.name=mydb

默认值：通过 : 指定默认值，当引用的属性不存在时使用。

server.port=${custom.port:8080}  # 若 custom.port 未定义，则使用 8080

环境变量引用：直接引用系统环境变量。

app.path=${HOME}/myapp  # 引用系统的 HOME 环境变量

注意事项

循环引用：避免属性间相互引用导致无限循环。
```
# 错误示例
a=${b}
b=${a}
```
优先级问题：SpringBoot 配置源（如命令行参数、环境变量、配置文件）的优先级高于属性引用，可能导致引用覆盖。
类型转换：引用属性时需确保类型兼容，如将字符串引用到数值类型可能引发异常。
YAML 中的引号：在 YAML 中，若引用值包含特殊字符（如 :），需用双引号包裹。
```
example: "${app.name}:${app.version}"
```

示例代码

配置类中使用引用

@Configuration
@ConfigurationProperties(prefix = "app")
public class AppConfig {
    private String info;  // 自动注入 "[email protected]"

    // Getter 和 Setter
}

测试验证

@SpringBootTest
public class PropertyReferenceTest {
    @Value("${app.info}")
    private String appInfo;

    @Test
    void testReference() {
        System.out.println(appInfo);  // 输出 "[email protected]"
    }
}

配置属性加密

概念定义

配置属性加密是指将SpringBoot应用配置文件（如application.properties或application.yml）中的敏感信息（如数据库密码、API密钥等）进行加密存储，避免明文暴露的安全风险。SpringBoot通过集成jasypt等库实现该功能。

使用场景

敏感信息保护：数据库密码、第三方服务密钥等
配置中心安全：与Spring Cloud Config配合使用时
CI/CD流程：避免在版本控制中暴露明文配置
生产环境部署：符合安全审计要求

实现方式（以jasypt为例）

1. 添加依赖

<dependency>
    <groupId>com.github.ulisesbocchiogroupId>
    <artifactId>jasypt-spring-boot-starterartifactId>
    <version>3.0.5version>
dependency>

2. 加密配置格式

# 加密后的值用ENC()包裹
spring.datasource.password=ENC(密文字符串)

3. 加密/解密工具类

import org.jasypt.encryption.pbe.StandardPBEStringEncryptor;

public class JasyptUtil {
    public static String encrypt(String key, String value) {
        StandardPBEStringEncryptor encryptor = new StandardPBEStringEncryptor();
        encryptor.setPassword(key);
        return encryptor.encrypt(value);
    }
    
    public static String decrypt(String key, String encrypted) {
        StandardPBEStringEncryptor encryptor = new StandardPBEStringEncryptor();
        encryptor.setPassword(key);
        return encryptor.decrypt(encrypted);
    }
}

配置密钥方式

方式1：环境变量（推荐）

export JASYPT_ENCRYPTOR_PASSWORD=your_secret_key

方式2：启动参数

java -jar app.jar --jasypt.encryptor.password=your_secret_key

方式3：配置文件（不推荐）

jasypt.encryptor.password=your_secret_key

高级配置选项

# 算法配置
jasypt.encryptor.algorithm=PBEWithMD5AndDES
# 迭代次数
jasypt.encryptor.keyObtentionIterations=1000
# 盐生成器
jasypt.encryptor.saltGeneratorClassName=org.jasypt.salt.RandomSaltGenerator

注意事项

密钥管理：加密密钥不应存放在代码或配置文件中
算法选择：默认算法强度较低，生产环境建议使用PBEWITHHMACSHA512ANDAES_256
性能影响：加解密操作会带来轻微性能开销
兼容性：加密后的配置在不同环境需保持密钥一致
日志安全：确保日志不会打印解密后的敏感信息

示例流程

生成加密值：

String encrypted = JasyptUtil.encrypt("secret-key", "real-password");
// 输出：ENC(AbCdEfG123456...)

配置文件中使用：

spring.datasource.url=jdbc:mysql://localhost:3306/db
spring.datasource.username=admin
spring.datasource.password=ENC(AbCdEfG123456...)

启动应用时指定密钥：

java -Djasypt.encryptor.password=secret-key -jar app.jar

配置属性验证

概念定义

配置属性验证是指在 Spring Boot 应用中，对从配置源（如 application.properties 或 application.yml）加载的属性值进行合法性检查的过程。通过验证可以确保配置值符合预期，避免运行时因配置错误导致的异常或逻辑问题。

使用场景

必填字段检查：确保关键配置项不为空。
数值范围限制：如端口号必须在 1-65535 之间。
格式校验：如邮箱、URL、正则表达式匹配。
条件依赖：某些配置需同时存在或互斥。

实现方式

1. 使用 JSR-303 注解验证

Spring Boot 支持通过 javax.validation 注解对 @ConfigurationProperties 类进行校验。

示例代码：

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.validation.annotation.Validated;
import javax.validation.constraints.*;

@Validated // 启用验证
@ConfigurationProperties(prefix = "app")
public class AppConfig {
    @NotBlank(message = "应用名称不能为空")
    private String name;

    @Min(value = 1, message = "端口号必须大于0")
    @Max(value = 65535, message = "端口号必须小于65536")
    private int port;

    @Pattern(regexp = "^https?://.+", message = "URL必须以http或https开头")
    private String url;

    // Getters and Setters
}

2. 自定义验证器

通过实现 Validator 接口或使用 @PostConstruct 方法进行复杂逻辑校验。

示例代码：

import javax.annotation.PostConstruct;

@ConfigurationProperties(prefix = "db")
public class DatabaseConfig {
    private String url;
    private String username;
    private String password;

    @PostConstruct
    public void validate() {
        if (url == null || username == null || password == null) {
            throw new IllegalStateException("数据库配置不完整");
        }
    }
}

常见注解

注解	作用
`@NotNull`	值不能为 null
`@NotBlank`	字符串不能为空或仅空白
`@Min`/`@Max`	数值最小/最大值限制
`@Size`	集合/字符串长度限制
`@Pattern`	正则表达式匹配
`@Email`	邮箱格式校验

注意事项

依赖引入：需添加 spring-boot-starter-validation 依赖：

<dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-starter-validationartifactId>
dependency>

错误处理：验证失败会抛出 BindValidationException，可通过 @ControllerAdvice 全局捕获。
嵌套验证：对嵌套对象需在字段上添加 @Valid：
```
@Valid
private SecurityConfig security;
```
宽松绑定：Spring Boot 默认支持属性名的宽松绑定（如 myProp 可匹配 my-prop），但验证时需注意注解是否兼容。

示例：完整的属性验证流程

定义配置类：

@Validated
@ConfigurationProperties(prefix = "mail")
public class MailConfig {
    @NotBlank
    private String host;
    
    @Email
    private String adminEmail;
}

配置文件（application.yml）：

mail:
  host: smtp.example.com
  admin-email: [email protected]

启用配置：在主类添加 @EnableConfigurationProperties：

@SpringBootApplication
@EnableConfigurationProperties(MailConfig.class)
public class MyApp { ... }

验证失败时的输出：

Binding to target org.springframework.boot.context.properties.bind.BindException: 
Failed to bind properties under 'mail' to com.example.MailConfig failed:
    Property: mail.adminEmail
    Value: invalid-email
    Reason: 必须是合法的电子邮件地址

配置属性转换

定义

配置属性转换（Property Conversion）是 Spring Boot 在加载配置文件（如 application.properties 或 application.yml）时，将配置值从字符串形式自动转换为目标 Java 类型的过程。Spring Boot 内置了大量默认的类型转换器，同时也支持自定义转换逻辑。

常见使用场景

基本类型转换：将字符串转换为 int、boolean、long 等基本类型或其包装类。
时间类型转换：如 Duration、Period、LocalDate 等时间相关类型的转换。
集合类型转换：将逗号分隔的字符串转换为 List、Set 等集合类型。
自定义对象转换：将配置值绑定到自定义的 POJO 类。

内置转换示例

基本类型

# application.properties
server.port=8080           # 转换为 int
app.enabled=true           # 转换为 boolean
app.timeout=5000           # 转换为 long

时间类型

app.session-timeout=30s    # 转换为 Duration
app.start-date=2023-01-01  # 转换为 LocalDate

集合类型

app.servers=192.168.1.1,192.168.1.2  # 转换为 List

自定义对象转换

假设有一个自定义配置类：

@ConfigurationProperties(prefix = "app")
public class AppConfig {
    private List<Endpoint> endpoints;

    // getter 和 setter
}

public class Endpoint {
    private String url;
    private int port;

    // getter 和 setter
}

配置文件：

app.endpoints[0].url=http://example.com
app.endpoints[0].port=8080
app.endpoints[1].url=http://test.com
app.endpoints[1].port=9090

自定义属性转换器

如果需要支持特殊类型的转换，可以实现 Converter 接口并注册为 Spring Bean。

示例：自定义字符串到 `Endpoint` 的转换

public class StringToEndpointConverter implements Converter<String, Endpoint> {
    @Override
    public Endpoint convert(String source) {
        String[] parts = source.split(":");
        Endpoint endpoint = new Endpoint();
        endpoint.setUrl(parts[0]);
        endpoint.setPort(Integer.parseInt(parts[1]));
        return endpoint;
    }
}

注册转换器：

@Configuration
public class ConversionConfig {
    @Bean
    public StringToEndpointConverter stringToEndpointConverter() {
        return new StringToEndpointConverter();
    }
}

配置文件：

app.endpoint=http://example.com:8080

常见误区与注意事项

类型不匹配：如果配置值无法转换为目标类型，会抛出 IllegalArgumentException。例如，将 abc 转换为 int。
集合分隔符：默认使用逗号分隔集合元素，但如果元素中包含逗号，需要转义或使用其他格式（如 YAML）。
时间单位：时间类型的单位（如 s、ms）必须符合 Duration 或 Period 的格式要求。
大小写敏感：枚举类型的转换是大小写敏感的，需确保配置值与枚举名称完全匹配。
自定义转换器优先级：自定义转换器的优先级高于默认转换器，但需确保其被正确注册为 Spring Bean。

高级用法：使用 `@ConfigurationPropertiesBinding`

对于更复杂的转换逻辑，可以实现 GenericConverter 或 ConditionalGenericConverter，并通过 @ConfigurationPropertiesBinding 注解标记为配置属性绑定专用的转换器。

@Component
@ConfigurationPropertiesBinding
public class CustomGenericConverter implements GenericConverter {
    @Override
    public Set<ConvertiblePair> getConvertibleTypes() {
        return Collections.singleton(new ConvertiblePair(String.class, CustomType.class));
    }

    @Override
    public Object convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType) {
        // 自定义转换逻辑
    }
}

配置属性默认值

概念定义

配置属性默认值指的是在 Spring Boot 应用中，当未显式配置某个属性时，Spring Boot 自动提供的预设值。这些默认值通常内置于框架或相关依赖中，旨在简化开发者的配置工作。

使用场景

快速启动项目：无需手动配置所有属性即可运行应用。
简化配置：仅需覆盖需要修改的属性，其余使用默认值。
框架集成：第三方库（如数据库连接池、服务器端口等）通常提供合理的默认值。

常见默认值示例

以下是一些典型的 Spring Boot 默认配置属性：

服务器端口：server.port=8080
应用上下文路径：server.servlet.context-path=（默认为空）
数据库连接池：HikariCP 的默认连接池大小与数据库类型相关。
日志级别：logging.level.root=INFO

如何查看默认值

官方文档：Spring Boot 官方文档列出了所有默认配置。
IDE 提示：在 application.properties 或 application.yml 文件中，IDE 通常会显示支持的属性和默认值。
源码：通过查看 spring-boot-autoconfigure 模块中的 *AutoConfiguration 类。

覆盖默认值

在 application.properties 或 application.yml 中显式定义属性即可覆盖默认值。例如：

# 覆盖服务器端口
server.port=9090

或 YAML 格式：

server:
  port: 9090

注意事项

优先级问题：Spring Boot 属性加载遵循特定优先级（如命令行参数 > 配置文件 > 默认值）。
依赖变化：不同版本的 Spring Boot 或库可能修改默认值，升级时需注意兼容性。
显式配置：某些默认值可能不适合生产环境（如数据库连接池大小），需根据实际情况调整。

自定义默认值

可以通过 @ConfigurationProperties 和 @Bean 结合的方式为自定义属性设置默认值。例如：

@Configuration
@ConfigurationProperties(prefix = "myapp")
public class MyAppProperties {
    private int timeout = 30; // 默认值30
    private String name = "default";

    // getters and setters
}

@Bean
public MyAppProperties myAppProperties() {
    return new MyAppProperties();
}

然后在配置文件中只需覆盖部分属性：

myapp:
  timeout: 60

二、核心配置文件详解

application.properties 文件结构

基本概念

application.properties 是 Spring Boot 默认的配置文件，采用 键值对（Key-Value） 格式存储配置信息。文件通常位于项目的 src/main/resources 目录下，Spring Boot 启动时会自动加载该文件中的配置。

文件格式

键值对格式
每行定义一个配置项，格式为 key=value，例如：
```
server.port=8080
spring.datasource.url=jdbc:mysql://localhost:3306/mydb
```

注释
使用 # 或 ! 开头表示注释：

# 这是服务器端口配置
server.port=8080

多级属性
通过 . 分隔层级，形成树形结构，例如：
```
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
```

常见配置分组

服务器配置

server.port=8080
server.servlet.context-path=/api

数据库配置

spring.datasource.url=jdbc:mysql://localhost:3306/test
spring.datasource.username=root
spring.datasource.password=123456

日志配置

logging.level.root=INFO
logging.level.com.example=DEBUG

自定义配置
支持用户自定义配置，例如：
```
app.name=MySpringBootApp
app.version=1.0.0
```

特殊语法

多环境配置
通过 spring.profiles.active 指定激活的配置文件（如 application-dev.properties）：
```
spring.profiles.active=dev
```
占位符（Placeholder）
支持引用其他配置项的值：
```
app.description=${app.name} version ${app.version}
```
列表/数组配置
使用逗号分隔多个值：
```
app.servers=192.168.1.1,192.168.1.2
```

示例代码

以下是一个完整的 application.properties 示例：

# 服务器配置
server.port=8080
server.servlet.context-path=/demo

# 数据库配置
spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=admin
spring.datasource.password=secret

# 自定义配置
app.name=SpringBootDemo
app.version=2.0.0
app.description=${app.name} @ ${server.port}

注意事项

键名区分大小写
server.port 和 Server.Port 会被视为不同的配置。
避免空格
键和值中不要随意添加空格（除非是值的部分），例如：
```
# 错误写法
server.port = 8080
# 正确写法
server.port=8080
```
优先级规则
Spring Boot 会按以下顺序加载配置（后加载的覆盖前者）：
- 项目内的 application.properties
- 项目内的 application-{profile}.properties
- 外部配置文件（如命令行参数、环境变量等）

application.yml 文件结构

1. 基本概念

application.yml 是 Spring Boot 项目中的核心配置文件之一，采用 YAML（YAML Ain’t Markup Language） 格式，通过层级缩进和键值对的方式组织配置数据。相比传统的 application.properties，YAML 格式更易读且支持复杂结构。

2. 文件结构特点

2.1 键值对结构

使用 key: value 形式，冒号后需加空格。
字符串可省略引号（特殊字符需用单/双引号包裹）。

server:
  port: 8080
  servlet:
    context-path: /api

2.2 层级缩进

通过 空格缩进（通常 2 个空格）表示层级关系，不可使用 Tab。

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/db
    username: root

2.3 列表/数组

使用短横线 - 表示列表项，缩进需对齐。

cors:
  allowed-origins:
    - "https://example.com"
    - "http://localhost:3000"

2.4 多文档块

通过 --- 分隔多个配置块，适用于不同环境的配置合并。

# 公共配置
spring:
  profiles:
    active: dev
---
# 开发环境
spring:
  profiles: dev
server:
  port: 8081

3. 常见使用场景

3.1 基础配置

服务器端口、上下文路径、日志级别等。

server:
  port: 8080
logging:
  level:
    org.springframework: INFO

3.2 数据源配置

数据库连接、连接池参数。

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/test
    username: user
    password: pass
    hikari:
      maximum-pool-size: 10

3.3 自定义配置

通过 @Value 或 @ConfigurationProperties 绑定。

app:
  auth:
    token-expire: 3600
    secret-key: "my-secret"

4. 注意事项

缩进严格一致：缩进错误会导致解析失败。
避免重复键：同一层级下重复的键会覆盖前者。
敏感信息保护：密码等敏感信息应使用 spring-boot-configuration-processor 或外部化配置（如 Vault）。
类型自动转换：YAML 会自动转换数字、布尔值等类型，字符串需显式引号包裹。

多环境配置文件命名规则

在 Spring Boot 中，多环境配置是一种常见的实践，允许开发者为不同的环境（如开发、测试、生产）定义不同的配置。Spring Boot 通过特定的文件命名规则来识别和加载不同环境的配置文件。

基本命名规则

Spring Boot 的多环境配置文件遵循以下命名格式：

application-{profile}.properties
或
application-{profile}.yml

其中：

application 是固定的前缀。
{profile} 是环境标识，例如 dev（开发环境）、test（测试环境）、prod（生产环境）等。

示例文件结构

以下是一个典型的多环境配置文件结构：

src/main/resources/
├── application.yml          # 主配置文件（公共配置）
├── application-dev.yml      # 开发环境配置
├── application-test.yml     # 测试环境配置
└── application-prod.yml     # 生产环境配置

激活指定环境的配置

可以通过以下方式激活特定的环境配置：

通过 spring.profiles.active 属性
在 application.properties 或 application.yml 中指定：
```
spring.profiles.active=dev
```
或 YAML 格式：
```
spring:
  profiles:
    active: dev
```
通过命令行参数
在运行应用时通过 --spring.profiles.active 指定：
```
java -jar myapp.jar --spring.profiles.active=prod
```
通过环境变量
设置环境变量 SPRING_PROFILES_ACTIVE：
```
export SPRING_PROFILES_ACTIVE=test
```

多环境配置的优先级

Spring Boot 会按以下顺序加载配置：

主配置文件（application.properties 或 application.yml）。
激活的环境配置文件（如 application-dev.yml）。
命令行参数或环境变量（优先级最高）。

多环境配置的合并规则

如果某个配置在多个文件中都存在，后加载的配置会覆盖先加载的配置。
可以通过 spring.config.import 引入额外的配置文件。

示例代码

假设有以下多环境配置：

application.yml（公共配置）

server:
  port: 8080
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mydb
    username: root
    password: root

application-dev.yml（开发环境配置）

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mydb_dev
logging:
  level:
    root: debug

application-prod.yml（生产环境配置）

server:
  port: 80
spring:
  datasource:
    url: jdbc:mysql://prod-db:3306/mydb_prod
    username: admin
    password: securepassword

注意事项

避免敏感信息硬编码
生产环境的密码等敏感信息应使用环境变量或配置中心（如 Spring Cloud Config）管理。
默认环境配置
如果没有显式激活任何环境，Spring Boot 会加载 application.properties 或 application.yml。
多环境配置的兼容性
确保不同环境的配置键一致，避免因环境切换导致配置缺失。

使用 @Profile 注解
可以通过 @Profile 注解实现 Bean 的环境隔离，例如：

@Configuration
@Profile("dev")
public class DevConfig {
    // 仅开发环境生效的 Bean
}

通过合理的多环境配置文件命名和激活机制，可以轻松实现不同环境的配置切换。

激活特定环境配置

概念定义

在 SpringBoot 中，激活特定环境配置是指通过配置或代码的方式，指定当前应用运行的环境（如开发环境 dev、测试环境 test、生产环境 prod 等），从而加载对应的配置文件（如 application-dev.yml、application-prod.yml）。SpringBoot 会根据激活的环境自动加载相应的配置，覆盖默认的 application.yml 或 application.properties 中的配置。

使用场景

多环境部署：在开发、测试和生产环境中使用不同的数据库连接、日志级别或第三方服务配置。
动态切换配置：通过简单修改环境变量或启动参数，快速切换应用运行环境。
隔离敏感信息：将生产环境的敏感配置（如密码、密钥）单独存放在生产环境配置文件中，避免泄露。

激活方式

SpringBoot 支持多种方式激活特定环境配置：

1. 通过配置文件指定

在 application.yml 或 application.properties 中设置 spring.profiles.active 属性：

# application.yml
spring:
  profiles:
    active: dev

2. 通过启动参数指定

在启动应用时通过命令行参数指定：

java -jar myapp.jar --spring.profiles.active=prod

3. 通过环境变量指定

设置操作系统环境变量：

export SPRING_PROFILES_ACTIVE=test

4. 通过 JVM 参数指定

在启动时通过 -D 参数指定：

java -Dspring.profiles.active=dev -jar myapp.jar

配置文件命名规则

SpringBoot 会根据 spring.profiles.active 的值加载对应的配置文件，命名格式为：

application-{profile}.yml

或

application-{profile}.properties

例如：

application-dev.yml（开发环境）
application-prod.yml（生产环境）

示例代码

假设有以下配置文件：

# application.yml（默认配置）
server:
  port: 8080
logging:
  level:
    root: info

# application-dev.yml（开发环境）
logging:
  level:
    root: debug
database:
  url: jdbc:mysql://localhost:3306/dev_db

# application-prod.yml（生产环境）
server:
  port: 80
database:
  url: jdbc:mysql://prod-server:3306/prod_db

激活开发环境时（spring.profiles.active=dev），SpringBoot 会合并 application.yml 和 application-dev.yml 的配置，最终生效的配置为：

server:
  port: 8080
logging:
  level:
    root: debug
database:
  url: jdbc:mysql://localhost:3306/dev_db

注意事项

优先级问题：application-{profile}.yml 的配置会覆盖 application.yml 中的同名配置。
多环境激活：可以同时激活多个环境，用逗号分隔（如 dev,db-mock），但需注意配置冲突。
默认配置：如果没有显式激活任何环境，SpringBoot 只会加载 application.yml。
Profile 不存在：如果指定的 Profile 不存在，SpringBoot 会忽略而不会报错。
敏感信息保护：生产环境配置应避免提交到代码仓库，可通过外部化配置（如 Vault、Kubernetes Secrets）管理。

高级用法

条件化 Bean 加载

通过 @Profile 注解可以指定 Bean 仅在特定环境下生效：

@Configuration
@Profile("dev")
public class DevConfig {
    @Bean
    public DataSource devDataSource() {
        // 开发环境数据源配置
    }
}

多文档配置

在单个 application.yml 中通过 --- 分隔多环境配置：

# 公共配置
server:
  port: 8080
spring:
  profiles:
    active: dev

---
# 开发环境配置
spring:
  profiles: dev
logging:
  level:
    root: debug

---
# 生产环境配置
spring:
  profiles: prod
server:
  port: 80

配置分组管理

概念定义

配置分组管理是指将SpringBoot应用程序的配置属性按照功能或模块进行逻辑分组，以提高配置的可读性和可维护性。通过@ConfigurationProperties注解结合前缀(prefix)实现属性绑定，可以创建多个配置类来管理不同模块的配置。

使用场景

多环境配置：开发、测试、生产环境使用不同配置组
模块化应用：不同业务模块有独立配置
第三方集成：Redis、MySQL等不同服务的配置分离
复杂配置项：当单个配置类过于庞大时进行拆分

实现方式

基础配置分组示例

// 数据库配置组
@ConfigurationProperties(prefix = "app.datasource")
@Data
public class DataSourceProperties {
    private String url;
    private String username;
    private String password;
    private int maxPoolSize;
}

// 缓存配置组
@ConfigurationProperties(prefix = "app.cache")
@Data
public class CacheProperties {
    private String host;
    private int port;
    private long timeout;
}

配置文件示例(application.yml)

app:
  datasource:
    url: jdbc:mysql://localhost:3306/demo
    username: root
    password: 123456
    max-pool-size: 20
  cache:
    host: redis.local
    port: 6379
    timeout: 5000

高级特性

嵌套配置分组

@ConfigurationProperties(prefix = "app")
@Data
public class AppProperties {
    private DataSource datasource;
    private Cache cache;
    
    @Data
    public static class DataSource {
        private String url;
        private String username;
    }
    
    @Data
    public static class Cache {
        private String host;
        private int port;
    }
}

配置验证

@Validated
@ConfigurationProperties(prefix = "app.security")
@Data
public class SecurityProperties {
    @NotEmpty
    private String secretKey;
    
    @Min(1)
    @Max(60)
    private int tokenExpireMinutes;
}

最佳实践

命名规范：
- 使用小写字母和连字符(-)作为分隔符
- 保持前缀命名一致性(如app.module.submodule)
组织原则：
- 按功能而非技术分层分组
- 单个配置类不超过15个属性
- 相关配置放在同一个分组
文档化：
- 为每个配置属性添加Javadoc说明
- 在配置类上添加使用示例

常见问题

属性绑定失败：
- 确保配置前缀与注解定义一致
- 检查属性名称的kebab-case与camelCase转换
配置覆盖顺序：
- 了解SpringBoot的属性源加载顺序
- 注意profile-specific配置的优先级
类型安全：
- 使用@DurationUnit等注解处理特殊类型
- 对于复杂类型考虑自定义转换器

与@Value对比优势

强类型绑定：避免字符串到类型的转换错误
IDE支持：更好的代码补全和导航
元数据支持：可通过spring-boot-configuration-processor生成配置元数据
验证支持：轻松集成JSR-303验证

性能考虑

配置类应尽量声明为final(Java 16+的record类型更佳)
避免在配置类中实现复杂逻辑
对于高频访问的配置项考虑缓存读取结果

配置项命名规范

在 Spring Boot 中，配置项的命名规范是确保配置清晰、一致且易于维护的关键。以下是详细的命名规则和最佳实践：

1. 基本规则

小写字母 + 连字符（kebab-case）：Spring Boot 官方推荐使用小写字母和连字符（-）分隔单词，例如 server.port 或 spring.datasource.url。
避免驼峰命名（camelCase）或下划线（snake_case）：虽然 Spring Boot 会自动将 camelCase 和 snake_case 转换为 kebab-case，但官方建议直接使用 kebab-case 以保持一致性。

2. 分层命名

配置项通常按功能模块分层，以点（.）分隔层级，例如：

server.port：服务器端口配置。
spring.datasource.username：数据库用户名配置。
logging.level.root：日志级别配置。

3. 常见前缀

Spring Boot 为不同模块提供了标准化的配置前缀，例如：

server.*：服务器相关配置（如端口、上下文路径）。
spring.*：Spring 框架核心配置（如数据源、事务）。
logging.*：日志相关配置。
management.*：Actuator 监控相关配置。

4. 自定义配置项

如果项目中需要自定义配置，建议遵循以下规则：

使用项目或模块前缀：避免与 Spring Boot 内置配置冲突。例如：
```
myapp.api.timeout=5000
myapp.cache.enabled=true
```
保持语义清晰：配置名应直接反映其用途，例如 myapp.security.jwt.secret。

5. 环境变量映射

当配置需通过环境变量传递时（如 Docker/K8s 部署），需转换为大写 + 下划线格式，例如：

server.port → SERVER_PORT
spring.datasource.url → SPRING_DATASOURCE_URL

6. 示例代码

# 标准配置示例
server.port=8080
spring.datasource.url=jdbc:mysql://localhost:3306/db
spring.datasource.username=root
logging.level.root=INFO

# 自定义配置示例
myapp.feature.enabled=true
myapp.retry.max-attempts=3

7. 注意事项

避免冗余：如 database.url 和 db.url 同时存在会导致混淆。
不要滥用缩写：例如 ds.url 不如 datasource.url 清晰。
统一风格：团队内需约定命名规范并保持一致。

通过遵循这些规范，可以显著提升配置的可读性和可维护性。

常用基础配置项

SpringBoot 提供了丰富的配置选项，可以通过 application.properties 或 application.yml 文件进行配置。以下是一些常用的基础配置项：

1. 服务器配置

1.1 端口配置

# 设置服务器端口，默认为 8080
server.port=8080

1.2 上下文路径

# 设置应用的上下文路径，默认为空
server.servlet.context-path=/myapp

1.3 服务器地址

# 设置服务器绑定的地址，默认为所有地址
server.address=0.0.0.0

2. 数据库配置

2.1 JDBC 连接

# 数据源配置
spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

2.2 Hikari 连接池（默认）

# 连接池配置
spring.datasource.hikari.maximum-pool-size=10
spring.datasource.hikari.minimum-idle=5
spring.datasource.hikari.connection-timeout=30000

3. 日志配置

3.1 日志级别

# 设置日志级别
logging.level.root=INFO
logging.level.org.springframework.web=DEBUG
logging.level.com.myapp=TRACE

3.2 日志文件

# 日志文件配置
logging.file.name=myapp.log
logging.file.path=/var/log
logging.pattern.console=%d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n

4. 应用配置

4.1 应用名称

# 应用名称
spring.application.name=my-springboot-app

4.2 环境配置

# 激活特定的配置文件
spring.profiles.active=dev

5. Web 相关配置

5.1 静态资源路径

# 静态资源路径配置
spring.mvc.static-path-pattern=/static/**
spring.web.resources.static-locations=classpath:/static/

5.2 文件上传

# 文件上传配置
spring.servlet.multipart.max-file-size=10MB
spring.servlet.multipart.max-request-size=10MB

6. 缓存配置

6.1 Redis 缓存

# Redis 配置
spring.redis.host=localhost
spring.redis.port=6379
spring.redis.password=
spring.cache.type=redis

6.2 缓存过期时间

# 缓存过期时间
spring.cache.redis.time-to-live=600000

7. 邮件配置

7.1 SMTP 配置

# 邮件配置
spring.mail.host=smtp.example.com
spring.mail.port=587
[email protected]
spring.mail.password=password
spring.mail.properties.mail.smtp.auth=true
spring.mail.properties.mail.smtp.starttls.enable=true

8. 安全配置

8.1 基本安全配置

# 安全配置
spring.security.user.name=admin
spring.security.user.password=admin123

8.2 CSRF 配置

# CSRF 配置
spring.security.csrf.enabled=true

9. 监控配置

9.1 Actuator 配置

# Actuator 配置
management.endpoints.web.exposure.include=health,info,metrics
management.endpoint.health.show-details=always

9.2 自定义指标

# 自定义指标
management.metrics.tags.application=my-springboot-app

10. 国际化配置

10.1 消息源配置

# 国际化配置
spring.messages.basename=messages
spring.messages.encoding=UTF-8

10.2 默认语言

# 默认语言
spring.messages.fallback-to-system-locale=false
spring.messages.default-locale=en

11. 测试配置

11.1 测试数据库

# 测试数据库配置
spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driver-class-name=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=
spring.h2.console.enabled=true
spring.h2.console.path=/h2-console

11.2 测试日志级别

# 测试日志级别
logging.level.org.springframework.test=DEBUG

12. 其他常用配置

12.1 时区配置

# 时区配置
spring.jackson.time-zone=GMT+8
spring.jackson.date-format=yyyy-MM-dd HH:mm:ss

12.2 自定义属性

# 自定义属性
app.name=My Application
app.version=1.0.0
app.description=This is a Spring Boot application

12.3 多环境配置

# 多环境配置
spring.profiles.include=dev,db

服务器端口配置

概念定义

服务器端口配置是指通过修改SpringBoot应用的配置文件，指定应用启动时监听的网络端口号。默认情况下，SpringBoot应用使用8080端口，但可以通过配置更改为其他端口。

使用场景

当默认8080端口被其他应用占用时
需要同时运行多个SpringBoot应用时
需要遵循企业网络端口规划规范时
生产环境需要特定端口时

配置方式

1. 通过application.properties配置

server.port=9090

2. 通过application.yml配置

server:
  port: 9090

3. 通过命令行参数配置

java -jar myapp.jar --server.port=9090

4. 通过环境变量配置

export SERVER_PORT=9090
java -jar myapp.jar

高级配置

随机端口配置

server.port=0

HTTPS端口配置

server.port=8443
server.ssl.key-store=classpath:keystore.jks
server.ssl.key-store-password=secret
server.ssl.key-password=secret

同时支持HTTP和HTTPS

@Bean
public ServletWebServerFactory servletContainer() {
    TomcatServletWebServerFactory tomcat = new TomcatServletWebServerFactory();
    tomcat.addAdditionalTomcatConnectors(createStandardConnector());
    return tomcat;
}

private Connector createStandardConnector() {
    Connector connector = new Connector("org.apache.coyote.http11.Http11NioProtocol");
    connector.setPort(8080);
    return connector;
}

注意事项

端口号范围应在0-65535之间
1024以下端口通常需要管理员权限
生产环境建议使用1024以上的端口
端口冲突会导致应用启动失败
云环境可能需要额外配置安全组规则

常见问题排查

端口被占用：检查端口占用情况netstat -ano|findstr "8080"
权限不足：Linux系统下1024以下端口需要sudo权限
配置未生效：检查配置文件的加载顺序和优先级
防火墙阻止：检查服务器防火墙设置

最佳实践

开发环境可以使用随机端口
测试环境使用固定端口
生产环境使用配置中心管理端口配置
记录使用的端口号到文档中
考虑使用服务发现机制替代硬编码端口

上下文路径配置

什么是上下文路径？

上下文路径（Context Path）是指Web应用程序在服务器上的根路径。例如，如果你的应用部署在 http://localhost:8080/myapp，那么 /myapp 就是上下文路径。在SpringBoot中，上下文路径可以通过配置来修改。

使用场景

多应用部署：在同一服务器上部署多个应用时，通过不同的上下文路径区分。
统一入口：某些场景下需要将应用挂载到特定路径（如 /api）。
与前端集成：前后端分离时，可能需要统一上下文路径。

配置方式

SpringBoot提供了多种配置上下文路径的方式：

1. 通过 `application.properties` 或 `application.yml`

# application.properties
server.servlet.context-path=/myapp

# application.yml
server:
  servlet:
    context-path: /myapp

2. 通过环境变量

export SERVER_SERVLET_CONTEXT_PATH=/myapp

3. 通过命令行参数

java -jar myapp.jar --server.servlet.context-path=/myapp

注意事项

路径格式：
- 必须以 / 开头（如 /myapp）。
- 不能以 / 结尾（错误示例：/myapp/）。
根路径：
- 设置为 / 表示没有上下文路径（直接通过 http://localhost:8080 访问）。
影响范围：
- 上下文路径会影响所有控制器（Controller）的请求映射。
- 静态资源路径也会被影响（如 /static 会变为 /myapp/static）。
与其他配置的冲突：
- 如果同时使用 server.servlet.context-path 和 spring.mvc.servlet.path，后者会作为前者的子路径。

示例代码

假设有一个简单的控制器：

@RestController
public class HelloController {
    @GetMapping("/hello")
    public String hello() {
        return "Hello, SpringBoot!";
    }
}

如果 context-path 设置为 /myapp，则访问路径为：http://localhost:8080/myapp/hello。
如果 context-path 设置为 /，则访问路径为：http://localhost:8080/hello。

测试验证

启动应用后，可以通过以下方式验证：

访问 http://localhost:8080/myapp/hello 查看是否返回预期结果。
检查日志中的 Tomcat started on port(s): 8080 (http) with context path '/myapp'。

常见问题

静态资源404：
- 原因：未考虑上下文路径，直接访问 /static/style.css。
- 解决：使用 /myapp/static/style.css 或模板中的相对路径。
重定向问题：
- 在控制器中直接返回 redirect:/page 时，实际会跳转到 /myapp/page。
Swagger集成：
- Swagger UI的访问路径会变为 /myapp/swagger-ui.html。

日志级别配置

什么是日志级别

日志级别用于定义日志信息的重要性或严重程度。在Spring Boot中，常见的日志级别从低到高依次为：

TRACE：最详细的日志信息，通常用于开发调试
DEBUG：调试信息，有助于诊断问题
INFO：常规运行信息
WARN：潜在问题警告
ERROR：错误信息，但不影响系统继续运行
FATAL：严重错误，通常会导致应用崩溃

配置日志级别

Spring Boot支持通过多种方式配置日志级别：

1. application.properties/yml配置

# 设置root日志级别
logging.level.root=WARN

# 设置特定包的日志级别
logging.level.org.springframework=DEBUG
logging.level.com.example=TRACE

YAML格式：

logging:
  level:
    root: WARN
    org.springframework: DEBUG
    com.example: TRACE

2. 环境变量配置

java -jar myapp.jar --logging.level.org.springframework=DEBUG

3. 编程式配置

@SpringBootApplication
public class MyApp {
    public static void main(String[] args) {
        SpringApplication.run(MyApp.class, args);
        LoggerContext loggerContext = (LoggerContext) LoggerFactory.getILoggerFactory();
        loggerContext.getLogger("org.springframework").setLevel(Level.DEBUG);
    }
}

日志级别使用场景

开发环境：通常设置为DEBUG或TRACE
测试环境：通常设置为INFO
生产环境：通常设置为WARN或ERROR

注意事项

性能影响：低级别日志(如TRACE/DEBUG)会产生大量日志输出，可能影响性能
日志框架选择：Spring Boot默认使用Logback，但也可切换为Log4j2
日志级别继承：未明确配置的包会继承父包的日志级别
动态调整：某些日志框架支持运行时动态调整日志级别

示例：Logback高级配置


<configuration>
    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%npattern>
        encoder>
    appender>

    <logger name="com.example.service" level="DEBUG" additivity="false">
        <appender-ref ref="CONSOLE" />
    logger>

    <root level="INFO">
        <appender-ref ref="CONSOLE" />
    root>
configuration>

常见问题

日志不输出：检查是否配置了正确的日志级别
日志过多：生产环境应避免使用低级别日志
日志文件过大：配置合理的滚动策略和日志保留时间

数据库连接配置

概念定义

数据库连接配置是指在SpringBoot应用中，通过配置文件或代码方式设置与数据库建立连接所需的参数。这些参数通常包括数据库URL、用户名、密码、驱动类名等。

核心配置参数

SpringBoot中常用的数据库连接配置参数包括：

# 基本配置
spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

# 连接池配置(HikariCP默认)
spring.datasource.hikari.maximum-pool-size=10
spring.datasource.hikari.minimum-idle=5
spring.datasource.hikari.idle-timeout=30000
spring.datasource.hikari.max-lifetime=1800000

不同数据库的配置示例

MySQL配置

spring.datasource.url=jdbc:mysql://localhost:3306/mydb?useSSL=false&serverTimezone=UTC
spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

PostgreSQL配置

spring.datasource.url=jdbc:postgresql://localhost:5432/mydb
spring.datasource.username=postgres
spring.datasource.password=123456
spring.datasource.driver-class-name=org.postgresql.Driver

Oracle配置

spring.datasource.url=jdbc:oracle:thin:@localhost:1521:ORCL
spring.datasource.username=system
spring.datasource.password=123456
spring.datasource.driver-class-name=oracle.jdbc.OracleDriver

多数据源配置

当需要连接多个数据库时，可以这样配置：

@Configuration
public class DataSourceConfig {
    
    @Bean
    @Primary
    @ConfigurationProperties("spring.datasource.primary")
    public DataSource primaryDataSource() {
        return DataSourceBuilder.create().build();
    }
    
    @Bean
    @ConfigurationProperties("spring.datasource.secondary")
    public DataSource secondaryDataSource() {
        return DataSourceBuilder.create().build();
    }
}

对应application.properties:

# 主数据源
spring.datasource.primary.url=jdbc:mysql://localhost:3306/db1
spring.datasource.primary.username=root
spring.datasource.primary.password=123456
spring.datasource.primary.driver-class-name=com.mysql.cj.jdbc.Driver

# 次数据源
spring.datasource.secondary.url=jdbc:mysql://localhost:3306/db2
spring.datasource.secondary.username=root
spring.datasource.secondary.password=123456
spring.datasource.secondary.driver-class-name=com.mysql.cj.jdbc.Driver

连接池配置

SpringBoot 2.x默认使用HikariCP连接池，可以这样配置：

# HikariCP配置
spring.datasource.hikari.connection-timeout=30000
spring.datasource.hikari.maximum-pool-size=20
spring.datasource.hikari.minimum-idle=10
spring.datasource.hikari.idle-timeout=600000
spring.datasource.hikari.max-lifetime=1800000

注意事项

敏感信息保护：不要将数据库密码等敏感信息直接写在配置文件中，建议使用Jasypt等工具加密
时区问题：MySQL 8.x需要设置serverTimezone参数
SSL警告：开发环境可以禁用SSL(useSSL=false)，生产环境应启用
连接泄露：确保正确关闭数据库连接，可以使用@Transactional管理事务
连接池大小：根据应用负载合理设置连接池大小

最佳实践

将不同环境的配置分离(application-dev.properties, application-prod.properties)
使用Spring Cloud Config等配置中心管理生产环境配置
定期监控数据库连接使用情况
为不同业务场景配置不同的数据源(读/写分离)

数据源连接池配置

概念定义

数据源连接池（Connection Pool）是一种用于管理数据库连接的技术，它预先创建并维护一定数量的数据库连接，应用程序可以从连接池中获取连接，使用完毕后归还连接，而不是频繁地创建和关闭连接。这样可以显著提高数据库操作的性能和资源利用率。

在SpringBoot中，常用的连接池实现包括：

HikariCP（默认）
Tomcat JDBC Pool
Commons DBCP2

使用场景

Web应用程序：需要频繁与数据库交互的Web应用。
高并发系统：需要处理大量并发请求的系统。
微服务架构：多个服务需要共享数据库连接资源。

常见配置参数

基本配置

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mydb
    username: root
    password: password
    driver-class-name: com.mysql.cj.jdbc.Driver

HikariCP 连接池配置

spring:
  datasource:
    hikari:
      # 连接池名称
      pool-name: MyHikariPool
      # 最小空闲连接数
      minimum-idle: 5
      # 最大连接数
      maximum-pool-size: 20
      # 连接空闲超时时间（毫秒）
      idle-timeout: 30000
      # 连接最大生命周期（毫秒）
      max-lifetime: 1800000
      # 连接超时时间（毫秒）
      connection-timeout: 30000
      # 自动提交
      auto-commit: true

Tomcat JDBC Pool 配置

spring:
  datasource:
    tomcat:
      initial-size: 5
      max-active: 20
      min-idle: 5
      max-idle: 10
      max-wait: 10000
      test-on-borrow: true
      validation-query: SELECT 1

代码示例

使用JdbcTemplate

@Repository
public class UserRepository {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    public List<User> findAll() {
        return jdbcTemplate.query(
            "SELECT * FROM users",
            (rs, rowNum) -> new User(
                rs.getLong("id"),
                rs.getString("name"),
                rs.getString("email")
            )
        );
    }
}

自定义数据源配置

@Configuration
public class DataSourceConfig {

    @Bean
    @ConfigurationProperties(prefix = "spring.datasource.hikari")
    public DataSource dataSource() {
        return DataSourceBuilder.create()
            .type(HikariDataSource.class)
            .build();
    }
}

常见误区与注意事项

连接泄漏：
- 确保每次获取连接后都正确关闭
- 使用try-with-resources语句
配置不当：
- maximum-pool-size不宜过大，通常建议在CPU核心数的2-3倍
- minimum-idle应根据实际负载调整
连接验证：
- 生产环境应配置connection-test-query
- 对于MySQL可以使用SELECT 1
多数据源配置：
- 需要为每个数据源创建独立的配置类
- 使用@Primary注解标记主数据源
监控连接池：
- 使用Spring Boot Actuator监控连接池状态
- 定期检查连接池指标

最佳实践

生产环境推荐使用HikariCP
根据应用负载合理设置连接池大小
配置适当的超时参数
实现连接的健康检查机制
监控连接池的关键指标

缓存配置

什么是缓存配置？

缓存配置是指在 Spring Boot 应用中，通过配置来管理和优化缓存的行为。缓存是一种存储数据的机制，用于减少重复计算或数据库查询的开销，从而提高应用性能。Spring Boot 提供了对多种缓存技术的支持，如 Caffeine、EhCache、Redis 等，并通过简单的配置即可集成这些缓存方案。

为什么需要缓存配置？

提升性能：缓存可以减少对数据库或其他外部资源的访问，降低响应时间。
减轻负载：减少重复计算或查询，降低系统资源消耗。
提高可用性：在高并发场景下，缓存可以缓解数据库压力，避免系统崩溃。

常见的缓存配置方式

Spring Boot 通过 spring.cache 前缀的配置项来管理缓存行为。以下是常见的配置选项：

1. 启用缓存

在 Spring Boot 应用中，首先需要在主类或配置类上添加 @EnableCaching 注解以启用缓存功能。

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

2. 配置缓存类型

通过 spring.cache.type 指定使用的缓存类型，例如：

spring.cache.type=caffeine

支持的缓存类型包括：

simple：基于内存的简单缓存（默认）。
caffeine：高性能的本地缓存。
ehcache：功能丰富的本地缓存。
redis：分布式缓存。
none：禁用缓存。

3. 缓存过期时间

对于某些缓存实现（如 Caffeine 或 Redis），可以配置缓存的过期时间。例如：

# Caffeine 缓存配置
spring.cache.caffeine.spec=maximumSize=500,expireAfterWrite=10m

maximumSize：缓存的最大条目数。
expireAfterWrite：写入后过期时间（例如 10m 表示 10 分钟）。

4. Redis 缓存配置

如果使用 Redis 作为缓存，可以配置连接信息：

spring.cache.type=redis
spring.redis.host=localhost
spring.redis.port=6379
spring.cache.redis.time-to-live=30m  # 缓存过期时间
spring.cache.redis.key-prefix=myapp:  # 缓存键前缀

缓存注解的使用

Spring Boot 提供了一系列注解来管理缓存行为：

1. `@Cacheable`

标记方法的返回值需要被缓存。例如：

@Cacheable(value = "users", key = "#id")
public User getUserById(Long id) {
    return userRepository.findById(id).orElse(null);
}

value：缓存名称。
key：缓存的键（支持 SpEL 表达式）。

2. `@CacheEvict`

标记方法执行后清除缓存。例如：

@CacheEvict(value = "users", key = "#id")
public void deleteUser(Long id) {
    userRepository.deleteById(id);
}

3. `@CachePut`

更新缓存，通常用于更新操作：

@CachePut(value = "users", key = "#user.id")
public User updateUser(User user) {
    return userRepository.save(user);
}

常见误区与注意事项

缓存穿透：查询不存在的数据时，缓存无法命中，导致大量请求直接访问数据库。可以通过缓存空值或使用布隆过滤器解决。
缓存雪崩：大量缓存同时失效，导致数据库压力骤增。可以通过设置不同的过期时间或使用熔断机制避免。
缓存一致性：更新数据时需同步更新缓存，避免脏数据。可以通过 @CacheEvict 或 @CachePut 保证一致性。
本地缓存的局限性：本地缓存（如 Caffeine）不适用于分布式环境，需根据场景选择合适的缓存方案。

示例代码

以下是一个完整的缓存配置示例：

添加依赖（以 Caffeine 为例）：

<dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-starter-cacheartifactId>
dependency>
<dependency>
    <groupId>com.github.ben-manes.caffeinegroupId>
    <artifactId>caffeineartifactId>
dependency>

配置 application.properties：

spring.cache.type=caffeine
spring.cache.caffeine.spec=maximumSize=1000,expireAfterWrite=30m

在 Service 中使用缓存：

@Service
public class UserService {
    @Cacheable(value = "users", key = "#id")
    public User getUserById(Long id) {
        // 模拟数据库查询
        return new User(id, "User " + id);
    }

    @CacheEvict(value = "users", key = "#id")
    public void deleteUser(Long id) {
        // 模拟删除操作
    }
}

模板引擎配置

什么是模板引擎

模板引擎是一种将动态数据与静态模板结合生成最终内容的工具。在SpringBoot中，常用的模板引擎包括Thymeleaf、Freemarker、Velocity等。它们允许开发者将业务逻辑与页面展示分离，提高代码的可维护性。

为什么需要模板引擎

前后端分离：模板引擎帮助后端开发者动态渲染HTML页面，减少前端工作量。
代码复用：通过模板片段、布局等功能，避免重复代码。
动态内容：根据业务数据动态生成页面内容。

常见模板引擎及配置

Thymeleaf

Thymeleaf是SpringBoot官方推荐的模板引擎，支持HTML5。

配置示例（application.properties）：

# 启用模板缓存（生产环境建议开启）
spring.thymeleaf.cache=true
# 模板文件前缀（默认templates/）
spring.thymeleaf.prefix=classpath:/templates/
# 模板文件后缀（默认.html）
spring.thymeleaf.suffix=.html
# 编码格式
spring.thymeleaf.encoding=UTF-8
# 模板模式（HTML5）
spring.thymeleaf.mode=HTML

Freemarker

Freemarker是另一种流行的模板引擎，语法简洁。

配置示例（application.properties）：

# 模板文件后缀（默认.ftlh）
spring.freemarker.suffix=.ftl
# 模板文件前缀（默认templates/）
spring.freemarker.prefix=classpath:/templates/
# 是否启用缓存
spring.freemarker.cache=true
# 编码格式
spring.freemarker.charset=UTF-8

使用示例（Thymeleaf）

Controller代码：

@Controller
public class GreetingController {
    @GetMapping("/greeting")
    public String greeting(Model model) {
        model.addAttribute("name", "World");
        return "greeting"; // 对应templates/greeting.html
    }
}

模板文件（greeting.html）：

DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>Greetingtitle>
head>
<body>
    <h1 th:text="'Hello, ' + ${name} + '!'">Hello, World!h1>
body>
html>

常见问题及解决方案

模板文件不生效
- 检查模板文件是否放在resources/templates目录下
- 确认文件后缀与配置一致
- 确保Controller返回的视图名称与模板文件名匹配（不含后缀）
缓存导致修改不生效
- 开发环境设置spring.thymeleaf.cache=false
- 修改后清理浏览器缓存
静态资源访问问题
- 确保静态资源放在resources/static目录
- 模板中引用静态资源使用Thymeleaf语法：
```
<link th:href="@{/css/style.css}" rel="stylesheet">
```

高级配置

自定义模板解析器

@Bean
public ITemplateResolver templateResolver() {
    SpringResourceTemplateResolver resolver = new SpringResourceTemplateResolver();
    resolver.setPrefix("classpath:/custom-templates/");
    resolver.setSuffix(".html");
    resolver.setTemplateMode("HTML5");
    resolver.setCharacterEncoding("UTF-8");
    return resolver;
}

多模板引擎共存

通过配置多个ViewResolver可以实现：

@Bean
public ViewResolver thymeleafViewResolver() {
    ThymeleafViewResolver resolver = new ThymeleafViewResolver();
    resolver.setTemplateEngine(templateEngine());
    resolver.setOrder(1);
    return resolver;
}

@Bean
public ViewResolver freemarkerViewResolver() {
    FreeMarkerViewResolver resolver = new FreeMarkerViewResolver();
    resolver.setPrefix("");
    resolver.setSuffix(".ftl");
    resolver.setOrder(2);
    return resolver;
}

静态资源路径配置

概念定义

静态资源路径配置是指SpringBoot项目中如何指定和访问静态资源（如HTML、CSS、JavaScript、图片等文件）的规则。SpringBoot默认提供了一套静态资源处理机制，开发者可以通过配置来修改默认行为。

默认静态资源路径

SpringBoot默认会从以下位置查找静态资源（按优先级排序）：

classpath:/META-INF/resources/
classpath:/resources/
classpath:/static/
classpath:/public/

自定义配置方式

1. 通过application.properties/yml配置

# 修改默认静态资源路径
spring.web.resources.static-locations=classpath:/custom-static/,file:/opt/static/

# 修改静态资源访问前缀
spring.mvc.static-path-pattern=/static-content/**

2. WebMvcConfigurer配置

@Configuration
public class WebConfig implements WebMvcConfigurer {
    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("/my-resources/**")
                .addResourceLocations("classpath:/my-static/", "file:/path/to/external/");
    }
}

常见使用场景

需要添加额外的静态资源目录
需要从文件系统加载静态资源
需要修改静态资源的URL访问前缀
需要为不同路径配置不同的资源位置

注意事项

自定义配置会覆盖默认配置，如果需要保留默认路径，需要显式包含
文件系统路径需要添加file:前缀
在Windows系统中，文件路径应使用/或转义的\\
生产环境建议将静态资源放在CDN或专用静态资源服务器

示例代码

// 同时保留默认路径和添加自定义路径的配置示例
@Configuration
public class WebConfig implements WebMvcConfigurer {
    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        // 保留默认配置
        registry.addResourceHandler("/**")
                .addResourceLocations(
                    "classpath:/META-INF/resources/",
                    "classpath:/resources/",
                    "classpath:/static/",
                    "classpath:/public/"
                );
        
        // 添加自定义配置
        registry.addResourceHandler("/external/**")
                .addResourceLocations("file:/opt/app/static/");
    }
}

三、高级配置技术

@ConfigurationProperties 注解详解

概念定义

@ConfigurationProperties 是 Spring Boot 提供的一个核心注解，用于将外部配置文件（如 application.properties 或 application.yml）中的属性值批量绑定到 Java 对象的字段上。它实现了类型安全的配置管理，避免了直接使用 @Value 注解逐个注入的繁琐操作。

核心特性

前缀绑定：通过 prefix 属性指定配置项的前缀（如 prefix = "app" 会匹配 app.* 的配置）。
松散绑定：支持属性名的松散匹配（如 userName、user-name、USER_NAME 可自动映射到同一字段）。
类型转换：自动将字符串配置转换为目标类型（如 int、List、Map 等）。
嵌套对象支持：可直接绑定复杂嵌套结构的配置。

使用场景

集中管理配置：将分散的配置项归类到特定对象中。
多环境配置：结合 @Profile 实现环境隔离。
第三方组件集成：为自定义 Starter 提供标准化配置入口。

基础用法示例

1. 配置文件内容（application.yml）

app:
  name: "MyApp"
  version: 1.0
  security:
    enabled: true
    roles: [ADMIN, USER]

2. 绑定配置的 Java 类

@Configuration
@ConfigurationProperties(prefix = "app")
public class AppConfig {
    private String name;
    private double version;
    private Security security;

    // 嵌套静态类
    public static class Security {
        private boolean enabled;
        private List<String> roles;

        // Getter/Setter 省略
    }

    // Getter/Setter 省略
}

高级用法

1. 集合类型绑定

app:
  servers:
    - "192.168.1.1"
    - "192.168.1.2"

对应字段：

private List<String> servers;

2. Map 类型绑定

app:
  endpoints:
    user: "/api/user"
    admin: "/api/admin"

对应字段：

private Map<String, String> endpoints;

激活配置类的方式

显式启用（推荐）：

@SpringBootApplication
@EnableConfigurationProperties(AppConfig.class)
public class MyApp { ... }

组件扫描：
在配置类上添加 @Component 注解（需确保类在扫描路径内）。

校验配置（结合 JSR-303）

@Validated
@ConfigurationProperties(prefix = "app")
public class AppConfig {
    @NotBlank
    private String name;

    @Min(1)
    private double version;
}

需添加依赖：

<dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-starter-validationartifactId>
dependency>

常见问题与注意事项

属性未生效：
- 检查 prefix 是否与配置文件一致
- 确保类有 Setter 方法
- 确认配置类被 Spring 容器管理
类型转换失败：
- 如配置 app.version=1.x 尝试映射到 double 字段会抛出异常

IDE 提示支持：

添加 spring-boot-configuration-processor 依赖可生成配置元数据，提供 IDE 自动补全：

<dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-configuration-processorartifactId>
    <optional>trueoptional>
dependency>

与 @Value 对比：

特性	`@ConfigurationProperties`	`@Value`
批量绑定	支持	需逐个声明
松散绑定	支持	严格匹配
SpEL 表达式	不支持	支持
复杂类型（如 List）	直接支持	需手动拆分字符串

@Value 注解

概念定义

@Value 是 Spring 框架提供的一个注解，用于将外部配置的值注入到 Spring 管理的 Bean 中。它可以用于字段、方法参数或构造函数参数上，支持从属性文件、环境变量、系统属性等来源获取值。

使用场景

注入简单值：如字符串、数字等。
注入配置文件中的值：从 application.properties 或 application.yml 中读取配置。
注入系统属性或环境变量：如 ${user.home} 或 ${JAVA_HOME}。
SpEL 表达式：支持 Spring 表达式语言（SpEL），可以进行动态计算。

语法格式

@Value("${property.name:defaultValue}")
private String fieldName;

${property.name}：表示从配置文件中读取 property.name 的值。
:defaultValue：可选，表示如果 property.name 不存在，则使用默认值。

示例代码

1. 注入简单值

@Value("Hello, World!")
private String greeting;

2. 注入配置文件中的值

假设 application.properties 中有以下配置：

app.name=MyApp
app.version=1.0.0

在代码中使用：

@Value("${app.name}")
private String appName;

@Value("${app.version}")
private String appVersion;

3. 注入系统属性或环境变量

@Value("${user.home}")
private String userHome;

@Value("${JAVA_HOME}")
private String javaHome;

4. 使用 SpEL 表达式

@Value("#{systemProperties['user.home']}")
private String userHomeSpEL;

@Value("#{T(java.lang.Math).random() * 100}")
private double randomNumber;

常见误区或注意事项

默认值的使用：
- 如果配置项不存在且未设置默认值，会抛出 IllegalArgumentException。
- 建议为关键配置项设置默认值，例如：
```
@Value("${app.timeout:30}")
private int timeout;
```
类型匹配：
- @Value 会自动尝试将字符串值转换为字段的类型。如果类型不匹配（例如将非数字字符串注入到 int 字段），会抛出异常。
动态更新：
- @Value 注入的值在应用启动时解析，之后不会动态更新。如果需要动态更新配置，可以使用 @ConfigurationProperties 或 Spring Cloud Config。
SpEL 表达式的复杂性：
- 避免在 @Value 中使用过于复杂的 SpEL 表达式，以免降低代码可读性。

静态字段：

@Value 不能直接用于静态字段。如果需要注入静态字段，可以通过 setter 方法实现：

private static String staticField;

@Value("${static.value}")
public void setStaticField(String value) {
    staticField = value;
}

高级用法

注入列表或数组

假设 application.properties 中有以下配置：

app.servers=server1,server2,server3

在代码中可以注入为列表或数组：

@Value("${app.servers}")
private List<String> serversList;

@Value("${app.servers}")
private String[] serversArray;

注入 Map

假设 application.properties 中有以下配置：

app.map={key1: 'value1', key2: 'value2'}

在代码中可以注入为 Map：

@Value("#{${app.map}}")
private Map<String, String> map;

总结

@Value 是 SpringBoot 中非常实用的注解，能够方便地将外部配置注入到代码中。合理使用 @Value 可以大大提高配置的灵活性和可维护性。

自定义配置类

概念定义

自定义配置类是指通过 @Configuration 注解标记的 Java 类，用于定义 Spring Boot 应用中的配置信息。这些类可以包含 @Bean 注解的方法，用于向 Spring 容器注册 Bean。自定义配置类通常用于集中管理应用的配置逻辑，替代传统的 XML 配置方式。

使用场景

注册第三方库的 Bean：当引入第三方库时，可以通过自定义配置类注册其所需的 Bean。
多环境配置：结合 @Profile 注解，可以为不同环境（如开发、测试、生产）定义不同的配置。
条件化配置：使用 @Conditional 系列注解（如 @ConditionalOnProperty），根据条件动态注册 Bean。
配置属性绑定：结合 @ConfigurationProperties，将外部配置（如 application.yml）绑定到 Java 对象。

示例代码

以下是一个简单的自定义配置类示例：

@Configuration
public class AppConfig {

    @Bean
    public MyService myService() {
        return new MyServiceImpl();
    }

    @Bean
    @Profile("dev")
    public DataSource devDataSource() {
        // 开发环境数据源配置
        return new EmbeddedDatabaseBuilder()
            .setType(EmbeddedDatabaseType.H2)
            .build();
    }

    @Bean
    @Profile("prod")
    public DataSource prodDataSource() {
        // 生产环境数据源配置
        return DataSourceBuilder.create().build();
    }
}

常见误区与注意事项

避免过度使用 @Bean：如果可以通过组件扫描（@ComponentScan）自动注册的 Bean，尽量使用 @Component 注解而非在配置类中显式声明。
配置类加载顺序：多个配置类之间可能存在依赖关系，可以通过 @DependsOn 或 @Order 注解控制加载顺序。
避免循环依赖：如果配置类中的 @Bean 方法相互依赖，可能导致循环依赖问题，应通过设计避免。
与 @SpringBootApplication 的关系：主类本身就是一个配置类，通常不需要额外标记 @Configuration。

高级用法

使用 @Import 导入其他配置类：

@Configuration
@Import({DatabaseConfig.class, SecurityConfig.class})
public class AppConfig {
    // 主配置类
}

条件化配置：

@Configuration
@ConditionalOnProperty(name = "feature.enabled", havingValue = "true")
public class FeatureConfig {
    @Bean
    public FeatureService featureService() {
        return new FeatureService();
    }
}

配置属性绑定：

@Configuration
@ConfigurationProperties(prefix = "app")
public class AppProperties {
    private String name;
    private int version;
    // getters and setters
}

自定义配置类是 Spring Boot 灵活配置的核心机制之一，合理使用可以大幅提升应用的可维护性和可扩展性。

@Conditional 条件化配置

概念定义

@Conditional 是 Spring 4.0 引入的核心注解，用于根据特定条件决定是否注册 Bean 或加载配置类。它允许开发者基于环境、属性、类路径等因素动态控制 Spring 应用的配置。

核心实现原理

通过 Condition 接口实现条件判断：

public interface Condition {
    boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata);
}

Spring 在容器刷新阶段会检查所有 @Conditional 注解，调用对应的 Condition 实现进行验证。

常用内置条件注解

注解	作用
`@ConditionalOnBean`	当容器中存在指定 Bean 时生效
`@ConditionalOnMissingBean`	当容器中不存在指定 Bean 时生效
`@ConditionalOnClass`	当类路径存在指定类时生效
`@ConditionalOnMissingClass`	当类路径不存在指定类时生效
`@ConditionalOnProperty`	当配置属性满足条件时生效
`@ConditionalOnExpression`	基于 SpEL 表达式判断
`@ConditionalOnWebApplication`	当是 Web 应用时生效
`@ConditionalOnNotWebApplication`	当不是 Web 应用时生效

典型使用示例

1. 基于属性的条件配置

@Configuration
@ConditionalOnProperty(
    prefix = "app.module",
    name = "enabled",
    havingValue = "true"
)
public class ModuleAutoConfiguration {
    // 当app.module.enabled=true时才会加载
}

2. 自定义条件实现

public class DatabaseTypeCondition implements Condition {
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        String dbType = context.getEnvironment().getProperty("db.type");
        return "mysql".equalsIgnoreCase(dbType);
    }
}

@Configuration
@Conditional(DatabaseTypeCondition.class)
public class MySQLAutoConfiguration {
    // 仅当db.type=mysql时生效
}

组合条件配置

@Configuration
@ConditionalOnClass({ DataSource.class, JdbcTemplate.class })
@ConditionalOnMissingBean(DataSource.class)
public class EmbeddedDatabaseConfig {
    // 当类路径存在DataSource和JdbcTemplate
    // 且容器中没有DataSource Bean时生效
}

常见误区

条件评估顺序问题：条件注解的评估顺序可能影响结果，建议使用显式 @AutoConfigureAfter 控制顺序
过度条件化：过多条件判断会增加启动时间，建议合理设计条件层级
条件冲突：多个互斥条件可能导致配置无法加载，需要确保条件逻辑完备

最佳实践

在自动配置类中广泛使用条件注解
优先使用组合注解（如 @ConditionalOnWebApplication）而非原始 @Conditional
为自定义条件提供详细的 @ConditionalOn... 元注解
通过 spring.autoconfigure.exclude 属性可以显式排除自动配置

调试技巧

启用调试日志查看条件评估结果：

logging.level.org.springframework.boot.autoconfigure=DEBUG

使用 ConditionEvaluationReport 获取详细评估报告：

@Autowired
private ApplicationContext context;

public void printConditions() {
    ConditionEvaluationReport report = ConditionEvaluationReport.get(
        context.getBeanFactory());
    report.getConditionAndOutcomesBySource().forEach((k,v) -> {
        System.out.println(k + " => " + v);
    });
}

配置属性绑定

概念定义

配置属性绑定（Configuration Properties Binding）是 SpringBoot 提供的一种将外部配置文件（如 application.properties 或 application.yml）中的属性值自动映射到 Java Bean 的机制。通过这种方式，可以方便地将配置信息注入到应用程序中，而无需手动解析配置文件。

核心注解

@ConfigurationProperties
用于标记一个类，表示该类将绑定配置文件中的属性。可以指定前缀（prefix）来限定绑定的属性范围。
@EnableConfigurationProperties
通常在配置类上使用，用于启用对 @ConfigurationProperties 注解类的支持。

使用场景

将分散的配置属性集中管理。
实现配置的动态加载和更新（结合 @RefreshScope 使用）。
支持多环境配置（如 dev、test、prod）。

基本用法示例

1. 定义配置类

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

@Component
@ConfigurationProperties(prefix = "app")
public class AppConfig {
    private String name;
    private int version;
    private DatabaseConfig database;

    // Getters and Setters
    // ...

    public static class DatabaseConfig {
        private String url;
        private String username;
        private String password;

        // Getters and Setters
        // ...
    }
}

2. 配置文件（`application.yml`）

app:
  name: "MyApp"
  version: 1
  database:
    url: "jdbc:mysql://localhost:3306/mydb"
    username: "root"
    password: "secret"

3. 使用配置类

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class AppController {
    @Autowired
    private AppConfig appConfig;

    @GetMapping("/config")
    public String getConfig() {
        return "App: " + appConfig.getName() + ", Version: " + appConfig.getVersion();
    }
}

高级特性

1. 属性验证

结合 JSR-303 验证注解（如 @NotNull、@Size）对配置属性进行校验：

@ConfigurationProperties(prefix = "app")
@Validated
public class AppConfig {
    @NotNull
    private String name;

    @Min(1)
    @Max(10)
    private int version;
}

2. 宽松绑定（Relaxed Binding）

SpringBoot 支持属性名的宽松匹配规则，例如：

配置文件中的 app.database-url 可绑定到 Java 字段 databaseUrl。
支持驼峰、短横线、下划线等多种命名风格。

3. 动态刷新

结合 Spring Cloud 的 @RefreshScope 实现配置动态更新：

@RefreshScope
@ConfigurationProperties(prefix = "app")
public class AppConfig { ... }

常见问题与注意事项

属性未绑定
- 确保 @ConfigurationProperties 的类被 Spring 容器管理（如添加 @Component）。
- 检查 prefix 是否与配置文件中的前缀一致。
类型不匹配
- 配置文件中的值必须与 Java 字段类型兼容（如字符串 "123" 可绑定到 int 类型，但 "abc" 会导致绑定失败）。
嵌套属性
- 嵌套类的字段需提供 public 的 getter/setter 方法。

IDE 提示

通过 spring-boot-configuration-processor 依赖生成配置元数据，实现 IDE 自动补全：

<dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-configuration-processorartifactId>
    <optional>trueoptional>
dependency>

最佳实践

为配置类添加 final 和 @ConstructorBinding（Spring Boot 2.2+）以实现不可变配置：

@ConfigurationProperties(prefix = "app")
@ConstructorBinding
public class AppConfig {
    private final String name;
    private final int version;

    public AppConfig(String name, int version) {
        this.name = name;
        this.version = version;
    }
}

避免在业务逻辑中直接使用 @Value，优先使用类型安全的属性绑定。
对敏感信息（如密码）使用 @ConfigurationProperties 结合加密库（如 Jasypt）。

配置属性元数据

概念定义

配置属性元数据（Configuration Properties Metadata）是 Spring Boot 提供的一种机制，用于描述和定义应用程序配置属性的结构、类型、默认值、描述信息等元数据。这些元数据通常存储在 META-INF/spring-configuration-metadata.json 或 additional-spring-configuration-metadata.json 文件中，供 IDE（如 IntelliJ IDEA、Eclipse）或其他工具在开发时提供智能提示、自动补全和配置验证。

作用与优势

开发体验提升：IDE 可以根据元数据提供配置属性的自动补全和文档提示。
配置验证：在编写 application.properties 或 application.yml 时，可以检查配置项是否存在或类型是否匹配。
文档生成：工具（如 Spring Boot Actuator）可以利用元数据生成配置属性的文档。

元数据结构

配置属性元数据通常包含以下字段：

name：配置属性的完整名称（如 spring.datasource.url）。
type：属性的数据类型（如 java.lang.String、java.lang.Integer）。
description：属性的描述信息。
defaultValue：属性的默认值。
deprecation：标记属性是否已弃用，以及替代属性。

示例元数据文件（additional-spring-configuration-metadata.json）：

{
  "properties": [
    {
      "name": "app.my-service.enabled",
      "type": "java.lang.Boolean",
      "description": "Whether to enable my custom service.",
      "defaultValue": true
    },
    {
      "name": "app.my-service.timeout",
      "type": "java.lang.Integer",
      "description": "Timeout in milliseconds for the service.",
      "defaultValue": 5000
    }
  ]
}

生成元数据

Spring Boot 在编译时会自动为 @ConfigurationProperties 注解的类生成元数据。例如：

@ConfigurationProperties(prefix = "app.my-service")
public class MyServiceProperties {
    private boolean enabled = true;
    private int timeout = 5000;

    // Getters and Setters
}

编译后，Spring Boot 会生成 META-INF/spring-configuration-metadata.json 文件。

自定义元数据

如果需要手动补充或覆盖元数据，可以在 src/main/resources/META-INF/ 下创建 additional-spring-configuration-metadata.json 文件。Spring Boot 会合并自动生成和手写的元数据。

注意事项

IDE 支持：确保使用的 IDE 安装了 Spring Boot 插件（如 IntelliJ 的 Spring Boot 支持）。
元数据更新：修改 @ConfigurationProperties 类后，需要重新编译以更新元数据。
手动元数据优先级：additional-spring-configuration-metadata.json 的配置会覆盖自动生成的元数据。

示例代码

假设有一个自定义配置类：

@ConfigurationProperties(prefix = "app.mail")
public class MailProperties {
    private String host;
    private int port;
    private String username;

    // Getters and Setters
}

生成的元数据可能如下：

{
  "properties": [
    {
      "name": "app.mail.host",
      "type": "java.lang.String",
      "description": "Mail server host."
    },
    {
      "name": "app.mail.port",
      "type": "java.lang.Integer",
      "description": "Mail server port."
    },
    {
      "name": "app.mail.username",
      "type": "java.lang.String",
      "description": "Mail server username."
    }
  ]
}

配置属性处理器（Configuration Properties Processor）

定义

配置属性处理器是 Spring Boot 中的一个注解处理器（Annotation Processor），主要用于在编译时处理 @ConfigurationProperties 注解。它的核心功能是生成配置属性的元数据（metadata），这些元数据会被 IDE（如 IntelliJ IDEA、Eclipse）或其他工具用于提供配置项的自动补全、类型检查和文档提示。

工作原理

编译时处理：在项目编译阶段，配置属性处理器会扫描所有带有 @ConfigurationProperties 注解的类。
生成元数据：为每个配置属性生成 META-INF/spring-configuration-metadata.json 文件，包含以下信息：
- 属性名称（如 server.port）
- 属性类型（如 java.lang.Integer）
- 默认值（如 8080）
- 描述信息（通过 @ConfigurationProperties 的 description 字段或 JavaDoc 提供）。

使用场景

IDE 支持：在 application.properties 或 application.yml 中输入配置时，IDE 会根据元数据提供自动补全和类型检查。
文档生成：工具（如 Spring Boot Actuator）可以利用元数据生成配置项的详细文档。
配置验证：结合 @Validated 注解，可以在启动时验证配置值的合法性。

如何启用

添加依赖（Maven 示例）：

<dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-configuration-processorartifactId>
    <optional>trueoptional>
dependency>

optional=true 表示该依赖仅用于编译时，不会传递到运行时。

定义配置类：

@ConfigurationProperties(prefix = "app")
public class AppConfig {
    private String name;
    private int timeout;
    // getters 和 setters
}

编译项目：执行 mvn compile 或 Gradle 等效命令后，会在 target/classes/META-INF 下生成元数据文件。

示例元数据文件

生成的 spring-configuration-metadata.json 内容示例：

{
  "groups": [
    {
      "name": "app",
      "type": "com.example.AppConfig",
      "description": "Application configuration properties."
    }
  ],
  "properties": [
    {
      "name": "app.name",
      "type": "java.lang.String",
      "description": "Name of the application."
    },
    {
      "name": "app.timeout",
      "type": "java.lang.Integer",
      "defaultValue": 30,
      "description": "Timeout in seconds."
    }
  ]
}

注意事项

需要重新编译：修改配置类后需重新编译才能更新元数据。
JavaDoc 支持：在配置类的字段或方法上添加 JavaDoc 可以生成描述信息。
自定义提示：通过 @ConfigurationProperties 的 hints 属性可以为枚举类型或特定值提供可选值提示。
排除无关属性：使用 @Deprecated 注解标记过时属性，或在元数据中设置 deprecated=true。

常见问题

元数据未生成：
- 检查依赖是否正确添加且 optional=true。
- 确认配置类已正确使用 @ConfigurationProperties。
IDE 不提示：
- 确保 IDE 启用了注解处理器（如 IntelliJ 需勾选 Build > Compiler > Annotation Processors 中的启用选项）。
- 清理并重新构建项目。

高级用法

手动补充元数据：在 src/main/resources/META-INF 下创建 additional-spring-configuration-metadata.json 文件，扩展或覆盖自动生成的元数据。
自定义类型转换：通过实现 Converter 或 GenericConverter 接口，支持复杂类型的属性绑定（如字符串到自定义对象的转换）。

配置属性编辑器

概念定义

配置属性编辑器（PropertyEditor）是 Spring 框架中用于将字符串形式的配置值转换为目标 Java 类型的机制。它主要用于处理配置文件（如 application.properties 或 application.yml）中的属性值到 Java 对象之间的转换。

核心作用

类型转换：将字符串配置值转换为复杂 Java 类型（如 Date、List、自定义对象等）
配置注入：配合 @Value 或 @ConfigurationProperties 实现自动类型转换

内置常用编辑器

Spring Boot 已内置以下常用属性编辑器：

基本类型：Integer、Boolean、Long 等
时间类型：Date、LocalDate、LocalDateTime
集合类型：List、Set、Map
文件资源：Resource

自定义属性编辑器

实现方式

实现 PropertyEditor 接口（传统方式）
继承 PropertyEditorSupport 类（推荐简化方式）

示例代码：自定义日期格式转换

public class CustomDateEditor extends PropertyEditorSupport {
    private final SimpleDateFormat dateFormat;

    public CustomDateEditor(String format) {
        this.dateFormat = new SimpleDateFormat(format);
    }

    @Override
    public void setAsText(String text) throws IllegalArgumentException {
        try {
            setValue(dateFormat.parse(text));
        } catch (ParseException e) {
            throw new IllegalArgumentException("Could not parse date: " + e.getMessage(), e);
        }
    }

    @Override
    public String getAsText() {
        Date value = (Date) getValue();
        return (value != null ? dateFormat.format(value) : "");
    }
}

注册自定义编辑器

@Configuration
public class EditorConfig implements WebMvcConfigurer {
    
    @Override
    public void addFormatters(FormatterRegistry registry) {
        registry.registerCustomEditor(Date.class, 
            new CustomDateEditor("yyyy-MM-dd HH:mm:ss"));
    }
}

使用场景

特殊格式转换：如非标准日期格式
复杂对象转换：将字符串转换为自定义对象
安全过滤：对输入值进行预处理

注意事项

线程安全：确保 PropertyEditor 实现是线程安全的
性能考虑：避免在频繁调用的场景使用复杂转换逻辑
错误处理：必须妥善处理转换失败情况
Spring Boot 2.0+ 推荐使用 Converter 或 Formatter 替代

替代方案（Spring Boot 推荐）

对于新项目，建议使用更现代的转换方式：

@Component
public class StringToDateConverter implements Converter<String, Date> {
    @Override
    public Date convert(String source) {
        // 转换逻辑
    }
}

常见问题

转换失败：确保输入格式与编辑器预期一致
编辑器未生效：检查是否正确注册
多格式支持：考虑实现多格式兼容逻辑

配置属性转换器

概念定义

配置属性转换器（Converter）是 SpringBoot 中用于将配置文件中的字符串值转换为目标类型的机制。它属于 Spring 框架的类型转换系统（org.springframework.core.convert），常用于处理 application.properties 或 application.yml 中的自定义类型转换。

核心接口

SpringBoot 通过以下接口实现属性转换：

Converter
基础接口，将 S 类型转换为 T 类型。

@FunctionalInterface
public interface Converter<S, T> {
    T convert(S source);
}

ConfigurationPropertiesBindingPostProcessor
负责在绑定 @ConfigurationProperties 时调用注册的转换器。

使用场景

自定义类型转换
将配置文件中的字符串（如 "192.168.1.1:8080"）转换为自定义对象（如 ServerAddress）。
枚举增强
支持更灵活的枚举值映射（如不区分大小写）。
兼容旧格式
处理历史配置的特殊格式（如日期字符串 "yyyy/MM/dd"）。

实现步骤

1. 定义目标类型

public class ServerAddress {
    private String ip;
    private int port;
    // 构造方法、Getter/Setter 省略
}

2. 实现转换器

import org.springframework.core.convert.converter.Converter;

public class StringToServerAddressConverter implements Converter<String, ServerAddress> {
    @Override
    public ServerAddress convert(String source) {
        String[] parts = source.split(":");
        return new ServerAddress(parts[0], Integer.parseInt(parts[1]));
    }
}

3. 注册转换器

方式一：通过 @Configuration 声明

@Configuration
public class ConverterConfig {
    @Bean
    public Converter<String, ServerAddress> serverAddressConverter() {
        return new StringToServerAddressConverter();
    }
}

方式二：使用 ConversionService

@Bean
public ConversionService conversionService() {
    DefaultConversionService service = new DefaultConversionService();
    service.addConverter(new StringToServerAddressConverter());
    return service;
}

示例：配置与使用

配置文件（application.yml）
```
app:
  server: "192.168.1.1:8080"
```

配置类绑定

@ConfigurationProperties(prefix = "app")
public class AppConfig {
    private ServerAddress server;
    // Getter/Setter
}

注意事项

线程安全性
确保转换器实现是无状态的，避免并发问题。
错误处理
在 convert() 方法中显式处理格式错误（如抛出 IllegalArgumentException）。
优先级
SpringBoot 内置转换器优先于自定义转换器，必要时可通过 @Order 调整顺序。
复合类型
对于嵌套对象（如 List），需额外实现 Converter。

高级用法

条件化注册

通过 Conditional 实现动态注册：

@Bean
@ConditionalOnProperty(name = "app.converter.enabled", havingValue = "true")
public Converter<String, ServerAddress> conditionalConverter() {
    return new StringToServerAddressConverter();
}

泛型支持

处理泛型集合类型：

public class StringToListConverter implements Converter<String, List<ServerAddress>> {
    @Override
    public List<ServerAddress> convert(String source) {
        return Arrays.stream(source.split(","))
                   .map(part -> new ServerAddress(part.split(":")[0], 
                        Integer.parseInt(part.split(":")[1])))
                   .collect(Collectors.toList());
    }
}

配置属性验证器

概念定义

配置属性验证器（Configuration Properties Validator）是 Spring Boot 提供的一种机制，用于验证应用程序配置属性（@ConfigurationProperties 注解的类）是否符合预期规则。它通过 JSR-303（Bean Validation）标准注解（如 @NotNull、@Size、@Min 等）或自定义验证逻辑，确保配置值在应用启动时满足业务要求。

使用场景

强制校验必填参数：确保关键配置（如数据库连接参数）不为空。
限制取值范围：验证数值范围（如端口号）、字符串格式（如正则表达式）。
依赖校验：检查多个关联属性的逻辑一致性（如当启用缓存时，必须配置缓存超时时间）。

核心实现步骤

1. 添加依赖

需引入 spring-boot-starter-validation：

<dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-starter-validationartifactId>
dependency>

2. 定义配置类并添加校验注解

import org.springframework.boot.context.properties.ConfigurationProperties;
import javax.validation.constraints.*;

@ConfigurationProperties(prefix = "app")
public class AppConfig {
    @NotBlank(message = "应用名称不能为空")
    private String name;

    @Min(value = 1, message = "线程数必须大于0")
    private int threadPoolSize;

    @Pattern(regexp = "^https?://.*", message = "URL必须以http或https开头")
    private String apiUrl;

    // Getter/Setter省略
}

3. 启用配置类

在启动类或配置类上添加 @EnableConfigurationProperties：

@SpringBootApplication
@EnableConfigurationProperties(AppConfig.class)
public class MyApp { ... }

高级用法

自定义验证器

实现 Validator 接口：

public class CustomValidator implements Validator {
    @Override
    public boolean supports(Class<?> clazz) {
        return AppConfig.class.isAssignableFrom(clazz);
    }

    @Override
    public void validate(Object target, Errors errors) {
        AppConfig config = (AppConfig) target;
        if (config.getThreadPoolSize() > 100) {
            errors.rejectValue("threadPoolSize", "too.large", "线程数不能超过100");
        }
    }
}

注册为Bean：

@Bean
public CustomValidator appConfigValidator() {
    return new CustomValidator();
}

分组校验

通过 @Validated 指定验证组：

public interface AdvancedCheck {}

@ConfigurationProperties(prefix = "app")
@Validated
public class AppConfig {
    @NotNull(groups = AdvancedCheck.class)
    private String advancedFeature;
}

注意事项

验证时机：校验发生在属性绑定后、Bean初始化前，失败会阻止应用启动。
错误信息：默认错误信息较简单，建议通过 message 属性自定义。
嵌套验证：对嵌套对象需在字段上添加 @Valid：

@Valid
private DatabaseConfig database;

宽松绑定：校验规则不影响Spring Boot的宽松绑定（如 apiUrl 可配为 api-url）。

示例配置

application.yml 示例：

app:
  name: "MyApp"
  thread-pool-size: 200  # 会触发自定义验证错误
  api-url: "invalid-url" # 会触发正则校验错误

启动时错误输出示例：

Binding to target org.springframework.boot.context.properties.bind.BindException: Failed to bind properties under 'app' to com.example.AppConfig failed:

    Property: app.threadPoolSize
    Value: 200
    Reason: 线程数不能超过100

    Property: app.apiUrl
    Value: "invalid-url"
    Reason: URL必须以http或https开头

配置属性监听器（Configuration Properties Listener）

概念定义

配置属性监听器是 SpringBoot 提供的一种机制，用于监听应用程序配置属性（通常来自 application.properties 或 application.yml）的变化，并在属性值发生改变时触发相应的回调逻辑。这种机制常用于动态调整应用程序行为，而无需重启服务。

核心实现方式

SpringBoot 主要通过以下两种方式实现配置监听：

1. `@ConfigurationProperties` + `@RefreshScope`

@RefreshScope
@ConfigurationProperties(prefix = "app")
public class AppConfig {
    private String title;
    private int timeout;
    
    // getters and setters
}

2. 实现 `ApplicationListener`

@Component
public class MyEnvChangeListener 
    implements ApplicationListener<EnvironmentChangeEvent> {
    
    @Override
    public void onApplicationEvent(EnvironmentChangeEvent event) {
        System.out.println("Changed keys: " + event.getKeys());
    }
}

典型使用场景

动态日志级别调整
运行时切换数据源配置
功能开关的热更新
服务降级阈值动态修改

注意事项

刷新范围：@RefreshScope 只对标注的 Bean 生效
性能影响：频繁刷新可能导致性能下降
线程安全：需要确保监听逻辑是线程安全的
非所有属性：@Value 注解的属性默认不支持动态更新

完整示例（结合 Spring Cloud Bus）

// 配置类
@RefreshScope
@ConfigurationProperties(prefix = "dynamic")
public class DynamicConfig {
    private String featureFlag;
    
    public String getFeatureFlag() {
        return this.featureFlag;
    }
    
    public void setFeatureFlag(String flag) {
        this.featureFlag = flag;
    }
}

// 使用类
@Service
public class FeatureService {
    @Autowired
    private DynamicConfig config;
    
    public boolean isFeatureEnabled() {
        return "true".equals(config.getFeatureFlag());
    }
}

// 监听器（可选）
@Component
public class ConfigChangeListener {
    @EventListener
    public void handle(RefreshScopeRefreshedEvent event) {
        System.out.println("Configuration refreshed!");
    }
}

常见问题解决方案

监听不生效：
- 确保添加了 spring-boot-starter-actuator 依赖
- 检查是否暴露了 /actuator/refresh 端点
部分属性不更新：
- 对于静态字段需要使用 @PostConstruct 重新初始化
- 考虑使用 Environment 接口直接获取最新值
性能优化：
- 对高频变更属性添加防抖逻辑
- 考虑使用配置中心的批量更新机制

动态配置刷新

概念定义

动态配置刷新（Dynamic Configuration Refresh）是指在应用运行时，无需重启服务即可更新应用配置的能力。Spring Boot 通过 @RefreshScope 和外部配置中心（如 Spring Cloud Config、Nacos、Apollo 等）实现这一功能。

核心机制

1. `@RefreshScope` 注解

用于标记需要动态刷新的 Bean。
原理：基于 Spring 的 Scope 机制，配置变更时会销毁并重新创建这些 Bean。

2. 配置中心集成

通过 spring-cloud-starter-config 等组件监听配置中心的变更事件。
触发方式：手动调用 /actuator/refresh 端点或配置中心自动推送。

使用场景

生产环境热更新：修改数据库连接池参数、日志级别等。
多环境切换：动态切换测试/生产环境的 API 地址。
功能开关：实时启用/禁用特定功能模块。

实现步骤

1. 添加依赖


<dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-starter-actuatorartifactId>
dependency>

<dependency>
    <groupId>org.springframework.cloudgroupId>
    <artifactId>spring-cloud-starter-configartifactId>
dependency>

2. 启用刷新端点

# application.yml
management:
  endpoints:
    web:
      exposure:
        include: refresh

3. 动态配置示例

@RestController
@RefreshScope
public class DemoController {
    @Value("${dynamic.message}")
    private String message;

    @GetMapping("/message")
    public String getMessage() {
        return message;
    }
}

注意事项

性能影响：频繁刷新会导致大量 Bean 重建，影响性能。
线程安全：确保 @RefreshScope Bean 是无状态的。
部分限制：
- 静态字段（static）无法动态更新。
- @ConfigurationProperties 需配合 @RefreshScope 使用。
日志监控：建议记录配置变更事件以便审计。

高级用法

监听配置变更事件

@Component
public class ConfigChangeListener {
    @EventListener
    public void handleRefresh(RefreshScopeRefreshedEvent event) {
        System.out.println("配置已刷新: " + event);
    }
}

条件刷新

通过自定义 RefreshEventListener 实现选择性刷新：

@Bean
public RefreshEventListener customRefreshListener() {
    return event -> {
        if (shouldRefresh(event.getKeys())) {
            // 执行刷新逻辑
        }
    };
}

常见问题

刷新失效：
- 检查是否遗漏 @RefreshScope
- 确认配置中心数据已实际变更
循环依赖：@RefreshScope Bean 避免相互依赖
敏感信息：动态更新的配置需考虑加密存储（如使用 Jasypt）

外部化配置管理

概念定义

外部化配置管理是指将应用程序的配置信息（如数据库连接、服务端口、第三方API密钥等）从代码中分离出来，存储在外部文件或环境中。SpringBoot通过多种机制支持外部化配置，使应用程序能够灵活适应不同环境（开发、测试、生产等）。

主要配置源

SpringBoot按以下优先级加载配置（高优先级覆盖低优先级）：

命令行参数（--server.port=8081）
SPRING_APPLICATION_JSON环境变量（内联JSON）
JNDI属性（java:comp/env）
Java系统属性（System.getProperties()）
操作系统环境变量
配置文件：
- application-{profile}.properties/yml（Profile专属）
- application.properties/yml（主配置文件）
@PropertySource注解加载的自定义文件
默认属性（通过SpringApplication.setDefaultProperties设置）

典型配置格式

1. properties格式示例

# 基础配置
server.port=8080
spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=admin

# 多环境配置
logging.level.root=INFO

2. YAML格式示例

server:
  port: 8080
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mydb
    username: admin
logging:
  level:
    root: INFO

环境隔离（Profile）

通过spring.profiles.active指定当前环境：

# application-dev.properties
spring.datasource.url=jdbc:mysql://dev-db:3306/mydb

# application-prod.properties
spring.datasource.url=jdbc:mysql://prod-db:3306/mydb

激活方式：

配置文件：spring.profiles.active=prod
命令行：--spring.profiles.active=dev
环境变量：export SPRING_PROFILES_ACTIVE=test

动态配置刷新

结合Spring Cloud Config实现动态刷新：

添加依赖：

<dependency>
    <groupId>org.springframework.cloudgroupId>
    <artifactId>spring-cloud-starter-configartifactId>
dependency>

在需要刷新的Bean上添加注解：

@RefreshScope
@RestController
public class MyController {
    @Value("${custom.message}")
    private String message;
    // ...
}

最佳实践

敏感信息保护：
- 使用Vault或KMS管理密钥
- 避免将密码明文写入版本控制
```
spring.datasource.password=${DB_PASSWORD}
```
配置组织结构：
- 按功能模块分组配置（如spring.redis.*）
- 自定义前缀避免冲突：
```
myapp:
  cache:
    timeout: 30s
```

验证配置：

使用@ConfigurationProperties进行类型安全绑定：

@ConfigurationProperties(prefix = "mail")
public class MailProperties {
    private String host;
    private int port;
    // getters/setters
}

多文件策略：
- 基础配置：application.yml
- 环境配置：application-{env}.yml
- 局部配置：application-{module}.yml

常见问题

配置覆盖失效：
- 检查属性源优先级
- 确保没有在代码中硬编码默认值
YAML缩进错误：
- 必须使用空格（不能使用Tab）
- 保持层级对齐
Profile未生效：
- 确认文件名格式正确（application-{profile}.yml）
- 检查激活命令是否生效

高级用法

自定义PropertySource：

public class CustomPropertySource implements PropertySource<Map<String, String>> {
    // 实现从自定义源加载配置
}

条件化配置：

@Configuration
@ConditionalOnProperty(name = "feature.enabled", havingValue = "true")
public class FeatureConfig { ... }

配置加密：

spring.datasource.password={cipher}FKSAJDFGYOS8F7GLHAKERGFHLSAJ

配置中心集成

概念定义

配置中心集成是指将SpringBoot应用的配置文件（如application.properties或application.yml）从本地迁移到集中式的配置管理服务中，实现配置的集中管理、动态更新和版本控制。常见的配置中心包括：

Spring Cloud Config（原生支持）
Nacos（阿里开源）
Apollo（携程开源）
Consul
Zookeeper

核心价值

动态更新：无需重启应用即可生效配置变更
环境隔离：支持dev/test/prod等多环境配置
版本管理：记录配置变更历史
权限控制：限制敏感配置的访问权限

SpringBoot集成示例（以Nacos为例）

1. 添加依赖


<dependency>
    <groupId>com.alibaba.cloudgroupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-configartifactId>
    <version>2022.0.0.0version>
dependency>

2. 创建bootstrap.yml

spring:
  application:
    name: order-service
  profiles:
    active: dev
  cloud:
    nacos:
      config:
        server-addr: 127.0.0.1:8848
        file-extension: yaml
        namespace: dev-namespace
        group: DEFAULT_GROUP

3. 动态刷新配置

@RestController
@RefreshScope  // 关键注解
public class ConfigController {
    @Value("${custom.config.message}")
    private String message;
    
    @GetMapping("/config")
    public String getConfig() {
        return message;
    }
}

配置中心数据结构

典型配置存储路径：

/{application}-{profile}.{file-extension}
示例：order-service-dev.yaml

最佳实践

敏感配置加密：使用Jasypt等工具加密数据库密码等敏感信息
配置分级：
- 公共配置（common.yaml）
- 应用专属配置（order-service.yaml）
本地缓存：配置中心不可用时启用本地缓存配置
监听机制：实现ApplicationListener处理配置变更事件

常见问题排查

配置不生效：
- 检查bootstrap.yml优先级高于application.yml
- 确认@RefreshScope注解已添加
连接失败：
- 验证配置中心服务地址
- 检查namespace/group是否存在
中文乱码：确保配置中心和服务端使用相同字符编码（推荐UTF-8）

与传统配置方式对比

特性	本地配置	配置中心
动态更新	需重启	实时生效
多环境支持	需多个文件	统一管理
配置共享	难实现	轻松共享
版本追溯	手动备份	自动版本控制

高级特性

配置灰度发布：向特定实例推送新配置
配置回滚：快速恢复到历史版本
配置推送轨迹：记录配置变更操作日志
配置权限分离：读写权限分离控制

配置安全保护

概念定义

配置安全保护是指在 SpringBoot 应用中，通过合理的配置和管理，确保敏感信息（如数据库密码、API 密钥等）不被泄露或滥用。SpringBoot 提供了多种机制来保护配置文件中的敏感数据，包括环境变量、加密配置和权限控制等。

使用场景

敏感信息保护：如数据库连接信息、第三方服务密钥等。
多环境配置：在不同环境（开发、测试、生产）中使用不同的配置，避免生产环境信息泄露。
权限控制：限制对配置文件的访问权限，防止未授权访问。

常见误区或注意事项

硬编码敏感信息：避免在代码中直接写入敏感信息，应使用配置文件或环境变量。
配置文件版本控制：不要将包含敏感信息的配置文件提交到版本控制系统（如 Git）。
加密配置：对于高度敏感的信息，应使用加密机制存储，并在运行时解密。
环境变量滥用：过度依赖环境变量可能导致配置管理混乱，应合理使用。

示例代码

1. 使用环境变量保护敏感信息

在 application.properties 或 application.yml 中引用环境变量：

# application.properties
spring.datasource.username=${DB_USERNAME}
spring.datasource.password=${DB_PASSWORD}

或

# application.yml
spring:
  datasource:
    username: ${DB_USERNAME}
    password: ${DB_PASSWORD}

在运行应用时设置环境变量：

export DB_USERNAME=admin
export DB_PASSWORD=secret
java -jar your-application.jar

2. 使用 Jasypt 加密配置

添加依赖：

<dependency>
    <groupId>com.github.ulisesbocchiogroupId>
    <artifactId>jasypt-spring-boot-starterartifactId>
    <version>3.0.5version>
dependency>

加密敏感信息：

java -cp jasypt-1.9.3.jar org.jasypt.intf.cli.JasyptPBEStringEncryptionCLI \
  input="secret" password=myEncryptionKey algorithm=PBEWithMD5AndDES

在配置文件中使用加密值：

# application.properties
spring.datasource.password=ENC(加密后的字符串)
jasypt.encryptor.password=myEncryptionKey

3. 使用 Spring Cloud Config 集中管理配置

添加依赖：

<dependency>
    <groupId>org.springframework.cloudgroupId>
    <artifactId>spring-cloud-starter-configartifactId>
dependency>

配置 bootstrap.properties：

spring.application.name=your-application
spring.cloud.config.uri=http://config-server:8888
spring.cloud.config.username=config-user
spring.cloud.config.password=${CONFIG_SERVER_PASSWORD}

最佳实践

分层配置：将敏感信息与普通配置分离，敏感信息通过环境变量或加密方式提供。
最小权限原则：配置文件和应用运行时仅授予必要的权限。
定期审计：定期检查配置文件和权限设置，确保没有泄露风险。
使用 Vault 或 AWS Secrets Manager：对于企业级应用，推荐使用专业的密钥管理服务。

四、实战配置案例

多数据源配置

概念定义

多数据源配置是指在 Spring Boot 应用中同时连接并管理多个数据库实例的能力。通过多数据源配置，应用可以同时操作多个不同的数据库（如 MySQL、PostgreSQL、Oracle 等），或者在同一数据库的不同实例之间切换。

使用场景

读写分离：主库负责写操作，从库负责读操作。
分库分表：数据分散存储在不同的数据库或表中。
多租户架构：不同租户的数据存储在不同的数据库中。
异构数据源：同时连接关系型数据库和 NoSQL 数据库。

实现步骤

1. 添加依赖

在 pom.xml 中添加数据库驱动依赖（以 MySQL 为例）：

<dependency>
    <groupId>mysqlgroupId>
    <artifactId>mysql-connector-javaartifactId>
    <scope>runtimescope>
dependency>
<dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-starter-data-jpaartifactId>
dependency>

2. 配置数据源

在 application.yml 中配置多个数据源：

spring:
  datasource:
    primary:
      jdbc-url: jdbc:mysql://localhost:3306/db1
      username: root
      password: password
      driver-class-name: com.mysql.cj.jdbc.Driver
    secondary:
      jdbc-url: jdbc:mysql://localhost:3306/db2
      username: root
      password: password
      driver-class-name: com.mysql.cj.jdbc.Driver

3. 配置数据源 Bean

创建配置类，定义多个数据源的 DataSource Bean：

@Configuration
public class DataSourceConfig {

    @Bean
    @Primary
    @ConfigurationProperties(prefix = "spring.datasource.primary")
    public DataSource primaryDataSource() {
        return DataSourceBuilder.create().build();
    }

    @Bean
    @ConfigurationProperties(prefix = "spring.datasource.secondary")
    public DataSource secondaryDataSource() {
        return DataSourceBuilder.create().build();
    }
}

4. 配置 JPA 或 MyBatis

为每个数据源配置独立的 EntityManagerFactory 和 TransactionManager（以 JPA 为例）：

@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(
    basePackages = "com.example.repository.primary",
    entityManagerFactoryRef = "primaryEntityManagerFactory",
    transactionManagerRef = "primaryTransactionManager"
)
public class PrimaryDataSourceConfig {

    @Primary
    @Bean
    public LocalContainerEntityManagerFactoryBean primaryEntityManagerFactory(
            EntityManagerFactoryBuilder builder,
            @Qualifier("primaryDataSource") DataSource dataSource) {
        return builder
                .dataSource(dataSource)
                .packages("com.example.entity.primary")
                .persistenceUnit("primary")
                .build();
    }

    @Primary
    @Bean
    public PlatformTransactionManager primaryTransactionManager(
            @Qualifier("primaryEntityManagerFactory") EntityManagerFactory entityManagerFactory) {
        return new JpaTransactionManager(entityManagerFactory);
    }
}

常见误区与注意事项

事务管理：不同数据源的事务管理器需要明确区分，避免事务跨数据源。
主数据源标记：必须使用 @Primary 注解标记一个主数据源。
包路径隔离：建议将不同数据源的实体类和 Repository 放在不同的包中。
连接池配置：为每个数据源配置独立的连接池参数（如最大连接数、超时时间等）。
性能影响：多数据源会增加应用复杂性和资源消耗，需合理评估需求。

动态数据源切换

对于需要运行时动态切换数据源的场景，可以通过抽象路由数据源实现：

public class DynamicDataSource extends AbstractRoutingDataSource {
    @Override
    protected Object determineCurrentLookupKey() {
        return DataSourceContextHolder.getDataSourceType();
    }
}

通过线程局部变量（ThreadLocal）保存当前数据源标识：

public class DataSourceContextHolder {
    private static final ThreadLocal<String> contextHolder = new ThreadLocal<>();

    public static void setDataSourceType(String dataSourceType) {
        contextHolder.set(dataSourceType);
    }

    public static String getDataSourceType() {
        return contextHolder.get();
    }

    public static void clearDataSourceType() {
        contextHolder.remove();
    }
}

多Redis实例配置

概念定义

多Redis实例配置是指在SpringBoot应用中同时连接多个Redis服务器或同一个Redis服务器的不同数据库。这种配置常用于以下场景：

读写分离（主从架构）
不同业务数据隔离
多租户系统
缓存与持久化存储分离

配置方式

1. 基础配置（application.yml）

spring:
  redis:
    # 默认实例（通常用于缓存）
    host: 127.0.0.1
    port: 6379
    database: 0
    
  # 自定义第二个实例
  redis.secondary:
    host: 127.0.0.1
    port: 6380
    database: 1

2. 配置类实现

@Configuration
public class MultiRedisConfig {

    // 主Redis配置
    @Bean
    @Primary
    public RedisConnectionFactory primaryRedisFactory(
            @Value("${spring.redis.host}") String host,
            @Value("${spring.redis.port}") int port) {
        return new LettuceConnectionFactory(host, port);
    }

    // 次Redis配置
    @Bean
    public RedisConnectionFactory secondaryRedisFactory(
            @Value("${spring.redis.secondary.host}") String host,
            @Value("${spring.redis.secondary.port}") int port) {
        LettuceConnectionFactory factory = new LettuceConnectionFactory(host, port);
        factory.afterPropertiesSet();
        return factory;
    }

    // 主RedisTemplate
    @Bean
    @Primary
    public RedisTemplate<String, Object> primaryRedisTemplate(
            RedisConnectionFactory primaryRedisFactory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(primaryRedisFactory);
        // 可在此配置序列化方式等
        return template;
    }

    // 次RedisTemplate
    @Bean(name = "secondaryRedisTemplate")
    public RedisTemplate<String, Object> secondaryRedisTemplate(
            RedisConnectionFactory secondaryRedisFactory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(secondaryRedisFactory);
        return template;
    }
}

使用示例

@Service
public class RedisService {

    @Autowired
    private RedisTemplate<String, Object> primaryRedisTemplate;
    
    @Autowired
    @Qualifier("secondaryRedisTemplate")
    private RedisTemplate<String, Object> secondaryRedisTemplate;

    public void multiInstanceDemo() {
        // 使用主实例
        primaryRedisTemplate.opsForValue().set("primaryKey", "value1");
        
        // 使用次实例
        secondaryRedisTemplate.opsForValue().set("secondaryKey", "value2");
    }
}

高级配置选项

连接池配置

spring:
  redis:
    lettuce:
      pool:
        max-active: 8
        max-idle: 8
        min-idle: 0
  redis.secondary:
    lettuce:
      pool:
        max-active: 16
        max-idle: 16
        min-idle: 4

哨兵模式配置

spring:
  redis:
    sentinel:
      master: mymaster
      nodes: 127.0.0.1:26379,127.0.0.1:26380
  redis.secondary:
    sentinel:
      master: secondary
      nodes: 127.0.0.1:26381,127.0.0.1:26382

注意事项

@Primary注解：必须为其中一个RedisTemplate标记@Primary，否则Spring无法自动装配
连接泄漏：多实例时更需注意连接的关闭，建议使用try-with-resources
性能影响：每个Redis实例都会创建独立的连接池，需合理配置连接数
事务处理：跨实例的事务无法保证原子性
监控分离：建议为不同实例配置独立的监控
Key命名规范：不同实例使用相同的key可能导致混淆，建议添加前缀

最佳实践

为不同业务使用不同的Redis实例
读写分离场景：主实例写，从实例读
大Key考虑分散到不同实例
使用Spring Profiles管理不同环境的配置
考虑使用Redis集群替代多实例配置（当需要水平扩展时）

常见问题解决

问题1：出现"Consider marking one of the beans as @Primary"错误
解决：确保为其中一个RedisConnectionFactory或RedisTemplate添加@Primary注解

问题2：连接数过高
解决：检查各实例的连接池配置，确保max-active设置合理

问题3：性能下降
解决：考虑使用连接池（如Lettuce或Jedis），并监控各实例性能指标

多消息队列配置

概念定义

多消息队列配置是指在 SpringBoot 项目中同时集成并管理多个消息队列（如 RabbitMQ、Kafka、ActiveMQ 等）的能力。通过合理的配置，可以实现不同业务场景下的消息通信需求，提高系统的灵活性和可扩展性。

使用场景

业务解耦：不同的业务模块使用不同的消息队列，避免相互影响。
性能优化：针对不同的消息处理需求（如高吞吐、低延迟），选择不同的消息队列。
多环境支持：开发、测试、生产环境使用不同的消息队列配置。
灾备方案：主备消息队列配置，提高系统的容错能力。

常见配置方式

1. 多 RabbitMQ 配置

spring:
  rabbitmq:
    primary:
      host: primary.rabbitmq.example.com
      port: 5672
      username: admin
      password: admin123
    secondary:
      host: secondary.rabbitmq.example.com
      port: 5672
      username: admin
      password: admin123

配置类示例：

@Configuration
public class MultiRabbitConfig {
    @Bean
    @Primary
    public CachingConnectionFactory primaryConnectionFactory(
            @Value("${spring.rabbitmq.primary.host}") String host,
            @Value("${spring.rabbitmq.primary.port}") int port,
            @Value("${spring.rabbitmq.primary.username}") String username,
            @Value("${spring.rabbitmq.primary.password}") String password) {
        CachingConnectionFactory connectionFactory = new CachingConnectionFactory();
        connectionFactory.setHost(host);
        connectionFactory.setPort(port);
        connectionFactory.setUsername(username);
        connectionFactory.setPassword(password);
        return connectionFactory;
    }

    @Bean
    public CachingConnectionFactory secondaryConnectionFactory(
            @Value("${spring.rabbitmq.secondary.host}") String host,
            @Value("${spring.rabbitmq.secondary.port}") int port,
            @Value("${spring.rabbitmq.secondary.username}") String username,
            @Value("${spring.rabbitmq.secondary.password}") String password) {
        // 类似primary的配置
    }
}

2. 多 Kafka 配置

spring:
  kafka:
    primary:
      bootstrap-servers: primary.kafka.example.com:9092
      producer:
        key-serializer: org.apache.kafka.common.serialization.StringSerializer
        value-serializer: org.apache.kafka.common.serialization.StringSerializer
    secondary:
      bootstrap-servers: secondary.kafka.example.com:9092
      producer:
        key-serializer: org.apache.kafka.common.serialization.StringSerializer
        value-serializer: org.apache.kafka.common.serialization.StringSerializer

配置类示例：

@Configuration
public class MultiKafkaConfig {
    @Bean
    @Primary
    public KafkaTemplate<String, String> primaryKafkaTemplate(
            @Value("${spring.kafka.primary.bootstrap-servers}") String bootstrapServers) {
        Map<String, Object> configProps = new HashMap<>();
        configProps.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, bootstrapServers);
        // 其他配置...
        return new KafkaTemplate<>(new DefaultKafkaProducerFactory<>(configProps));
    }

    @Bean
    public KafkaTemplate<String, String> secondaryKafkaTemplate(
            @Value("${spring.kafka.secondary.bootstrap-servers}") String bootstrapServers) {
        // 类似primary的配置
    }
}

注意事项

资源消耗：每个消息队列连接都会占用系统资源，需合理评估
事务管理：跨消息队列的事务处理需要特殊考虑
监控维护：多个消息队列需要分别监控和维护
连接池配置：为每个连接配置适当的连接池参数
异常处理：需要为每个消息队列实现独立的异常处理机制

最佳实践

使用 @Qualifier 注解明确指定要使用的消息队列
为不同的消息队列配置不同的线程池
实现消息队列的健康检查机制
考虑使用抽象工厂模式管理多个消息队列
在微服务架构中，可以考虑为每个服务配置独立的消息队列

示例：多RabbitMQ使用

@Service
public class OrderService {
    private final RabbitTemplate primaryRabbitTemplate;
    private final RabbitTemplate secondaryRabbitTemplate;

    public OrderService(
            @Qualifier("primaryRabbitTemplate") RabbitTemplate primaryRabbitTemplate,
            @Qualifier("secondaryRabbitTemplate") RabbitTemplate secondaryRabbitTemplate) {
        this.primaryRabbitTemplate = primaryRabbitTemplate;
        this.secondaryRabbitTemplate = secondaryRabbitTemplate;
    }

    public void processOrder(Order order) {
        // 重要订单使用主队列
        if(order.isPriority()) {
            primaryRabbitTemplate.convertAndSend("priority.orders", order);
        } else {
            secondaryRabbitTemplate.convertAndSend("normal.orders", order);
        }
    }
}

跨域配置（CORS Configuration）

什么是跨域？

跨域（Cross-Origin Resource Sharing，CORS）是指浏览器出于安全考虑，限制从一个源（协议+域名+端口）加载的资源与另一个源的资源进行交互。例如：

前端运行在 http://localhost:8080，后端 API 在 http://api.example.com，此时浏览器会阻止请求。

为什么需要跨域配置？

现代 Web 应用通常采用前后端分离架构，前端和后端可能部署在不同域名或端口下。若未配置 CORS，浏览器会拒绝跨域请求，导致前端无法访问后端 API。

SpringBoot 中的跨域解决方案

1. 全局配置（推荐）

通过 WebMvcConfigurer 接口实现全局跨域配置：

@Configuration
public class CorsConfig implements WebMvcConfigurer {
    @Override
    public void addCorsMappings(CorsRegistry registry) {
        registry.addMapping("/**")  // 匹配所有路径
                .allowedOrigins("*") // 允许所有源（生产环境应指定具体域名）
                .allowedMethods("GET", "POST", "PUT", "DELETE") // 允许的 HTTP 方法
                .allowedHeaders("*") // 允许所有请求头
                .allowCredentials(true) // 允许携带 Cookie
                .maxAge(3600); // 预检请求缓存时间（秒）
    }
}

2. 注解配置（局部配置）

在单个控制器或方法上使用 @CrossOrigin 注解：

@RestController
@CrossOrigin(origins = "http://example.com") // 允许特定源
public class MyController {
    @GetMapping("/data")
    @CrossOrigin(origins = "*") // 覆盖类级别配置
    public String getData() {
        return "Hello CORS!";
    }
}

3. 过滤器配置

通过自定义过滤器实现跨域：

@Bean
public FilterRegistrationBean<CorsFilter> corsFilter() {
    CorsConfiguration config = new CorsConfiguration();
    config.addAllowedOrigin("*");
    config.addAllowedHeader("*");
    config.addAllowedMethod("*");

    UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
    source.registerCorsConfiguration("/**", config);

    FilterRegistrationBean<CorsFilter> bean = 
        new FilterRegistrationBean<>(new CorsFilter(source));
    bean.setOrder(0); // 设置过滤器优先级
    return bean;
}

关键配置项说明

配置项	说明
`allowedOrigins`	允许访问的源（`*` 表示全部，生产环境建议指定具体域名）
`allowedMethods`	允许的 HTTP 方法（如 `GET`、`POST`）
`allowedHeaders`	允许的请求头（如 `Content-Type`、`Authorization`）
`allowCredentials`	是否允许发送 Cookie（设为 `true` 时，`allowedOrigins` 不能为 `*`）
`maxAge`	预检请求（OPTIONS）的缓存时间，减少重复预检

常见问题与注意事项

allowCredentials 与 allowedOrigins 冲突
若启用 allowCredentials(true)，则 allowedOrigins 必须指定具体域名（不能为 *）。
预检请求（Preflight）
复杂请求（如 Content-Type: application/json）会先发送 OPTIONS 请求，需确保后端支持。
生产环境安全建议
- 避免使用 allowedOrigins("*")，应明确指定前端域名。
- 限制 allowedMethods 和 allowedHeaders 为最小必要集合。
网关层配置
如果使用 Nginx 或 Spring Cloud Gateway，可在网关层统一处理跨域，减少后端压力。

测试跨域是否生效

使用 curl 模拟预检请求：

curl -X OPTIONS http://your-api.com/data \
  -H "Origin: http://your-frontend.com" \
  -H "Access-Control-Request-Method: POST"

检查响应头中是否包含：

Access-Control-Allow-Origin: http://your-frontend.com
Access-Control-Allow-Methods: POST

拦截器配置

什么是拦截器？

拦截器（Interceptor）是 Spring MVC 提供的一种机制，允许在请求处理的不同阶段（如请求到达 Controller 前、Controller 方法执行后、视图渲染后等）插入自定义逻辑。拦截器常用于权限验证、日志记录、性能监控等场景。

拦截器的核心接口

Spring 的拦截器基于 HandlerInterceptor 接口，该接口定义了三个方法：

preHandle：在 Controller 方法执行前调用，返回 true 表示继续执行，返回 false 则中断请求。
postHandle：在 Controller 方法执行后、视图渲染前调用。
afterCompletion：在请求完成后调用（视图渲染完毕），通常用于资源清理。

如何配置拦截器？

以下是完整的拦截器配置步骤：

1. 创建自定义拦截器

实现 HandlerInterceptor 接口或继承 HandlerInterceptorAdapter（Spring 5.3 后已废弃，建议直接实现接口）。

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.web.servlet.HandlerInterceptor;

public class AuthInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, 
                             HttpServletResponse response, 
                             Object handler) throws Exception {
        // 权限校验逻辑
        if (!checkAuth(request)) {
            response.sendError(403, "Forbidden");
            return false;
        }
        return true;
    }

    private boolean checkAuth(HttpServletRequest request) {
        // 实现具体的权限校验
        return true;
    }
}

2. 注册拦截器

通过 WebMvcConfigurer 配置类注册拦截器，并指定拦截路径。

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class WebConfig implements WebMvcConfigurer {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new AuthInterceptor())
                .addPathPatterns("/api/**")      // 拦截的路径
                .excludePathPatterns("/api/login"); // 排除的路径
    }
}

拦截器的执行顺序

可以通过 order() 方法设置多个拦截器的执行顺序，值越小优先级越高。

registry.addInterceptor(new LogInterceptor()).order(1);
registry.addInterceptor(new AuthInterceptor()).order(2);

常见使用场景

权限验证：检查用户是否登录或是否有权限访问接口。
日志记录：记录请求参数、响应时间等信息。
性能监控：统计接口耗时。
全局参数处理：如设置线程本地变量（ThreadLocal）。

注意事项

preHandle 返回值：必须正确处理 true/false，否则会导致请求中断或循环。
路径匹配规则：
- /** 匹配所有路径。
- /api/* 匹配单级路径（如 /api/user，但不匹配 /api/user/1）。
拦截器与过滤器的区别：
- 过滤器（Filter）是 Servlet 规范，拦截器是 Spring 机制。
- 过滤器更底层，拦截器可以获取 Spring 上下文中的 Bean。
避免阻塞操作：拦截器中不要执行耗时操作，否则会影响请求响应速度。

过滤器配置

概念定义

过滤器（Filter）是 Java Web 应用中的一种组件，用于在请求到达 Servlet 之前或响应返回客户端之前对请求和响应进行预处理或后处理。在 Spring Boot 中，过滤器通常用于实现跨域处理、日志记录、权限验证、请求参数校验等功能。

使用场景

权限控制：检查用户是否登录或是否有权限访问某些资源。
日志记录：记录请求和响应的详细信息，用于调试或审计。
跨域处理：设置响应头以支持跨域请求（CORS）。
请求参数处理：对请求参数进行校验或修改。
性能监控：记录请求处理时间，用于性能分析。

常见实现方式

在 Spring Boot 中，可以通过以下方式配置过滤器：

1. 使用 `@Component` 和 `@WebFilter` 注解

import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import java.io.IOException;

@Component
@WebFilter(urlPatterns = "/*") // 过滤所有请求
public class MyFilter implements Filter {

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        // 初始化逻辑
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        // 预处理逻辑
        System.out.println("Before request processing");

        // 继续执行过滤器链
        chain.doFilter(request, response);

        // 后处理逻辑
        System.out.println("After request processing");
    }

    @Override
    public void destroy() {
        // 销毁逻辑
    }
}

2. 通过 `FilterRegistrationBean` 注册

import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class FilterConfig {

    @Bean
    public FilterRegistrationBean<MyFilter> myFilterRegistration() {
        FilterRegistrationBean<MyFilter> registration = new FilterRegistrationBean<>();
        registration.setFilter(new MyFilter());
        registration.addUrlPatterns("/*"); // 过滤所有请求
        registration.setOrder(1); // 设置过滤器执行顺序
        return registration;
    }
}

注意事项

执行顺序：过滤器的执行顺序由 FilterRegistrationBean 的 setOrder 方法决定，数值越小优先级越高。
性能影响：过滤器中的逻辑应尽量高效，避免阻塞请求处理。
异常处理：在 doFilter 方法中捕获并处理异常，避免异常传播到上层。
资源释放：在 destroy 方法中释放过滤器占用的资源（如数据库连接、文件句柄等）。
跨域处理：如果使用过滤器处理跨域问题，需确保与其他跨域配置（如 @CrossOrigin 注解）不冲突。

示例：日志记录过滤器

import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;

public class LoggingFilter implements Filter {

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        HttpServletRequest httpRequest = (HttpServletRequest) request;
        System.out.println("Request URL: " + httpRequest.getRequestURL());
        System.out.println("Request Method: " + httpRequest.getMethod());

        long startTime = System.currentTimeMillis();
        chain.doFilter(request, response);
        long duration = System.currentTimeMillis() - startTime;

        System.out.println("Request processed in " + duration + "ms");
    }

    // 其他方法（init、destroy）可留空
}

常见误区

忽略 chain.doFilter：忘记调用 chain.doFilter 会导致请求无法继续处理。
过度使用过滤器：将业务逻辑放入过滤器中可能导致代码难以维护。
线程安全问题：如果过滤器包含共享状态（如成员变量），需确保线程安全。

定时任务配置

什么是定时任务

定时任务（Scheduled Task）是指在指定的时间或周期性地执行某项任务的功能。在SpringBoot中，可以通过简单的注解和配置实现定时任务的调度。

使用场景

数据统计报表生成（如每日凌晨生成前一天的销售报表）
数据清理（如定期清理日志文件）
缓存刷新（如定时更新热点数据缓存）
消息重试机制（如定时检查失败的消息并重发）

SpringBoot中的实现方式

1. 启用定时任务

在启动类上添加@EnableScheduling注解：

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

2. 创建定时任务方法

使用@Scheduled注解标记方法：

@Component
public class MyScheduledTasks {
    
    // 每5秒执行一次
    @Scheduled(fixedRate = 5000)
    public void taskWithFixedRate() {
        System.out.println("Fixed Rate Task: " + System.currentTimeMillis());
    }
    
    // 每天凌晨1点执行
    @Scheduled(cron = "0 0 1 * * ?")
    public void dailyTask() {
        System.out.println("Daily Task executed at: " + new Date());
    }
}

配置参数详解

@Scheduled参数

fixedRate：固定频率执行，单位毫秒

@Scheduled(fixedRate = 5000) // 每5秒执行

fixedDelay：固定延迟执行（上次任务结束后间隔指定时间）
```
@Scheduled(fixedDelay = 3000) // 上次执行完后3秒再执行
```
initialDelay：初始延迟（首次执行的延迟时间）
```
@Scheduled(initialDelay = 1000, fixedRate = 5000)
```

cron：Cron表达式（最灵活）

@Scheduled(cron = "0 15 10 * * ?") // 每天10:15执行

Cron表达式格式

秒 分 时 日 月 周 年（可选）

常用示例：

0 0 * * * ?：每小时执行
0 0 12 * * ?：每天中午12点
0 15 10 ? * MON-FRI：工作日10:15执行
0 0/5 14,18 * * ?：每天14点和18点，每隔5分钟执行

配置线程池

默认情况下，定时任务使用单线程执行。可以通过配置线程池提高并发能力：

@Configuration
public class SchedulerConfig implements SchedulingConfigurer {
    @Override
    public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
        ThreadPoolTaskScheduler taskScheduler = new ThreadPoolTaskScheduler();
        taskScheduler.setPoolSize(10);
        taskScheduler.setThreadNamePrefix("scheduled-task-");
        taskScheduler.initialize();
        taskRegistrar.setTaskScheduler(taskScheduler);
    }
}

常见问题与注意事项

单线程问题：默认所有定时任务共享一个线程，长时间运行的任务会阻塞其他任务
异常处理：定时任务中的异常需要捕获处理，否则会导致任务终止
分布式环境：在集群环境下需要考虑任务重复执行问题（可结合Redis锁或ShedLock解决）
时间配置：Cron表达式中的周和日字段是互斥的，通常指定一个而另一个设为?
服务器时区：确保服务器时区与预期一致，特别是跨时区部署时

最佳实践示例

@Component
public class BestPracticeScheduler {
    private static final Logger logger = LoggerFactory.getLogger(BestPracticeScheduler.class);
    
    // 使用线程池+异常处理+分布式锁的完整示例
    @Scheduled(cron = "0 0 2 * * ?") // 每天凌晨2点执行
    public void dataCleanupTask() {
        try {
            if (tryAcquireLock("dataCleanup")) {
                logger.info("开始执行数据清理任务");
                // 实际业务逻辑
                logger.info("数据清理任务完成");
            }
        } catch (Exception e) {
            logger.error("数据清理任务执行失败", e);
        } finally {
            releaseLock("dataCleanup");
        }
    }
    
    private boolean tryAcquireLock(String lockKey) {
        // 实现分布式锁逻辑
        return true;
    }
    
    private void releaseLock(String lockKey) {
        // 释放锁逻辑
    }
}

动态配置定时任务

可以通过实现SchedulingConfigurer接口实现动态配置：

@Configuration
public class DynamicSchedulerConfig implements SchedulingConfigurer {
    
    @Value("${task.interval}")
    private long taskInterval;
    
    @Override
    public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
        taskRegistrar.addFixedRateTask(() -> {
            System.out.println("Dynamic Task: " + System.currentTimeMillis());
        }, taskInterval);
    }
}

异步任务配置

什么是异步任务

异步任务是指任务的执行不会阻塞主线程，而是由单独的线程池或线程来执行。在SpringBoot中，我们可以通过简单的配置和注解来实现异步任务的执行。

使用场景

耗时操作（如发送邮件、生成报表）
非核心业务流程（如日志记录）
需要提高响应速度的场景
定时任务执行

核心注解

@EnableAsync：启用异步支持，需要加在配置类或主类上
@Async：标记方法为异步执行

基本配置示例

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

@Service
public class MyService {
    @Async
    public void asyncMethod() {
        // 异步执行的逻辑
    }
}

线程池配置

SpringBoot允许自定义异步任务使用的线程池：

@Configuration
@EnableAsync
public class AsyncConfig implements AsyncConfigurer {
    
    @Override
    public Executor getAsyncExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(5);
        executor.setMaxPoolSize(10);
        executor.setQueueCapacity(100);
        executor.setThreadNamePrefix("Async-");
        executor.initialize();
        return executor;
    }
    
    @Override
    public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
        return new SimpleAsyncUncaughtExceptionHandler();
    }
}

配置参数详解

corePoolSize：核心线程数
maxPoolSize：最大线程数
queueCapacity：队列容量
keepAliveSeconds：线程空闲时间（秒）
threadNamePrefix：线程名前缀

高级配置

可以通过application.properties配置：

spring.task.execution.pool.core-size=5
spring.task.execution.pool.max-size=10
spring.task.execution.pool.queue-capacity=100
spring.task.execution.thread-name-prefix=Async-

注意事项

异步方法不能与被调用方法在同一个类中（因为Spring使用代理机制）
异步方法最好有void返回类型，如果需要返回值可以使用Future或CompletableFuture
注意线程池参数的合理设置，避免OOM
异步方法抛出的异常需要通过AsyncUncaughtExceptionHandler处理

返回值处理示例

@Async
public Future<String> asyncMethodWithReturn() {
    // 执行逻辑
    return new AsyncResult<>("result");
}

// 调用方
Future<String> future = service.asyncMethodWithReturn();
String result = future.get(); // 阻塞获取结果

异常处理

自定义异常处理器：

public class CustomAsyncExceptionHandler implements AsyncUncaughtExceptionHandler {
    @Override
    public void handleUncaughtException(Throwable ex, Method method, Object... params) {
        // 处理异常逻辑
    }
}

性能优化建议

根据业务场景合理设置线程池大小
监控线程池使用情况
考虑使用@Async("specificExecutor")为不同任务指定不同线程池
对于CPU密集型任务，线程数不宜过多
对于IO密集型任务，可以适当增加线程数

邮件服务配置

概念定义

邮件服务配置是指在 Spring Boot 应用中，通过配置相关参数来集成邮件发送功能。Spring Boot 提供了对 JavaMail 的自动配置支持，开发者可以通过简单的配置快速实现邮件发送功能。

使用场景

用户注册时的验证邮件发送
密码重置邮件
系统通知邮件
营销推广邮件
异常告警邮件

配置参数详解

Spring Boot 通过 spring.mail 前缀提供邮件相关配置：

# 邮件服务器地址
spring.mail.host=smtp.example.com
# 邮件服务器端口
spring.mail.port=587
# 协议（默认为smtp）
spring.mail.protocol=smtp
# 用户名
[email protected]
# 密码
spring.mail.password=your-password
# 默认编码
spring.mail.default-encoding=UTF-8
# 其他属性配置
spring.mail.properties.mail.smtp.auth=true
spring.mail.properties.mail.smtp.starttls.enable=true
spring.mail.properties.mail.smtp.connectiontimeout=5000
spring.mail.properties.mail.smtp.timeout=3000
spring.mail.properties.mail.smtp.writetimeout=5000

核心组件

JavaMailSender：Spring 提供的邮件发送接口
MimeMessage：复杂邮件消息对象
SimpleMailMessage：简单邮件消息对象

示例代码

1. 发送简单文本邮件

@Service
public class EmailService {
    
    @Autowired
    private JavaMailSender mailSender;
    
    public void sendSimpleEmail(String to, String subject, String text) {
        SimpleMailMessage message = new SimpleMailMessage();
        message.setFrom("[email protected]");
        message.setTo(to);
        message.setSubject(subject);
        message.setText(text);
        mailSender.send(message);
    }
}

2. 发送HTML格式邮件

public void sendHtmlEmail(String to, String subject, String htmlContent) throws MessagingException {
    MimeMessage message = mailSender.createMimeMessage();
    MimeMessageHelper helper = new MimeMessageHelper(message, true);
    
    helper.setFrom("[email protected]");
    helper.setTo(to);
    helper.setSubject(subject);
    helper.setText(htmlContent, true);  // true表示内容是HTML
    
    mailSender.send(message);
}

3. 发送带附件的邮件

public void sendEmailWithAttachment(String to, String subject, String text, 
                                  String attachmentPath, String attachmentName) 
                                  throws MessagingException {
    MimeMessage message = mailSender.createMimeMessage();
    MimeMessageHelper helper = new MimeMessageHelper(message, true);
    
    helper.setFrom("[email protected]");
    helper.setTo(to);
    helper.setSubject(subject);
    helper.setText(text);
    
    FileSystemResource file = new FileSystemResource(new File(attachmentPath));
    helper.addAttachment(attachmentName, file);
    
    mailSender.send(message);
}

常见误区与注意事项

安全配置：
- 避免在代码中硬编码密码
- 使用环境变量或配置中心管理敏感信息
- 启用TLS/SSL加密
性能问题：
- 邮件发送是阻塞操作，考虑异步发送
- 对于批量邮件，使用连接池配置
邮件服务器限制：
- 注意发送频率限制
- 避免被标记为垃圾邮件
测试建议：
- 开发环境使用Mock或测试邮件服务器
- 生产环境前充分测试各种邮件类型
国际化：
- 注意邮件内容的编码问题
- 为不同地区用户提供本地化内容

高级配置

1. 使用连接池

spring.mail.properties.mail.smtp.connectionpool=true
spring.mail.properties.mail.smtp.connectionpoolsize=5

2. 异步发送配置

@Async
public void sendAsyncEmail(String to, String subject, String text) {
    sendSimpleEmail(to, subject, text);
}

3. 使用模板引擎

结合Thymeleaf发送模板邮件：

public void sendTemplateEmail(String to, String subject, Map<String, Object> model) 
    throws MessagingException {
    Context context = new Context();
    context.setVariables(model);
    
    String htmlContent = templateEngine.process("email-template", context);
    
    sendHtmlEmail(to, subject, htmlContent);
}

常见问题排查

认证失败：
- 检查用户名密码是否正确
- 确认是否需要应用专用密码
连接超时：
- 检查网络连接
- 调整超时时间配置
邮件进入垃圾箱：
- 检查SPF/DKIM/DMARC记录
- 优化邮件内容避免触发垃圾邮件规则
编码问题：
- 确保统一使用UTF-8编码
- 特殊字符正确转义

文件上传配置

概念定义

文件上传配置是指在 SpringBoot 应用中，通过配置文件或代码设置，实现对用户上传文件的支持，包括文件大小限制、存储路径、临时目录等参数的管理。

核心配置参数

SpringBoot 通过 Multipart 相关属性控制文件上传行为，主要配置项如下：

# application.properties 示例
spring.servlet.multipart.enabled=true
spring.servlet.multipart.max-file-size=10MB
spring.servlet.multipart.max-request-size=100MB
spring.servlet.multipart.file-size-threshold=1MB
spring.servlet.multipart.location=/tmp

enabled：是否启用文件上传（默认true）
max-file-size：单个文件最大尺寸（默认1MB）
max-request-size：单次请求最大尺寸（默认10MB）
file-size-threshold：文件大小阈值，超过此值会写入临时文件
location：临时存储目录（系统临时目录默认）

自定义配置类

对于更复杂的场景，可通过配置类自定义：

@Configuration
public class UploadConfig implements WebMvcConfigurer {
    @Bean
    public MultipartConfigElement multipartConfigElement() {
        MultipartConfigFactory factory = new MultipartConfigFactory();
        factory.setLocation("/custom/tmp");
        factory.setMaxFileSize(DataSize.ofMegabytes(50));
        factory.setMaxRequestSize(DataSize.ofGigabytes(1));
        return factory.createMultipartConfig();
    }
}

存储路径处理

推荐的最佳实践：

@Value("${file.upload-dir}")
private String uploadDir;

@PostConstruct
public void init() {
    try {
        Files.createDirectories(Paths.get(uploadDir));
    } catch (IOException e) {
        throw new RuntimeException("初始化上传目录失败", e);
    }
}

常见问题解决方案

1. 文件大小限制异常

错误表现：

org.springframework.web.multipart.MaxUploadSizeExceededException

解决方案：

检查是否同时设置了 max-file-size 和 max-request-size
确保单位正确（MB/MiB 区分）

2. 临时目录权限问题

错误表现：

java.io.IOException: The temporary upload location is not valid

解决方案：

显式设置 spring.servlet.multipart.location
确保应用有目录读写权限

3. 中文文件名乱码

解决方案：

spring.http.encoding.force=true
spring.http.encoding.charset=UTF-8

完整上传示例

@RestController
@RequestMapping("/api/files")
public class FileController {
    
    @PostMapping
    public String handleUpload(
        @RequestParam("file") MultipartFile file,
        @RequestParam(required = false) String description) {
        
        if (file.isEmpty()) {
            return "文件不能为空";
        }
        
        try {
            byte[] bytes = file.getBytes();
            Path path = Paths.get(uploadDir + file.getOriginalFilename());
            Files.write(path, bytes);
            return "上传成功: " + path.toString();
        } catch (IOException e) {
            return "上传失败: " + e.getMessage();
        }
    }
}

高级配置建议

生产环境注意事项：
- 禁用文件自动删除（spring.servlet.multipart.resolve-lazily=false）
- 定期清理临时目录
- 使用绝对路径而非相对路径

云存储集成：

@Bean
public StorageService cloudStorage() {
    return new S3StorageService(accessKey, secretKey);
}

安全防护：
- 校验文件类型（不要依赖扩展名）
- 扫描病毒文件
- 设置访问权限控制

测试验证方法

@SpringBootTest
@AutoConfigureMockMvc
class FileUploadTests {
    
    @Autowired
    private MockMvc mvc;
    
    @Test
    void testUpload() throws Exception {
        MockMultipartFile file = new MockMultipartFile(
            "file",
            "test.txt",
            "text/plain",
            "Hello World".getBytes()
        );
        
        mvc.perform(multipart("/upload")
            .file(file))
            .andExpect(status().isOk());
    }
}

安全认证配置

概念定义

安全认证配置是 SpringBoot 应用中用于保护资源访问权限的核心机制，通过验证用户身份（Authentication）和授权（Authorization）确保系统安全性。Spring Security 是 SpringBoot 官方推荐的安全框架，提供开箱即用的认证与授权功能。

核心组件

SecurityFilterChain
请求拦截链，定义URL访问规则和认证逻辑。
UserDetailsService
加载用户信息的接口，需实现自定义用户数据源。
PasswordEncoder
密码加密器（如BCryptPasswordEncoder）。

基础配置示例

@Configuration
@EnableWebSecurity
public class SecurityConfig {
    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http
            .authorizeHttpRequests(auth -> auth
                .requestMatchers("/public/**").permitAll()
                .requestMatchers("/admin/**").hasRole("ADMIN")
                .anyRequest().authenticated()
            )
            .formLogin(form -> form
                .loginPage("/login")
                .defaultSuccessUrl("/home")
                .permitAll()
            )
            .logout(logout -> logout
                .logoutSuccessUrl("/login?logout")
            );
        return http.build();
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}

认证方式

表单登录
默认提供/login页面，可通过formLogin()自定义：

.formLogin(form -> form
    .loginProcessingUrl("/auth")  // 自定义登录处理URL
    .usernameParameter("user")    // 修改用户名参数名
    .passwordParameter("pass")
)

HTTP Basic认证
适用于API场景：

http.httpBasic(Customizer.withDefaults());

OAuth2/第三方登录
集成社交登录（如GitHub、Google）：

http.oauth2Login(oauth -> oauth
    .loginPage("/oauth-login")
    .defaultSuccessUrl("/dashboard")
);

用户存储方案

内存用户（测试用）

@Bean
public UserDetailsService users() {
    UserDetails user = User.builder()
        .username("user")
        .password(passwordEncoder().encode("123"))
        .roles("USER")
        .build();
    return new InMemoryUserDetailsManager(user);
}

数据库存储
实现UserDetailsService接口：

@Service
public class JpaUserDetailsService implements UserDetailsService {
    @Override
    public UserDetails loadUserByUsername(String username) {
        User user = userRepository.findByUsername(username);
        return new CustomUserDetails(user); // 自定义UserDetails实现
    }
}

高级配置

方法级安全
使用注解控制方法访问：

@PreAuthorize("hasRole('ADMIN')")
@PostMapping("/delete")
public String deleteData() { /* ... */ }

CSRF防护
默认启用，API场景可禁用：
```
http.csrf(csrf -> csrf.disable());
```

CORS配置

@Bean
CorsConfigurationSource corsConfigurationSource() {
    CorsConfiguration config = new CorsConfiguration();
    config.addAllowedOrigin("https://trusted.com");
    config.addAllowedMethod("*");
    UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
    source.registerCorsConfiguration("/**", config);
    return source;
}

常见问题

密码未加密
必须配置PasswordEncoder，否则报There is no PasswordEncoder mapped错误。

静态资源拦截
需放行资源路径：

.requestMatchers("/css/**", "/js/**").permitAll()

角色前缀问题
Spring Security 自动添加ROLE_前缀，数据库角色字段应存储为ADMIN而非ROLE_ADMIN。

最佳实践

生产环境禁用H2 Console等开发接口
使用HTTPS强制安全传输
定期更新依赖库修复安全漏洞

国际化配置（i18n）

国际化（Internationalization，简称 i18n）是指应用程序能够适应不同语言和地区的需求，而无需修改代码。Spring Boot 提供了强大的国际化支持，允许开发者轻松地实现多语言切换。

基本概念

Locale（区域设置）：表示特定的地理、政治或文化区域，通常由语言和国家代码组成（如 zh_CN 表示中文-中国）。
MessageSource：Spring 提供的接口，用于解析国际化消息。
ResourceBundle：Java 提供的机制，用于加载不同语言的消息资源文件。

使用场景

多语言网站或应用
需要根据用户的语言偏好显示不同内容
错误消息、按钮标签等需要本地化的文本

配置步骤

1. 创建消息资源文件

在 src/main/resources 目录下创建消息资源文件，命名格式为 messages_语言代码_国家代码.properties：

messages.properties       # 默认消息（通常为英文）
messages_zh_CN.properties # 中文-中国
messages_fr_FR.properties # 法语-法国

示例 messages_zh_CN.properties 内容：

welcome.message=欢迎使用我们的应用！
error.notfound=未找到资源

2. 配置 Spring Boot

在 application.properties 或 application.yml 中配置：

spring.messages.basename=messages
spring.messages.encoding=UTF-8

3. 使用国际化消息

在 Controller 中使用

@RestController
public class GreetingController {
    
    @Autowired
    private MessageSource messageSource;
    
    @GetMapping("/greet")
    public String greet(Locale locale) {
        return messageSource.getMessage("welcome.message", null, locale);
    }
}

在 Thymeleaf 模板中使用

<p th:text="#{welcome.message}">p>

在 JSP 中使用

高级用法

1. 参数化消息

资源文件：

greeting=你好，{0}！今天是{1}。

Java 代码：

String[] params = {"张三", "星期一"};
messageSource.getMessage("greeting", params, locale);

2. 默认 Locale 解析

可以自定义 Locale 解析器：

@Bean
public LocaleResolver localeResolver() {
    SessionLocaleResolver slr = new SessionLocaleResolver();
    slr.setDefaultLocale(Locale.US); // 设置默认区域
    return slr;
}

@Bean
public LocaleChangeInterceptor localeChangeInterceptor() {
    LocaleChangeInterceptor lci = new LocaleChangeInterceptor();
    lci.setParamName("lang"); // 通过URL参数切换语言
    return lci;
}

@Override
public void addInterceptors(InterceptorRegistry registry) {
    registry.addInterceptor(localeChangeInterceptor());
}

然后可以通过 URL 切换语言：http://example.com?lang=zh_CN

常见问题与注意事项

文件编码：确保资源文件使用 UTF-8 编码，避免中文乱码。
缺失键处理：当找不到对应语言的键时，会回退到默认文件（messages.properties）。
性能考虑：频繁切换语言可能影响性能，可以考虑缓存机制。
测试覆盖：确保测试所有支持的语言，特别是右到左语言（如阿拉伯语）的布局问题。
动态内容：对于用户生成的内容，需要单独处理，不属于静态国际化资源。

最佳实践

将所有可翻译文本集中管理，避免硬编码在代码中。
使用有意义的键名，如 user.login.error.invalid_credentials 而非 error1。
考虑使用专业的国际化工具（如 Smartcat、Poedit）管理翻译资源。
为翻译人员提供上下文说明，避免歧义。

通过合理配置和使用 Spring Boot 的国际化功能，可以轻松构建支持多语言的应用程序。

性能监控配置

概念定义

性能监控配置是指在 SpringBoot 应用中，通过集成监控工具或框架，对应用的运行状态、性能指标（如响应时间、吞吐量、内存使用率等）进行实时采集、分析和展示的配置过程。常见的性能监控工具包括 Spring Boot Actuator、Prometheus、Grafana、Micrometer 等。

使用场景

应用健康检查：监控应用是否正常运行，如数据库连接、磁盘空间等。
性能瓶颈分析：通过监控响应时间、CPU 使用率等指标，定位性能瓶颈。
告警与优化：当某些指标超出阈值时触发告警，帮助开发者及时优化。
生产环境运维：长期监控应用状态，确保稳定性。

常见配置方式

1. 使用 Spring Boot Actuator

Spring Boot Actuator 是 Spring Boot 提供的监控工具，可以暴露应用的运行状态和指标。

依赖配置

<dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-starter-actuatorartifactId>
dependency>

启用端点

在 application.properties 或 application.yml 中配置：

# 启用所有端点
management.endpoints.web.exposure.include=*
# 启用特定端点（如 health, metrics, info）
management.endpoints.web.exposure.include=health,metrics,info

访问监控端点

/actuator/health：应用健康状态。
/actuator/metrics：性能指标（如 JVM 内存、线程数等）。
/actuator/prometheus：以 Prometheus 格式暴露指标（需额外依赖）。

2. 集成 Prometheus + Grafana

Prometheus 用于采集和存储指标数据，Grafana 用于可视化展示。

添加 Micrometer 依赖

<dependency>
    <groupId>io.micrometergroupId>
    <artifactId>micrometer-registry-prometheusartifactId>
dependency>

配置 Prometheus 端点

management.endpoints.web.exposure.include=prometheus

Grafana 配置

在 Grafana 中配置 Prometheus 数据源。
导入 Spring Boot 监控仪表盘（如 ID：4701）。

3. 自定义监控指标

通过 Micrometer 自定义业务指标（如接口调用次数、耗时等）。

示例代码

import io.micrometer.core.instrument.Counter;
import io.micrometer.core.instrument.MeterRegistry;
import org.springframework.stereotype.Component;

@Component
public class CustomMetrics {
    private final Counter apiCallCounter;

    public CustomMetrics(MeterRegistry registry) {
        apiCallCounter = Counter.builder("api.calls.total")
                .description("Total number of API calls")
                .register(registry);
    }

    public void incrementApiCall() {
        apiCallCounter.increment();
    }
}

常见误区与注意事项

端点暴露安全：生产环境中应限制敏感端点（如 env、heapdump）的访问，可通过 management.endpoints.web.exposure.exclude 排除。
性能开销：高频采集指标可能影响应用性能，需合理设置采集间隔（如 Prometheus 的 scrape_interval）。
指标过多：避免采集无用指标，聚焦核心业务和系统指标。
监控告警阈值：设置合理的告警阈值，避免频繁误报。

示例：完整配置（application.yml）

management:
  endpoints:
    web:
      exposure:
        include: health,metrics,prometheus
  metrics:
    export:
      prometheus:
        enabled: true
    tags:
      application: my-springboot-app  # 添加自定义标签

健康检查配置

什么是健康检查

健康检查（Health Check）是 Spring Boot Actuator 提供的一种监控机制，用于检测应用程序的运行状态。它通过暴露一个 HTTP 端点（默认是 /actuator/health）来展示应用的当前健康状况，包括数据库连接、磁盘空间、外部服务依赖等关键组件的状态。

健康检查的作用

监控应用状态：帮助运维人员快速发现应用是否正常运行。
自动化运维：结合 Kubernetes、Docker 等容器编排工具，实现自动重启或流量切换。
依赖检查：验证应用依赖的外部服务（如数据库、Redis、MQ）是否可用。

配置健康检查

Spring Boot 默认集成了健康检查功能，但需要引入 spring-boot-starter-actuator 依赖：

<dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-starter-actuatorartifactId>
dependency>

1. 基础配置

默认情况下，健康检查端点返回简单的 UP 或 DOWN 状态。可以通过 application.properties 或 application.yml 配置更详细的信息：

# 开启健康检查详细信息（默认仅管理员可见）
management.endpoint.health.show-details=always

2. 自定义健康检查

Spring Boot 允许通过实现 HealthIndicator 接口自定义健康检查逻辑。例如，检查一个外部 API 是否可用：

import org.springframework.boot.actuate.health.Health;
import org.springframework.boot.actuate.health.HealthIndicator;
import org.springframework.stereotype.Component;

@Component
public class CustomHealthIndicator implements HealthIndicator {
    @Override
    public Health health() {
        boolean isApiHealthy = checkExternalApi();
        if (isApiHealthy) {
            return Health.up().withDetail("message", "External API is healthy").build();
        } else {
            return Health.down().withDetail("error", "External API is unreachable").build();
        }
    }

    private boolean checkExternalApi() {
        // 实现检查逻辑，比如发送 HTTP 请求
        return true; // 示例代码，实际需替换为真实逻辑
    }
}

3. 内置健康检查项

Spring Boot 提供了多种内置的健康检查项，例如：

DataSourceHealthIndicator：检查数据库连接。
DiskSpaceHealthIndicator：检查磁盘空间。
RedisHealthIndicator：检查 Redis 连接。

可以通过配置禁用某些检查项：

management.health.db.enabled=false

常见使用场景

Kubernetes 探针：
在 Kubernetes 中，可以配置 livenessProbe 和 readinessProbe 指向 /actuator/health 端点，实现容器健康状态管理。
微服务监控：
在微服务架构中，通过健康检查端点聚合所有服务的状态（如使用 Spring Cloud Gateway 或 Prometheus）。

注意事项

敏感信息暴露：
开启 show-details=always 可能会暴露内部细节，建议在生产环境中结合 Spring Security 限制访问权限。
性能影响：
健康检查的逻辑应尽量轻量，避免频繁调用外部服务或复杂计算。
自定义健康检查的异常处理：
如果自定义 HealthIndicator 抛出异常，端点会返回 DOWN 状态，需确保逻辑健壮性。

示例：整合 Spring Security 保护端点

如果项目引入了 Spring Security，可以通过以下配置限制健康检查端点的访问：

@Configuration
public class ActuatorSecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
            .antMatchers("/actuator/health").permitAll() // 允许所有人访问健康检查
            .antMatchers("/actuator/**").hasRole("ADMIN") // 其他端点仅管理员可访问
            .and().httpBasic();
    }
}

通过合理配置健康检查，可以显著提升应用的可靠性和可维护性。

自定义Starter配置

概念定义

自定义Starter是SpringBoot提供的一种模块化配置方式，允许开发者将一组相关的依赖、自动配置类和默认属性打包成一个可重用的组件。通过引入该Starter依赖，应用可以快速获得特定功能的支持，而无需手动配置大量Bean。

核心组成

自动配置类：包含@Configuration注解的类，定义需要自动创建的Bean
spring.factories文件：在META-INF目录下，声明自动配置类的全限定名
属性配置类：带有@ConfigurationProperties的类，支持外部化配置
条件注解：如@ConditionalOnClass等，控制配置的生效条件

创建步骤

1. 创建Maven项目

<project>
    <modelVersion>4.0.0modelVersion>
    <groupId>com.examplegroupId>
    <artifactId>my-spring-boot-starterartifactId>
    <version>1.0.0version>
    
    <dependencies>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-autoconfigureartifactId>
        dependency>
    dependencies>
project>

2. 编写自动配置类

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

3. 定义配置属性类

@ConfigurationProperties("my.service")
public class MyProperties {
    private String prefix = "default";
    private boolean enabled = true;
    
    // getters and setters
}

4. 注册自动配置

在src/main/resources/META-INF/下创建spring.factories文件：

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.example.MyAutoConfiguration

高级配置技巧

条件化Bean注册

@Bean
@ConditionalOnProperty(name = "my.service.cache.enabled", havingValue = "true")
public CacheManager cacheManager() {
    return new SimpleCacheManager();
}

配置顺序控制

@AutoConfigureAfter(DataSourceAutoConfiguration.class)
public class MyAutoConfiguration {
    // ...
}

使用自定义Starter

在项目中添加依赖：

<dependency>
    <groupId>com.examplegroupId>
    <artifactId>my-spring-boot-starterartifactId>
    <version>1.0.0version>
dependency>

在application.properties中配置：

my.service.prefix=custom
my.service.enabled=true

最佳实践

命名规范：遵循spring-boot-starter-{name}的命名约定
模块划分：将自动配置与核心实现分离
版本管理：保持与SpringBoot版本的兼容性
文档说明：清晰说明Starter的功能和配置项

常见问题解决

配置不生效：
- 检查spring.factories文件位置是否正确
- 确认没有@Conditional条件阻止配置加载
属性绑定失败：
- 确保属性类有正确的setter方法
- 检查属性前缀是否匹配
Bean冲突：
- 使用@ConditionalOnMissingBean避免重复创建
- 通过@AutoConfigureOrder调整加载顺序

172. SpringBoot 配置详解

一、SpringBoot 配置基础

SpringBoot 配置概述

什么是 SpringBoot 配置

主要配置方式

配置加载顺序

多环境配置

常见配置项

注意事项

示例代码

配置文件类型（properties/yml）

概念定义

使用场景

示例代码对比

Properties 示例

YAML 示例

常见误区与注意事项

高级特性

配置文件加载顺序

默认加载顺序

示例代码

1. 多环境配置示例

2. 外部配置文件覆盖示例

注意事项

SpringBoot 配置优先级规则

配置来源及优先级（从高到低）

示例验证

注意事项

代码示例

环境变量配置

什么是环境变量配置

使用场景

配置方式

1. 系统环境变量

2. SpringBoot配置文件

3. 启动参数

优先级顺序

代码中获取环境变量

最佳实践

常见问题

示例：多环境配置

命令行参数配置

概念定义

使用场景

常见格式

参数类型

示例代码

参数优先级

注意事项

高级用法

替代方案

调试技巧

配置属性来源

1. 命令行参数

2. Java 系统属性（System.getProperties()）

3. 操作系统环境变量

4. 配置文件（application-{profile}.properties/yml）

5. @Configuration 类中的 @PropertySource

6. 默认属性（SpringApplication.setDefaultProperties）

常见误区

最佳实践

配置属性继承

概念定义

使用场景

实现方式

常见误区与注意事项

示例代码

最佳实践

配置属性覆盖

概念定义

配置源优先级

使用场景

示例代码

1. 通过命令行参数覆盖

2. 通过环境变量覆盖

3. 多配置文件覆盖

常见误区与注意事项

高级用法

1. 使用 @TestPropertySource 覆盖测试配置

2. 动态覆盖属性

1. 使用 `@TestPropertySource` 覆盖测试配置

在 `application.properties` 中

在 `application.yml` 中

示例：自定义字符串到 `Endpoint` 的转换

高级用法：使用 `@ConfigurationPropertiesBinding`