Java开发日记之你会不会5种牛的yml文件读取方式_Java

前言

除了烂大街的@value和@configurationproperties外，还能够通过哪些方式，来读取yml配置文件的内容？

1、environment

在spring中有一个类environment，它可以被认为是当前应用程序正在运行的环境，它继承了propertyresolver接口，因此可以作为一个属性解析器使用。先创建一个yml文件，属性如下：

person:
  name: hydra
  gender: male
  age: 18

使用起来也非常简单，直接使用@autowired就可以注入到要使用的类中，然后调用它的getproperty()方法就可以根据属性名称取出对应的值了。

@restcontroller
public class environmentcontroller {
    @autowired
    private environment environment;
    @getmapping("envtest")
    private void getenv(){
        system.out.println(environment.getproperty("person.name"));
        system.out.println(environment.getproperty("person.gender"));
        integer autoclose = environment
            .getproperty("person.age", integer.class);
        system.out.println(autoclose);
        string defaultvalue = environment
            .getproperty("person.other", string.class, "defaultvalue");
        system.out.println(defaultvalue);
    }
}

在上面的例子中可以看到，除了简单的获取外，environment提供的方法还可以对取出的属性值进行类型转换、以及默认值的设置，调用一下上面的接口，打印结果如下：

hydra
male
18
defaultvalue

除了获取属性外，还可以用来判断激活的配置文件，先在application.yml中激活pro文件：

spring:
  profiles:
    active: pro

可以通过acceptsprofiles方法来检测某一个配置文件是否被激活加载，或者通过getactiveprofiles方法拿到所有被激活的配置文件。测试接口：

@getmapping("getactiveenv")
private void getactiveenv(){
    system.out.println(environment.acceptsprofiles("pro"));
    system.out.println(environment.acceptsprofiles("dev"));
    string[] activeprofiles = environment.getactiveprofiles();
    for (string activeprofile : activeprofiles) {
        system.out.println(activeprofile);
    }
}

打印结果：

true
false
pro

2、yamlpropertiesfactorybean

在spring中还可以使用yamlpropertiesfactorybean来读取自定义配置的yml文件，而不用再被拘束于application.yml及其激活的其他配置文件。

在使用过程中，只需要通过setresources()方法设置自定义yml配置文件的存储路径，再通过getobject()方法获取properties对象，后续就可以通过它获取具体的属性，下面看一个例子：

@getmapping("fctest")
public void ymlprofctest(){
    yamlpropertiesfactorybean yamlprofb = new yamlpropertiesfactorybean();
    yamlprofb.setresources(new classpathresource("application2.yml"));
    properties properties = yamlprofb.getobject();
    system.out.println(properties.get("person2.name"));
    system.out.println(properties.get("person2.gender"));
    system.out.println(properties.tostring());
}

查看运行结果，可以读取指定的application2.yml的内容：

fcant
female
{person2.age=18, person2.gender=female, person2.name=fcant}

但是这样的使用中有一个问题，那就是只有在这个接口的请求中能够取到这个属性的值，如果再写一个接口，不使用yamlpropertiesfactorybean读取配置文件，即使之前的方法已经读取过这个yml文件一次了，第二个接口取到的仍然还是空值。来对这个过程进行一下测试：

@value("${person2.name:null}")
private string name;
@value("${person2.gender:null}")
private string gender;
@getmapping("fctest2")
public void ymlprofctest2(){
    system.out.println(name);
    system.out.println(gender);
}

先调用一次fctest接口，再调用fctest2接口时会打印null值：

null
null

想要解决这个问题也很简单，可以配合propertysourcesplaceholderconfigurer使用，它实现了beanfactorypostprocessor接口，也就是一个bean工厂后置处理器的实现，可以将配置文件的属性值加载到一个properties文件中。使用方法如下：

@configuration
public class propertyconfig {
    @bean
    public static propertysourcesplaceholderconfigurer placeholderconfigurer() {
        propertysourcesplaceholderconfigurer configurer 
            = new propertysourcesplaceholderconfigurer();
        yamlpropertiesfactorybean yamlprofb 
            = new yamlpropertiesfactorybean();
        yamlprofb.setresources(new classpathresource("application2.yml"));
        configurer.setproperties(yamlprofb.getobject());
        return configurer;
    }
}

再次调用之前的接口，结果如下，可以正常的取到application2.yml中的属性：

fcant
female

除了使用yamlpropertiesfactorybean将yml解析成properties外，其实还可以使用yamlmapfactorybean解析yml成为map，使用方法非常类似：

@getmapping("fcmaptest")
public void ymlmapfctest(){
    yamlmapfactorybean yamlmapfb = new yamlmapfactorybean();
    yamlmapfb.setresources(new classpathresource("application2.yml"));
    map<string, object> map = yamlmapfb.getobject();
    system.out.println(map);
}

打印结果：

{person2={name=fcant, gender=female, age=18}}

3、监听事件

springboot是通过监听事件的方式来加载和解析的yml文件，那么也可以仿照这个模式，来加载自定义的配置文件。
首先，定义一个类实现applicationlistener接口，监听的事件类型为applicationenvironmentpreparedevent，并在构造方法中传入要解析的yml文件名：

public class ymllistener implements 
    applicationlistener<applicationenvironmentpreparedevent> {
    private string ymlfilepath;
    public ymllistener(string ymlfilepath){
        this.ymlfilepath = ymlfilepath;
    }
    //...
}

自定义的监听器中需要实现接口的onapplicationevent()方法，当监听到applicationenvironmentpreparedevent事件时会被触发：

@override
public void onapplicationevent(applicationenvironmentpreparedevent event) {
    configurableenvironment environment = event.getenvironment();
    resourceloader loader = new defaultresourceloader();
    yamlpropertysourceloader ymlloader = new yamlpropertysourceloader();
    try {
        list<propertysource<?>> sourcelist = ymlloader
            .load(ymlfilepath, loader.getresource(ymlfilepath));
        for (propertysource<?> propertysource : sourcelist) {
            environment.getpropertysources().addlast(propertysource);
        }
    } catch (ioexception e) {
        e.printstacktrace();
    }
}

上面的代码中，主要实现了：

获取当前环境environment，当applicationenvironmentpreparedevent事件被触发时，已经完成了environment的装载，并且能够通过event事件获取
通过yamlpropertysourceloader加载、解析配置文件
将解析完成后的origintrackedmappropertysource添加到environment中

修改启动类，在启动类中加入这个监听器：

public static void main(string[] args) {
    springapplication application = new springapplication(myapplication.class);
    application.addlisteners(new ymllistener("classpath:/application2.yml"));
    application.run(args);
}

在向environment中添加propertysource前加一个断点，查看环境的变化。
执行完成后，可以看到配置文件源已经被添加到了环境中。

启动完成后再调用一下接口，查看结果：

fcant
female

能够正确的取到配置文件中的值，说明自定义的监听器已经生效。

4、snakeyml

前面介绍的几种方式，在spring环境下无需引入其他依赖就可以完成的，接下来要介绍的snakeyml在使用前需要引入依赖，但是同时也可以脱离spring环境单独使用。先引入依赖坐标：

<dependency>
    <groupid>org.yaml</groupid>
    <artifactid>snakeyaml</artifactid>
    <version>1.23</version>
</dependency>

准备一个yml配置文件：

person1:
  name: hydra
  gender: male
person2:
  name: fcant
  gender: female

在使用snakeyml解析yml时，最常使用的就是load、loadlall、loadas方法，这三个方法可以加载yml文件或字符串，最后返回解析后的对象。先从基础的load方法开始演示：

public void test1(){
    yaml yaml=new yaml();
    map<string, object> map =
            yaml.load(getclass().getclassloader()
                    .getresourceasstream("snake1.yml"));
    system.out.println(map);
}

运行上面的代码，打印map中的内容：

{person1={name=hydra, gender=male}, person2={name=fcant, gender=female}}

接下来看一下loadall方法，它可以用来加载yml中使用—-连接符连接的多个文档，将上面的yml文件进行修改：

person1:
  name: hydra
  gender: male
---
person2:
  name: fcant
  gender: female

在添加了连接符后，尝试再使用load方法进行解析，报错显示发现了另一段yml文档从而无法正常解析。

这时候修改上面的代码，使用loadall方法：

public void test2(){
    yaml yaml=new yaml();
    iterable<object> objects = 
        yaml.loadall(getclass().getclassloader()
            .getresourceasstream("snake2.yml"));
    for (object object : objects) {
        system.out.println(object);
    }
}

执行结果如下：

{person1={name=hydra, gender=male}}
{person2={name=fcant, gender=female}}

可以看到，loadall方法返回的是一个对象的迭代，里面的每个对象对应yml中的一段文档，修改后的yml文件就被解析成了两个独立的map。
接下来再来看一下loadas方法，它可以在yml解析过程中指定类型，直接封装成一个对象。直接复用上面的snake1.yml，在解析前先创建两个实体类对象用于接收：

@data
public class person {
    singleperson person1;
    singleperson person2;
}
@data
public class singleperson {
    string name;
    string gender;
}

下面使用loadas方法加载yml，注意方法的第二个参数，就是用于封装yml的实体类型。

public void test3(){
    yaml yaml=new yaml();
    person person = 
        yaml.loadas(getclass().getclassloader().
            getresourceasstream("snake1.yml"), person.class);
    system.out.println(person.tostring());
}

查看执行结果：

person(person1=singleperson(name=hydra, gender=male), person2=singleperson(name=fcant, gender=female))

实际上，如果想要将yml封装成实体对象，也可以使用另一种方法。在创建yaml对象的时候，传入一个指定实体类的构造器对象，然后直接调用load方法就可以实现：

public void test4(){
    yaml yaml=new yaml(new constructor(person.class));
    person person = yaml.load(getclass().getclassloader().
            getresourceasstream("snake1.yml"));
    system.out.println(person.tostring());
}

执行结果与上面相同：

person(person1=singleperson(name=hydra, gender=male), person2=singleperson(name=fcant, gender=female))

snakeyml其实实现了非常多的功能，这里就不一一列举了，有兴趣的小伙伴可以自己查看一下文档。其实在springboot的底层，也是借助了snakeyml来进行的yml的解析操作。

5、jackson-dataformat-yaml

相比大家平常用jackson比较多的场景是用它来处理json，其实它也可以用来处理yml，使用前需要引入依赖：

<dependency>
    <groupid>com.fasterxml.jackson.dataformat</groupid>
    <artifactid>jackson-dataformat-yaml</artifactid>
    <version>2.12.3</version>
</dependency>

使用jackson读取yml也非常简单，这里用到了常用的objectmapper，在创建objectmapper对象时指定使用yaml工厂，之后就可以简单的将yml映射到实体：

public void read() throws ioexception {
    objectmapper objectmapper = new objectmapper(new yamlfactory());
    inputstream input =
        new fileinputstream("f:\\work\\yml\\src\\main\\resources\\snake1.yml");
    person person = objectmapper.readvalue(input, person.class);
    system.out.println(person.tostring());
}

运行结果：

person(person1=singleperson(name=hydra, gender=male), person2=singleperson(name=fcant, gender=female))

如果想要生成yml文件的话，可以调用objectmapper的writevalue方法实现：

public void write() throws ioexception {
    map<string,object> map=new hashmap<>();
    singleperson person1 = new singleperson("trunks", "male");
    singleperson person2 = new singleperson("goten", "male");
    person person=new person(person1,person2);
    map.put("person",person);
    objectmapper objectmapper = new objectmapper(new yamlfactory());
    objectmapper
            .writevalue(new file("f:\\work\\yml\\src\\main\\resources\\jackson-gen.yml"),map);
}

查看生成的yml文件，可以看到jackson对字符串类型严格的添加了引号，还在文档的开头添加了yml的链接符。至于其他jackson读写yml的复杂功能，可以在工作中自己去探索使用。

总结

这里介绍了5种读取yml配置文件的方式，前3种依赖于spring环境，而snakeyml和jackson则可以脱离环境独立使用，可以说它们是对@value和@configurationproperties注解使用的补充。这几种方法的使用场景不同，也各有各的有优点，各自具备一些特殊的用法，而在工作中更多情况下，要根据具体的用途进行一种方案的选取或多种的搭配使用。

到此这篇关于java开发日记之你会不会5种牛的yml文件读取方式的文章就介绍到这了,更多相关java yml文件读取方式内容请搜索代码网以前的文章或继续浏览下面的相关文章希望大家以后多多支持代码网！