Yaml转Json

缘起

年前，由于项目需求进行装备的优化和架构的升级，领导给我来了个任务，让我去进行技术调研

需求将装备中心的yaml装备文件里边的装备转为Json的形式，以便后边能够经过写装备文件的办法，让数据源变的可拔插

调研进程

本着有轮子就直接用，绝不自己造轮子的态度，我成功找到了 snakeyaml 这个依靠

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

1.0 进口点

Yaml yaml = new Yaml();

注意：此实现并不是一个线程安全的

1.1 根本用法

yml 文件：

common.cloud:
  discovery: consul
  config: consul

Java 代码：

  @Test
  public void YAMLToJSON01() {
    Yaml yaml = new Yaml();
    InputStream resourceAsStream = this.getClass().getClassLoader().getResourceAsStream("yamlToJson.yml");
    // 解析唯一的 yaml 文档转为 Java 目标
    Map<String, Object> load = yaml.load(resourceAsStream);
    JSONObject jsonObject = JSONObject.parseObject(load);
    System.out.println(jsonObject.toString());
   }

成果

{"common.cloud":{"discovery":"consul","config":"consul"}}

1.2 自定义类型解析

yml 文件：

cloud:
   discovery: consul
   config: consul
extension:
   - data: application-oracle-public.yml
    refresh: true

Java 代码：

首先是创立对应的实体类

@Data
public class Cloud {
  private Contact cloud;
  private List<Contact02> extension;
}
@Data
public class Contact {
  private String discovery;
  private String config;
}
@Data
public class Contact02 {
  private String data;
  private String refresh;
}

  @Test
  public void YAMLToJSON02() {
    Yaml yaml = new Yaml(new Constructor(Cloud.class));
    InputStream resourceAsStream = this.getClass()
         .getClassLoader()
         .getResourceAsStream("yamlToJson.yml");
    // 解析 yaml 文档转为 Cloud 目标
    Cloud cloud = yaml.load(resourceAsStream);
    JSONObject jsonObject = JSONObject.parseObject(JSONObject.toJSONString(cloud));
    System.out.println(jsonObject.toString());
   }

成果

{"cloud":{"discovery":"consul","config":"consul"},"extension":[{"data":"application-oracle-public.yml","refresh":"true"}]}

1.3 实战

1.3.1 从本地读装备文件

在项目中，假设领导只需求 spring.cloud.nacos 这一块的装备内容，但咱们把整个装备文件的内容悉数取出来了，那肯定是不符合领导需求的

于是就有了接下来的一些代码，一些要害的注释也标注在了代码中

yml 文件:

spring.cloud.nacos:
  discovery:
   server-addr: xxx
  config:
   server-addr: xxx
   file-extension: yml
   extension-configs:
    - data-id: application-oracle-public.yml
     refresh: true
eureka:
  instance:
   preferIpAddress: true
   instanceId: ${spring.application.name}-${spring.cloud.client.ip-address}-${server.port}
  client:
   serviceUrl:
    defaultZone: http://xxx/eureka/

Java 代码:

  @Test
  public void YAMLToJSON01() {
    Yaml yaml = new Yaml();
    InputStream resourceAsStream = this.getClass().getClassLoader().getResourceAsStream("bootstrap.yml");
    // 解析 yaml 文档转为 Map
    Map<String, Object> load = yaml.load(resourceAsStream);
    HashMap<String, Object> objectObjectHashMap = new HashMap<>();
    // 经过 key 取到对应的 value 然后放到新的 Map 中
    objectObjectHashMap.put("spring.cloud.nacos", load.get("spring.cloud.nacos"));
    JSONObject jsonObject = JSONObject.parseObject(JSONObject.toJSONString(objectObjectHashMap));
    System.out.println(jsonObject.toString());
   }

成果

{"spring.cloud.nacos":{"discovery":{"server-addr":"xxx"},"config":{"file-extension":"yml","server-addr":"xxx","extension-configs":[{"refresh":true,"data-id":"application-oracle-public.yml"}]}}}

下面的代码是使用静态内部类的办法去确保线程的安全

public class YamlToJsonUtil implements Serializable {
  private final static String BOOTSTRAP = "bootstrap-test.yml";
​
  private final Yaml yaml = new Yaml(new SafeConstructor());
​
  /**
   * Yaml to json.
   *
   * @param key the key
   * @return the json object
   */
  public JSONObject YamlToJson(String key) {
    YamlToJsonUtil instance = YamlToJsonInner.instance;
    Yaml yaml = instance.getYaml();
    InputStream resourceAsStream = null;
    try {
      resourceAsStream = this.getClass().getClassLoader().getResourceAsStream(BOOTSTRAP);
     } catch (Exception e) {
      throw new RuntimeException(e);
     }
    Map<String, Object> load = null;
    Map<String, Object> result = new HashMap<>();
    load = yaml.load(resourceAsStream);
    result.put(key, load.get(key));
    return JSONObject.parseObject(JSONObject.toJSONString(result));
   }
​
  private YamlToJsonUtil() {
​
   }
​
  /**
   * Gets instance.
   *
   * @return the instance
   */
  public static YamlToJsonUtil getInstance() {
    return YamlToJsonInner.instance;
   }
​
  private static class YamlToJsonInner {
    private static final YamlToJsonUtil instance = new YamlToJsonUtil();
   }
​
  /**
   * Gets yaml.
   *
   * @return the yaml
   */
  public Yaml getYaml() {
    return yaml;
   }
}

@Test
public void YAMLToJSON03() {
  String key = "spring.cloud.nacos";
  YamlToJsonUtil yamlToJsonUtil = YamlToJsonUtil.getInstance();
  JSONObject jsonObject = yamlToJsonUtil.YamlToJson(key);
  System.out.println(jsonObject);
}

到了这一步领导的需求根本已经完成了一大半，接下来只需求再从装备中心中将这些装备取出来就能够摸鱼下班了

那么问题来了：该怎么从装备中心中找到那一份装备文件呢？

就在这时，我想起来了 Spring 里边的 org.springframework.core.env.PropertySource 这个类。 org.springframework.core.env.PropertySource 这一个类望文生义便是特点源的意思,再详细一点便是对获取键值对资源的抽象类。咱们能够从org.springframework.core.env.AbstractEnvironment#getPropertySources 这个办法中得到装备中心里边的装备以及环境装备，再经过过滤即可得到咱们想到的数据

(ps:上面提到的这个类以及对应的办法咱们能够自行百度，由于篇幅等原因就不在这里详解了)

1.3.2 从装备中心读装备文件

接下来直接看代码：

public Map<String, Object> getPropertyMap(Environment environment) {
    // 得到当前环境中一切的特点调集
    List<?> propertySourceCollection = ((StandardEnvironment) environment)
            .getPropertySources().stream()
            .map(PropertySource::getSource)
            .collect(Collectors.toList());
    List<LinkedHashMap<String, Object>> list = new ArrayList<>();
    for (Object source : propertySourceCollection) {
        // 判断特点类型是否为 LinkedHashMap
        if (source instanceof LinkedHashMap) {
            list.add((LinkedHashMap<String, Object>) source);
        }
    }
    // 将调集中多个 LinkedHashMap 合并为一个 Map
    return list.stream()
            .flatMap(map -> map.entrySet().stream())
            .collect(Collectors.toMap(
                    Map.Entry::getKey,
                    Map.Entry::getValue,
                    (value1, value2) -> value1));
}

经过测验，上面的代码能够将装备中心中的一切装备都存储在一个 Map<String, Object> 中。

可是由于 yaml.load() 并没有入参为 Map<String, Object> 的重载办法，所以咱们还得引入这个依靠

<dependency>
    <groupId>pl.jalokim.propertiestojson</groupId>
    <artifactId>java-properties-to-json</artifactId>
    <version>5.1.0</version>
</dependency>

这个依靠里边的办法能够将 Map 转为 properties，再转为 json，刚好满意咱们的需求。

Map<String, Object> propertyMap = getPropertyMap(environment);
// 将 Map 转为 Json
String json = new PropertiesToJsonConverter().convertFromValuesAsObjectMap(propertyMap);

直接上整个从装备中心读yaml装备文件里边的装备转为Json的悉数代码

线程安全单例：

/**
 * The type Yaml to json util.
 */
public class YamlToJsonForCloudUtil implements Serializable {
    private final Yaml yaml = new Yaml(new SafeConstructor());
    /**
     * Yaml to json.
     *
     * @param key the key of the configuration file in Consul or Nacos
     * @return the json object
     */
    public JSONObject YamlToJson(String key) {
        YamlToJsonForCloudUtil instance = YamlToJsonInner.instance;
        Environment environment = instance.getEnvironment();
        if (environment == null) {
            throw new RuntimeException("Environment 为空！");
        }
        Map<String, Object> propertyMap = getPropertyMap(environment);
        // 将 Map 转为 Json
        String json = new PropertiesToJsonConverter().convertFromValuesAsObjectMap(propertyMap);
        Yaml yaml = instance.getYaml();
        Map<String, Object> load = null;
        Map<String, Object> result = new HashMap<>();
        // 解析 String 中唯一的 YAML 文档并转为 Map
        load = yaml.load(json);
        result.put(key, load.get(key));
        return JSONObject.parseObject(JSONObject.toJSONString(result));
    }
    /**
     * Gets property map.
     *
     * @param environment the environment
     * @return the property map
     */
    public Map<String, Object > getPropertyMap(Environment environment) {
        // 得到当前环境中一切的特点调集
        List<?> propertySourceCollection = ((StandardEnvironment) environment)
                .getPropertySources().stream()
                .map(PropertySource::getSource)
                .collect(Collectors.toList());
        List<LinkedHashMap<String, Object>> list = new ArrayList<>();
        for (Object source : propertySourceCollection) {
            // 判断特点类型是否为 LinkedHashMap
            if (source instanceof LinkedHashMap) {
                list.add((LinkedHashMap<String, Object>) source);
            }
        }
        // 将调集中多个 LinkedHashMap 合并为一个 Map
        return list.stream()
                .flatMap(map -> map.entrySet().stream())
                .collect(Collectors.toMap(
                        Map.Entry::getKey,
                        Map.Entry::getValue,
                        (value1, value2) -> value1));
    }
    private YamlToJsonForCloudUtil() {
    }
    /**
     * Gets instance.
     *
     * @return the instance
     */
    public static YamlToJsonForCloudUtil getInstance() {
        return YamlToJsonInner.instance;
    }
    private static class YamlToJsonInner {
        private static final YamlToJsonForCloudUtil instance = new YamlToJsonForCloudUtil();
    }
    /**
     * Gets yaml.
     *
     * @return the yaml
     */
    public Yaml getYaml() {
        return yaml;
    }
    /**
     * Gets environment.
     *
     * @return the environment
     */
    public Environment getEnvironment() {
        return SpringContextUtil.getBean(Environment.class);
    }
}

东西类：

@Component
public class SpringContextUtil implements ApplicationContextAware {
    private static ApplicationContext applicationContext;
    /**
     * 实现ApplicationContextAware接口的回调办法，设置上下文环境
     */
    @Override
    public void setApplicationContext(@NotNull ApplicationContext applicationContext){
        SpringContextUtil.applicationContext = applicationContext;
    }
    /**
     * 获得spring上下文
     * @return ApplicationContext spring上下文
     */
    public static ApplicationContext getApplicationContext(){
        return applicationContext;
    }
    /**
     * 获取bean
     * @param name service注解办法name为小驼峰格局
     * @return  Object bean的实例目标
     */
    public static Object getBean(String name) throws BeansException {
        return getApplicationContext().getBean(name);
    }
    public static <T> T getBean(Class<T> className) {
        return getApplicationContext().getBean(className);
    }
    /**
     * 经过接口类型，返回一切实现了这个接口的实现类
     *
     * @param clazz
     * @param <T>
     * @return
     */
    public static <T> Map<String, T> getBeansOfType(Class<T> clazz) {
        return getApplicationContext().getBeansOfType(clazz);
    }
}

测验：

@Test
public void YamlToJsonEnvironment() {
    YamlToJsonForCloudUtil yamlToJsonUtil = YamlToJsonForCloudUtil.getInstance();
    JSONObject dom = yamlToJsonUtil.YamlToJson("dom");
    System.out.println(JSONObject.toJSONString(dom));
}

结束

谢谢各位的观看，小弟是个Java新手也是第一次更文，如果有更好的办法欢迎咱们在评论区指出来，如果有什么主张也欢迎咱们提出