Spring Boot配置文件详解

　　Spring Boot提供了两种常用的配置文件，分别是properties文件和yml文件。

一、yml配置方式

　　以空格的缩进程度来控制层级关系。空格的个数并不重要，只要左边空格对齐则视为同一个层级。注意不能用tab代替空格。且大小写敏感。支持字面值，对象，数组三种数据结构，也支持复合结构。

　　创建一个Spring Boot 的全局配置文件 application.yml，配置属性参数。主要有字符串，带特殊字符的字符串，布尔类型，数值，集合，行内集合，行内对象，集合对象这几种常用的数据格式。

yaml:
  str: 字符串可以不加引号
  specialStr: "双引号直接输出\n特殊字符"
  specialStr2: '单引号可以转义\n特殊字符'
  flag: false
  num: 666
  Dnum: 88.88
  list:
    - one
    - two
    - two
  set: [1,2,2,3]
  map: {k1: v1, k2: v2}
  positions:
    - name: ITDragon
      salary: 15000.00
    - name: ITDragonBlog
      salary: 18888.88

　　创建实体类YamlEntity.java 获取配置文件中的属性值，通过注解@ConfigurationProperties获取配置文件中的指定值并注入到实体类中。

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

import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * YAML 语法实体类
 *
 * 切记点：
 * 一、冒号后面加空格，即 key:(空格)value
 * 二、每行参数左边空格数量决定了该参数的层级，不可乱输入。
 */

@Component
@ConfigurationProperties(prefix = "yaml")
public class YamlEntity {

    // 字面值，字符串，布尔，数值
    private String str; // 普通字符串
    private String specialStr; // 输出特殊字符串
    private String specialStr2;// 转义特殊字符串
    private Boolean flag;   // 布尔类型
    private Integer num;    // 整数
    private Double dNum;    // 小数

    // 数组，List和Set，两种写法： 第一种：-空格value，每个值占一行，需缩进对齐；第二种：[1,2,...n] 行内写法
    private List<Object> list;  // list可重复集合
    private Set<Object> set;    // set不可重复集合

    // Map和实体类，两种写法：第一种：key空格value，每个值占一行，需缩进对齐；第二种：{key: value,....} 行内写法
    private Map<String, Object> map; // Map K-V
    private List<Position> positions;  // 复合结构，集合对象

    public String getStr() {
        return str;
    }

    public void setStr(String str) {
        this.str = str;
    }

    public String getSpecialStr() {
        return specialStr;
    }

    public void setSpecialStr(String specialStr) {
        this.specialStr = specialStr;
    }

    public String getSpecialStr2() {
        return specialStr2;
    }

    public void setSpecialStr2(String specialStr2) {
        this.specialStr2 = specialStr2;
    }

    public Boolean getFlag() {
        return flag;
    }

    public void setFlag(Boolean flag) {
        this.flag = flag;
    }

    public Integer getNum() {
        return num;
    }

    public void setNum(Integer num) {
        this.num = num;
    }

    public Double getdNum() {
        return dNum;
    }

    public void setdNum(Double dNum) {
        this.dNum = dNum;
    }

    public List<Object> getList() {
        return list;
    }

    public void setList(List<Object> list) {
        this.list = list;
    }

    public Set<Object> getSet() {
        return set;
    }

    public void setSet(Set<Object> set) {
        this.set = set;
    }

    public Map<String, Object> getMap() {
        return map;
    }

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

    public List<Position> getPositions() {
        return positions;
    }

    public void setPositions(List<Position> positions) {
        this.positions = positions;
    }

    @Override
    public String toString() {
        return "YamlEntity{" +
                "str='" + str + '\'' +
                ", specialStr='" + specialStr + '\'' +
                ", specialStr2='" + specialStr2 + '\'' +
                ", flag=" + flag +
                ", num=" + num +
                ", dNum=" + dNum +
                ", list=" + list +
                ", set=" + set +
                ", map=" + map +
                ", positions=" + positions +
                '}';
    }
}

测试用例在最下面。

二、Properties

　　properties文件大家经常用，这里就简单介绍一下。其语法结构形如：key=value。注意中文乱码问题，需要转码成ASCII。

userinfo.account=itdragonBlog
userinfo.age=25
userinfo.active=true
userinfo.created-date=2018/03/31 16:54:30
userinfo.map.k1=v1
userinfo.map.k2=v2
userinfo.list=one,two,three
userinfo.position.name=Java\u67B6\u6784\u5E08(Java架构师)
userinfo.position.salary=19999.99

　　从配置文件中取值注入到实体类中，和YAML是一样的。

package com.itdragon.entity;

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

import java.util.Date;
import java.util.List;
import java.util.Map;

/**
 * 用户信息
 * @ConfigurationProperties : 被修饰类中的所有属性会和配置文件中的指定值（该值通过prefix找到）进行绑定
 */
@Component
@ConfigurationProperties(prefix = "userinfo")
public class UserInfo {

    private String account;
    private Integer age;
    private Boolean active;
    private Date createdDate;
    private Map<String, Object> map;
    private List<Object> list;
    private Position position;

    public String getAccount() {
        return account;
    }

    public void setAccount(String account) {
        this.account = account;
    }

    public Integer getAge() {
        return age;
    }

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

    public Boolean getActive() {
        return active;
    }

    public void setActive(Boolean active) {
        this.active = active;
    }

    public Date getCreatedDate() {
        return createdDate;
    }

    public void setCreatedDate(Date createdDate) {
        this.createdDate = createdDate;
    }

    public Map<String, Object> getMap() {
        return map;
    }

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

    public List<Object> getList() {
        return list;
    }

    public void setList(List<Object> list) {
        this.list = list;
    }

    public Position getPosition() {
        return position;
    }

    public void setPosition(Position position) {
        this.position = position;
    }

    @Override
    public String toString() {
        return "UserInfo{" +
                "account='" + account + '\'' +
                ", age=" + age +
                ", active=" + active +
                ", createdDate=" + createdDate +
                ", map=" + map +
                ", list=" + list +
                ", position=" + position +
                '}';
    }
}

　　测试用例在最下面。

三、配置文件取值对比

一）ConfigurationProperties和Value优缺点

　　ConfigurationProperties注解的优缺点

一、可以从配置文件中批量注入属性；

二、支持获取复杂的数据类型；

三、对属性名匹配的要求较低，比如user-name，user_name，userName，USER_NAME都可以取值；

四、支持JAVA的JSR303数据校验；

五、缺点是不支持强大的SpEL表达式；

Value注解的优缺点正好相反，它只能一个个配置注入值；不支持数组、集合等复杂的数据类型；不支持数据校验；对属性名匹配有严格的要求。最大的特点是支持SpEL表达式，使其拥有更丰富的功能。

二）@ConfigurationProperties详解

第一步：导入依赖。若要使用ConfigurationProperties注解，需要导入依赖 spring-boot-configuration-processor；

第二步：配置数据。在application.yml配置文件中，配置属性参数，其前缀为itdragon，参数有字面值和数组，用来判断是否支持获取复杂属性的能力；

第三步：匹配数据。在类上添加注解ConfigurationProperties，并设置prefix属性值为itdragon。并把该类添加到Spring的IOC容器中。

第四步：校验数据。添加数据校验Validated注解，开启数据校验，测试其是否支持数据校验的功能；

第五步：测试ConfigurationProperties注解是否支持SpEL表达式；

导入依赖：pom.xml 添加 spring-boot-configuration-processor依赖

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-configuration-processor</artifactId>
  <optional>true</optional>
</dependency>

配置数据：application.yml 配置属性参数，nick-name是用来判断匹配属性的松散性，若换成nick_name依然可以获取值。

itdragon:
  nick-name: ITDragonBlog
  email: 1234567890@qq.com
  iphone: 1234567890
  abilities: [java, sql, html]
  created_date: 2018/03/31 15:27:30

匹配和校验数据：

package com.itdragon.entity;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
import org.springframework.validation.annotation.Validated;

import javax.validation.constraints.Email;
import java.util.Date;
import java.util.List;

/**
 * ConfigurationProperties 注解语法类
 * 第一步：导入依赖 spring-boot-configuration-processor；
 * 第二步：把ConfigurationProperties注解修饰的类添加到Spring的IOC容器中；
 * 第三步：设置prefix属性，指定需要注入属性的前缀；
 * 第四步：添加数据校验注解，开启数据校验；
 *
 * 注意点：
 * 一、nickName和createdDate在yml配置文件中，对应参数分别是中划线和下划线，用于测试其对属性名匹配的松散性
 * 二、email和iphone 测试其支持JSR303数据校验
 * 三、abilities 测试其支持复杂的数据结构
 *
 * 若想运行成功，需要注释33行
 */

@Component
@ConfigurationProperties(prefix = "itdragon")
@Validated
public class ConfigurationPropertiesEntity {

    private String nickName;    // 解析成功，支持松散匹配属性
    private String email;
//    @Email                      // 解析失败，数据校验成功：BindValidationException: Binding validation errors on itdragon
    private String iphone;
    private List<String> abilities;
    private Date createdDate;   // 解析成功，支持松散匹配属性

//    @ConfigurationProperties("#{(1+2-3)/4*5}")
    private String operator;    // 语法报错，不支持SpEL表达式：not applicable to field

    public String getNickName() {
        return nickName;
    }

    public void setNickName(String nickName) {
        this.nickName = nickName;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public String getIphone() {
        return iphone;
    }

    public void setIphone(String iphone) {
        this.iphone = iphone;
    }

    public List<String> getAbilities() {
        return abilities;
    }

    public void setAbilities(List<String> abilities) {
        this.abilities = abilities;
    }

    public Date getCreatedDate() {
        return createdDate;
    }

    public void setCreatedDate(Date createdDate) {
        this.createdDate = createdDate;
    }

    @Override
    public String toString() {
        return "ConfigurationPropertiesEntity{" +
                "nickName='" + nickName + '\'' +
                ", email='" + email + '\'' +
                ", iphone='" + iphone + '\'' +
                ", abilities=" + abilities +
                ", createdDate=" + createdDate +
                '}';
    }
}

三）@Value详解

第一步：在属性上添加Value注解，通过${}设置参数从配置文件中注入值；

第二步：修改${itdragon.ceatred_date}中的参数值，改为${itdragon.ceatredDate}测试是否能解析成功；

第三步：添加数据校验Validated注解，开启数据校验，测试其是否支持数据校验的功能；

第四步：测试Value注解是否支持SpEL表达式；

package com.itdragon.entity;

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

import javax.validation.constraints.Email;
import java.util.Date;
import java.util.List;

/**
 * Value 注解语法类
 * 第一步：在属性上添加注解Value注入参数
 * 第二步：把Value注解修饰的类添加到Spring的IOC容器中；
 * 第三步：添加数据校验注解，检查是否支持数据校验；
 *
 * 注意点：
 * 一、nickName和createdDate在yml配置文件中，对应参数分别是中划线和下划线，用于测试其对属性名匹配的松散性
 * 二、email和iphone 测试其支持JSR303数据校验
 * 三、abilities 测试其支持复杂的数据结构
 *
 * 结论：
 * 一、createDate取值必须和yml配置文件中的参数保持一致，
 * 二、既是在iphone上添加邮箱验证注解依然可以通过测试，
 * 三、不支持复杂的数据结构，提示错误和第一条相同：IllegalArgumentException: Could not resolve placeholder 'itdragon.abilities' in value "${itdragon.abilities}"
 *
 * 若想运行成功，需要注释42行；修改44行，将ceatredDate修改为ceatred_date
 */

@Component
@Validated
public class ValueEntity {

    @Value("${itdragon.nick-name}")
    private String nickName;
    @Value("${itdragon.email}")
    private String email;
    @Email
    @Value("${itdragon.iphone}")        // 解析成功，并不支持数据校验
    private String iphone;
//    @Value("${itdragon.abilities}")     // 解析错误，并不支持复杂的数据结构
    private List<String> abilities;
//    @Value("${itdragon.ceatredDate}")   // 解析错误，并不支持松散匹配属性，必须严格一致
    private Date createdDate;

    // Value注解的强大一面：支持SpEL表达式
    @Value("#{(1+2-3)/4*5}")            // 算术运算
    private String operator;
    @Value("#{1>2 || 2 <= 3}")          // 关系运算
    private Boolean comparison;
    @Value("#{systemProperties['java.version']}") // 系统配置：os.name
    private String systemProperties;
    @Value("#{T(java.lang.Math).abs(-18)}") // 表达式
    private String mapExpression;

    public String getNickName() {
        return nickName;
    }

    public void setNickName(String nickName) {
        this.nickName = nickName;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public String getIphone() {
        return iphone;
    }

    public void setIphone(String iphone) {
        this.iphone = iphone;
    }

    public List<String> getAbilities() {
        return abilities;
    }

    public void setAbilities(List<String> abilities) {
        this.abilities = abilities;
    }

    public Date getCreatedDate() {
        return createdDate;
    }

    public void setCreatedDate(Date createdDate) {
        this.createdDate = createdDate;
    }

    public String getOperator() {
        return operator;
    }

    public void setOperator(String operator) {
        this.operator = operator;
    }

    public Boolean getComparison() {
        return comparison;
    }

    public void setComparison(Boolean comparison) {
        this.comparison = comparison;
    }

    public String getSystemProperties() {
        return systemProperties;
    }

    public void setSystemProperties(String systemProperties) {
        this.systemProperties = systemProperties;
    }

    public String getMapExpression() {
        return mapExpression;
    }

    public void setMapExpression(String mapExpression) {
        this.mapExpression = mapExpression;
    }

    @Override
    public String toString() {
        return "ValueEntity{" +
                "nickName='" + nickName + '\'' +
                ", email='" + email + '\'' +
                ", iphone='" + iphone + '\'' +
                ", abilities=" + abilities +
                ", createdDate=" + createdDate +
                ", operator='" + operator + '\'' +
                ", comparison=" + comparison +
                ", systemProperties='" + systemProperties + '\'' +
                ", mapExpression='" + mapExpression + '\'' +
                '}';
    }
}

四）配置文件取值小结

一、ConfigurationProperties注解支持批量注入，而Value注解适合单个注入；

二、ConfigurationProperties注解支持数据校验，而Value注解不支持；

三、ConfigurationProperties注解支持松散匹配属性，而Value注解必须严格匹配属性；

四、ConfigurationProperties不支持强大的SpEL表达式，而Value支持；

四、配置文件占位符

占位符和随机数比较简单，这里就直接贴出代码。需要注意的是：

一、占位符的值必须是完整路径

二、占位符设置默认值，冒号后面不能有空格

ran:  # 这里的prefix不能是random，
  ran-value: ${random.value}
  ran-int: ${random.int}
  ran-long: ${random.long}
  ran-int-num: ${random.int(10)}
  ran-int-range: ${random.int[10,20]}
  ran-placeholder: placeholder_${ran.ran-value:此处不能有空格，且key为完整路径}

package com.itdragon.entity;

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

/**
 * 随机数和占位符语法类
 */

@Component
@ConfigurationProperties(prefix = "ran")
public class RandomEntity {

    private String ranValue;    // 随机生成一个字符串
    private Integer ranInt;     // 随机生成一个整数
    private Long ranLong;       // 随机生成一个长整数
    private Integer ranIntNum;  // 在指定范围内随机生成一个整数
    private Integer ranIntRange;// 在指定区间内随机生成一个整数
    private String ranPlaceholder;// 占位符

    public String getRanValue() {
        return ranValue;
    }

    public void setRanValue(String ranValue) {
        this.ranValue = ranValue;
    }

    public Integer getRanInt() {
        return ranInt;
    }

    public void setRanInt(Integer ranInt) {
        this.ranInt = ranInt;
    }

    public Long getRanLong() {
        return ranLong;
    }

    public void setRanLong(Long ranLong) {
        this.ranLong = ranLong;
    }

    public Integer getRanIntNum() {
        return ranIntNum;
    }

    public void setRanIntNum(Integer ranIntNum) {
        this.ranIntNum = ranIntNum;
    }

    public Integer getRanIntRange() {
        return ranIntRange;
    }

    public void setRanIntRange(Integer ranIntRange) {
        this.ranIntRange = ranIntRange;
    }

    public String getRanPlaceholder() {
        return ranPlaceholder;
    }

    public void setRanPlaceholder(String ranPlaceholder) {
        this.ranPlaceholder = ranPlaceholder;
    }

    @Override
    public String toString() {
        return "RandomEntity{" +
                "ranValue='" + ranValue + '\'' +
                ", ranInt=" + ranInt +
                ", ranLong=" + ranLong +
                ", ranIntNum=" + ranIntNum +
                ", ranIntRange=" + ranIntRange +
                ", ranPlaceholder='" + ranPlaceholder + '\'' +
                '}';
    }
}

测试代码：

package com.itdragon.yml;

import com.itdragon.entity.*;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringBootYmlApplicationTests {

    @Autowired
    private UserInfo userInfo;

    @Autowired
    private YamlEntity yamlEntity;

    @Autowired
    private ConfigurationPropertiesEntity configurationPropertiesEntity;

    @Autowired
    private ValueEntity valueEntity;

    @Autowired
    private RandomEntity randomEntity;

    @Test
    public void contextLoads() {
        System.out.println("YAML Grammar : " + yamlEntity);
//        System.out.println("UserInfo : " + userInfo);
//        System.out.println("ConfigurationProperties Grammar : " + configurationPropertiesEntity);
//        System.out.println("Value Grammar : " + valueEntity);
//        System.out.println("Random Grammar : " + randomEntity);
    }

}

原文链接：https://www.cnblogs.com/itdragon/p/8686554.html