配置文件

SpringBoot使用一个全局的配置文件，配置文件名是固定的；
•application.properties
•application.yml
配置文件的作用：修改SpringBoot自动配置的默认值；SpringBoot在底层都给我们自动配置好；

YAML文件语法

基本语法

  • k:(空格)v ：表示一对键值对（空格必须有）；
  • 以空格的缩进来控制层级关系；只要是左对齐的一列数据，都是同一个层级的。
  • 属性和值大小写敏感；
  • 不支持 tab 缩进
  • 可以使用 -小写字母 或 _小写字母 来 代替 大写字母 , 如 userName 与 user-name , user_name 含义是一样的

  • key: value 格式书写。key 后面跟着冒号, 再后面跟着一个空格, 然后是值。

    值的写法

  • 普通的值（数字，字符串，布尔）

  • 对象、Map (属性和值) (键值对)
  • 数组 (List、Set)

字面量：普通的值（数字，字符串，布尔）

直接就是 key: value , 如:

  1. age: 18
  2. name: mysgk

注意:

  • 字符串默认不用加上单引号或者双引号；
  • " " ：双引号；不会转义字符串里面的特殊字符；特殊字符会作为本身想表示的意思。 name: "zhangsan \n lisi" 表示为： zhangsan 换行 lisi
  • ' ' ：单引号；会转义特殊字符，特殊字符最终只是一个普通的字符串数据。 name: 'zhangsan \n lisi' 表示为： zhangsan \n lisi

对象、Map（属性和值）（键值对）

对象还是 k: v 的方式
k: v ：在下一行来写对象的属性和值的关系；注意缩进 (不支持 tab, 使用空格), 如:

  1. person:
  2.     age: 18
  3.     name: zhangshan

行内写法：

  1. person: {age: 18,name: zhangshan}

数组（List、Set）

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

  1. animals:
  2.     - cat
  3.     - dog
  4.     - pig

行内写法:

  1. animals: [cat,dog,pig]

读取配置文件（配置文件的注入）

  1. person:
  2.   lastName: hello
  3.   age: 18
  4.   boss: false
  5.   birth: 2017/12/12
  6.   maps: {k1: v1,k2: 12}
  7.   lists: 
  8.     ‐ lisi 
  9.     ‐ zhaoliu
  10. dog:
  11.   name: 小狗
  12.   age: 12

使用@Value注解

  1. @Componnet
  2. class ReadValueOfYml{
  3.     @Value("${userproperties.name}")
  4.     private String name;
  5.     @Value("${userproperties.age}")
  6.     private String age;
  7.     @Value("${userproperties.sex}")
  8.     private String sex;
  9.     @Value("${userproperties.email}")
  10.     private String email;
  12.     @Value("${useryml.name}")
  13.     private String nameyml;
  14.     @Value("${useryml.age}")
  15.     private String ageyml;
  16.     @Value("${useryml.sex}")
  17.     private String sexyml;
  18.     @Value("${useryml.email}")
  19.     private String emailyml;
  21.     @Test
  22.     public void testValue(){
  24.         System.out.println("name=" + name + "，age=" + age + "，sex=" 
  25.         + sex + "，email" + email);
  27.        System.out.println("nameyml=" + nameyml + "，ageyml=" + ageyml 
  28.        + "，sexyml=" + sexyml + "，emailyml" + emailyml);
  29.     }
  30. }

使用@ConfigurationProperties注解

  1. useryml:
  2.   name: gongjie
  3.   age: 23
  4.   sex: 1
  5.   email: 111@163.com
  1. /**
  2.  * 将配置文件中配置的每一个属性的值，映射到这个组件中 
  3.  * @ConfigurationProperties：告诉SpringBoot将本类中的所有属性和配置文件中相关的配置进行绑定； 
  4.  * prefix = "person"：配置文件中哪个下面的所有属性进行一一映射 
  5.  *
  6.  * 只有这个组件是容器中的组件，才能容器提供的@ConfigurationProperties功能； 
  7.  **/
  8. @Component
  9. @ConfigurationProperties(prefix = "userproperties")
  10. public class ReadPropertiesValue {
  11.     private String name;
  12.     private String age;
  13.     private String email;
  14.     private String sex;
  16.     @Override
  17.     public String toString() {
  18.         return "ReadPropertiesValue{" +
  19.                 "name='" + name + '\'' +
  20.                 ", age=" + age +
  21.                 ", email='" + email + '\'' +
  22.                 ", sex=" + sex +
  23.                 '}';
  24.     }
  26.     public void setName(String name) {
  27.         this.name = name;
  28.     }
  30.     public void setAge(String age) {
  31.         this.age = age;
  32.     }
  34.     public void setEmail(String email) {
  35.         this.email = email;
  36.     }
  38.     public void setSex(String sex) {
  39.         this.sex = sex;
  40.     }
  41. }

注意：ReadPropertiesValue类上如果不是一个组件，则在容器无法获取。需要在启动类上加@EnableConfigurationProperties(ReadPropertiesValue.class)将其注册到容器中。

@Value获取值和@ConfifigurationProperties获取值比较
image.png
如果说，我们只是在某个业务逻辑中需要获取一下配置文件中的某项值，使用 @Value ；
如果说，我们专门编写了一个javaBean来和配置文件进行映射，我们就直接使用 @ConfifigurationProperties ；

使用Environment

注意：这种方式是直接依赖注入Evnironment对象，然后使用environment.getProperty("键名")即可读取对应的值。’

  1. @Autowired
  2. Environment environment;
  4. @Test
  5. public void environmentTest(){
  7.     System.out.println(environment.getProperty("userproperties.name") 
  8.     + "==" + environment.getProperty("userproperties.age") + "==" + 
  9.     environment.getProperty("userproperties.sex") + "==" + 
  10.     environment.getProperty("userproperties.email"));
  12.     System.out.println(environment.getProperty("useryml.name") + "==" 
  13.     + environment.getProperty("useryml.age") + "==" + 
  14.     environment.getProperty("useryml.sex") + "==" + 
  15.     environment.getProperty("useryml.email"));
  17. }

读取自定义配置文件

@PropertySource：加载指定的配置文件

  1. @Component
  2. @PropertySource(value = "classpath:configValue.yml")
  3. public class ReadYmlByValue {
  5.     @Value("${userconfigvalueyml.name}")
  6.     public String name;
  7.     @Value("${userconfigvalueyml.age}")
  8.     public String age;
  9.     @Value("${userconfigvalueyml.sex}")
  10.     public String sex;
  11.     @Value("${userconfigvalueyml.email}")
  12.     public String email;
  14.     @Override
  15.     public String toString() {
  16.         return "ReadYmlByValue{" +
  17.                 " + name + '\'' +
  18.                 ", age='" + age + '\'' +
  19.                 ", sex='" + sex + '\'' +
  20.                 ", email='" + email + '\'' +
  21.                 '}';
  22.     }
  23. }

@ImportResource：导入Spring的配置文件，让配置文件里面的内容生效

Spring Boot里面没有Spring的配置文件，我们自己编写的配置文件，也不能自动识别；
想让Spring的配置文件生效，加载进来；@ImportResource标注在一个配置类上.

  1. @ImportResource(locations = {"classpath:beans.xml"}) // 导入Spring的配置文件让其生效

配置文件占位符

随机数

${random.value}、${random.int}、${random.long} ${random.int(10)}、${random.int[1024,65536]}

**

占位符获取之前配置的值，如果没有可以是用 :指定默认值

  1. person.last‐name=张三${random.uuid} 
  2. person.age=${random.int} 
  3. person.birth=2017/12/15 
  4. person.boss=false 
  5. person.maps.k1=v1 
  6. person.maps.k2=14 
  7. person.lists=a,b,c 
  8. person.dog.name=${person.hello:hello}_dog 
  9. person.dog.age=15

Profifile

多Profifile文件

我们在主配置文件编写的时候，文件名可以是 application-{profifile}.properties/yml
默认使用application.properties的配置；

yml支持多文档块方式

  1. server: 
  2.   port: 8081 
  3. spring: 
  4.   profiles: 
  5.     active: prod # 指顶当前环境是prod
  6. ‐‐‐ 
  7. server: 
  8.   port: 8083 
  9.   spring: 
  10.     profiles: dev #指定属于哪个环境
  11. ‐‐‐
  12. server: 
  13.   port: 8084 
  14. spring: 
  15.   profiles: prod #指定属于哪个环境

激活指定profifile

1、在配置文件中指定 spring.profifiles.active=dev
2、命令行：
java -jar spring-boot-02-confifig-0.0.1-SNAPSHOT.jar --spring.profifiles.active=dev； 可以直接在测试的时候，配置传入命令行参数
3、虚拟机参数；
-Dspring.profifiles.active=dev

配置文件加载位置

springboot 启动会扫描以下位置的 application.properties 或者 application.yml 文件作为Spring boot的默认配置文件。
–file:./config/
–file:./
–classpath:/config/
–classpath:/
优先级由高到底，高优先级的配置会覆盖低优先级的配置；
SpringBoot会从这四个位置全部加载主配置文件；互补配置；

我们还可以通过 spring.confifig.location 来改变默认的配置文件位置
项目打包好以后，我们可以使用命令行参数的形式，启动项目的时候来指定配置文件的新位置；指定配置文件和默 认加载的这些配置文件共同起作用形成互补配置；
java -jar spring-boot-02-confifig-02-0.0.1-SNAPSHOT.jar
--spring.confifig.location=G:/application.properties

外部配置加载顺序

SpringBoot也可以从以下位置加载配置； 优先级从高到低；高优先级的配置覆盖低优先级的配置，所有的配置会 形成互补配置
1.命令行参数
所有的配置都可以在命令行上进行指定
java -jar spring-boot-02-confifig-02-0.0.1-SNAPSHOT.jar --server.port=8087 --server.context-path=/abc
多个配置用空格分开； —配置项=值
2.来自java:comp/env的JNDI属性
3.Java系统属性（System.getProperties()）
4.操作系统环境变量
5.RandomValuePropertySource配置的random.属性值
由jar包外向jar包内进行寻找；
优先加载带profile
6.jar包外部的application-{profifile}.properties或application.yml(带spring.profifile)配置文件
7.jar包内部的application-{profifile}.properties或application.yml(带spring.profifile)配置文件
再来加载不带profifile
8.jar包外部的application.properties或application.yml(不带spring.profifile)配置文件
*9.jar包内部的application.properties或application.yml(不带spring.profifile)配置文件
10.@Confifiguration注解类上的@PropertySource
11.通过SpringApplication.setDefaultProperties指定的默认属性
所有支持的配置加载来源；