java yaml配置处理，yaml格式化，yaml节点增加，删除。多yaml合并

置顶 已于 2022-03-21 18:51:50 修改
阅读量5.4k 收藏 10
点赞数 2
分类专栏： JAVA 文章标签： java yaml
于 2021-10-13 18:28:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/loney_wolf/article/details/120743145
版权

       多环境配置文件管理，增加一个配置属性，多套环境配置文件需同时增加，如果忘记了，那么就报错。对多环境配置文件进行管理，使用yaml作为文件时，就涉及到yaml的一些解析，修改，新增操作。

java管理yaml

1. 环境依赖

       首先需要依赖snakeyaml，这里使用的是1.23版本

<dependency>
    <groupId>org.yaml</groupId>
    <artifactId>snakeyaml</artifactId>
    <version>1.23</version>
</dependency>

2. snakeyaml方法简单介绍

加载yaml对象：
       < T > T - loadAs(String，Class) ：加载yaml对象，返回Class对象
       < T > Object - load(String)：加载yaml对象，返回object对象
       iterable < object > - loadAll(String)：加载yaml对象，返回迭代器
对象转为字符：
       String dump(object)：object转化为字符串对象（只转化最外层yaml节点）
       String dumpAsMap(Map)：Map对象转化为字符串对象

 String content = "nacos:\n" +
                "  dg: 889990\n" +
                "  addd: 444\n" +
                "  ggggg:\n" +
                "    aaaa: ''\n" +
                "spring:\n" +
                "  redis:\n" +
                "    path: 3344\n" +
                "ooo:\n" +
                "  pp: ''\n";
                
        Yaml yaml = new Yaml();
        Map map = yaml.loadAs(content, Map.class);
        System.out.println(map);
        
        Object load = yaml.load(content);
        System.out.println(load);
        
        Iterable<Object> objects = yaml.loadAll(content);
        for (Iterator<Object> it = objects.iterator(); it.hasNext();){
            Map<String,Object> object = (Map<String, Object>) it.next();
            System.out.println(object);
        }

        String dump = yaml.dump(map);
        System.out.println(dump);
        
        String s = yaml.dumpAsMap(map);
        System.out.println(s);

3. yaml处理思路

       snakeyaml解析获取到的Map集合是嵌套集合，{redis={host=6379，url=xxx}}，这样的结构去做配置信息的变更比对是不方便的。
       因此先将此数据类型，转化为非嵌套Map集合，即{redis.host=6379,redis.url=xxx}的数据格式（Spring @value注解取值时，也是这种数据结构，IOC容器加载时，对配置文件进行解析，也是解析成这种格式）。
       解析为以上格式之后，再去对新旧配置进行节点的新增，删除判断就容易多了，提取以上Map集合的Key值放入List集合中，使用List集合的差集方法，即可得到新旧配置的差异对象。
       得到差异对象后，再将List对象使用Map容器承装(Map嵌套容器)，将变更对象与原嵌套对象进行合并，再转化为yaml字符串，之后该输出到文件输出到文件，该存储就存储。

4. yaml字符串转非嵌套Map对象

输出结果：{nacos.ggggg.aaaa=, nacos.dg=889990, spring.redis.path=3344, ooo.pp=, nacos.addd=444}


private static final Map<String,String> cacheYamlMap = new HashMap<>();

public static void main(String[] args) {
    String content = "nacos:\n" +
            "  dg: 889990\n" +
            "  addd: 444\n" +
            "  ggggg:\n" +
            "    aaaa: ''\n" +
            "spring:\n" +
            "  redis:\n" +
            "    path: 3344\n" +
            "ooo:\n" +
            "  pp: ''\n";

    Yaml yaml = new Yaml();
    Iterable<Object> oldYaml = yaml.loadAll(content);
    analyzeYamlToList(oldYaml);
    System.out.println(cacheYamlMap);
}


public static void analyzeYamlToList(Iterable<Object> newYaml){
    for (Iterator<Object> it = newYaml.iterator(); it.hasNext();){
        Map<String,Object> object = (Map<String, Object>) it.next();
        parseYamlToMap(object,null);
    }
}

public static void parseYamlToMap(Map<String, Object> item, String key){
    item.forEach((k,v) -> {
        if(Objects.isNull(v))
            if (key == null)
                cacheYamlMap.put(k, "");
            else
                cacheYamlMap.put(key.concat(".").concat(k), "");
        else if (v instanceof LinkedHashMap)
            if (key == null)
                parseYamlToMap((Map<String, Object>) v,k);
            else
                parseYamlToMap((Map<String, Object>) v,key.concat(".").concat(k));
        else
        if (key == null)
            cacheYamlMap.put(k, v.toString());
        else
            cacheYamlMap.put(key.concat(".").concat(k), v.toString());
    });
}

5. List对象转嵌套yaml对象

输出结果：{redis={host={name=}, aaa={bbb=}}, nacos={server={name=}}}

 public static void main(String[] args) {
	 List<String> yaml = new ArrayList<>();
	   yaml.add("redis.host.name");
	   yaml.add("redis.aaa.bbb");
	   yaml.add("redis.aaa.bbb.ccc");
	   yaml.add("nacos.server.name");
	
	   Object map = transListToLinkMap(yaml);
	   System.out.println(map);
	}
	
	public static Object transListToLinkMap(List<String> yamlKey){
	   Map<String,Object> linkMap = new LinkedHashMap();
	   for (String val: yamlKey ) {
	       Map<String,Object> map = (Map<String, Object>) transStringToLinkMap(val);
	       addYamlMap(linkMap,map);
	   }
	
	   return linkMap;
	}
	
	private static Object transStringToLinkMap(String val){
	   int i = val.indexOf(".");
	   if(i < 0){
	       Map<String,Object> map = new LinkedHashMap<>();
	       map.put(val,"");
	       return map;
	   }
	
	   String key = val.substring(0, i);
	   String value = val.substring(i + 1);
	   Map<String ,Object> linkedHashMap = (Map<String, Object>) transStringToLinkMap(value);
	
	   Map<String,Object> map = new LinkedHashMap<>();
	   map.put(key,linkedHashMap);
	   return map;
	}
	
	public static void addYamlMap(Map<String, Object> originMap, Map<String, Object> addMap){
	   for (Map.Entry<String,Object> val : addMap.entrySet()) {
	       boolean common = false;
	       for (Map.Entry<String,Object> obj : originMap.entrySet()) {
	           if (val.getKey().equals(obj.getKey())){
	               common = true;
	               try {
	                   Map<String,Object> objVal = (Map<String,Object>) obj.getValue();
	                   Map<String,Object> addVal = (Map<String,Object>) val.getValue();
	                   addYamlMap(objVal,addVal);
	               }catch (Exception e){
	                   break;
	               }
	               break;
	           }
	       }
	       if(!common){
	           originMap.put(val.getKey(),val.getValue());
	       }
	   }
	}

6. 新旧yaml对比，yaml新增，删除属性

       懒得一个个demo贴了，下面贴出我写的yamlUtil类，需要什么功能自由组合。
       以下yaml属性新增的时候，默认值是""空字符串，未设默认值，需要默认值自行修改。


private static final Map<String,String> cacheYamlMap = new HashMap<>();

public enum ConstantEnum{
    ADD("add"),

    REMOVE("remove");

    private String code;

    public String getCode() {
        return code;
    }

    public void setCode(String code) {
        this.code = code;
    }

    ConstantEnum(String code){
        this.code = code;
    }

	public static ConstantEnum getInstance(String code){
    	for (ConstantEnum constantEnum: values()) {
            if(constantEnum.getCode().equals(code)){
                return constantEnum;
            }
        }
        return null;
    }
}

public static void main(String[] args) {
    //加两个attr节点下属性，删addd属性
    String oldContent = "nacos:\n" +
            "  dg: 889990\n" +
            "  addd: 444\n" +
            "spring:\n" +
            "  redis:\n" +
            "    path: 3344\n";
    String newContent = "nacos:\n" +
            "  dg: 889990\n" +
            "spring:\n" +
            "  redis:\n" +
            "    path: 3344\n" +
            "    attr:\n" +
            "      name: 3333\n" +
            "      value: 4444";

    Yaml yaml = new Yaml();
    List<String> addAttr = YamlParserUtil.compareAndGetDiffAttr(oldContent, newContent, YamlParserUtil.ConstantEnum.ADD);
    List<String> removeAttr = YamlParserUtil.compareAndGetDiffAttr(oldContent, newContent, YamlParserUtil.ConstantEnum.REMOVE);
    Map<String,Object> addMap = (Map<String, Object>) YamlParserUtil.transListToLinkMap(addAttr);
    Map<String,Object> removeMap = (Map<String, Object>) YamlParserUtil.transListToLinkMap(removeAttr);

    Map originMap = yaml.loadAs(oldContent, Map.class);
    YamlParserUtil.addAndRemoveYaml(originMap,removeMap,addMap);
    String dump = yaml.dumpAsMap(originMap);
    System.out.println(dump);
}

/**
 * trans key list to map
 * demo: spring.redis.host to {spring={redis={host=}}}
 * @param yamlKey
 * @return
 */
public static Object transListToLinkMap(List<String> yamlKey){
    Map<String,Object> linkMap = new LinkedHashMap();
    for (String val: yamlKey ) {
        Map<String,Object> map = (Map<String, Object>) transStringToLinkMap(val);
        addYamlMap(linkMap,map);
    }

    return linkMap;
}

public static void addAndRemoveYaml(Map<String,Object> originMap,Map<String,Object> removeMap,Map<String,Object> addMap){
    removeYamlMap(originMap,removeMap);
    addYamlMap(originMap,addMap);
}

public static boolean removeYamlMap(Map<String, Object> originMap, Map<String, Object> removeMap){
    for (Map.Entry<String,Object> val : removeMap.entrySet()) {
        for (Map.Entry<String,Object> obj :originMap.entrySet()) {
            if(val.getKey().equals(obj.getKey())){
                try {
                    Map<String,Object> objVal = (Map<String,Object>) obj.getValue();
                    Map<String,Object> addVal = (Map<String,Object>) val.getValue();
                    if(removeYamlMap(objVal,addVal)){
                        originMap.remove(val.getKey());
                        break;
                    }
                }catch (Exception e){
                    originMap.remove(val.getKey());
                    break;
                }
            }
        }
    }
    if(originMap==null || originMap.isEmpty()){
        return true;
    }
    return false;
}

/**
 * {spring={redis={host=}}} | {spring={rabbit={host=}}} merge to {spring={redis={host=},rabbit={host=}}}
 *
 * Combine the addMap collection, do not allow the same key value to be overwritten
 * @param originMap
 * @param addMap
 */
public static void addYamlMap(Map<String, Object> originMap, Map<String, Object> addMap){
    for (Map.Entry<String,Object> val : addMap.entrySet()) {
        boolean common = false;
        for (Map.Entry<String,Object> obj : originMap.entrySet()) {
            if (val.getKey().equals(obj.getKey())){
                common = true;
                try {
                    Map<String,Object> objVal = (Map<String,Object>) obj.getValue();
                    Map<String,Object> addVal = (Map<String,Object>) val.getValue();
                    addYamlMap(objVal,addVal);
                }catch (Exception e){
                    break;
                }
                break;
            }
        }
        if(!common){
            originMap.put(val.getKey(),val.getValue());
        }
    }
}

/**
 * spring.redis.host to {spring={redis={host=}}}
 *
 * trans string to map，Parse the yaml string
 * @param val
 * @return
 */
private static Object transStringToLinkMap(String val){
    int i = val.indexOf(".");
    if(i < 0){
        Map<String,Object> map = new LinkedHashMap<>();
        map.put(val,"");
        return map;
    }

    String key = val.substring(0, i);
    String value = val.substring(i + 1);
    Map<String ,Object> linkedHashMap = (Map<String, Object>) transStringToLinkMap(value);

    Map<String,Object> map = new LinkedHashMap<>();
    map.put(key,linkedHashMap);
    return map;
}

/**
 *
 * compare yaml content get diff key list
 * @param oldContent
 * @param newContent
 * @return
 */
public static List<String> compareAndGetDiffAttr(String oldContent, String newContent,ConstantEnum type){
    Yaml yaml = new Yaml();
    Iterable<Object> oldYaml = yaml.loadAll(oldContent);
    List<String> oldKey = analyzeYamlToList(oldYaml);

    Iterable<Object> newYaml = yaml.loadAll(newContent);
    List<String> recent = analyzeYamlToList(newYaml);

    if(ConstantEnum.ADD.equals(type)){
        List<String> compareList = new ArrayList<>(recent);
        compareList.removeAll(oldKey);
        return compareList;
    }else{
        List<String> compareList = new ArrayList<>(oldKey);
        compareList.removeAll(recent);
        return compareList;
    }
}

public static List<String> analyzeYamlToList(Iterable<Object> newYaml){
    for (Iterator<Object> it = newYaml.iterator(); it.hasNext();){
        Map<String,Object> object = (Map<String, Object>) it.next();
        parseYamlToMap(object,null);
    }

    List<String> keyList = new ArrayList<>();
    cacheYamlMap.forEach((key,val)->{ keyList.add(key); });

    cacheYamlMap.clear();
    return keyList;
}

/**
 *  {spring={redis={host=},rabbit={host=}}} to {spring.redis.host= ,spring.rabbit.host=}
 *
 * trans yaml map to key map
 * @param item
 * @param key
 */
public static void parseYamlToMap(Map<String, Object> item, String key){
    item.forEach((k,v) -> {
        if(Objects.isNull(v))
            if (key == null)
                cacheYamlMap.put(k, "");
            else
                cacheYamlMap.put(key.concat(".").concat(k), "");
        else if (v instanceof LinkedHashMap)
            if (key == null)
                parseYamlToMap((Map<String, Object>) v,k);
            else
                parseYamlToMap((Map<String, Object>) v,key.concat(".").concat(k));
        else
        if (key == null)
            cacheYamlMap.put(k, v.toString());
        else
            cacheYamlMap.put(key.concat(".").concat(k), v.toString());
    });
}

7.新增属性属性值不为空

不同的业务需求，面向的yaml对象不一样，要的效果不一样，下面的代码对比标题6，做了一些变动，以及注释，各位看官可在次基础上自由发挥。（6的升级版本）


    private static final Map<String,String> cacheYamlMap = new HashMap<>();

    public enum ConstantEnum{
        ADD("add"),

        REMOVE("remove");

        private String code;

        public String getCode() {
            return code;
        }

        public void setCode(String code) {
            this.code = code;
        }

        ConstantEnum(String code){
            this.code = code;
        }

        public static ConstantEnum getInstance(String code){
            for (ConstantEnum constantEnum: values()) {
                if(constantEnum.getCode().equals(code)){
                    return constantEnum;
                }
            }
            return null;
        }
    }

    public static void main(String[] args) {
        //加两个attr节点下属性，删addd属性
        String oldContent = "nacos:\n" +
                "  dg: 889990\n" +
                "  addd: 444\n" +
                "spring:\n" +
                "  redis:\n" +
                "    path: 3344\n";
        String newContent = "nacos:\n" +
                "  dg: 889333333990\n" +
                "spring:\n" +
                "  redis:\n" +
                "    path: 3344\n" +
                "    attr:\n" +
                "      name: 3333\n" +
                "      value: 4444";

        Yaml yaml = new Yaml();
        //以就模板为基准模板，对比新模板，筛选出新增的属性
        List<Map<String, String>> addAttr = compareAndGetDiffAttr(oldContent, newContent, ConstantEnum.ADD);
        //以旧模板为基准模板，对比新模板，筛选删除属性
        List<String> removeAttr = compareAndGetDiffAttr(oldContent, newContent, ConstantEnum.REMOVE);

        //将筛选出的属性集合，转化为linkMap格式
        Map<String,Object> addMap = (Map<String, Object>) transMapListToLinkMap(addAttr);
        Map<String,Object> removeMap = (Map<String, Object>) transListToLinkMap(removeAttr);

        //以旧模板值为标准值，除了增加的属性值，其他均为旧模板值
        Map originMap = yaml.loadAs(oldContent, Map.class);
        //对旧模板进行新增，删除属性操作
        addAndRemoveYaml(originMap,removeMap,addMap);
        String dump = yaml.dumpAsMap(originMap);
        System.out.println(dump);
    }

    /**
     * trans key list to map
     * demo: spring.redis.host to {spring={redis={host=}}}
     * @param yamlKey
     * @return
     */
    public static Object transListToLinkMap(List<String> yamlKey){
        Map<String,Object> linkMap = new LinkedHashMap();
        for (String val: yamlKey ) {
            Map<String,Object> map = (Map<String, Object>) transStringToLinkMap(val,null);
            addYamlMap(linkMap,map);
        }

        return linkMap;
    }

    public static Object transMapListToLinkMap(List<Map<String, String>> yamlKey){
        Map<String,Object> linkMap = new LinkedHashMap();
        for (Map<String, String> val: yamlKey ) {
            for (Map.Entry<String,String> value :val.entrySet()) {
                Map<String,Object> map = (Map<String, Object>) transStringToLinkMap(value.getKey(),value.getValue());
                addYamlMap(linkMap,map);
            }
        }

        return linkMap;
    }

    public static void addAndRemoveYaml(Map<String,Object> originMap,Map<String,Object> removeMap,Map<String,Object> addMap){
        removeYamlMap(originMap,removeMap);
        addYamlMap(originMap,addMap);
    }

    public static boolean removeYamlMap(Map<String, Object> originMap, Map<String, Object> removeMap){
        for (Map.Entry<String,Object> val : removeMap.entrySet()) {
            for (Map.Entry<String,Object> obj :originMap.entrySet()) {
                if(val.getKey().equals(obj.getKey())){
                    try {
                        Map<String,Object> objVal = (Map<String,Object>) obj.getValue();
                        Map<String,Object> addVal = (Map<String,Object>) val.getValue();
                        if(removeYamlMap(objVal,addVal)){
                            originMap.remove(val.getKey());
                            break;
                        }
                    }catch (Exception e){
                        originMap.remove(val.getKey());
                        break;
                    }
                }
            }
        }
        if(originMap==null || originMap.isEmpty()){
            return true;
        }
        return false;
    }

    /**
     * {spring={redis={host=}}} | {spring={rabbit={host=}}} merge to {spring={redis={host=},rabbit={host=}}}
     *
     * Combine the addMap collection, do not allow the same key value to be overwritten
     * @param originMap
     * @param addMap
     */
    public static void addYamlMap(Map<String, Object> originMap, Map<String, Object> addMap){
        //遍历新旧两个嵌套集合，将值，属性进行合并
        for (Map.Entry<String,Object> val : addMap.entrySet()) {
            boolean common = false;
            for (Map.Entry<String,Object> obj : originMap.entrySet()) {
                if (val.getKey().equals(obj.getKey())){
                    common = true;
                    try {
                        Map<String,Object> objVal = (Map<String,Object>) obj.getValue();
                        Map<String,Object> addVal = (Map<String,Object>) val.getValue();
                        addYamlMap(objVal,addVal);
                    }catch (Exception e){
                        break;
                    }
                    break;
                }
            }
            if(!common){
                originMap.put(val.getKey(),val.getValue());
            }
        }
    }

    /**
     * spring.redis.host to {spring={redis={host=}}}
     *
     * trans string to map，Parse the yaml string
     * @param val
     * @return
     */
    private static Object transStringToLinkMap(String yamlKey,String val){
        int i = yamlKey.indexOf(".");
        if(i < 0){
            Map<String,Object> map = new LinkedHashMap<>();
            map.put(yamlKey,val);
            return map;
        }

        String key = yamlKey.substring(0, i);
        String value = yamlKey.substring(i + 1);
        Map<String ,Object> linkedHashMap = (Map<String, Object>) transStringToLinkMap(value,val);

        Map<String,Object> map = new LinkedHashMap<>();
        map.put(key,linkedHashMap);
        return map;
    }

    /**
     *
     * compare yaml content get diff key list
     * @param oldContent
     * @param newContent
     * @return
     */
    public static List compareAndGetDiffAttr(String oldContent, String newContent,ConstantEnum type){
        Yaml yaml = new Yaml();
        //获取旧模板的key集合
        Iterable<Object> oldYaml = yaml.loadAll(oldContent);
        List<String> oldKey = analyzeYamlToList(oldYaml);

        Iterable<Object> newYaml = yaml.loadAll(newContent);

        //新增比较特殊，需要保留原值，
        if(ConstantEnum.ADD.equals(type)){
            //获取新模板的Key value集合
            List<Map<String, String>> list = analyzeYamlToListMap(newYaml);
            Iterator<Map<String, String>> iterator = list.iterator();

            //遍历，与旧模板进行对比，删除掉相同key的元素，留下的就是新增的
            while (iterator.hasNext()){
                //以新模板为基准对比
                for (Map.Entry<String,String> value :iterator.next().entrySet()) {
                    for (String key :oldKey) {
                        if(key.equals(value.getKey())){
                            iterator.remove();
                            break;
                        }
                    }
                }
            }

            return list;
        }else{
            //旧模板与新模板进行取差集，得到旧模板与新模板的差异属性，即需要删除的属性
            List<String> recent = analyzeYamlToList(newYaml);
            //以旧模板为基准
            List<String> compareList = new ArrayList<>(oldKey);
            compareList.removeAll(recent);
            return compareList;
        }
    }

    public static List<String> analyzeYamlToList(Iterable<Object> newYaml){
        //将yaml遍历器中的嵌套集合转化为单个KEY VALUE对应的Map集合，存放至静态变量
        for (Iterator<Object> it = newYaml.iterator(); it.hasNext();){
            Map<String,Object> object = (Map<String, Object>) it.next();
            parseYamlToMap(object,null);
        }

        //将上一个步骤存放的集Map集合提取成List集合，提取单个Key值
        List<String> keyList = new ArrayList<>();
        cacheYamlMap.forEach((key,val)->{ keyList.add(key); });

        cacheYamlMap.clear();
        return keyList;
    }

    public static List<Map<String,String>> analyzeYamlToListMap(Iterable<Object> newYaml){
        //将yaml遍历器中的嵌套集合转化为单个KEY VALUE对应的Map集合，存放至静态变量
        for (Iterator<Object> it = newYaml.iterator(); it.hasNext();){
            Map<String,Object> object = (Map<String, Object>) it.next();
            parseYamlToMap(object,null);
        }
        //将上一个步骤存放的集Map集合提取成List集合，并且拆分为单个Map，放入集合（便于后续便利）
        List<Map<String,String>> keyList = new ArrayList<>();
        cacheYamlMap.forEach((key,val)->{
            Map<String,String> map = new HashMap<>();
            map.put(key,val);
            keyList.add(map);
        });

        cacheYamlMap.clear();
        return keyList;
    }
    /**
     *  {spring={redis={host=},rabbit={host=}}} to {spring.redis.host= ,spring.rabbit.host=}
     *
     * trans yaml map to key map
     * @param item
     * @param key
     */
    public static void parseYamlToMap(Map<String, Object> item, String key){
        //将嵌套Map集合，转化为单个Key value对应的属性集合
        item.forEach((k,v) -> {
            if(Objects.isNull(v))
                if (key == null)
                    cacheYamlMap.put(k, "");
                else
                    cacheYamlMap.put(key.concat(".").concat(k), v.toString());
            else if (v instanceof LinkedHashMap)
                if (key == null)
                    parseYamlToMap((Map<String, Object>) v,k);
                else
                    parseYamlToMap((Map<String, Object>) v,key.concat(".").concat(k));
            else
            if (key == null)
                cacheYamlMap.put(k, v.toString());
            else
                cacheYamlMap.put(key.concat(".").concat(k), v.toString());
        });
    }
轻点 别打脸
关注
  • 2
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
YAML、YML在线编辑器(格式化校验)解析工具-toolfk.com
无涯教程
11-07 2万+
本文要推荐的[ToolFk]是一款程序员经常使用的线上免费测试工具箱，ToolFk 特色是专注于程序员日常的开发工具，不用安装任何软件，只要把内容贴上按一个执行按钮,就能获取到想要的内容结果。ToolFk还支持BarCode条形码在线生成、QueryList采集器、PHP代码在线运行、PHP混淆、加密、解密、Python代码在线运行、JavaScript在线运行、YAML格式化...
Java解析yaml文件
新生代农民工Steven
05-09 9073
Java解析yaml文件1. 什么是yaml ?2. 导入maven依赖3. yaml 案例文件4. 示例代码5. 解析结果 1. 什么是yaml ? 参考下方链接 yaml快速入门 2. 导入maven依赖 <dependency> <groupId>org.yaml</groupId> <artifactId>snakeyaml</artifactId> &
jvm参数配置springboot，就是这么简单_springboot yml设置jvm参数
最新发布
m0_74932057的博客
04-15 1829
面试题文档来啦，内容很多，485页！由于笔记的内容太多，没办法全部展示出来，下面只截取部分内容展示。有想获取完整版笔记的朋友，
yaml文件格式详解及实例
liu_chen_yang的博客
03-01 6210
yaml 是专门用来写配置文件的语言 yaml文件也是一种配置文件类型，后缀名是.yaml或.yml都可以 >运维适用于k8s、docker-compose，也是最近在学k8s要用到yaml文件格式
Java中解析yml或yaml配置文件
weixin_44732769的博客
11-13 3422
yaml、yml文件解析： 方式一：@Value注解 方式二：封装全部数据到Environment对象 方式三：自定义对象封装指定数据
格式化读写 yaml作为配置文件
huanghong6956的博客
08-21 900
https://www.cnblogs.com/yoyoketang/p/9255109.html
spring+apollo动态获取yaml格式的配置方式
08-19
"spring+apollo动态获取yaml格式的配置方式" spring框架中，默认情况下都是使用.properties格式的配置文件，但是有时我们需要定义list或者map类型的配置，那么yaml格式就具有优势。下面将详细介绍spring+apollo动态...
java 一键读取yaml、propertites配置文件内容，转换为一级map
10-09
纯java底层读取配置文件，生成map，可以根据key模糊匹配查询，封装好了方法。比如getVal("spring.dubbo*url")
yaml文件解析(java)
08-12
在IT行业中，YAML（Yet Another Markup Language）是一种流行的、易于阅读的数据序列化格式，常用于配置文件和数据交换。Java作为一种广泛使用的编程语言，提供了多种库来处理YAML文件，如SnakeYAML和Jackson YAML。...
mermal:将YAML文件合并在一起
05-17
将一个或多个YAML文件合并到一个基本文件中。用法mermal在NPM上可用。 mermal提供API和CLI。安装 # Locally$ yarn add mermal # Using yarn$ npm install mermal # Using npm# Or globally$ yarn global add mermal ...
yaml配置文件解析-yaml
08-30
Yaml 是⼀种所有编程语⾔可⽤的友好的数据序列化标准。语法和其他⾼阶语⾔类似，并且可以简单表达字 典、列表和其他基本数据类型的 形态。语法规则如下： 1. ⼤⼩写敏感。 2. 使⽤缩进表⽰层级关系。 3. 使⽤空格键...
yamlformatter：重新格式化YAML文件，并在可能的情况下添加锚点
02-12
YAML格式化程序 漂亮的YAML文件！ 特征： 自动添加锚点/别名以重复数据 删除不需要的空格 正确的缩进 用法 Packagist尚没有此功能，因此将其添加为vcs存储库： "repositories": [ { "type": "vcs", "url": "https://github.com/danielskeenan/yamlformatter.git" } ] 查看带有vendor/bin/yamlformatter format --help可用选项vendor/bin/yamlformatter format --help Usage: format [options] [--] <INPUT> [<OUTPUT>] Arguments: INPUT
Java解析与生成yaml
十一仓
07-23 3664
1 yaml基本介绍 yaml “Yet Another Markup Language” 仍是一种标记语言 ####1.1基本语法 大小写敏感 使用缩进表示层级关系 缩进不允许使用tab,只允许空格 缩进的空格数不重要，只要相同层级的元素左对齐即可 ‘#’ 表示注释 2 Java解析与生成yaml 2.1 在项目中添加Maven依赖 <dependency> <groupId>org.yaml</groupId> <artifactId>
snakeyaml自定义pojo写入yml文件时属性字段排序问题
feinifi的博客
02-18 1298
snakeyaml自定义pojo写入yml文件时属性排序问题解决。
Python 修改yaml文件后，yaml文件中的注释消失。以及顺序重排，但内容正确的问题
songlh1234的博客
06-28 3658
该问题的原因就在于，yaml.dump()方法，是将新的格式内容重新生成yaml文件。（因为#注释掉了，所以load时就没包含#注释的内容），所以把内容重新生成时，未被#注释的内容没问题。但重新生成的新文件，不包含被注释的内容，且因为重新dump生成新文件。里面内容的顺序也会发生改变。如果希望只改变yaml文件里的内容，而不更改注释，可以使用一般的文件读取。通过ReadLine来实现。 这里引用别人现成的代码，一个是修改以“=”为配置特征的setting.properties的配置文件，以及以“:”为分隔
Springboot配置-Yaml数据格式小记
qq_26849881的博客
06-12 286
介绍一下springboot中yaml配置文件的基础语法
yaml文件解析，查询、添加、修改（java）
baidu_28291037的博客
08-12 5118
yaml文件解析（java）
IDEA 自动格式化代码插件saveactions格式化yml文件错误
離殇
12-17 1853
IDEA自动格式化插件格式化yml文件后，导致缩进格式改变，运行项目无法加载配置文件 将Ident：2 修改成Ident：3即可
K8S---yaml文件详解
Liqi23的博客
02-27 1921
没有相关资源，使用 run 命令 --dry-run 选项已有相关资源，使用 get 命令 --export 选项写yaml太累怎么办？用 --dry-run 命令生成用get命令导出或kubectl edit svc nginx-service #复制配置，再粘贴到新文件。
java怎么读取yaml配置
04-29
Java 读取 YAML 配置可以使用 SnakeYAML 库，具体步骤如下： 1. 引入 SnakeYAML 库 在 Maven 项目中，可以在 pom.xml 文件中添加以下依赖： ```xml <groupId>org.yaml <artifactId>snakeyaml <version>1.27 ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值