SpringBoot 配置文件核心用法：Properties 与 YAML

读取配置文件

方式：使用 @Value 注解，以 ${key} 格式读取。

代码示例：

import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class PropertiesController {
    @Value("${mykey.key1}")
    private String key1;

    @RequestMapping("/key")
    public String key() {
        return "读取到值:" + key1;
    }
}

配置示例：

mykey.key1=bite

访问 /key 接口时，会返回配置文件中 mykey.key1 对应的值（如 读取到值:bite）。

@PostConstruct 核心说明

@PostConstruct 是 Java EE 中的注解（Spring 也完全支持），作用是：在 Spring 容器创建完 Bean 实例、完成依赖注入后，自动执行标注了这个注解的方法。简单说：Bean 先被创建 → 依赖注入（比如 @Autowired 注入的对象）→ @PostConstruct 方法执行。

适用场景：

• 初始化数据（比如加载配置、初始化缓存、连接第三方服务）；
• 执行 Bean 创建后的前置操作（依赖注入完成后才能执行，避免空指针）。

完整可运行示例：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;

// 普通的 Spring Bean
@Component
public class UserService {
    // 依赖注入的对象
    @Autowired
    private ConfigService configService;

    // 空参、无返回值的初始化方法
    @PostConstruct
    public void init() {
        // 此时 configService 已经完成注入，可安全使用
        String config = configService.getConfig();
        System.out.println("Bean 初始化完成，加载配置：" + config);
        // 还可以做缓存初始化、数据预加载等操作
    }
}

// 依赖的 ConfigService（示例）
@Component
class ConfigService {
    public String getConfig() {
        return "数据库连接配置：jdbc:mysql://localhost:3306/test";
    }
}

关键注意点：

1. 标注的方法必须是：无参数、无返回值（void）、非静态；
2. 执行时机：晚于 @Autowired 依赖注入，早于 Bean 被业务代码使用；
3. 替代方案：Spring 的 InitializingBean 接口（但 @PostConstruct 更简洁）。

properties 缺点分析

properties 配置是以 key-value 的形式配置的，配置文件中会有很多的冗余的信息，比如层级关系需要用点号连接。想要解决这个问题，就可以使用 yml 配置文件的格式化优势。

yml 配置文件说明

yml 是 YAML 的缩写，它的全称是 Yet Another Markup Language，翻译成中文就是'另一种标记语言'。我们先来学习 yml 的语法。

yml 基本语法

yml 是树形结构的配置文件，它的基础语法是 "key: value"。

• key 和 value 之间使用英文冒号加空格的方式组成，空格不可省略。

基础语法如下：

# 正确写法（冒号后必须带空格）
server:
  port: 8080
  host: localhost
# 错误写法（无空格，配置无法解析）
# server:port:8080

1. 基础键值对（核心语法）

见上方示例。

2. 数据类型

# 字符串（默认无需引号，特殊字符需加引号）
name: 张三
nickname: "zhangsan:001" # 包含特殊符号时加双引号
remark: 'hello\nworld' # 单引号会转义特殊字符，\n 不会换行
# 数字
age: 20
score: 98.5
# 布尔值
enabled: true
disabled: false
# 空值
empty: null
# 或 ~
# 日期（ISO 8601 格式）
birthday: 2024-03-18

3. 集合 / 数组（两种写法）

# 写法 1：短横线 + 空格（推荐，层级清晰）
user:
  hobbies:
    - 篮球
    - 游泳
    - 编程
# 写法 2：中括号简写（单行）
user:
  tags: [Java, SpringBoot, MySQL]

4. 对象 / 嵌套配置

# 多层嵌套（SpringBoot 常用）
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/test
    username: root
    password: 123456
  redis:
    host: 127.0.0.1
    port: 6379
    timeout: 5000ms

5. 注释规则

# 单行注释（仅支持单行，用 # 开头）
server:
  port: 8080 # 端口配置（行内注释也需用 #）
# 多行注释需每行加 #
# 开发环境端口
# 生产环境可改为 80

使用 yml 连接数据库

使用示例：

spring:
  datasource:
    url: jdbc:mysql://127.0.0.1:3306/dbname?characterEncoding=utf8&useSSL=false
    username: root
    password: root

yml 和 properties 连接数据库的配置对比：yml 结构更清晰，减少了重复的前缀。

yml 使用进阶

配置不同数据类型及 null

# 字符串
string.value: Hello
# 布尔值，true 或 false
boolean.value: true
boolean.value1: false
# 整数
int.value: 10
# 浮点数
float.value: 3.14159
# Null，~代表 null
null.value: ~
# "" 空字符串
empty.value: ''

yml 配置读取

yml 读取配置的方式和 properties 相同，使用 @Value 注解即可。

yml 配置：

string:
  hello: bite

Java 代码：

@RestController
public class ReadYml {
    @Value("${string.hello}")
    private String hello;

    @RequestMapping("/ymlKey")
    public String key() {
        return "读取到值:" + hello;
    }
}

访问地址：http://127.0.0.1:8080/ymlKey。运行结果页面显示：读取到值:bite。

注意事项：value 值加单双引号

字符串默认不用加上单引号或者双引号，如果加英文的单双引号可以表示特殊的含义。

尝试在 application.yml 中配置如下信息：

string:
  str1: Hello \n Spring Boot.
  str2: 'Hello \n Spring Boot.'
  str3: "Hello \n Spring Boot."

读取程序实现代码如下：

@RestController
public class ReadYml {
    @Value("${string.str1}")
    private String str1;
    @Value("${string.str2}")
    private String str2;
    @Value("${string.str3}")
    private String str3;

    @RequestMapping("/yml")
    public String readYml() {
        System.out.println(str1);
        System.out.println(str2);
        System.out.println(str3);
        return "yml";
    }
}

以上程序的执行结果如下：

Hello \n Spring Boot.
Hello \n Spring Boot.
Hello Spring Boot.

从上述结果可以看出：

• 字符串默认不用加上单引号或者双引号。
• 单引号会转义特殊字符，使其失去特殊功能，始终是一个普通的字符串。
• 双引号不会转义字符串里面的特殊字符，特殊字符会表示本身的含义。

\n 本意表示的是换行：

• 使用单引号会转义，\n 不再表示换行，而是表示一个普通的字符串。
• 使用双引号不会转义，\n 表示的是它本身的含义，就是换行。

配置对象

我们还可以在 yml 中配置对象，如下配置：

student:
  id: 1
  name: Java
  age: 18

或者是使用行内写法（与上面的写法作用一致）：

student: {id: 1, name: Java, age: 18}

这个时候就不能用 @Value 来读取配置中的对象了，此时要使用另一个注解 @ConfigurationProperties 来读取。

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

@ConfigurationProperties(prefix = "student")
@Component
@Data
public class Student {
    private int id;
    private String name;
    private int age;
}

调用类的实现如下：

@RestController
public class StudentController {
    @Autowired
    private Student student;

    @RequestMapping("/readStudent")
    public String readStudent() {
        return student.toString();
    }
}

访问地址：http://127.0.0.1:8080/readStudent。

配置集合

配置文件也可以配置 list 集合，如下所示：

dbtypes:
  name:
    - mysql
    - sqlserver
    - db2

集合的读取和对象一样，也是使用 @ConfigurationProperties 来读取的。

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
import java.util.List;

@Component
@ConfigurationProperties("dbtypes")
@Data
public class ListConfig {
    private List<String> name;
}

访问集合的实现如下：

@RestController
public class ReadYml2 {
    @Autowired
    private ListConfig listConfig;

    @RequestMapping("/readList")
    public String readList() {
        return listConfig.toString();
    }
}

配置 Map

配置文件也可以配置 map，如下所示：

maptypes:
  map:
    k1: kk1
    k2: kk2
    k3: kk3

或者是使用行内写法（与上面的写法作用一致）：

maptypes: {map: {k1: kk1, k2: kk2, k3: kk3}}

Map 的读取和对象一样，也是使用 @ConfigurationProperties 来读取的。

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
import java.util.HashMap;

@Component
@ConfigurationProperties("maptypes")
@Data
public class MapConfig {
    private HashMap<String, String> map;
}

打印类的实现：

@RestController
public class ReadYml2 {
    @Autowired
    private MapConfig mapConfig;

    @RequestMapping("/readMap")
    public String readStudent() {
        return mapConfig.toString();
    }
}

yml 优缺点

优点

1. 可读性高，写法简单，易于理解
2. 支持更多的数据类型，可以简单表达对象、数组、List、Map 等数据形态
3. 支持更多的编程语言，不止是 Java 中可以使用，在 Golang、Python、Ruby、JavaScript 中也可以使用

缺点

1. 不适合写复杂的配置文件 转换的过程也比较花费精力，如果配置更复杂一点，可读性会更差，代码也会更难写
2. 对格式有较强的要求（一个空格可能会引起一场血案）

转换为 yml 示例：

keycloak:
  realm: demo
  resource: fm-cache-cloud
  credentials:
    secret: d4589683-0ce7-4982-bcd3
  security:
    - authRoles:
        - user
      collections:
        - name: ssologinurl
          patterns:
            - /login/*

比如 properties 格式如下：

keycloak.realm=demo
keycloak.resource=fm-cache-cloud
keycloak.credentials.secret=d4589683-0ce7-4982-bcd3
keycloak.security[0].authRoles[0]=user
keycloak.security[0].collections[0].name=ssologinurl
keycloak.security[0].collections[0].patterns[0]=/login/*