SpringBoot: 配置文件及自动配置原理

6、 springboot配置文件及自动配置原理

6.1、 配置文件

SpringBoot使用一个全局的配置文件 ， 配置文件名称是固定的

• application.properties
  语法结构 ： key=value

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

配置文件的作用 ：修改SpringBoot自动配置的默认值，因为SpringBoot在底层都给我们自动配置好了；

6.2、YAML

YAML是 “YAML Ain’t a Markup Language” （YAML不是一种置标语言）的递归缩写。在开发的这种语言时，YAML 的意思其实是：“Yet Another Markup Language”（仍是一种置标语言）

• YAML A Markup Language ：是一个标记语言
• YAML isnot Markup Language ：不是一个标记语言

标记语言

以前的配置文件，大多数都是使用xml来配置；比如一个简单的端口配置，我们来对比下yaml和xml

yaml配置：

server：
    prot: 8080

xml配置：

<server>
    <port>8081<port>
server>

1. YAML语法

基础语法：

k:(空格) v  

以此来表示一对键值对（空格不能省略）；以空格的缩进来控制层级关系，只要是左边对齐的一列数据都是同一个层级的。

注意 ：属性和值的大小写都是十分敏感的。例子：

server:
    port: 8081
    path: /hello

2. 值的写法

字面量：普通的值 [ 数字，布尔值，字符串 ]

k: v

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

“” 双引号，不会转义字符串里面的特殊字符 ， 特殊字符会作为本身想表示的意思；

比如 ： name: “kuang \n shen” 输出 ： kuang 换行 shen

‘’ 单引号，会转义特殊字符 ， 特殊字符最终会变成和普通字符一样输出

比如 ： name: ‘kuang \n shen’ 输出 ： kuang \n shen

对象、Map（键值对）

k: 
    v1:
    v2:
 

在下一行来写对象的属性和值得关系，注意缩进；比如：

student:
    name: qinjiang
    age: 3

行内写法

student: {name: qinjiang,age: 3}

数组（ List、set ）

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

pets:
 - cat
 - dog
 - pig

行内写法

pets: [cat,dog,pig]

【特别注意】：yaml语法中特别要注意空格

例如：

# 对空格的要求十分的高
#注入到我们的配置中
server:
  port: 8081


# 普通的可以-value
#name: qingjiang

#对象
#特别注意空格
student:
  name: qingjing
  age: 3


# 行内写法
student2: {name: qingjaing,age: 3}

#数组
pets:
  - cat
  - dog
  - pig

pets2: {cat,dog,pig}

#properties 只能保存兼职对
student.name = qingjiang
student.age = 3

3. 修改SpringBoot的默认端口号

配置文件中添加，端口号的参数，就可以切换端口；

server.port=8081

6.3、注入配置文件

1. 程序实现

1. 如果要使用properties配置文件可能导入时存在乱码现象 ， 需要在IDEA中进行调整 ，为了省事我们这里直接使用yml文件 ， 将默认的 application.properties后缀修改为yml
   

2. 导入配置文件处理器，在pom.xml中导入配置文件处理器的依赖，不然会报错

在配置中会出现下面这样的爆红现象。

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

3. 编写yml 配置文件，在刚建立的application.yml文件中编写配置文件，

person:
    name: qinjiang1
    age: 3
    happy: false
    birth:  2019/3/26
    maps: {k1: v1,k2: v2}
    lists:
      - code
      - girl
      - music
    dog:
      name: 旺财
      age: 3

4. 在SpringBoot的主程序的同级目录下建一个pojo包，**只有这样，主程序才会对这些类生效 ；**在概包中我们建立两个实体类：Person类，Dog类
   

Person类：

package com.westos.pojo;

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

import java.util.Date;
import java.util.List;
import java.util.Map;
/*
//怎么把配置配资文件的值绑定到我们的对象中；
//将配置文件中配置的每一个属性的值，映射到这个组件中；
//prefix : 在配置文件中的一个对象；

//@Validated //可以支持JSR303数据校验

@Component //被容器托管
@PropertySource(value = "classpath:person.properties") //加载指定的配置文件 classpath:项目类路径
//@ConfigurationProperties(prefix = "person") ：默认加载全局的配置文件

*/

@Component
@ConfigurationProperties(prefix = "person")
//通过这个注解把yaml中配置的值和这个实体类绑定在一起
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;
    public Person() {
    }

    public Person(String name, Integer age, Boolean happy, Date birth, Map<String, Object> maps, List<Object> lists, Dog dog) {

        this.name = name;
        this.age = age;
        this.happy = happy;
        this.birth = birth;
        this.maps = maps;
        this.lists = lists;
        this.dog = dog;
    }

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Boolean getHappy() {
        return happy;
    }

    public void setHappy(Boolean happy) {
        this.happy = happy;
    }

    public Date getBirth() {
        return birth;
    }

    public void setBirth(Date birth) {
        this.birth = birth;
    }

    public Map<String, Object> getMaps() {
        return maps;
    }

    public void setMaps(Map<String, Object> maps) {
        this.maps = maps;
    }

    public List<Object> getLists() {
        return lists;
    }

    public void setLists(List<Object> lists) {
        this.lists = lists;
    }

    public Dog getDog() {
        return dog;
    }

    public void setDog(Dog dog) {
        this.dog = dog;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", happy=" + happy +
                ", birth=" + birth +
                ", maps=" + maps +
                ", lists=" + lists +
                ", dog=" + dog +
                '}';
    }
}

public class Person {

    //@Value("${person.name}")
    //数据验证 : 前端；数据合法，才传递到后台
    //@Email(message="必须是邮箱")
    //properties单一的取值 ：
    @Value("${name}")
    private String lastName;
    //@Value("#{1*2}")
    private Integer age;
    private Boolean happy;
    private Date birth;
    private Map<String,Object> maps;
    private List<Object> hobbys;

Dog类

package com.westos.pojo;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component //被容器托管
public class Dog {
    private String name;
    private String age;

    public Dog() {
    }

    public Dog(String name, String age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public String getAge() {
        return age;
    }

    public void setAge(String age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", age='" + age + '\'' +
                '}';
    }
}

记得写上 toString（）方法，方便调试输出结果

5. 确认无误后，到测试单元中进行测试，看是否注入成功！

package com.westos;

import com.westos.pojo.Dog;
import com.westos.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
    private Person person;
    @Test
    void contextLoads() {
        System.out.println(person);
    }

}

运行结果

2. 其他实现方式

上面采用的方法都是最简单的方式，开发中最常用的；

事实上还存在其他的实现方式，道理都是相同得；

配置文件除了yml，还有我们之前常用的properties ，没有最先讲的元因是： properties配置文件在写中文的时候，会有乱码 ， 我们需要去IDEA中设置编码格式为UTF-8；
如图示：

settings–>File Encodings 中配置；

使用@value

还有，我们的类和配置文件直接关联着 ， 我们使用的是@configurationProperties的方式，还有一种方式是使用@value

//怎么把配置配资文件的值绑定到我们的对象中；
//将配置文件中配置的每一个属性的值，映射到这个组件中；
//prefix : 在配置文件中的一个对象；

//@Validated //可以支持JSR303数据校验

@Component //被容器托管
//@PropertySource(value = "classpath:person.properties") //加载指定的配置文件 classpath:项目类路径
@ConfigurationProperties(prefix = "person")//默认加载全局的配置文件
public class Person {

    //@Value("${person.name}")
    //数据验证 : 前端；数据合法，才传递到后台
    //@Email(message="必须是邮箱")
    //properties单一的取值 ：
    @Value("${person.name}")//从配置文件中取值
    private String lastName;
    @Value("#{1*2}")//#{SPEL}   spring表达式
    private Integer age;
    @Value("true")//字面量
    private Boolean happy;

    private Date birth;
    private Map<String,Object> maps;
    private List<Object> hobbys;
    //get、set方法
    //toString()方法 

或者

@Component
public class Dog {
    @Value("旺财1")
    private String name;
    @Value("3*")
    private String age;
    //get、set方法
    //toString()方法 
    
}

这个的测试类

@SpringBootTest
class Springboot02ConfigApplicationTests {

    @Autowired
    private Dog dog;
    private Person person;
    @Test
    void contextLoads() {
        System.out.println(dog);
    }
}

结果

加载指定配置文件（@PropertySource）

@PropertySource ：加载指定的配置文件；使用@configurationProperties默认从全局配置文件中获取值；

新建一个qingjiang.properties，在其内部进行写值

//javaConfig 绑定我们配置文件的值可以采取这些方式
//加载指定的配置文件
@PropertySource(value = "classpath:qingjiang.properties")
public class Person {
    //SPEL表达式取出配合文件的值
   @Value("${name}")
    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. 配置文件占位符

随机数

${random.value}、${random.int}、${random.long}、${random.int(10)}等等

占位符引用其他属性的值，如果不存在可以设置默认值,编写yml配置文件，

person:
    name: qinjiang${random.uuid}
    age: ${random.int}
    happy: false
    birth: 2000/01/01
    maps: {k1: v1,k2: v2}
    lists:
      - code
      - girl
      - music
    dog:
      name: ${person.hello:hello}_旺财
      age: 1

这个使用起来并不友好！我们需要为每个属性单独注解赋值，比较麻烦；

• cp只需要写一次即可 ， value则需要每个字段都添加

• 松散绑定 ：这个什么意思呢? 比如我的yml中写的last-name，这个和lastName是一样的， - 后面跟着的字母默认是大写的。这就是松散绑定

• JSR303数据校验 ， 这个就是我们可以在字段是增加一层过滤器验证 ， 可以保证数据的合法性

• 复杂类型封装，yml中可以封装对象 ， 使用@value就不支持

结论：

• 配置yml和配置properties都可以获取到值 ， 强烈推荐 yml
• 如果我们在某个业务中，只需要获取配置文件中的某个值，可以使用一下 @value
• 如果说，我们专门编写了一个JavaBean来和配置文件进行映射，就直接使用@configurationProperties不要犹豫！

4. JSR303数据校验

spring-boot中可以用@validated来校验数据，如果数据异常则会统一抛出异常，方便异常中心统一处理。我们这里来写个注解让我们的name只能支持Email格式

@Component //注册bean
@ConfigurationProperties(prefix = "person")
@Validated  //数据校验
public class Person {

    //@Value("${person.name}")
    @Email //name必须是邮箱格式
    private String name;
}

运行结果

总结：使用数据校验，可以保证数据的正确性；

6.4 、多环境切换

profile是Spring对不同环境提供不同配置功能的支持，可以通过激活不同的环境版本，实现快速切换环境；

1. 方式一：多配置文件

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

例如：application-test.properties 代表测试环境配置 application-dev.properties 代表开发环境配置

但是Springboot并不会直接启动这些配置文件，它默认使用application.properties主配置文件；

我们需要通过一个配置来选择需要激活的环境；

#比如在配置文件中指定使用dev环境，我们可以通过设置不同的端口号进行测试；
#我们启动SpringBoot，就可以看到已经切换到dev下的配置了；
spring.profiles.active=dev

2. 方式二：yml的多文档块

和properties配置文件中一样，但是使用yml去实现不需要创建多个配置文件，更加方便了

server:
  port: 8081
#选择要激活那个环境块
spring:
  profiles:
    active: prod

---
server:
  port: 8083
#配置环境的名称
spring:
  profiles: dev


---

server:
  port: 8084
spring:
  profiles: prod  #配置环境的名称

注意：如果yml和properties同时都配置了端口，并且没有激活其他环境 ， 默认会使用properties配置文件的！

3. 配置文件加载位置

springboot 启动会扫描以下位置的application.properties或者application.yml文件作为Spring boot的默认配置文件

优先级1：项目路径下的config文件夹配置文件
优先级2：项目路径下配置文件
优先级3：资源路径下的config文件夹配置文件
优先级4：资源路径下配置文件
优先级由高到底，高优先级的配置会覆盖低优先级的配置；

SpringBoot会从这四个位置全部加载主配置文件；互补配置；

我们在最低级的配置文件中设置一个项目访问路径的配置来测试互补问题；

#配置项目的访问路径
server.servlet.context-path=/kuang

4. 【扩展】指定位置加载配置文件

我们还可以通过spring.config.location来改变默认的配置文件位置

项目打包好以后，我们可以使用命令行参数的形式，启动项目的时候来指定配置文件的新位置；

这种情况，一般是后期运维做的多，相同配置，外部指定的配置文件优先级最高

java -jar spring-boot-config.jar --spring.config.location=F:/application.properties

外部加载配置文件的方式十分多，我们选择最常用的即可，在开发的资源文件中进行配置！