SpringBoot解析yml/yaml/properties配置文件的四种方式汇总

已于 2023-02-21 15:59:10 修改
阅读量2.1k 收藏 5
点赞数 3
分类专栏： 框架知识 文章标签： spring boot java
于 2023-02-19 11:00:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51091560/article/details/129108338
版权

目录

一、配置文件注入方式一@Value

二、配置文件注入方式二@ConfigurationProperties

三、自定义解析类，直接暴力读取yml配置文件

四、Spring配置文件的解析类Environment获取式

一、配置文件注入方式一@Value

配置文件：

# 严格识别空格

# 属性(String/Byte/Short/Integer/Long/Float/Double/Character/Boolean)
properties:
  name1: 徐城和

# 数组/集合(Arrays/List/Set)
arrays:
  srr1: 小徐,小杨
  srr2: [小张,小林]

# 键值对(Map)
maps:
  map1: {key1: value1,key2: value2}

注入/解析类： 

package parseconfiguration;

import autowired.SubGenericityApplication;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.Set;

/**
 * 配置文件注入方式一@Value
 * 
 * 其中，该注入方式：
 * -仅可注入单属性值和常规数组/集合写法，其它配置或写法需要使用方式二注入
 * -属性不需要Get/Set方法支持
 * -可以注入任意类型数据，自动转换注入
 * -没配置或无法识别或类型无法转换，均会导致配置失败，会报错，因此需要配合default默认值使用
 * 
 * @author Chenghe Xu
 * @date 2023/2/14 10:34
 */
@SpringBootTest(classes = SubGenericityApplication.class)
public class Test01 {
    
    @Value("${properties.name1}")
    private String name1;
    
    @Value("${arrays.srr1}")
//    private String[] srr1;
//    private List<String> srr1;
    private Set<String> srr1;
    
    @Test
    public void test1() {
        
        System.out.println("name1 = " + name1);
        
        System.out.print("srr1 = |");
        for (String s : srr1) {
            System.out.print(s + "|");
        }
        System.out.println();
                
    }
    
}

/**
 * 数组注入时会按英文逗号分割
 * 字符串不会
 */
@SpringBootTest(classes = SubGenericityApplication.class)
class Test01_1 {
    
    /**
     * 在生产环境，@Value防止没配置或注入失败，直接报错，需要配合default使用
     */
    @Value("${properties.name2:没配置,没默认值会直接报错}")
    private String name2;
    
    @Value("${arrays.srr2:无法识别,没默认值会直接报错}")
//    private String[] srr2;
//    private List<String> srr2;
    private Set<String> srr2;
    
    @Value("${maps.map1:类型无法转换,没默认值会直接报错}")
    private String map1;
    
    @Test
    public void test1() {
        
        System.out.println("name2 = " + name2);
    
        System.out.print("srr2 = |");
        for (String s : srr2) {
            System.out.print(s + "|");
        }
        System.out.println();
    
        System.out.println("map1 = " + map1);
    
    }
    
}

二、配置文件注入方式二@ConfigurationProperties

 配置文件：

# 严格识别空格
myproperties:

  # 属性(String/Byte/Short/Integer/Long/Float/Double/Character/Boolean)
  name1: 徐城和
  
  # 数组/集合(Arrays/List/Set)
  srr1: 小徐,小杨
  srr2: [小张,小林]
  srr3:
    - 小君
    - 小白
  
  # 键值对(Map)
  map1: {key1: value1,key2: value2}
  map2:
    key3: value3
    key4: value4
  
  # 对象(Object)
  pet1: {name: 旺财,age: 3}
  pet2: 
    name: 莉莉
    age: 2

注入/解析类： 

package parseconfiguration;

import autowired.SubGenericityApplication;
import lombok.Data;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import java.util.Map;
import java.util.Set;

/**
 * 配置文件注入方式二@ConfigurationProperties
 * 
 * 其中，该注入方式：
 * -需要配合启动类注解标记：@EnableConfigurationProperties({Test02.class})/@ConfigurationPropertiesScan({"parseconfiguration"})
 * -或配合注册为Bean：@Configuration/@Component，或再引入配置处理器依赖：spring-boot-configuration-processor
 * -属性需要Get/Set方法支持
 * -可以注入任意类型数据，自动转换注入
 * -无法识别或类型无法转换，会导致配置失败，会报错；没配置则不注入
 * 
 * @author Chenghe Xu
 * @date 2023/2/17 9:47
 */
@Data
//@Component
//@Configuration
@ConfigurationProperties("myproperties")
@SpringBootTest(classes = SubGenericityApplication.class)
public class Test02 {
    
    private String name1;
    
//    private String[] srr1;
//    private String[] srr2;
//    private String[] srr3;
//    private List<String> srr1;
//    private List<String> srr2;
//    private List<String> srr3;
    private Set<String> srr1;
    private Set<String> srr2;
    private Set<String> srr3;
    
    private Map<String, String> map1;
    private Map<String, String> map2;
    
    private Pet pet1;
    private Pet pet2;
    
    @Test
    public void test1() {
        
        System.out.println("name1 = " + name1);
        
        System.out.print("srr1 = |");
        for (String s : srr1) {
            System.out.print(s + "|");
        }
        System.out.println();
        
        System.out.print("srr2 = |");
        for (String s : srr2) {
            System.out.print(s + "|");
        }
        System.out.println();
        
        System.out.print("srr3 = |");
        for (String s : srr3) {
            System.out.print(s + "|");
        }
        System.out.println();
        
        System.out.print("map1 = |");
        map1.forEach((k, v) -> {
            System.out.print(k + "=");
            System.out.print(v + "|");
        });
        System.out.println();
        
        System.out.print("map2 = |");
        map2.forEach((k, v) -> {
            System.out.print(k + "=");
            System.out.print(v + "|");
        });
        System.out.println();
        
        System.out.println("pet1 = " + pet1);
        System.out.println("pet2 = " + pet2);
        
    }
    
}

@SpringBootTest(classes = SubGenericityApplication.class)
class Test02_1 {
    
    @Autowired
    private Test02 test02;
    
    @Test
    public void test1() {
        
        System.out.println("test02.getName1() = " + test02.getName1());
        
        System.out.println("test02.getSrr1() = " + test02.getSrr1());
        System.out.println("test02.getSrr2() = " + test02.getSrr2());
        System.out.println("test02.getSrr3() = " + test02.getSrr3());
    
        System.out.println("test02.getMap1() = " + test02.getMap1());
        System.out.println("test02.getMap2() = " + test02.getMap2());
    
        System.out.println("test02.getPet1() = " + test02.getPet1());
        System.out.println("test02.getPet2() = " + test02.getPet2());
    
    }
    
}

/**
 * @PostConstruct
 * 实现全局静态变量访问优化
 * -可以优化重复的@Autowired注解，直接静态访问
 */
@Component
class ConfigurationUtil {
    
    public static Test02 staticTest02;
    
    @Autowired
    public Test02 test02;
    
    @PostConstruct
    public void initialize() {
        System.out.println("==Spring容器启动时初始化该方法==");
        staticTest02 = this.test02;
    }
    
}

@SpringBootTest(classes = SubGenericityApplication.class)
class Test02_2 {
    
    @Test
    public void test1() {
        
        System.out.println("ConfigurationUtil.staticTest02.getName1() = " + ConfigurationUtil.staticTest02.getName1());
        
        System.out.println("ConfigurationUtil.staticTest02.getSrr1() = " + ConfigurationUtil.staticTest02.getSrr1());
        System.out.println("ConfigurationUtil.staticTest02.getSrr2() = " + ConfigurationUtil.staticTest02.getSrr2());
        System.out.println("ConfigurationUtil.staticTest02.getSrr3() = " + ConfigurationUtil.staticTest02.getSrr3());
        
        System.out.println("ConfigurationUtil.staticTest02.getMap1() = " + ConfigurationUtil.staticTest02.getMap1());
        System.out.println("ConfigurationUtil.staticTest02.getMap2() = " + ConfigurationUtil.staticTest02.getMap2());
        
        System.out.println("ConfigurationUtil.staticTest02.getPet1() = " + ConfigurationUtil.staticTest02.getPet1());
        System.out.println("ConfigurationUtil.staticTest02.getPet2() = " + ConfigurationUtil.staticTest02.getPet2());
        
    }
    
}

@Data
class Pet {
    
    private String name;
    private Integer age;
    
    @Override
    public String toString() {
        return "|name=" + name + "|age=" + age + '|';
    }
    
}

三、自定义解析类，直接暴力读取yml配置文件

 配置文件：

#####自定义解析类，直接暴力读取yml配置文件#####

# 属性(String/Byte/Short/Integer/Long/Float/Double/Character/Boolean)
properties.username1=大傻逼

# 数组/集合(Arrays/List/Set)
arrys.srr1=1,2,3,4,5
arrys.srr2=1.1,2.2,3.3,4.4,5.5

# 键值对(Map)
maps.map1.key1=vlaue1

# 对象(Object)
pets.pet1.name=小汪
pets.pet1.age=1

注入/解析类： 

package parseconfiguration;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.core.io.ClassPathResource;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.nio.charset.StandardCharsets;
import java.util.Properties;

/**
 * 自定义解析类，直接暴力读取yml配置文件
 *
 * @author Chenghe Xu
 * @date 2023/2/17 15:48
 */
public class Test05 {
    
    public static void main(String[] args) {
//        Properties properties = ConfigurationReader.properties;
        Properties properties = ConfigurationReader.getProperties();
        
        System.out.print("properties = |");
        properties.forEach((k, v) -> {
            System.out.print(k + "=");
            System.out.print(v + "|");
        });
        System.out.println();
        
        System.out.println("properties.username1 = " + ConfigurationReader.getProperty("properties.username1"));
        System.out.println("arrys.srr1 = " + ConfigurationReader.getProperty("arrys.srr1"));
        System.out.println("arrys.srr2 = " + ConfigurationReader.getProperty("arrys.srr2"));
        System.out.println("maps.map1.key1 = " + ConfigurationReader.getProperty("maps.map1.key1"));
        System.out.println("pets.pet1.name = " + ConfigurationReader.getProperty("pets.pet1.name"));
        System.out.println("pets.pet1.age = " + ConfigurationReader.getProperty("pets.pet1.age"));
        
    }
    
}

class ConfigurationReader {
    
    private static final Logger LOGGER = LoggerFactory.getLogger(Test05.class);
    
//    public static Properties properties = new Properties();
    private static Properties properties = new Properties();
    
    public static Properties getProperties() {
        return properties;
    }
    
    public static String getProperty(String key){
        return properties.getProperty(key);
    }
    
    /**
     * static语句块的作用：
     * 由于static修饰的变量或语句块会在类被加载时，仅且执行一次
     * 所以可以进行调用方法初始化(静态)成员变量
     * 即可以通过访问类名访问静态成员变量或其Get方法
     */
    static {
        init();
    }
    
    public static void init() {
        InputStream inputStream = null;
        InputStreamReader inputStreamReader = null;
        BufferedReader bufferedReader = null;
        try {
            // 可解析多个配置文件
            String[] paths = {"application-Test05.properties"};
            for (String path : paths) {
                ClassPathResource resource = new ClassPathResource(path);
                // 处理中文乱码
                inputStream = resource.getInputStream();
//                inputStreamReader = new InputStreamReader(inputStream, "UTF-8");
//                inputStreamReader = new InputStreamReader(inputStream, "utf-8");
                inputStreamReader = new InputStreamReader(inputStream, StandardCharsets.UTF_8);
                bufferedReader = new BufferedReader(inputStreamReader);
//                properties.load(inputStreamReader);
                properties.load(bufferedReader);
            }
            // 关闭资源
            inputStream.close();
            inputStreamReader.close();
            bufferedReader.close();
            LOGGER.info("读取完成");
        } catch (IOException e) {
            LOGGER.error("无法读取配置文件");
        }
    }
    
}

四、Spring配置文件的解析类Environment获取式

 配置文件：

#####Spring配置文件的解析类Environment获取式#####
myproperties:
  es:
    index:
      type:
        documents:
          fields: 小徐001,小徐002,小徐003

注入/解析类：

package parseconfiguration;

import autowired.SubGenericityApplication;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.core.env.Environment;

/**
 * Spring配置文件的解析类Environment获取式
 *
 * @author Chenghe Xu
 * @date 2023/2/21 15:29
 */
@SpringBootTest(classes = SubGenericityApplication.class)
public class Test06 {
    
    // Spring配置文件的解析类
    @Autowired
    private Environment environment;
    
    @Test
    public void test1() {
        
        // 直接匹配获取
        String stringArrays01 = environment.getProperty("myproperties.es.index.type.documents.fields");
        System.out.println("stringArrays01 = " + stringArrays01);
    
        // 指定类型获取
        String[] arrays01 = environment.getProperty("myproperties.es.index.type.documents.fields", String[].class);
        System.out.print("arrays01 = |");
        for (String s : arrays01) {
            System.out.print(s + "|");
        }
        System.out.println();
    
        // 带默认值获取
        String stringArrays02 = environment.getProperty("myproperties.es.index.type.documents.fields01", "没有配置该属性");
        System.out.println("stringArrays02 = " + stringArrays02);
    
        // 综合类型和默认值
        String[] arrays02 = environment.getProperty("myproperties.es.index.type.documents.fields01", 
                String[].class, new String[]{"小徐004","小徐005","小徐006"});
        System.out.print("arrays02 = |");
        for (String s : arrays02) {
            System.out.print(s + "|");
        }
        System.out.println();
        
    }
    
}
BB-X
关注
  • 3
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
SpringBoot配置-读取 .yml配置文件
总该长大了的博客
03-13 7万+
之前会使用springboot，但基础知识掌握的不扎实，今天看了关于配置文件，下边稍作整理一下：大家都知道springboot的优点是配置文件少，相比springMVC少了很多的配置文件，下面就介绍一下springboot中的配置文件，传统的springboot的配置文件是以properties结尾的，如图所示：springboot出了一种新的方法，文件是这样的例如上图中的salary ：1000...
SpringBoot中properties、yaml、yml的优先级
Knight
06-16 3579
properties的优先级高(当只有properties，yml，yaml)优先级低的配置会被先加载，所以优先级高的配置会覆盖优先级低的配置。properties（最高）> yml > yaml(最低)yml的优先级高(当只有yml，yaml)
yml配置文件解析
最新发布
qq_52312147的博客
05-20 696
当你设置了上下文路径后，所有的请求URI必须以该上下文路径开头，才能访问到应用程序3。(2) springboot .yml配置所有内容总结_boot.yml-CSDN博客. https://blog.csdn.net/youtiantin/article/details/118113839.(1) Spring Boot项目中yml文件的常见配置 - CSDN博客. https://blog.csdn.net/melck/article/details/133094420.Spring Boot的。
SpringBoot配置文件的注入和读取
m0_65190367的博客
05-26 1323
首先：二者的功能都是一样的，.properties 文件是最早期的文件格式， 也是SpringBoot 的默认文件，项目诞生之初就自带的，而 .yml 是后来为了提高效率而衍生出的另一种格式，它相对于前者更写法更简洁，功能更强大，但唯一的不足在于新手容易写错，工作中最常用的是 .yml格式。其次：这两种文件在一个项目中理论上可以同时存在，但一般开发不会这样使用，尽量统一使用一种，因为这两种文件都存在的情况下，框架会优先加载 properties 文件，另一方面统一有助于代码的读写。
静态方法调用yml配置文件中的值
PhilsphyPrgram的博客
10-13 2122
InitializingBean使用
快速理解yaml(yml)和properties文件
热门推荐
Mango的博客
02-11 2万+
一、两种文件的区别 1.语法上的区别 yaml语法如下： server: port: 8081 servlet: context-path: /mango properties语法如下： # 设置服务器端口号 server.port=8081 # 修改上下文路径 server.servlet.context-path=/mango 注：以上两种语法所表示的效果相同。 二、两种文...
SpringBoot配置
凉茶铺的博客
04-08 1473
SpringBoot是基于约定的，所以很多配置都有默认值，但如果想使用自己的配置替换默认配置的话，就可以使用application.properties或者application.yml（application.yaml）进行配置。默认配置文件名称：application在同一级目录下优先级为：properties > yaml > yml例如：配置内置Tomcat的端口properties：yml:大小写敏感数据值前边必须有空格，作为分隔符使用缩进表示层级关系缩进时不允许使用Tab键，只允许使用空格（各个
解析yml、yaml的工具类库文件
04-27
在IT行业中，YAML（YAML Ain't Markup Language）是一种数据序列化语言，常用于配置文件和数据交换。它的语法简洁、清晰，易于人类阅读，同时也方便机器解析。标题提到的"解析yml、yaml的工具类库文件"是关于处理...
9种yml/properties配置文件文件读取方式
04-20
java对yml/properties配置文件文件读取方式，，列举了9种方式，10个使用技巧，@Value中 static变量、@Value中集合、@ConfigurationProperties读取为实体类、@PropertySource加载自定义yml文件、...
SpringBoot获取yml和properties配置文件的内容
08-30
Spring Boot支持两种主要的配置文件格式：`application.properties`和`application.yml`。这两种格式都允许开发者以结构化的方式存储和管理应用程序的配置参数。 首先，让我们关注`yml`配置文件。YAML (YAML Ain't ...
SpringBoot yml配置文件调用过程解析
08-25
SpringBoot 框架提供了多种方式来配置和管理应用程序的参数和配置文件，其中 yml 配置文件是一种非常流行和常用的配置文件格式。了解 SpringBoot yml 配置文件的调用过程是非常重要的，本文将详细介绍 SpringBoot ...
详解springboot读取yml配置的几种方式
08-25
主要介绍了详解springboot读取yml配置的几种方式，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
python解析yml配置文件
Boush
02-24 5261
本文主要演示如何使用 python 代码，解析 yml 格式的配置文件，并将配置文件中的内容打印出来。
深入Spring Boot (四)：YAML属性配置文件使用详解
weixin_34248487的博客
03-05 2527
Spring Boot弱化配置的特性让属性配置文件的使用也更加便捷，它默认支持对application.properties或application.yml属性配置文件处理，即在application.properties或application.yml文件中添加属性配置，可以使用@Value注解将属性值注入到beans中，或使用@ConfigurationProperties注解将属性值绑定到结...
【玩转SpringBoot】配置文件yml的正确打开姿势
李新杰的CSDN
09-26 6885
序言在很久以前，Spring的配置文件是基于XML的。它的名字就是applicationContext.xml，没错，就只有这一个xml文件。它里面配置了所有的东西。但是...
springboot单元测试读取yml文件
mySherlock的博客
04-24 6529
pom文件配置 <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter</artifactId> ...
Java SpringBoot 读取、使用yaml文件类型的简述，和对集合list的使用解析
Counter-Strike大牛
08-10 1万+
基本类型的使用 yml文件大部分使用的都是字符串，如果想使用其它类型，只要直接按其它类型写变量值就可以了。 举例： #使用boolean my-switch: is-on: true Java中使用只要加上@Value就可以了： @Value(&quot;${my-switch.is-on}&quot;) private boolean switchOn; 使用其它类型也是一样的。 集...
java编辑yml_springboot yml配置文件注入值
weixin_39959369的博客
12-24 278
1.编写javabean:package com.example.springboot.bean;import org.springframework.boot.context.properties.ConfigurationProperties;import org.springframework.stereotype.Component;import java.util.Date;import...
java 解析 yaml
xin.wang的博客
06-15 6000
当前还在维护的YAML解析器/生成器有： SnakeYAML 完整的YAML 1.1解析器，尤其是SnakeYAML能够分析来自于规范的所有示例支持Unicode，包括UTF-8/UTF-16的输入/输出为序列化和反序列化本地的Java对象提供了高级API支持YAML类型库中的所有类型比较理性的错误信息 YamlBeans：支持YAML 1.0和1.1FasterXML/jackso
springboot2读取yml配置文件的几种方式
05-13
在Spring Boot 2中，可以使用以下几种方式读取YAML配置文件： 1. 通过@ConfigurationProperties注解读取YAML配置文件 @Configuration @ConfigurationProperties(prefix = "myconfig") public class MyConfig { private String name; private int age; //省略getter/setter } 在YAML配置文件中配置： myconfig: name: "Tom" age: 20 2. 通过@Value注解读取YAML配置文件 @Value("${myconfig.name}") private String name; @Value("${myconfig.age}") private int age; 在YAML配置文件中配置： myconfig: name: "Tom" age: 20 3. 通过Environment读取YAML配置文件 @Autowired private Environment env; String name = env.getProperty("myconfig.name"); int age = Integer.parseInt(env.getProperty("myconfig.age")); 在YAML配置文件中配置： myconfig: name: "Tom" age: 20 以上三种方式都可以读取YAML配置文件，选择哪种方式，要根据具体的业务场景和个人喜好来决定。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

BB-X

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值