一、SpringBoot配置文件

1. SpringBoot默认配置文件

• SpringBoot使用默认的全局的配置文件：application.properties/application.yml
• 配置文件名固定是是application

`application.properties`
	语法结构: key=value

`application.yml`
	语法结构: key：空格 value

点击查看配置文件详情

# 应用服务配置
server:
  port: 8080 # 应用监听端口
  servlet:
    context-path: /app # 应用基础访问路径前缀

# MySQL数据库连接配置（适用于MySQL 8）
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver # MySQL 8驱动类
    url: jdbc:mysql://localhost:3306/mydb?useSSL=false&characterEncoding=utf8&serverTimezone=UTC # 数据库URL
    username: your_username # 数据库用户名
    password: your_password # 数据库密码

# MySQL数据库连接配置（适用于MySQL 5.7）
spring:
  datasource:
    driver-class-name: com.mysql.jdbc.Driver # MySQL 5.7驱动类
    url: jdbc:mysql://localhost:3306/mydb?useSSL=false&characterEncoding=utf8&useLegacyDatetimeCode=false&serverTimezone=UTC # 数据库URL
    username: your_username # 数据库用户名
    password: your_password # 数据库密码

# 日志配置
logging:
  level:
    root: info # 全局日志级别
  pattern:
    console: "%d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{50} - %msg%n" # 控制台日志格式

# MyBatis配置
mybatis:
  mapper-locations: classpath:/mapper/*.xml # Mapper文件位置
  type-aliases-package: com.example.model # 实体类别名包路径

# MyBatis Plus配置
mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl # SQL日志实现

# Redis配置
spring:
  redis:
    host: localhost # Redis服务地址
    port: 6379 # Redis服务端口
    password: your_password # Redis密码
    jedis:
      pool:
        max-active: 8 # 连接池最大连接数
        max-idle: 8 # 连接池中的最大空闲连接
        min-idle: 0 # 连接池中的最小空闲连接

# RabbitMQ配置
  rabbitmq:
    host: localhost # RabbitMQ服务地址
    port: 5672 # RabbitMQ服务端口
    username: guest # RabbitMQ用户名
    password: guest # RabbitMQ密码

# Elasticsearch配置
  elasticsearch:
    rest:
      uris: http://localhost:9200 # Elasticsearch服务地址

# 邮箱配置
  mail:
    host: smtp.example.com # 邮件服务器地址
    username: your_email@example.com # 邮箱用户名
    password: your_password # 邮箱密码
    properties:
      mail:
        smtp:
          auth: true
          starttls:
            enable: true # 开启STARTTLS安全连接

# 文件上传大小限制配置
  servlet:
    multipart:
      max-file-size: 10MB # 单个文件最大大小
      max-request-size: 100MB # 请求的最大大小

2. 配置文件的作用

SpringBoot在底层给我们自动做了一些配置，所以springboot项目不编写配置文件也可以正常运行，但是根据我们的具体开发我们需要修改SpringBoot自动配置的默认值；

比如我们可以更改默认启动的端口号

在application.properties中添加

#更改项目端口号
server.port=8081

然后重新启动，可以看到启动的端口号变更 然后访问localhost:8081即可

3. 配置文件的位置

springboot启动会扫描以下位置的application.properties/application.yml文件作为其默认配置文件：

1. 项目路径下的config文件夹：此位置的配置文件拥有最高优先级。
2. 项目根路径：位于config文件夹外的项目根路径下的配置文件优先级略低。
3. 资源（resources）路径下的config文件夹：资源目录下的config文件夹中的配置文件优先级位于第三。
4. 资源（resources）路径下：资源目录下直接放置的配置文件优先级最低。

可以发现：springboot项目生成时的默认配置文件优先级是最低的

• 优先级由高到底，高优先级的配置会覆盖低优先级的配置；
• SpringBoot会从这四个位置全部加载主配置文件；互补配置；

在资源（resources）路径下添加properties和yaml两个配置文件，添加以下代码测试

# application.properties配置项目的上下文路径
server.servlet.context-path=/zsr

# application.yml配置项目的上下文路径和端口
server:
  servlet:
    context-path: /zzz #配置项目的访问路径
  port: 8081 #配置端口号

然后启动项目测试，可以看到，最终配置的项目上下文路径是/zsr，且访问端口为8081 因此：当两个配置文件同时存在的时候，相同的配置会优先加载properties配置文件，对于那些只出现在其中一个配置文件中的“多余的”配置项，Spring Boot会采用一种互补的方式来处理，即这些配置项仍然会生效。

4. 多环境切换

在实际的项目开发中，一个项目通常会存在多个环境，例如，开发环境、测试环境和生产环境等。不同环境的配置也不尽相同，例如开发环境使用的是开发数据库，测试环境使用的是测试数据库，而生产环境使用的是线上的正式数据库。

Profile 为在不同环境下使用不同的配置提供了支持，我们可以通过激活、指定参数等方式快速切换环境。

方式一：多配置文件

Spring Boot 的配置文件共有两种形式：.properties 文件和 .yml 文件，不管哪种形式，它们都能通过文件名的命名形式区分出不同的环境的配置，文件命名格式为：

application-{profile}.properties/yml

其中，{profile} 一般为各个环境的名称或简称，例如 dev、test 和 prod 等等，这个根据自己的场景来定义。

我们再编写配置文件时，文件名可以是application-{profile}.properties/yml，用来指定多个不同的环境版本；

application.properties 代表主环境

# /src/main/resources/application.properties
server.port=8080

application-test.properties 代表测试环境配置

# /src/main/resources/application-test.properties
server.port=8081

application-dev.properties 代表开发环境配置

# /src/main/resources/application-dev.properties
server.port=8082

当我们运行测试时，如果未加指定，它默认使用application.properties主配置文件；

实际开发中，面对不同的环境，我们可以在默认配置文件application,properties中指定所需的配置文件环境，例如以下指定使用dev的配置文件：

# /src/main/resources/application.properties
server.port=8080
spring.profiles.active=dev

此后再启动SpringBoot，就可以看到已经切换到dev下的配置环境；

YAML格式亦是如此

方式二：一个配置文件（yaml的多文档块）

1. 环境分隔：最常见的用法是环境配置分隔，如开发、测试、生产环境的配置。使用---可以在一个文件中定义所有环境的配置，通过设置spring.profiles.active来选择激活哪一套配置。
2. 配置组织：在一些情况下，即使是同一环境中，也可能因为配置项繁多而需要逻辑上的分割，使用---可以帮助组织和区分这些配置，虽然这些配置仍然属于同一环境。
3. 可读性与维护性：对于一些较长的YAML文件，使用---分隔不同部分，可以提高文件的可读性。团队成员可以快速定位到文件的特定部分，而不需要滚动查看大量的内容。

server:  
	port: 8080
#选择要激活那个环境块
spring:  
	profiles:    
		active: prod
		
---
server:  
	port: 8081
spring:  
	profiles: dev #配置环境名称dev

---
server:  
	port: 8082
spring:  
	profiles: prod  #配置环境名称prod

注意：

如果yml和 properties的配置文件同时存在，同时都配置了端口，但是yaml多环境没有指定环境，默认会使用properties配置文件的！

5. @Profile 注解

当配置了环境变量，那么就对应的环境变量配置文件就会生效，这是针对变量而言，此外我们可以指定哪些组件在什么环境才允许被加载到 Spring 容器里。

比如指定某个组件只有在 dev 环境才被加载到容器里，如：

@Profile("dev")
@RestController
public class HelloController {

    @GetMapping("/hello")
    public String hello() {
        return "Hello Spring Boot";
    }
}

此时该容器在 dev 环境才会注入到容器里，也就是处于其他环境，访问 /hello 是失效的。

总结

任何@Component, @Configuration 或 @ConfigurationProperties 都可以使用 @Profile 标记，来指定何时被加载。【容器中的组件都可以被 @Profile标记】

6. 外部化配置

场景：线上应用如何 快速修改配置，并应 用最新配置？

• SpringBoot 使用 配置优先级 + 外部配置 简化配置更新、简化运维。
• 只需要给 jar 应用所在的文件夹放一个 application.yml 最新配置文件，重启项目就能自动应用最新配置

Spring Boot 允许将 配置外部化，以便可以在不同的环境中使用相同的应用程序代码。

我们可以使用各种 外部配置源，包括 Java Properties 文件、YAML 文件、环境变量和命令行参数。

@Value 可以获取值，也可以用 @ConfigurationProperties 将所有属性绑定到 java object 中。

以下是 SpringBoot 属性源加载顺序。后面的会覆盖前面的值。由低到高，高优先级配置覆盖低优先级：

1. 默认属性（通过 SpringApplication.setDefaultProperties 指定的）
2. @PropertySource 指定加载的配置（需要写在 @Configuration 类上才可生效）
3. 配置文件（application.properties/yml 等）
4. RandomValuePropertySource 支持的 random.* 配置（如：@Value("${random.int}")）
5. OS 环境变量
6. Java 系统属性（System.getProperties()）
7. JNDI 属性（来自 java:comp/env）
8. ServletContext 初始化参数
9. ServletConfig 初始化参数
10. SPRING_APPLICATION_JSON 属性（内置在环境变量或系统属性中的 JSON）
11. 命令行参数
12. 测试属性。(@SpringBootTest 进行测试时指定的属性)
13. 测试类 @TestPropertySource 注解
14. Devtools 设置的全局属性。($HOME/.config/spring-boot)

结论：配置可以写到很多位置，常见的优先级顺序：命令行 > 配置文件 > springapplication 配置。

---

二、YAML配置注入

当我们新建一个项目Springboot项目时，默认使用properties格式的配置文件，其实SpringBoot还支持yaml格式的配置文件，且这是最流行，最为广泛使用的

1. YAML入门

1、什么是YAML？

YAML 有两种展开方式：

• YAML Ain't a Markup Language：YAML 不是一种标记语言
• Yet Another Markup Language：YAML是一种标记语言

之所以用反向缩略语重命名，是为了强调 YAML以数据做为中心，而不是以标记语言为重点

功能：

• YAML的语法和其他高级语言类似，并且可以简单表达清单、散列表，标量等数据形态。
• 它使用空白符号缩进和大量依赖外观的特色，特别适合用来表达或编辑数据结构、各种配置文件、倾印调试内容、文件大纲（例如：许多电子邮件标题格式和YAML非常接近）

2、对比传统标记语言

以前的配置文件，大多数都是使用 XML 来配置；YAML 作为一种比 XML 更为简单易读的序列化语言，正越来越多地被用于应用及配置文件的开发中

比如一个简单的端口配置，我们来对比下yaml和xml：

<!--传统xml配置-->
<server>
    <port>8081<port>
</server>

#YAML配置
server：
  prot: 8080

简单的一个对比就可以看出：YAML可读性好，易于实现

不仅如此，YAML还有很多其他有点：

• YAML和脚本语言的交互性好
• YAML使用实现语言的数据类型
• YAML有一个一致的信息模型
• YAML可以基于流来处理
• YAML表达能力强，扩展性好

总之，YAML试图用一种比XML更敏捷的方式，来完成XML所完成的任务

3、基本语法

• 大小写敏感
• 使用缩进表示层级关系
• 缩进不允许使用tab，只允许空格
• 缩进的空格数不重要，只要相同层级的元素左对齐即可
• #表示注释

4、数据类型

YAML 支持以下几种数据类型：

• 对象：键值对的集合，又称为映射（mapping）/ 哈希（hashes） / 字典（dictionary）
• 数组：一组按次序排列的值，又称为序列（sequence） / 列表（list）
• 纯量（scalars）：单个的、不可再分的值

对象

对象键值对使用冒号结构表示 key: value，冒号后面要加一个空格。

password: 123456

对象的行内写法：

User: {name: zsr,age: 20}

还可以使用缩进表示层级关系：

User:
  name: zsr
  age: 20

数组

用 - 值表示数组中的一个元素，比如：

pets:
 - cat
 - dog
 - pig

行内格式：使用[]括号，并用逗号分隔每个元素。这种格式适合表示简单或较短的数组，比如：

pets: [cat,dog,pig]

数组中的复杂对象：当数组的元素是复杂对象时，可以在-符号下面缩进一个空格并列出对象的属性，比如：

companies:
    -
        id: 1
        name: company1
        price: 200W
    -
        id: 2
        name: company2
        price: 500W

意思是 companies 属性是一个数组，每一个数组元素又是由 id、name、price 三个属性构成。

数组也可以使用流式(flow)的方式表示：

companies: [{id: 1,name: company1,price: 200W},{id: 2,name: company2,price: 500W}]

纯量

纯量是最基本的，不可再分的值，包括：

• 字符串
• 布尔值
• 整数
• 浮点数
• Null
• 时间
• 日期

纯量直接写在后面就可以，字符串默认不用加上双引号或者单引号；

key: value

当字符串中包含某些特殊字符或格式需求时，我们可能会用上单引号或者双引号：

• 双引号" "：在双引号中，特殊字符（如换行符\n、制表符\t等）会被解析成它们实际的字符意义。这意味着，你可以在双引号包围的字符串中使用转义字符来表达特殊的格式需求

# 使用双引号
name: "kuang \n shen"
# 输出结果为：
kuang
shen

• 单引号' '：单引号中的内容会被当作字面量处理，即所有的特殊字符包括转义字符（如\n）都会作为普通文本字符输出，不会被解析为其特殊的意义。

# 使用单引号
name: 'kuang \n shen'
# 输出结果为：
kuang \n shen

使用一个例子来快速了解纯量的基本使用：

boolean: 
    - TRUE  #true,True都可以
    - FALSE  #false，False都可以
float:
    - 3.14
    - 6.8523015e+5  #可以使用科学计数法
int:
    - 123
    - 0b1010_0111_0100_1010_1110    #二进制表示
null:
    nodeName: 'node'
    parent: ~  #使用~表示null
string:
    - 哈哈
    - 'Hello world'  #可以使用双引号或者单引号包裹特殊字符
    - newline
      newline2    #字符串可以拆成多行,每一行会被转化成一个空格
date:
    - 2018-02-17    #日期必须使用ISO 8601格式,即yyyy-MM-dd
datetime: 
    -  2018-02-17T15:02:31+08:00    #时间使用ISO 8601格式,时和日期之间使用T连接,最后使用+代表时区

2. SpringBoot——yaml注入配置文件

1、批量读取配置文件(@ConfigurationProperties)

yaml文件更强大的地方在于，他可以配置读取配置文件给我们的实体类直接注入匹配值！

1. 编写一个实体类 Dog

在主程序同级目录下新建pojo包，在包下新建一个Dog实体类

package com.zsr.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.stereotype.Component;

@Data
@AllArgsConstructor//有参构造
@NoArgsConstructor//无参构造
@Component//注册bean到容器中
public class Dog {
    private String name;
    private Integer age;
}

2. 编写一个Person实体类

Person类，包含所有常见数据类型，以及Dog对象

@Data
@AllArgsConstructor
@NoArgsConstructor
@Component //注册bean到容器中
public class Person {
    private String name;
    private Integer age;
    private Boolean happy;
    private Date birth;
    private Map<String, Object> maps;
    private List<Object> lists;
    private Dog dog; // 实体对象属性
}

3. 编写yaml配置文件

在springboot项目中的resources目录下新建一个文件 application.yml，使用yaml配置的方式进行注入

person:
  name: zsr
  age: 20
  happy: True
  birth: 2000/02/04
  maps: {k1: v1,k2: v2}
  lists:
    - guitar
    - sing
    - play
  dog:
    name: 多多
    age: 4

4. yaml配置注入

刚才已经把person对象的所有属性值都写好了，再通过@ConfigurationProperties注解注入到我们的类中，

/*
@ConfigurationProperties作用：
	将配置文件中配置的每一个属性的值，映射到这个组件中；
	告诉SpringBoot将本类中的所有属性和配置文件中相关的配置进行绑定
	参数 prefix = “person” : 将配置文件中的person下面的所有属性一一对应
*/
@Component //注册bean
@ConfigurationProperties(prefix = "person")
public class Person {
    private String name;
    private Integer age;
    private Boolean happy;
    private Date birth;
    private Map<String,Object> maps;
    private List<Object> lists;
    private Dog dog;
}

IDEA爆红提示：springboot配置注解处理器没有找到，我们点击Open Document查看文档

发现未找到，我们降低版本为2.1.9即可：官方网址 (opens new window)

进入到网页中，可以找到一个依赖，加上他，就不会爆红提示

<!-- 导入配置文件处理器-->
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-configuration-processor</artifactId>
	<optional>true</optional>
</dependency>

5. 测试

配置完成后，我们修改测试类进行测试

package com.zsr;

import com.zsr.pojo.Dog;
import com.zsr.pojo.Person;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class Springboot02ConfigApplicationTests {
    @Autowired //将person自动注入进来
    private Person person;

    @Test
    void contextLoads() {
        System.out.println(person); //打印看下person对象
    }
}

结果：所有值全部注入成功！yaml配置成功注入到实体类！

2、yaml配置文件占位符

在YAML中，你可以使用${...}语法来引用配置文件内或环境变量中已定义的值。这使得你可以在不同配置值之间建立关系，或者根据环境变量动态设置配置。

person:
  name: zsr${random.uuid} # 使用${random.uuid}生成一个随机的UUID字符串
  age: ${random.int}      # 使用${random.int}生成一个随机的整数
  happy: true
  birth: 2000/02/04
  maps: {k1: v1, k2: v2}
  lists:
    - guitar
    - sing
    - play
  dog:
    name: ${person.hello:other}_多多 # 引用其他配置值，如果未定义person.hello，则使用默认值other
    age: 4

然后运行测试：

3、@Value注解

@Value注解用于将一个值注入到bean的字段中。 这个值可以是硬编码的字符串，也可以是从配置文件中解析出来的。例如，@Value(“${property.name (opens new window)}”)会读取配置文件中名为property.name的属性值。

@Component
public class MyComponent {
    @Value("${my.property}")
    private String myProperty;
    // @Value注解用于注入配置属性值，从配置文件中读取my.property的值
}

4、加载指定的配置文件(@PropertySource)

以上我们通过@configurationProperties注解默认从全局配置文件中获取值

• 此时配置文件名必须为application才能被spring认出
• 其实我们可以通过@PropertySource指定加载的配置文件，可以自定义文件名

1、首先我们去在resources目录下新建一个person.properties文件，并添加一些配置：

name=zsr
age=20
happy=True
birth=2000/02/04
lists=guitar,sing,play

2、在实体类Person中使用@PropertySource注解指定加载person.properties文件，并通过@Value注解将配置文件中的属性值注入到相应的字段中：

package com.zsr.pojo;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.PropertySource;
import org.springframework.stereotype.Component;
import java.util.Date;
import java.util.List;
import java.util.Map;

@Component // 注册Bean到Spring容器中
@PropertySource(value = "classpath:person.properties") // 指定加载的配置文件
public class Person {
    @Value("${name}") // 使用SPEL表达式从配置文件中取值
    private String name;
    @Value("${age}")
    private Integer age;
    @Value("${happy}")
    private Boolean happy;
    @Value("${birth}")
    private Date birth;
    private Map<String, Object> maps; // 注意：Properties文件不支持复杂类型如Map
    @Value("#{'${lists}'.split(',')}") // 将字符串按逗号分割转换为List
    private List<Object> lists;
    private Dog dog; // 注意：Properties文件不能直接存储对象
}

3、编写一个测试类来验证是否成功加载了指定的配置文件，并注入了配置值：

package com.zsr;

import com.zsr.pojo.Person;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class Springboot02ConfigApplicationTests {
    @Autowired // 自动注入Person对象
    private Person person;
    
    @Test
    void contextLoads() {
        System.out.println(person); // 打印Person对象查看配置是否注入成功
    }
}

4、运行测试

指定配置文件绑定成功！

3. 测试@Value注入

1、新建一个实体类User

package com.zsr.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.stereotype.Component;

@Component
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private String name;
    private int age;
    private String sex;
}

2、编辑配置文件 user.properties

name=zsr

3、我们在User类上使用@Value来进行注入！

package com.zsr.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.context.annotation.PropertySource;
import org.springframework.stereotype.Component;
import org.springframework.beans.factory.annotation.Value;

@Component
@Data
@AllArgsConstructor
@NoArgsConstructor
@PropertySource(value = "classpath:user.properties")
public class User {
    //直接使用@value()
    @Value("${user.name}")//从配置文件中取值
    private String name;
    @Value("#{9*2}")//SPEL表达式:@Value("#{表达式}")
    private int age;
    @Value("男") //纯量
    private String sex;
}

4、Springboot测试类测试

package com.zsr;

import com.zsr.pojo.Person;
import com.zsr.pojo.User;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class Springboot02ConfigApplicationTests {

    @Autowired //将user自动注入进来
    private User user;

    @Test
    void contextLoads() {
        System.out.println(user); //打印看下person对象
    }

}

结果正常输出：

5. 对比小结

特性	@ConfigurationProperties	@Value
声明位置	通常在类级别使用，一次性绑定多个相关属性	用于字段级别，每个字段需要单独声明
松散绑定	支持（如lastName和last-name可以自动映射到同一个属性）	不支持（需要精确匹配属性名）
JSR303数据校验	支持（可以在类上使用校验注解保证数据合法性）	不支持（无法直接应用JSR303校验注解）
复杂类型封装	支持（可以直接绑定对象、列表等复杂类型）	不支持（主要用于简单类型的值注入）
使用场景	适用于批量绑定配置属性，特别是复杂类型的配置	适用于单个或少量配置值的注入，特别是当需要从环境变量或系统属性中读取时

• @ConfigurationProperties注解提供了一种类型安全的方式来加载配置属性，尤其适合于管理多个相关的配置属性和复杂的配置结构。它的松散绑定特性和对JSR303数据校验的支持使得配置更加灵活和健壮。
• 相比之下，@Value注解更适合于注入单个配置值的场景，尤其是当值来自于表达式或环境变量时。它的使用更为简单直接，但在处理复杂类型或需要进行属性级别校验的情况下不如@ConfigurationProperties方便。

最佳实践：

• 配置 yaml 和配置 properties 都可以获取到值时，首荐 yaml；
• 如果在某个业务中，只需要获取配置文件中的某个值，可以使用一下@value
• 如果有编写的JavaBean来和配置文件进行一一映射，就直接@configurationProperties