5種高大上的yml檔案讀取方式，你知道嗎？

碼農參上發表於2022-01-21
原文網址 : https://www.cnblogs.com/trunks2008/p/15829085.html

原創：微信公眾號 碼農參上，歡迎分享，轉載請保留出處。

在上一篇文章中，我們從原始碼角度分析了SpringBoot解析yml配置檔案的全流程，那麼我們今天就來點實戰，總結一下除了爛大街的@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的內容：

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

但是這樣的使用中有一個問題，那就是隻有在這個介面的請求中能夠取到這個屬性的值，如果再寫一個介面，不使用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中的屬性：

susan
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=susan, 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前加一個斷點，檢視環境的變化：

執行完成後，可以看到配置檔案源已經被新增到了環境中：

啟動完成後再呼叫一下介面，檢視結果：

susan
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: susan
  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=susan, gender=female}}

接下來看一下loadAll方法，它可以用來載入yml中使用---連線符連線的多個文件，將上面的yml檔案進行修改：

person1:
  name: hydra
  gender: male
---
person2:
  name: susan
  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=susan, 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=susan, 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=susan, 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=susan, 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註解使用的補充。這幾種方法的使用場景不同，也各有各的優點，各自具備一些特殊的用法，而我們在工作中更多情況下，要根據具體的用途進行一種方案的選取或多種的搭配使用。

好了，希望這篇實戰能夠幫助到大家，我是Hydra，我們下篇再見。

作者簡介，碼農參上，一個熱愛分享的公眾號，有趣、深入、直接，與你聊聊技術。個人微信DrHydra9，歡迎新增好友，進一步交流。

相關文章