关于springboot:SpringBoot动态更新yml文件

35次阅读

共计 7929 个字符,预计需要花费 20 分钟才能阅读完成。

前言

在零碎运行过程中,可能因为一些配置项的简略变动须要从新打包启停我的项目,这对于在运行中的我的项目会造成数据失落,客户操作无响应等状况产生,针对这类状况对开发框架进行降级提供 yml 文件实时批改更新性能

我的项目依赖

我的项目基于的是 2.0.0.RELEASE 版本,所以 snakeyaml 须要独自引入,高版本已蕴含在内

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

网上大多数办法是引入 spring-cloud-context 配置组件调用 ContextRefresher 的 refresh 办法达到同样的成果,思考以下两点未应用

  • 开发框架应用了 logback 日志,引入 spring-cloud-context 会造成日志配置读取谬误
  • 引入 spring-cloud-context 会同时引入 spring-boot-starter-actuator 组件,会凋谢一些健康检查路由及端口,须要对框架平安方面进行额定管制

YML 文件内容获取

读取 resource 文件下的文件须要应用 ClassPathResource 获取 InputStream

    public String getTotalYamlFileContent() throws Exception {
        String fileName = "application.yml";
        return getYamlFileContent(fileName);
    }
    public String getYamlFileContent(String fileName) throws Exception {ClassPathResource classPathResource = new ClassPathResource(fileName);
        return onvertStreamToString(classPathResource.getInputStream());
    }
    public static String convertStreamToString(InputStream inputStream) throws Exception{return IOUtils.toString(inputStream, "utf-8");
    }

YML 文件内容更新

咱们获取到 yml 文件内容后可视化显示到前台进行展现批改,将批改后的内容通过 yaml.load 办法转换成 Map 构造,再应用 yaml.dumpAsMap 转换为流写入到文件

    public void updateTotalYamlFileContent(String content) throws Exception {
        String fileName = "application.yml";
        updateYamlFileContent(fileName, content);
    }
    public void updateYamlFileContent(String fileName, String content) throws Exception {Yaml template = new Yaml();
        Map<String, Object> yamlMap = template.load(content);

        ClassPathResource classPathResource = new ClassPathResource(fileName);

        Yaml yaml = new Yaml();
        // 字符输入
        FileWriter fileWriter = new FileWriter(classPathResource.getFile());
        // 用 yaml 办法把 map 构造格式化为 yaml 文件构造
        fileWriter.write(yaml.dumpAsMap(yamlMap));
        // 刷新
        fileWriter.flush();
        // 敞开流
        fileWriter.close();}

YML 属性刷新

yml 属性在程序中读取应用个别有三种

  • 应用 Value 注解
    @Value("${system.systemName}")
    private String systemName;
  • 通过 enviroment 注入读取
    @Autowired
    private Environment environment;
    
    environment.getProperty("system.systemName")
  • 应用 ConfigurationProperties 注解读取
@Component
@ConfigurationProperties(prefix = "system")
public class SystemConfig {private String systemName;}

Property 刷新

咱们通过 environment.getProperty 办法读取的配置汇合理论是存储在 PropertySources 中的,咱们只须要把键值对全副取出存储在 propertyMap 中,将更新后的 yml 文件内容转换成雷同格局的 ymlMap,两个 Map 进行合并,调用 PropertySources 的 replace 办法进行整体替换即可

然而 yaml.load 后的 ymlMap 和 PropertySources 取出的 propertyMap 两者数据解构是不同的,须要进行手动转换

propertyMap 汇合就是单纯的 key,value 键值对,key 是 properties 模式的名称,例如 system.systemName=>xxxxx 团体管理系统

ymlMap 汇合是 key,LinkedHashMap 的嵌套层次结构,例如 system=>(systemName=>xxxxx 团体管理系统)

  • 转换方法如下
  public HashMap<String, Object> convertYmlMapToPropertyMap(Map<String, Object> yamlMap) {HashMap<String, Object> propertyMap = new HashMap<String, Object>();
        for (String key : yamlMap.keySet()) {
            String keyName = key;
            Object value = yamlMap.get(key);
            if (value != null && value.getClass() == LinkedHashMap.class) {convertYmlMapToPropertyMapSub(keyName, ((LinkedHashMap<String, Object>) value), propertyMap);
            } else {propertyMap.put(keyName, value);
            }
        }
        return propertyMap;
    }

    private void convertYmlMapToPropertyMapSub(String keyName, LinkedHashMap<String, Object> submMap, Map<String, Object> propertyMap) {for (String key : submMap.keySet()) {
            String newKey = keyName + "." + key;
            Object value = submMap.get(key);
            if (value != null && value.getClass() == LinkedHashMap.class) {convertYmlMapToPropertyMapSub(newKey, ((LinkedHashMap<String, Object>) value), propertyMap);
            } else {propertyMap.put(newKey, value);
            }
        }
    }
  • 刷新办法如下
        String name = "applicationConfig: [classpath:/" + fileName + "]";
        MapPropertySource propertySource = (MapPropertySource) environment.getPropertySources().get(name);
        Map<String, Object> source = propertySource.getSource();
        Map<String, Object> map = new HashMap<>(source.size());
        map.putAll(source);

        Map<String, Object> propertyMap = convertYmlMapToPropertyMap(yamlMap);

        for (String key : propertyMap.keySet()) {Object value = propertyMap.get(key);
            map.put(key, value);
        }
        environment.getPropertySources().replace(name, new MapPropertySource(name, map));

注解刷新

不论是 Value 注解还是 ConfigurationProperties 注解,理论都是通过注入 Bean 对象的属性办法应用的,咱们先自定注解 RefreshValue 来润饰属性所在 Bean 的 class

通过实现 InstantiationAwareBeanPostProcessorAdapter 接口在系统启动时过滤筛选对应的 Bean 存储下来,在更新 yml 文件时通过 spring 的 event 告诉更新对应

bean 的属性即可

  • 注册事件应用 EventListener 注解
    @EventListener
    public void updateConfig(ConfigUpdateEvent configUpdateEvent) {if(mapper.containsKey(configUpdateEvent.key)){List<FieldPair> fieldPairList = mapper.get(configUpdateEvent.key);
            if(fieldPairList.size()>0){for (FieldPair fieldPair:fieldPairList) {fieldPair.updateValue(environment);
                }
            }
        }
    }
  • 告诉触发事件应用 ApplicationContext 的 publishEvent 办法
    @Autowired
    private ApplicationContext applicationContext;
    
      for (String key : propertyMap.keySet()) {applicationContext.publishEvent(new YamlConfigRefreshPostProcessor.ConfigUpdateEvent(this, key));
    }

YamlConfigRefreshPostProcessor 的残缺代码如下

@Component
public class YamlConfigRefreshPostProcessor extends InstantiationAwareBeanPostProcessorAdapter implements EnvironmentAware {private Map<String, List<FieldPair>> mapper = new HashMap<>();
    private Environment environment;

    @Override
    public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {processMetaValue(bean);
        return super.postProcessAfterInstantiation(bean, beanName);
    }

    @Override
    public void setEnvironment(Environment environment) {this.environment = environment;}

    private void processMetaValue(Object bean) {Class clz = bean.getClass();
        if (!clz.isAnnotationPresent(RefreshValue.class)) {return;}

        if (clz.isAnnotationPresent(ConfigurationProperties.class)) {
            //@ConfigurationProperties 注解
            ConfigurationProperties config = (ConfigurationProperties) clz.getAnnotation(ConfigurationProperties.class);
            for (Field field : clz.getDeclaredFields()) {String key = config.prefix() + "." + field.getName();
                if(mapper.containsKey(key)){mapper.get(key).add(new FieldPair(bean, field, key));
                }else{List<FieldPair> fieldPairList = new ArrayList<>();
                    fieldPairList.add(new FieldPair(bean, field, key));
                    mapper.put(key, fieldPairList);
                }
            }
        } else {
            //@Valuez 注解
            try {for (Field field : clz.getDeclaredFields()) {if (field.isAnnotationPresent(Value.class)) {Value val = field.getAnnotation(Value.class);
                        String key = val.value().replace("${", "").replace("}","");
                        if(mapper.containsKey(key)){mapper.get(key).add(new FieldPair(bean, field, key));
                        }else{List<FieldPair> fieldPairList = new ArrayList<>();
                            fieldPairList.add(new FieldPair(bean, field, key));
                            mapper.put(key, fieldPairList);
                        }
                    }
                }
            } catch (Exception e) {e.printStackTrace();
                System.exit(-1);
            }
        }
    }

    public static class FieldPair {private static PropertyPlaceholderHelper propertyPlaceholderHelper = new PropertyPlaceholderHelper("${", "}",
                ":", true);
        private Object bean;
        private Field field;
        private String value;

        public FieldPair(Object bean, Field field, String value) {
            this.bean = bean;
            this.field = field;
            this.value = value;
        }

        public void updateValue(Environment environment) {boolean access = field.isAccessible();
            if (!access) {field.setAccessible(true);
            }
            try {if (field.getType() == String.class) {String updateVal = environment.getProperty(value);
                    field.set(bean, updateVal);
                }
                else if (field.getType() == Integer.class) {Integer updateVal = environment.getProperty(value,Integer.class);
                    field.set(bean, updateVal);
                }
                else if (field.getType() == int.class) {int updateVal = environment.getProperty(value,int.class);
                    field.set(bean, updateVal);
                }
                else if (field.getType() == Boolean.class) {Boolean updateVal = environment.getProperty(value,Boolean.class);
                    field.set(bean, updateVal);
                }
                else if (field.getType() == boolean.class) {boolean updateVal = environment.getProperty(value,boolean.class);
                    field.set(bean, updateVal);
                }
                else {String updateVal = environment.getProperty(value);
                    field.set(bean, JSONObject.parseObject(updateVal, field.getType()));
                }
            } catch (IllegalAccessException e) {e.printStackTrace();
            }
            field.setAccessible(access);
        }

        public Object getBean() {return bean;}

        public void setBean(Object bean) {this.bean = bean;}

        public Field getField() {return field;}

        public void setField(Field field) {this.field = field;}

        public String getValue() {return value;}

        public void setValue(String value) {this.value = value;}
    }

    public static class ConfigUpdateEvent extends ApplicationEvent {
        String key;

        public ConfigUpdateEvent(Object source, String key) {super(source);
            this.key = key;
        }
    }

    @EventListener
    public void updateConfig(ConfigUpdateEvent configUpdateEvent) {if(mapper.containsKey(configUpdateEvent.key)){List<FieldPair> fieldPairList = mapper.get(configUpdateEvent.key);
            if(fieldPairList.size()>0){for (FieldPair fieldPair:fieldPairList) {fieldPair.updateValue(environment);
                }
            }
        }
    }
}

正文完
 0