JavaSpringBootyml
除了烂大街的@Value@ConfigurationProperties外,还能够通过哪些方式,来读取yml配置文件的内容。

1、Environment

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

  1. person:
  2. name: hydra
  3. gender: male
  4. age: 18

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

  1. @RestController
  2. public class EnvironmentController {
  3. @Autowired
  4. private Environment environment;
  5. @GetMapping("envTest")
  6. private void getEnv(){
  7. System.out.println(environment.getProperty("person.name"));
  8. System.out.println(environment.getProperty("person.gender"));
  9. Integer autoClose = environment
  10. .getProperty("person.age", Integer.class);
  11. System.out.println(autoClose);
  12. String defaultValue = environment
  13. .getProperty("person.other", String.class, "defaultValue");
  14. System.out.println(defaultValue);
  15. }
  16. }

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

  1. hydra
  2. male
  3. 18
  4. defaultValue

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

  1. spring:
  2. profiles:
  3. active: pro

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

  1. @GetMapping("getActiveEnv")
  2. private void getActiveEnv(){
  3. System.out.println(environment.acceptsProfiles("pro"));
  4. System.out.println(environment.acceptsProfiles("dev"));
  5. String[] activeProfiles = environment.getActiveProfiles();
  6. for (String activeProfile : activeProfiles) {
  7. System.out.println(activeProfile);
  8. }
  9. }

打印结果:

  1. true
  2. false
  3. pro

2、YamlPropertiesFactoryBean

在Spring中还可以使用YamlPropertiesFactoryBean来读取自定义配置的yml文件,而不用再被拘束于application.yml及其激活的其他配置文件。
在使用过程中,只需要通过setResources()方法设置自定义yml配置文件的存储路径,再通过getObject()方法获取Properties对象,后续就可以通过它获取具体的属性,下面看一个例子:

  1. @GetMapping("fcTest")
  2. public void ymlProFctest(){
  3. YamlPropertiesFactoryBean yamlProFb = new YamlPropertiesFactoryBean();
  4. yamlProFb.setResources(new ClassPathResource("application2.yml"));
  5. Properties properties = yamlProFb.getObject();
  6. System.out.println(properties.get("person2.name"));
  7. System.out.println(properties.get("person2.gender"));
  8. System.out.println(properties.toString());
  9. }

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

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

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

  1. @Value("${person2.name:null}")
  2. private String name;
  3. @Value("${person2.gender:null}")
  4. private String gender;
  5. @GetMapping("fcTest2")
  6. public void ymlProFctest2(){
  7. System.out.println(name);
  8. System.out.println(gender);
  9. }

先调用一次fcTest接口,再调用fcTest2接口时会打印null值:

  1. null
  2. null

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

  1. @Configuration
  2. public class PropertyConfig {
  3. @Bean
  4. public static PropertySourcesPlaceholderConfigurer placeholderConfigurer() {
  5. PropertySourcesPlaceholderConfigurer configurer
  6. = new PropertySourcesPlaceholderConfigurer();
  7. YamlPropertiesFactoryBean yamlProFb
  8. = new YamlPropertiesFactoryBean();
  9. yamlProFb.setResources(new ClassPathResource("application2.yml"));
  10. configurer.setProperties(yamlProFb.getObject());
  11. return configurer;
  12. }
  13. }

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

  1. fcant
  2. female

除了使用YamlPropertiesFactoryBean将yml解析成Properties外,其实还可以使用YamlMapFactoryBean解析yml成为Map,使用方法非常类似:

  1. @GetMapping("fcMapTest")
  2. public void ymlMapFctest(){
  3. YamlMapFactoryBean yamlMapFb = new YamlMapFactoryBean();
  4. yamlMapFb.setResources(new ClassPathResource("application2.yml"));
  5. Map<String, Object> map = yamlMapFb.getObject();
  6. System.out.println(map);
  7. }

打印结果:

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

3、监听事件

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

  1. public class YmlListener implements
  2. ApplicationListener<ApplicationEnvironmentPreparedEvent> {
  3. private String ymlFilePath;
  4. public YmlListener(String ymlFilePath){
  5. this.ymlFilePath = ymlFilePath;
  6. }
  7. //...
  8. }

自定义的监听器中需要实现接口的onApplicationEvent()方法,当监听到ApplicationEnvironmentPreparedEvent事件时会被触发:

  1. @Override
  2. public void onApplicationEvent(ApplicationEnvironmentPreparedEvent event) {
  3. ConfigurableEnvironment environment = event.getEnvironment();
  4. ResourceLoader loader = new DefaultResourceLoader();
  5. YamlPropertySourceLoader ymlLoader = new YamlPropertySourceLoader();
  6. try {
  7. List<PropertySource<?>> sourceList = ymlLoader
  8. .load(ymlFilePath, loader.getResource(ymlFilePath));
  9. for (PropertySource<?> propertySource : sourceList) {
  10. environment.getPropertySources().addLast(propertySource);
  11. }
  12. } catch (IOException e) {
  13. e.printStackTrace();
  14. }
  15. }

上面的代码中,主要实现了:

  • 获取当前环境Environment,当ApplicationEnvironmentPreparedEvent事件被触发时,已经完成了Environment的装载,并且能够通过event事件获取
  • 通过YamlPropertySourceLoader加载、解析配置文件
  • 将解析完成后的OriginTrackedMapPropertySource添加到Environment

修改启动类,在启动类中加入这个监听器:

  1. public static void main(String[] args) {
  2. SpringApplication application = new SpringApplication(MyApplication.class);
  3. application.addListeners(new YmlListener("classpath:/application2.yml"));
  4. application.run(args);
  5. }

在向environment中添加propertySource前加一个断点,查看环境的变化。
执行完成后,可以看到配置文件源已经被添加到了环境中。
启动完成后再调用一下接口,查看结果:

  1. Fcant
  2. female

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

4、SnakeYml

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

  1. <dependency>
  2. <groupId>org.yaml</groupId>
  3. <artifactId>snakeyaml</artifactId>
  4. <version>1.23</version>
  5. </dependency>

准备一个yml配置文件:

  1. person1:
  2. name: hydra
  3. gender: male
  4. person2:
  5. name: fcant
  6. gender: female

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

  1. public void test1(){
  2. Yaml yaml=new Yaml();
  3. Map<String, Object> map =
  4. yaml.load(getClass().getClassLoader()
  5. .getResourceAsStream("snake1.yml"));
  6. System.out.println(map);
  7. }

运行上面的代码,打印Map中的内容:

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

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

  1. person1:
  2. name: hydra
  3. gender: male
  4. ---
  5. person2:
  6. name: fcant
  7. gender: female

在添加了连接符后,尝试再使用load方法进行解析,报错显示发现了另一段yml文档从而无法正常解析。
这时候修改上面的代码,使用loadAll方法:

  1. public void test2(){
  2. Yaml yaml=new Yaml();
  3. Iterable<Object> objects =
  4. yaml.loadAll(getClass().getClassLoader()
  5. .getResourceAsStream("snake2.yml"));
  6. for (Object object : objects) {
  7. System.out.println(object);
  8. }
  9. }

执行结果如下:

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

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

  1. @Data
  2. public class Person {
  3. SinglePerson person1;
  4. SinglePerson person2;
  5. }
  6. @Data
  7. public class SinglePerson {
  8. String name;
  9. String gender;
  10. }

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

  1. public void test3(){
  2. Yaml yaml=new Yaml();
  3. Person person =
  4. yaml.loadAs(getClass().getClassLoader().
  5. getResourceAsStream("snake1.yml"), Person.class);
  6. System.out.println(person.toString());
  7. }

查看执行结果:

  1. Person(person1=SinglePerson(name=hydra, gender=male), person2=SinglePerson(name=fcant, gender=female))

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

  1. public void test4(){
  2. Yaml yaml=new Yaml(new Constructor(Person.class));
  3. Person person = yaml.load(getClass().getClassLoader().
  4. getResourceAsStream("snake1.yml"));
  5. System.out.println(person.toString());
  6. }

执行结果与上面相同:

  1. Person(person1=SinglePerson(name=hydra, gender=male), person2=SinglePerson(name=fcant, gender=female))

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

5、jackson-dataformat-yaml

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

  1. <dependency>
  2. <groupId>com.fasterxml.jackson.dataformat</groupId>
  3. <artifactId>jackson-dataformat-yaml</artifactId>
  4. <version>2.12.3</version>
  5. </dependency>

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

  1. public void read() throws IOException {
  2. ObjectMapper objectMapper = new ObjectMapper(new YAMLFactory());
  3. InputStream input =
  4. new FileInputStream("F:\\Work\\yml\\src\\main\\resources\\snake1.yml");
  5. Person person = objectMapper.readValue(input, Person.class);
  6. System.out.println(person.toString());
  7. }

运行结果:

  1. Person(person1=SinglePerson(name=hydra, gender=male), person2=SinglePerson(name=fcant, gender=female))

如果想要生成yml文件的话,可以调用ObjectMapperwriteValue方法实现:

  1. public void write() throws IOException {
  2. Map<String,Object> map=new HashMap<>();
  3. SinglePerson person1 = new SinglePerson("Trunks", "male");
  4. SinglePerson person2 = new SinglePerson("Goten", "male");
  5. Person person=new Person(person1,person2);
  6. map.put("person",person);
  7. ObjectMapper objectMapper = new ObjectMapper(new YAMLFactory());
  8. objectMapper
  9. .writeValue(new File("F:\\Work\\yml\\src\\main\\resources\\jackson-gen.yml"),map);
  10. }

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

总结

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