java讀取解析application.yml

java讀取解析application.yml

不用依賴spring容器，可單獨使用。
bug已修改...

第一步、首先要2個jar

<!-- properties和yaml格式化 -->
<dependency>
    <groupId>com.fasterxml.jackson.dataformat</groupId>
    <artifactId>jackson-dataformat-yaml</artifactId>
    <version>2.9.8</version>
</dependency>
<dependency>
    <groupId>com.fasterxml.jackson.dataformat</groupId>
    <artifactId>jackson-dataformat-properties</artifactId>
    <version>2.9.8</version>
</dependency>

第二步、新建一個BootYaml.java

import cn.hutool.core.convert.Convert;
import cn.hutool.core.io.FileUtil;
import cn.hutool.core.io.resource.ClassPathResource;
import cn.hutool.core.map.MapUtil;
import cn.hutool.core.text.StrSpliter;
import cn.hutool.core.util.StrUtil;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonToken;
import com.fasterxml.jackson.dataformat.javaprop.JavaPropsFactory;
import com.fasterxml.jackson.dataformat.yaml.YAMLFactory;
import com.fasterxml.jackson.dataformat.yaml.YAMLGenerator;
import com.fasterxml.jackson.dataformat.yaml.YAMLParser;
import com.ynzhongxi.pay.utils.Tools;
import org.yaml.snakeyaml.Yaml;

import java.io.BufferedReader;
import java.io.IOException;
import java.nio.charset.Charset;
import java.util.LinkedHashMap;
import java.util.List;

/**
 * 寫一個SpringBoot讀取Yaml配置文件的類
 *
 * @author lixingwu
 */
public class BootYaml extends Yaml {
    /**
     * 環境配置路徑的鍵值
     */
    private String active;
    /**
     * 引入yml的鍵值
     */
    private String include;
    /**
     * 配置文件的前綴
     */
    private String prefix;

    /**
     * <p>方法名稱：根據application.yml轉化為LinkedHashMap.</p>
     * <p>詳細描述：會解析spring.profiles.active啟用的配置和spring.profiles.include引入的文件.</p>
     * <p>創建時間：2019-07-10 17:39:38</p>
     * <p>創建作者：李興武</p>
     * <p>修改記錄：</p>
     *
     * @param path application.yml
     * @return the linked hash map
     * @author "lixingwu"
     */
    public LinkedHashMap loadAs(String path) {
        // 組合一個map，把啟用的配置，引入的文件組合起來
        LinkedHashMap<String, Object> mapAll = new LinkedHashMap<>();
        LinkedHashMap<String, Object> mainMap = yml2Map(path);
        // 讀取啟用的配置
        Object active = mainMap.get(this.active);
        if (!Tools.isBlank(active)) {
            mapAll.putAll(yml2Map(StrUtil.format("{}-{}.yml", this.prefix, active)));
        }
        // 加載引入的yml
        Object include = mainMap.get(this.include);
        // include是使用逗號分隔開的，需要切割一下
        List<String> split = StrSpliter.split(Convert.toStr(include), StrUtil.C_COMMA, true, true);
        for (String inc : split) {
            mapAll.putAll(yml2Map(StrUtil.format("{}-{}.yml", this.prefix, inc)));
        }
        // 主配置覆蓋其他配置
        mapAll.putAll(mainMap);
        // 把map轉化為字符串
        String mapString = MapUtil.joinIgnoreNull(mapAll, "\n", "=");
        // 再把map字符串轉化為yamlStr字符串
        String yamlStr = properties2YamlStr(mapString);
        // 使用Yaml構建LinkedHashMap
        return super.loadAs(yamlStr, LinkedHashMap.class);
    }

    /**
     * <p>方法名稱：Yml 格式轉 LinkedHashMap.</p>
     * <p>詳細描述：轉載自 https://www.cnblogs.com/xujingyang/p/10613206.html .</p>
     * <p>創建時間：2019-07-10 09:30:19</p>
     * <p>創建作者：李興武</p>
     * <p>修改記錄：</p>
     *
     * @param path Yml路徑
     * @author "lixingwu"
     */
    public LinkedHashMap<String, Object> yml2Map(String path) {
        final String dot = ".";
        LinkedHashMap<String, Object> map = new LinkedHashMap<>();
        ClassPathResource resource = new ClassPathResource(path);
        // 文件不存在，置空
        if (Tools.isBlank(resource)) {
            return map;
        }
        BufferedReader reader = resource.getReader(Charset.defaultCharset());
        try {
            YAMLFactory yamlFactory = new YAMLFactory();
            YAMLParser parser = yamlFactory.createParser(reader);
            StringBuilder key = new StringBuilder();
            String value;
            JsonToken token = parser.nextToken();
            while (token != null) {
                if (!JsonToken.START_OBJECT.equals(token)) {
                    if (JsonToken.FIELD_NAME.equals(token)) {
                        if (key.length() > 0) {
                            key.append(dot);
                        }
                        key.append(parser.getCurrentName());

                        token = parser.nextToken();
                        if (JsonToken.START_OBJECT.equals(token)) {
                            continue;
                        }
                        value = parser.getText();
                        map.put(key.toString(), value);

                        int dotOffset = key.lastIndexOf(dot);
                        if (dotOffset > 0) {
                            key = new StringBuilder(key.substring(0, dotOffset));
                        }
                    } else if (JsonToken.END_OBJECT.equals(token)) {
                        int dotOffset = key.lastIndexOf(dot);
                        if (dotOffset > 0) {
                            key = new StringBuilder(key.substring(0, dotOffset));
                        } else {
                            key = new StringBuilder();
                        }
                    }
                }
                token = parser.nextToken();
            }
            parser.close();
            return map;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * <p>方法名稱：Properties內容轉化為yaml內容.</p>
     * <p>詳細描述：.</p>
     * <p>創建時間：2019-07-10 15:06:48</p>
     * <p>創建作者：李興武</p>
     * <p>修改記錄：</p>
     *
     * @param content Properties內容
     * @return the string
     * @author "lixingwu"
     */
    public String properties2YamlStr(String content) {
        // 臨時生成yml
        String filePath = FileUtil.getTmpDirPath() + "/temp.yml";

        JsonParser parser;
        JavaPropsFactory factory = new JavaPropsFactory();
        try {
            parser = factory.createParser(content);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        try {
            YAMLFactory yamlFactory = new YAMLFactory();
            YAMLGenerator generator = yamlFactory.createGenerator(FileUtil.getOutputStream(filePath));
            JsonToken token = parser.nextToken();
            while (token != null) {
                if (JsonToken.START_OBJECT.equals(token)) {
                    generator.writeStartObject();
                } else if (JsonToken.FIELD_NAME.equals(token)) {
                    generator.writeFieldName(parser.getCurrentName());
                } else if (JsonToken.VALUE_STRING.equals(token)) {
                    generator.writeString(parser.getText());
                } else if (JsonToken.END_OBJECT.equals(token)) {
                    generator.writeEndObject();
                }
                token = parser.nextToken();
            }
            parser.close();
            generator.flush();
            generator.close();
            // 讀取臨時生成yml的內容
            String ymlContent = FileUtil.readUtf8String(filePath);
            // 刪除臨時生成yml
            FileUtil.del(filePath);
            return ymlContent;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    public String getActive() {
        return active;
    }

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

    public String getInclude() {
        return include;
    }

    public void setInclude(String include) {
        this.include = include;
    }

    public String getPrefix() {
        return prefix;
    }

    public void setPrefix(String prefix) {
        this.prefix = prefix;
    }
}

第三步、創建工具類YmlPropUtils.java

import cn.hutool.core.convert.Convert;
import cn.hutool.core.text.StrSpliter;
import cn.hutool.core.util.StrUtil;
import com.ynzhongxi.pay.pojo.system.BootYaml;

import java.util.LinkedHashMap;
import java.util.List;

/**
 * 讀取application.yml件
 *
 * @author lixingwu
 */
public class YmlPropUtils {
    private LinkedHashMap prop;
    private static YmlPropUtils ymlPropUtils = new YmlPropUtils();

    /**
     * 私有構造，禁止直接創建
     */
    private YmlPropUtils() {
        BootYaml yaml = new BootYaml();
        yaml.setActive("spring.profiles.active");
        yaml.setInclude("spring.profiles.include");
        yaml.setPrefix("application");
        prop = yaml.loadAs("application.yml");
    }

    /**
     * 獲取單例
     *
     * @return YmlPropUtils
     */
    public static YmlPropUtils getInstance() {
        if (ymlPropUtils == null) {
            ymlPropUtils = new YmlPropUtils();
        }
        return ymlPropUtils;
    }

    /**
     * 根據屬性名讀取值
     * 先去主配置查詢，如果查詢不到，就去啟用配置查詢
     *
     * @param name 名稱
     */
    public Object getProperty(String name) {
        LinkedHashMap param = prop;
        List<String> split = StrSpliter.split(name, StrUtil.C_DOT, true, true);
        for (int i = 0; i < split.size(); i++) {
            if (i == split.size() - 1) {
                return param.get(split.get(i));
            }
            param = Convert.convert(LinkedHashMap.class, param.get(split.get(i)));
        }
        return null;
    }
}

第四步、測試一下

public static void main(String[] args) {
    Object property = YmlPropUtils.getInstance().getProperty("spring.datasource.type");
    System.out.println(property);
}

over！over！