Yml转properties文件工具类YmlUtils（不用引任何插件和依赖）

约定不等于承诺〃 2022-09-07 14:48 157阅读 0赞

【诞生背景】

最近在做某配置中心的时候，配置中心采用properties格式进行配置的（如下图）。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3N1bm55enlx_size_16_color_FFFFFF_t_70][]

而我们工程的项目配置文件是yml格式的（如下图）。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3N1bm55enlx_size_16_color_FFFFFF_t_70 1][]

如果人为手动的一条一条，将yml文件中的配置数据，添加到配置中心，难免会消耗大量的人力和精力，况且还容易输入错误。因此，需要一个工具或插件，将 yml 文件的格式，转换为properties文件。

【Convert YAML and Properties File 插件的不足】

IDEA 有一个插件叫 Convert YAML and Properties File， 于是，首先用了一下 这个插件后，发现了，发现这个插件不太友好，具体有以下几点。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3N1bm55enlx_size_16_color_FFFFFF_t_70 2][]

比如，现在我们有如下的 yml 配置文件：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3N1bm55enlx_size_16_color_FFFFFF_t_70 3][] 我们用插件将它转化为 properties 文件。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3N1bm55enlx_size_16_color_FFFFFF_t_70 4][]

下面是转化后的效果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3N1bm55enlx_size_16_color_FFFFFF_t_70 5][]

从这转换后的效果，我们不难发现该插件有以下几点问题：

（1）转化后，原 yml 配置文件消失（如果转出了问题，想看原配置文件，还看不了了）；

（2）排序出现混乱，没有按照原 yml 文件数据进行输出（msg相关的配置本来在原yml文件中是第二个配置，转换后却成为了第一个；同理，mybatis的配置本是最后一个，转化后却放在了第二个）；

（3）所有注释均不见了（所有相关的注释全都不见了，包括行级注释和末尾注释）；

（4）某些值没有进行配置，但转化后，却显示为了 null 字符串（如 msg.sex 的配置）；

（5）该插件仅IDEA有，Eclipse中还没有，不能垮开发工具使用；

【自写小工具 YmlUtils 实现】

针对上面 IDEA 插件的不足，于是自己写了一款小工具 YmlUtils（源码在文章结尾处 ），你可以将它放在工程中的任何位置。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3N1bm55enlx_size_16_color_FFFFFF_t_70 6][]

现在，我们同样以刚刚的 yml 配置文件为测试模板，来测试下这款小工具。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3N1bm55enlx_size_16_color_FFFFFF_t_70 7][]

测试的方法很简单，只需要将 yml 配置文件放在根目录下，然后写个 Test 类，调用里面的 castProperties 方法即可。

YmlUtils.castProperties("application-test.yml");

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3N1bm55enlx_size_16_color_FFFFFF_t_70 8][]

执行方法后，首先我们可以看到控制台会将 porperties 文件的内容打印到控制台上面：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3N1bm55enlx_size_16_color_FFFFFF_t_70 9][]

程序运行完成后，根目录下会多出一个与yml同名的properties文件，该文件就直接拷贝到相应的地方进行使用，而且原文件也并未收到任何损坏和影响。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3N1bm55enlx_size_16_color_FFFFFF_t_70 10][]

**【源码展示】**

最后附上工具类源码，如果对你有用，记得一键三连（支持原创）。

package com.test.utils;
    
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileWriter;
    import java.io.IOException;
    import java.nio.charset.StandardCharsets;
    import java.util.*;
    
    /**
     * Yaml 配置文件转 Properties 配置文件工具类
     * @author https://zyqok.blog.csdn.net/
     * @since 2021/08/24
     */
    public class YmlUtils {
    
        /**
         * 将 yml 文件转化为 properties 文件
         *
         * @param ymlFileName 工程根目录下（非resources目录）的 yml 文件名称（如：abc.yml）
         * @return List<Node> 每个Nyml 文件中每行对应解析的数据
         */
        public static List<YmlNode> castProperties(String ymlFileName) {
            if (ymlFileName == null || ymlFileName.isEmpty() || !ymlFileName.endsWith(".yml")) {
                throw new RuntimeException("请输入yml文件名称！！");
            }
            File ymlFile = new File(ymlFileName);
            if (!ymlFile.exists()) {
                throw new RuntimeException("工程根目录下不存在 " + ymlFileName + "文件！！");
            }
            String fileName = ymlFileName.split(".yml", 2)[0];
            // 获取文件数据
            String yml = read(ymlFile);
            List<YmlNode> nodeList = getNodeList(yml);
            // 去掉多余数据，并打印
            String str = printNodeList(nodeList);
            // 将数据写入到 properties 文件中
            String propertiesName = fileName + ".properties";
            File file = new File(propertiesName);
            if (!file.exists()) {
                try {
                    file.createNewFile();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            try (FileWriter writer = new FileWriter(file)) {
                writer.write(str);
                writer.flush();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return nodeList;
        }
    
        /**
         * 将yml转化为porperties文件，并获取转化后的键值对
         *
         * @param ymlFileName 工程根目录下的 yml 文件名称
         * @return 转化后的 porperties 文件键值对Map
         */
        public static Map<String, String> getPropertiesMap(String ymlFileName) {
            Map<String, String> map = new HashMap<>();
            List<YmlNode> list = castProperties(ymlFileName);
            for (YmlNode node : list) {
                if (node.getKey().length() > 0) {
                    map.put(node.getKey(), node.getValue());
                }
            }
            return map;
        }
    
        private static String read(File file) {
            if (Objects.isNull(file) || !file.exists()) {
                return "";
            }
            try (FileInputStream fis = new FileInputStream(file)) {
                byte[] b = new byte[(int) file.length()];
                fis.read(b);
                return new String(b, StandardCharsets.UTF_8);
            } catch (IOException e) {
                e.printStackTrace();
            }
            return "";
        }
    
        private static String printNodeList(List<YmlNode> nodeList) {
            StringBuilder sb = new StringBuilder();
            for (YmlNode node : nodeList) {
                if (node.getLast().equals(Boolean.FALSE)) {
                    continue;
                }
                if (node.getEmptyLine().equals(Boolean.TRUE)) {
                    System.out.println();
                    sb.append("\r\n");
                    continue;
                }
                // 判断是否有行级注释
                if (node.getHeadRemark().length() > 0) {
                    String s = "# " + node.getHeadRemark();
                    System.out.println(s);
                    sb.append(s).append("\r\n");
                    continue;
                }
                // 判断是否有行末注释 (properties中注释不允许末尾注释，故而放在上面)
                if (node.getTailRemark().length() > 0) {
                    String s = "# " + node.getTailRemark();
                    System.out.println(s);
                    sb.append(s).append("\r\n");
                }
                //
                String kv = node.getKey() + "=" + node.getValue();
                System.out.println(kv);
                sb.append(kv).append("\r\n");
            }
            return sb.toString();
        }
    
        private static List<YmlNode> getNodeList(String yml) {
            String[] lines = yml.split("\r\n");
            List<YmlNode> nodeList = new ArrayList<>();
            Map<Integer, String> keyMap = new HashMap<>();
            Set<String> keySet = new HashSet<>();
            for (String line : lines) {
                YmlNode node = getNode(line);
                if (node.getKey() != null && node.getKey().length() > 0) {
                    int level = node.getLevel();
                    if (level == 0) {
                        keyMap.clear();
                        keyMap.put(0, node.getKey());
                    } else {
                        int parentLevel = level - 1;
                        String parentKey = keyMap.get(parentLevel);
                        String currentKey = parentKey + "." + node.getKey();
                        keyMap.put(level, currentKey);
                        node.setKey(currentKey);
                    }
                }
                keySet.add(node.getKey() + ".");
                nodeList.add(node);
            }
            // 标识是否最后一级
            for (YmlNode each : nodeList) {
                each.setLast(getNodeLast(each.getKey(), keySet));
            }
            return nodeList;
        }
    
        private static boolean getNodeLast(String key, Set<String> keySet) {
            if (key.isEmpty()) {
                return true;
            }
            key = key + ".";
            int count = 0;
            for (String each : keySet) {
                if (each.startsWith(key)) {
                    count++;
                }
            }
            return count == 1;
        }
    
        private static YmlNode getNode(String line) {
            YmlNode node = new YmlNode();
            // 初始化默认数据（防止NPE）
            node.setEffective(Boolean.FALSE);
            node.setEmptyLine(Boolean.FALSE);
            node.setHeadRemark("");
            node.setKey("");
            node.setValue("");
            node.setTailRemark("");
            node.setLast(Boolean.FALSE);
            node.setLevel(0);
            // 空行，不处理
            String trimStr = line.trim();
            if (trimStr.isEmpty()) {
                node.setEmptyLine(Boolean.TRUE);
                return node;
            }
            // 行注释，不处理
            if (trimStr.startsWith("#")) {
                node.setHeadRemark(trimStr.replaceFirst("#", "").trim());
                return node;
            }
            // 处理值
            String[] strs = line.split(":", 2);
            // 拆分后长度为0的，属于异常数据，不做处理
            if (strs.length == 0) {
                return node;
            }
            // 获取键
            node.setKey(strs[0].trim());
            // 获取值
            String value;
            if (strs.length == 2) {
                value = strs[1];
            } else {
                value = "";
            }
            // 获取行末备注
            String tailRemark = "";
            if (value.contains(" #")) {
                String[] vs = value.split("#", 2);
                if (vs.length == 2) {
                    value = vs[0];
                    tailRemark = vs[1];
                }
            }
            node.setTailRemark(tailRemark.trim());
            node.setValue(value.trim());
            // 获取当前层级
            int level = getNodeLevel(line);
            node.setLevel(level);
            node.setEffective(Boolean.TRUE);
            return node;
        }
    
        private static int getNodeLevel(String line) {
            if (line.trim().isEmpty()) {
                return 0;
            }
            char[] chars = line.toCharArray();
            int count = 0;
            for (char c : chars) {
                if (c != ' ') {
                    break;
                }
                count++;
            }
            return count / 2;
        }
    }
    
    class YmlNode {
    
        /** 层级关系 */
        private Integer level;
        /** 键 */
        private String key;
        /** 值 */
        private String value;
        /** 是否为空行 */
        private Boolean emptyLine;
        /** 当前行是否为有效配置 */
        private Boolean effective;
        /** 头部注释（单行注释） */
        private String headRemark;
        /** 末尾注释 */
        private String tailRemark;
        /** 是否为最后一层配置 */
        private Boolean last;
    
        public Boolean getLast() {
            return last;
        }
    
        public void setLast(Boolean last) {
            this.last = last;
        }
    
        public Integer getLevel() {
            return level;
        }
    
        public void setLevel(Integer level) {
            this.level = level;
        }
    
        public String getKey() {
            return key;
        }
    
        public void setKey(String key) {
            this.key = key;
        }
    
        public String getValue() {
            return value;
        }
    
        public void setValue(String value) {
            this.value = value;
        }
    
        public Boolean getEmptyLine() {
            return emptyLine;
        }
    
        public void setEmptyLine(Boolean emptyLine) {
            this.emptyLine = emptyLine;
        }
    
        public Boolean getEffective() {
            return effective;
        }
    
        public void setEffective(Boolean effective) {
            this.effective = effective;
        }
    
        public String getHeadRemark() {
            return headRemark;
        }
    
        public void setHeadRemark(String headRemark) {
            this.headRemark = headRemark;
        }
    
        public String getTailRemark() {
            return tailRemark;
        }
    
        public void setTailRemark(String tailRemark) {
            this.tailRemark = tailRemark;
        }
    
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3N1bm55enlx_size_16_color_FFFFFF_t_70]: /images/20220829/ade05d0b61be46a8a0bb3b0f327235a6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3N1bm55enlx_size_16_color_FFFFFF_t_70 1]: /images/20220829/1e2db6efae1848d388e291e669d60652.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3N1bm55enlx_size_16_color_FFFFFF_t_70 2]: /images/20220829/09196f5f962049a1a74615f86a5e9707.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3N1bm55enlx_size_16_color_FFFFFF_t_70 3]: /images/20220829/090cc80f74074bd4a426537396b774e0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3N1bm55enlx_size_16_color_FFFFFF_t_70 4]: /images/20220829/70781692636944ee89202e8b7a2c3f19.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3N1bm55enlx_size_16_color_FFFFFF_t_70 5]: /images/20220829/d1e16d18ae4648db816acd8ee0111603.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3N1bm55enlx_size_16_color_FFFFFF_t_70 6]: /images/20220829/3ad06e8e9ccd4bf1beed2abea01f2624.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3N1bm55enlx_size_16_color_FFFFFF_t_70 7]: /images/20220829/71f875d7cdec4f06b491a7a19850fe3f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3N1bm55enlx_size_16_color_FFFFFF_t_70 8]: /images/20220829/1037276c10a84c2386cd2acedf0e5cd3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3N1bm55enlx_size_16_color_FFFFFF_t_70 9]: /images/20220829/3a87ec4a28c84f0e94d419cdb8013b91.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3N1bm55enlx_size_16_color_FFFFFF_t_70 10]: /images/20220829/1ee9953297ea4f378a6c6f55becbbed8.png