8. Spring Boot 配置文件

源码地址：SpringBoot_demo

本篇文章内容源码位于上述地址的com/chenshu/springboot_demo/config包下

1. 配置文件是什么

上节说到，Spring Boot的项目分为三个部分：源代码目录、资源目录、单元测试目录。

而配置文件的位置就位于资源目录resources的第一级，名为application.properties，可见配置文件于Spring Boot项目的重要性：

上一篇文章提到了Spring Boot约定大于配置的思想，这里就能够体现：它的命名只能是application.xxx。

2. 配置文件的作用

整个项目中所有重要的数据都是在配置文件中配置的，比如：

• 项目的启动端口：过去所有项目都是在一个本地Tomcat的配置文件中所配置的端口号，通过Context Path区分项目，如今由于内置的Tomcat，只要通过配置文件的配置就可以设定项目的启动端口号；
• 数据库的连接信息（包含用户名和密码的设置）：过去要以代码的形式连接数据库，在Spring Boot时代只要简单的几句配置语句就可以完成；
• 日志信息配置：如日志持久化等

3. 配置文件的两种格式

配置文件主要分为以下两种格式：

• .properties
• .yml

3.1 语法差别

以配置项目的启动端口号为例：

(1) properties语法

它的语法特别简单，也就是"键"=“值”

server.port=8080
1

观察一下它的键"server.port"，类似于java中导包时用来区分不同的包下的类（把server看成包，把port看作类）

---

(2) yml语法

该格式可以说是properties格式的升级，yml格式则是更改了键的形式，键的级别之间用':' + '\n' + '\t'分割，值和键之间必须用':' + '空格'分割

server:
  port: 8081
1
2

3.2 读取顺序

两种格式的配置文件可以共存在一个项目中，当一个项目有两种格式的配置文件的时候，会先去读取application.properties文件，再去读取application.yml文件，前者的优先级最高。也就是说两个文件中都配置了"server.port"这一个键的话，那么会以.properties中的配置为主

server.port=8888
1

server:
  port: 9999
1
2

但是实际开发中通常会使用统一的配置文件格式，这样可以更方便的维护。

4. application.properties编码问题

4.1 问题描述

在application.properties和application.yml中都可以通过'#'来写注解：

# 设置端口号
server.port=8888
1
2

但是在application.properties默认是以ISO-8859-1来编码的，而idea默认是以utf-8来解码的，有中文的情况下，如果关闭了项目下次再打开就会变成乱码：

关闭idea，并重新打开该项目：

4.2 解决方案

1、关闭项目

2、更改所有设置

3、更改.properties的编码方式

4、点击Apply+OK，这样设置完之后的项目的properties文件就都是以utf-8来编码的了，当前项目的话还需自己手动打开当前项目的设置，其他步骤和上述一样：

5. 常用配置内容

这里使用yaml的格式，简单看看，后续都会用到：

# 配置启动端口号
server:
  port: 9999
# 配置数据库的连接字符串
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/blog_system?characterEncoding=utf8&useSSL=false
    username: root
    password: root
    driver-class-name: com.mysql.jdbc.Driver
# 配置日志输出信息
logging:
  level:
    com:
      example:
        demo: debug
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

更多配置点这：Spring Boot 各种配置项

6. 读取配置文件的信息

配置文件内容分类：

1. Spring Boot 内置的配置项目，比如server.port
2. 用户自定义的配置项

我们可以自行定义配置项（下面用properties来定义，yml同理）：

# 用户自定义配置项
mykey.key1=chenshu
1
2

读取配置文件中的值：

想要读取配置文件中的值，需要在类的字段上添加一个@Value注解，@Value注解中的参数必须要使用${}将键包裹起来，如读取键为mykey.key1的值就这样写：@Value("${mykey.key1}")

@RestController
public class TestController {
    //读取配置文件中的值
    @Value("${mykey.key1}")
    private String myKey;

    //配置路由
    @RequestMapping("/getkey")
    public String getMyKey() {
        return myKey;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

浏览器中搜索该方法的路由：

7. yml 配置文件说明

yml是YAML的缩写，全称为Yet Another Markup Language（另一种标记语言）

在开发中更推荐使用yml，举个例子：

application.properties有下面配置：

# 数据库的连接配置
# 数据库的url
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/druid_test?characterEncoding=utf8
# 数据库username
spring.datasource.username=root
#数据库password
spring.datasource.password=root
1
2
3
4
5
6
7

在application.yml中是下面这样：

spring:
  datasource:
    url: jdbc:mysql://127.0.0.1:3306/druid_test?characterEncoding=utf8
    username: root
    password: root
1
2
3
4
5

7.1 优点分析

1. yml消除更多冗余信息，properties每次都要重新写spring.datasource
2. yml能更直观的区分配置文件的层级结构
3. yml 支持更多的数据类型，它可以简单表达清单(数组)、散列表，标量等数据形态。它使用空白符号缩进和大量依赖外观的特色，特别适合用来表达或编辑数据结构、各种配置文件等。
4. yml支持更多的编程语言，它不止是Java 中可以使用在 Golang、PHP、Python、Ruby、JavaScript、Perl中。

7.2 yml字符串修饰符问题

• 当不使用任何字符串修饰符的情况下，会将原生的值赋值给变量
• 当使用单引号来修饰的情况下，会将原生的值赋值给变量
• 当使用双引号来修饰的情况下，那么value值中的特殊字符就会发挥自身的用途，比如"\n"就会实现换行的效果

配置文件：

mykey:
  key1: I am \n Chenshu
  key2: 'I am \n Chenshu'
  key3: "I am \n Chenshu"
1
2
3
4

测试代码：

@RestController
public class TestController {

    @Value("${mykey.key1}")
    private String myKey1;

    @Value("${mykey.key2}")
    private String myKey2;

    @Value("${mykey.key3}")
    private String myKey3;

    //配置路由
    @RequestMapping("/getkey")
    public void getMyKey() {
        System.out.println(myKey1);
        System.out.println(myKey2);
        System.out.println(myKey3);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

输出结果：

I am \n Chenshu
I am \n Chenshu
I am 
 Chenshu
1
2
3
4

7.3 通过yml配置对象属性

yml配置对象属性支持两种写法：

原始写法：

User:
  id: 1
  name: zhangsan
  age: 20
1
2
3
4

行内写法：

User: {id: 1, name: zhangsan, age: 20}
1

1. 编写一个model类：

public class User {
    private int id;
    private String name;
    private int age;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    
    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + ''' +
                ", age=" + age +
                '}';
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

2. 在model上添加注解：
   在添加@Component的基础上，还要添加@ConfigurationProperties(prefix = "user")：

@Component
@ConfigurationProperties(prefix = "user")
public class User {
1
2
3

3. 在TestController中注入依赖：

@Autowired
private User user;
1
2

4. 编写路由方法，返回配置文件中获取的对象的值：

@RequestMapping("/getuser")
public String getUser() {
    return "Hi, " + user;
}
1
2
3
4

5. 访问对应路由：

注意事项：

1. @ConfigurationProperties(prefix = "user")，表示从配置文件中读取键为"user"的对象，将对象中的字段赋值给Bean，其实就跟传统的Spring中的通过配置文件的setter属性注入是一样的，该注解必须要有setter方法，通过setter方法注入值，否则会报错，把setAge()屏蔽后启动项目会失败：
2. 必须绑定五大类注解使用，因为 @ConfigurationProperties(prefix = "user")的作用只是赋值，setter()方法使用的前提是有这个对象。

Property: user.age
    Value: "20"
    Origin: class path resource [application.yml] - 15:36
    Reason: java.lang.IllegalStateException: No setter found for property: age
1
2
3
4

7.4 通过yml配置集合

7.3讲到的配置对象属性只能配置基本类型，如int，String等，其实配置集合也是配置对象属性的一种，不过属性由基本类型变成了list集合，yml配置list集合同样支持两种写法：

原始写法：

dbtypes:
  name:
    - mysql
    - sqlserver
    - sqlite
1
2
3
4
5

行内写法：

dbtypes: {name: [mysql,sqlserver,sqlite]}
1

1. 编写一个model类（这次我们直接加上来自Lombok的@Data注解，作用是省去了编写setter、getter以及toString方法）：

@Data
public class DBTypes {
    private List name;
}
1
2
3
4

2. 在model上添加注解：
   在添加@Component的基础上，还要添加@ConfigurationProperties(prefix = "dbtypes")：

@Data
@Component
@ConfigurationProperties(prefix = "dbtypes")
public class DBTypes {
    private List name;
}
1
2
3
4
5
6

3. 在TestController中注入依赖：

@Autowired
private DBTypes dbTypes;
1
2

4. 编写路由方法，返回配置文件中获取的对象的值：

@RequestMapping("/getdb")
public String getDBTypes() {
    return "Hi, " + dbTypes;
}
1
2
3
4

5. 访问对应路由：

8. 多环境的配置文件设置

在实际开发中涉及到多环境的开发，如：

• 开发环境的配置文件
• 测试环境的配置文件
• 生产环境的配置文件

而不同环境需要使用不同的配置文件设置（如不同的环境需要连接不同的数据库），通过多环境的配置文件设置，就不用再通过单一的配置文件改来改去了。

Spring Boot的约定大于配置，它们的命名也是有约定的，命名方式为：application-xxx.yml（其中只有xxx是可以修改的）

我在resources目录下新增了这三个配置文件，分别代表三种开发环境：

• 开发环境：application-dev.yml
• 测试环境：application-test.yml
• 生产环境：application-prod.yml

这里我们把application.properties文件给忽视掉，resources目录下只有四个配置文件，此时application.yml是主配置文件

我在三种环境的配置文件中分别设置了启动端口为：8001、8002、8003，并且连接了不同的数据库：

application-dev.yml:

# 开发环境的配置文件
server:
  port: 8001

spring:
  datasource:
    url: jdbc:mysql://127.0.0.1:3306/dev?characterEncoding=utf8
    username: root
    password: root
1
2
3
4
5
6
7
8
9

application-test.yml:

# 测试环境的配置文件
server:
  port: 8002

spring:
  datasource:
    url: jdbc:mysql://127.0.0.1:3306/test?characterEncoding=utf8
    username: root
    password: root
1
2
3
4
5
6
7
8
9

application-prod.yml：

# 生产环境的配置文件
server:
  port: 8003

spring:
  datasource:
    url: jdbc:mysql://127.0.0.1:3306/prod?characterEncoding=utf8
    username: root
    password: root
1
2
3
4
5
6
7
8
9

然后在主配置环境中设置运行环境为开发环境，这样Spring Boot项目在读配置文件的时候会读取主配置文件+设置的运行环境的配置文件的内容：

application.yml：

# 运行环境设置
spring:
  profiles:
    active: dev
1
2
3
4

发现确实是以application-dev.yml的配置文件中设置的启动端口号启动项目：

总结：在实际开发中可以把公共的配置写在主配置文件application.yml中，不同开发环境下需要不同的设置再分别写入application-xxx.yml中，并且在主配置文件中设置相应的运行环境，以实现多环境的配置文件设置。