java代码修改yml配置文件_java怎么动态修改yml文件中数据源连接信息

背景

参加一个比赛，测评程序每次在测试的时候，都是随机分配3台服务器，IP地址不固定。程序提供一个接口，每次测评开始前会传过来3个IP地址，需要动态修改yml配置文件中程序连接的redis集群节点

添加依赖

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

修改文件的工具类

package com.weilc.chatservice.util;

import org.yaml.snakeyaml.DumperOptions;
import org.yaml.snakeyaml.Yaml;

import java.io.*;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;

public class YmlUtil {
    private final static DumperOptions OPTIONS = new DumperOptions();

    private static File file;

    private static InputStream ymlInputSteam;

    private static Object CONFIG_MAP;

    private static Yaml yaml;

    static {
        //将默认读取的方式设置为块状读取
        OPTIONS.setDefaultFlowStyle(DumperOptions.FlowStyle.BLOCK);
    }

    /**
     * 使用其他方法之前必须调用一次 设置yml的输出文件,当没有设置输入流时可以不设置输入流,默认以此文件读入
     *
     * @param file 输出的文件
     */
    public static void setYmlFile(File file) throws FileNotFoundException {
        YmlUtil.file = file;
        if (ymlInputSteam == null) {
            setYmlInputSteam(new FileInputStream(file));
        }
    }


    /**
     * 使用其他方法之前必须调用一次 设置yml的输入流
     *
     * @param inputSteam 输入流
     */
    public static void setYmlInputSteam(InputStream inputSteam) {
        ymlInputSteam = inputSteam;
        yaml = new Yaml(OPTIONS);
        CONFIG_MAP = yaml.load(ymlInputSteam);
    }

    /**
     * 根据键获取值
     *
     * @param key 键
     * @return 查询到的值
     */
    @SuppressWarnings("unchecked")
    public static Object getByKey(String key) {
        if (ymlInputSteam == null) {
            return null;
        }
        String[] keys = key.split("\\.");
        Object configMap = CONFIG_MAP;
        for (String s : keys) {
            if (configMap instanceof Map) {
                configMap = ((Map<String, Object>) configMap).get(s);
            } else {
                break;
            }
        }
        return configMap == null ? "" : configMap;
    }

    public static void saveOrUpdateByKey(String key, Object value) throws IOException {
        KeyAndMap keyAndMap = new KeyAndMap(key).invoke();
        key = keyAndMap.getKey();
        Map<String, Object> map = keyAndMap.getMap();
        map.put(key, value);
        //将数据重新写回文件
        yaml.dump(CONFIG_MAP, new FileWriter(file));
    }

    public static void removeByKey(String key) throws Exception {
        KeyAndMap keyAndMap = new KeyAndMap(key).invoke();
        key = keyAndMap.getKey();
        Map<String, Object> map = keyAndMap.getMap();
        Map<String, Object> fatherMap = keyAndMap.getFatherMap();
        map.remove(key);
        if (map.size() == 0) {
            Set<Map.Entry<String, Object>> entries = fatherMap.entrySet();
            for (Map.Entry<String, Object> entry : entries) {
                if (entry.getValue() == map) {
                    fatherMap.remove(entry.getKey());
                }
            }
        }
        yaml.dump(CONFIG_MAP, new FileWriter(file));
    }

    private static class KeyAndMap {
        private String key;
        private Map<String, Object> map;
        private Map<String, Object> fatherMap;

        public KeyAndMap(String key) {
            this.key = key;
        }

        public String getKey() {
            return key;
        }

        public Map<String, Object> getMap() {
            return map;
        }

        public Map<String, Object> getFatherMap() {
            return fatherMap;
        }

        @SuppressWarnings("unchecked")
        public KeyAndMap invoke() {
            if (file == null) {
                System.err.println("请设置文件路径");
            }
            if (null == CONFIG_MAP) {
                CONFIG_MAP = new LinkedHashMap<>();
            }
            String[] keys = key.split("\\.");
            key = keys[keys.length - 1];
            map = (Map<String, Object>) CONFIG_MAP;
            for (int i = 0; i < keys.length - 1; i++) {
                String s = keys[i];
                if (map.get(s) == null || !(map.get(s) instanceof Map)) {
                    map.put(s, new HashMap<>(4));
                }
                fatherMap = map;
                map = (Map<String, Object>) map.get(s);
            }
            return this;
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

测试

@PostMapping("/updateCluster")
public ResponseEntity updateCluster(@RequestBody String[] ips) throws Exception{
    String redisNodes = "";
    for (String ip : ips) {
        redisNodes += ip + ":6379,";
        redisNodes += ip + ":6380,";
    }
    //去除尾部空格
    redisNodes = redisNodes.substring(0, redisNodes.length() - 1);
    //修改配置文件
    log.info("----------开始修改配置文件----------");
    File file = new File("application.yml");
    YmlUtil.setYmlFile(file);
    log.info("yml节点nodes修改前:" + YmlUtil.getByKey("spring.redis.cluster.nodes"));
    YmlUtil.saveOrUpdateByKey("spring.redis.cluster.nodes", redisNodes);
    log.info("yml节点nodes修改后:" + YmlUtil.getByKey("spring.redis.cluster.nodes"));
    //重启服务
    String startSh = "cd ~ && sh start.sh run";
    log.info("----------开始重启服务----------");
    execLinux(startSh);
    return ResponseEntity.ok().build();
}

private boolean execLinux(String cmd) {
    try {
        log.info("exec shell: " + cmd);
        Runtime runtime = Runtime.getRuntime();
        Process process = runtime.exec(cmd);
        int result = process.waitFor();
        log.info("exec result: " + result);
    } catch (Exception e) {
        e.printStackTrace();
    }
    return true;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

我这里开发了一个接口用于接收IP地址数组，然后开始拼接redis集群的nodes数据，最后使用工具类进行替换。然后执行重启服务的shell脚本

问题

在实际的运行中，因为我们使用的是jar包，上面测试类的第12行代码需要读取配置文件的位置并修改，使用上面的代码读取不到，所以我们需要把配置文件单独拿出来，然后修改第12行的代码，并且修改启动脚本，以指定配置文件的方式启动jar包

修改代码

File file = new File("./application.yml");
1

修改启动脚本

java -jar demo.jar --spring.config.location=./application.yml
1