• SpringBoot如何动态更新yml文件？

    前言

    在系统运行过程中，可能由于一些配置项的简单变动需要重新打包启停项目，这对于在运行中的项目会造成数据丢失，客户操作无响应等情况发生，针对这类情况对开发框架进行升级提供yml文件实时修改更新功能

    项目依赖

    项目基于的是2.0.0.RELEASE版本，所以snakeyaml需要单独引入，高版本已包含在内

    1. <dependency>
    2.             <groupId>org.yamlgroupId>
    3.             <artifactId>snakeyamlartifactId>
    4.             <version>1.23version>
    5.         dependency>

    网上大多数方法是引入spring-cloud-context配置组件调用ContextRefresher的refresh方法达到同样的效果，考虑以下两点未使用

    • 开发框架使用了logback日志，引入spring-cloud-context会造成日志配置读取错误
    • 引入spring-cloud-context会同时引入spring-boot-starter-actuator组件，会开放一些健康检查路由及端口，需要框架安全方面进行额外控制

    YML文件内容获取

    读取resource文件下的文件需要使用ClassPathResource获取InputStream

    1. public String getTotalYamlFileContent() throws Exception {
    2.         String fileName = "application.yml";
    3.         return getYamlFileContent(fileName);
    4.     }
    5.     public String getYamlFileContent(String fileName) throws Exception {
    6.         ClassPathResource classPathResource = new ClassPathResource(fileName);
    7.         return onvertStreamToString(classPathResource.getInputStream());
    8.     }
    9.     public static String convertStreamToString(InputStream inputStream) throws Exception{
    10.        return IOUtils.toString(inputStream, "utf-8");
    11.     }

    YML文件内容更新

    我们获取到yml文件内容后可视化显示到前台进行展示修改，将修改后的内容通过yaml.load方法转换成Map结构，再使用yaml.dumpAsMap转换为流写入到文件

    1. public void updateTotalYamlFileContent(String content) throws Exception {
    2.         String fileName = "application.yml";
    3.         updateYamlFileContent(fileName, content);
    4.     }
    5.     public void updateYamlFileContent(String fileName, String content) throws Exception {
    6.         Yaml template = new Yaml();
    7.         Map yamlMap = template.load(content);
    8.  
    9.         ClassPathResource classPathResource = new ClassPathResource(fileName);
    10.  
    11.         Yaml yaml = new Yaml();
    12.         //字符输出
    13.         FileWriter fileWriter = new FileWriter(classPathResource.getFile());
    14.         //用yaml方法把map结构格式化为yaml文件结构
    15.         fileWriter.write(yaml.dumpAsMap(yamlMap));
    16.         //刷新
    17.         fileWriter.flush();
    18.         //关闭流
    19.         fileWriter.close();
    20.     }

    YML属性刷新

    yml属性在程序中读取使用一般有三种

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

    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集团管理系统)

    • 转换方法如下
    1. public HashMap convertYmlMapToPropertyMap(Map yamlMap) {
    2.         HashMap propertyMap = new HashMap();
    3.         for (String key : yamlMap.keySet()) {
    4.             String keyName = key;
    5.             Object value = yamlMap.get(key);
    6.             if (value != null && value.getClass() == LinkedHashMap.class) {
    7.                 convertYmlMapToPropertyMapSub(keyName, ((LinkedHashMap) value), propertyMap);
    8.             } else {
    9.                 propertyMap.put(keyName, value);
    10.             }
    11.         }
    12.         return propertyMap;
    13.     }
    14.  
    15.     private void convertYmlMapToPropertyMapSub(String keyName, LinkedHashMap submMap, Map propertyMap) {
    16.         for (String key : submMap.keySet()) {
    17.             String newKey = keyName + "." + key;
    18.             Object value = submMap.get(key);
    19.             if (value != null && value.getClass() == LinkedHashMap.class) {
    20.                 convertYmlMapToPropertyMapSub(newKey, ((LinkedHashMap) value), propertyMap);
    21.             } else {
    22.                 propertyMap.put(newKey, value);
    23.             }
    24.         }
    25.     }
    • 刷新方法如下
    1. String name = "applicationConfig: [classpath:/" + fileName + "]";
    2.         MapPropertySource propertySource = (MapPropertySource) environment.getPropertySources().get(name);
    3.         Map source = propertySource.getSource();
    4.         Map map = new HashMap<>(source.size());
    5.         map.putAll(source);
    6.  
    7.         Map propertyMap = convertYmlMapToPropertyMap(yamlMap);
    8.  
    9.         for (String key : propertyMap.keySet()) {
    10.             Object value = propertyMap.get(key);
    11.             map.put(key, value);
    12.         }
    13.         environment.getPropertySources().replace(name, new MapPropertySource(name, map));

    注解刷新

    不论是Value注解还是ConfigurationProperties注解，实际都是通过注入Bean对象的属性方法使用的，我们先自定注解RefreshValue来修饰属性所在Bean的class

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

    bean的属性即可

    • 注册事件使用EventListener注解
    1. @EventListener
    2.     public void updateConfig(ConfigUpdateEvent configUpdateEvent) {
    3.         if(mapper.containsKey(configUpdateEvent.key)){
    4.             List fieldPairList = mapper.get(configUpdateEvent.key);
    5.             if(fieldPairList.size()>0){
    6.                 for (FieldPair fieldPair:fieldPairList) {
    7.                     fieldPair.updateValue(environment);
    8.                 }
    9.             }
    10.         }
    11.     }
    • 通知触发事件使用ApplicationContext的publishEvent方法
    1. @Autowired
    2.     private ApplicationContext applicationContext;
    3.     
    4.     for (String key : propertyMap.keySet()) {
    5.        applicationContext.publishEvent(new YamlConfigRefreshPostProcessor.ConfigUpdateEvent(this, key));
    6.     }


    YamlConfigRefreshPostProcessor的完整代码如下

    1. @Component
    2. public class YamlConfigRefreshPostProcessor extends InstantiationAwareBeanPostProcessorAdapter implements EnvironmentAware {
    3.     private Map> mapper = new HashMap<>();
    4.     private Environment environment;
    5.  
    6.     @Override
    7.     public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
    8.         processMetaValue(bean);
    9.         return super.postProcessAfterInstantiation(bean, beanName);
    10.     }
    11.  
    12.     @Override
    13.     public void setEnvironment(Environment environment) {
    14.         this.environment = environment;
    15.     }
    16.  
    17.     private void processMetaValue(Object bean) {
    18.         Class clz = bean.getClass();
    19.         if (!clz.isAnnotationPresent(RefreshValue.class)) {
    20.             return;
    21.         }
    22.  
    23.         if (clz.isAnnotationPresent(ConfigurationProperties.class)) {
    24.             //@ConfigurationProperties注解
    25.             ConfigurationProperties config = (ConfigurationProperties) clz.getAnnotation(ConfigurationProperties.class);
    26.             for (Field field : clz.getDeclaredFields()) {
    27.                 String key = config.prefix() + "." + field.getName();
    28.                 if(mapper.containsKey(key)){
    29.                     mapper.get(key).add(new FieldPair(bean, field, key));
    30.                 }else{
    31.                     List fieldPairList = new ArrayList<>();
    32.                     fieldPairList.add(new FieldPair(bean, field, key));
    33.                     mapper.put(key, fieldPairList);
    34.                 }
    35.             }
    36.         } else {
    37.             //@Valuez注解
    38.             try {
    39.                 for (Field field : clz.getDeclaredFields()) {
    40.                     if (field.isAnnotationPresent(Value.class)) {
    41.                         Value val = field.getAnnotation(Value.class);
    42.                         String key = val.value().replace("${", "").replace("}", "");
    43.                         if(mapper.containsKey(key)){
    44.                             mapper.get(key).add(new FieldPair(bean, field, key));
    45.                         }else{
    46.                             List fieldPairList = new ArrayList<>();
    47.                             fieldPairList.add(new FieldPair(bean, field, key));
    48.                             mapper.put(key, fieldPairList);
    49.                         }
    50.                     }
    51.                 }
    52.             } catch (Exception e) {
    53.                 e.printStackTrace();
    54.                 System.exit(-1);
    55.             }
    56.         }
    57.     }
    58.  
    59.     public static class FieldPair {
    60.         private static PropertyPlaceholderHelper propertyPlaceholderHelper = new PropertyPlaceholderHelper("${", "}",
    61.                 ":", true);
    62.         private Object bean;
    63.         private Field field;
    64.         private String value;
    65.  
    66.         public FieldPair(Object bean, Field field, String value) {
    67.             this.bean = bean;
    68.             this.field = field;
    69.             this.value = value;
    70.         }
    71.  
    72.         public void updateValue(Environment environment) {
    73.             boolean access = field.isAccessible();
    74.             if (!access) {
    75.                 field.setAccessible(true);
    76.             }
    77.             try {
    78.                 if (field.getType() == String.class) {
    79.                     String updateVal = environment.getProperty(value);
    80.                     field.set(bean, updateVal);
    81.                 }
    82.                 else if (field.getType() == Integer.class) {
    83.                     Integer updateVal = environment.getProperty(value,Integer.class);
    84.                     field.set(bean, updateVal);
    85.                 }
    86.                 else if (field.getType() == int.class) {
    87.                     int updateVal = environment.getProperty(value,int.class);
    88.                     field.set(bean, updateVal);
    89.                 }
    90.                 else if (field.getType() == Boolean.class) {
    91.                     Boolean updateVal = environment.getProperty(value,Boolean.class);
    92.                     field.set(bean, updateVal);
    93.                 }
    94.                 else if (field.getType() == boolean.class) {
    95.                     boolean updateVal = environment.getProperty(value,boolean.class);
    96.                     field.set(bean, updateVal);
    97.                 }
    98.                 else {
    99.                     String updateVal = environment.getProperty(value);
    100.                     field.set(bean, JSONObject.parseObject(updateVal, field.getType()));
    101.                 }
    102.             } catch (IllegalAccessException e) {
    103.                 e.printStackTrace();
    104.             }
    105.             field.setAccessible(access);
    106.         }
    107.  
    108.         public Object getBean() {
    109.             return bean;
    110.         }
    111.  
    112.         public void setBean(Object bean) {
    113.             this.bean = bean;
    114.         }
    115.  
    116.         public Field getField() {
    117.             return field;
    118.         }
    119.  
    120.         public void setField(Field field) {
    121.             this.field = field;
    122.         }
    123.  
    124.         public String getValue() {
    125.             return value;
    126.         }
    127.  
    128.         public void setValue(String value) {
    129.             this.value = value;
    130.         }
    131.     }
    132.  
    133.     public static class ConfigUpdateEvent extends ApplicationEvent {
    134.         String key;
    135.  
    136.         public ConfigUpdateEvent(Object source, String key) {
    137.             super(source);
    138.             this.key = key;
    139.         }
    140.     }
    141.  
    142.     @EventListener
    143.     public void updateConfig(ConfigUpdateEvent configUpdateEvent) {
    144.         if(mapper.containsKey(configUpdateEvent.key)){
    145.             List fieldPairList = mapper.get(configUpdateEvent.key);
    146.             if(fieldPairList.size()>0){
    147.                 for (FieldPair fieldPair:fieldPairList) {
    148.                     fieldPair.updateValue(environment);
    149.                 }
    150.             }
    151.         }
    152.     }
    153. }

  • 相关阅读:
    学习笔记--强化学习（1）
    【贪心基本算法】贪心算法常见题目
    【Redis】Redis 淘汰、雪崩、击穿、穿透、预热
    【cpolar】Ubuntu本地快速搭建web小游戏网站，公网用户远程访问
    GEE错误——Tile error: Arrays must have same lengths on all axes but the cat axis
    脚手架构建VUE项目
    vue双向绑定/小程序双向绑定？
    【ROS】RViz、Gazebo和Navigation的关系
    spring引入外部属性文件
    DNS外带注入
  • 原文地址：https://blog.csdn.net/weixin_48890074/article/details/133788680