JSON数据平铺和对象化

平铺

常见的json数据

{
	"a": {
		"b": "b",
		"c": "c"
	},
	"d": {
		"e": {
			"f": "f",
			"g": "g"
		},
		"h": "h"
	}
}

平铺后的结果

{
	"a:b" : "b",
	"a:c": "c",
	"d:e:f": "f",
	"d:e:g": "g",
	"d:h" : "h"
}

递归处理（没处理存在数组的情况下）

public static void display() {
    Map map = JacksonUtils.toObj(json, Map.class);
    Map<String, String> dataMap = new LinkedHashMap<>();
    deepTraverse(map, "", dataMap);
}

public static void deepTraverse(Map map, String pathKey, Map<String, String> dataMap) {
    for (Object key : map.keySet()) {
        Object o = map.get(key);
        if (o instanceof Map) {
            // 处理层级key
            if (StrUtil.isEmpty(pathKey)) {
                deepTraverse((Map) o, key.toString(), dataMap);
            } else {
                deepTraverse((Map) o, pathKey + "." + key, dataMap);
            }
        }
        if (o instanceof String) {
            // 最后一层key
            key = pathKey + "." + key;
            // 添加数据
            dataMap.put(key.toString(), o.toString());
        }
    }
}

json-flattener处理（含数组处理）

maven依赖

<dependency>
     <groupId>com.github.wnameless.json</groupId>
     <artifactId>json-flattener</artifactId>
     <version>0.8.1</verison>
 </dependency>

Java代码

String flatten = JsonFlattener.flatten(json);

如何把数据转回json

{
	"a":"a1",
	"b.b1":"b11",
	"c[0]":"c1",
	"c[1]":"c2",
	"c[2]":"c3",
	"d[0].d1":"d2"
}

转换回去的数据

{
    "a": "a1",
    "b": {
        "b1": "b11"
    },
    "c": [
        "c1",
        "c2",
        "c3"
    ],
    "d": [
        {
            "d1": "d2"
        }
    ]
}

Java（不含数组处理）

JsDTO实体类里面两个属性，一个key，一个value

public static void display() {
	// 读取上面json字符串存储到对象
	List<JsDTO> jsList = getJsList();
    Map<String, Object> map = new LinkedHashMap<>();
    for (JsDTO dto : jsList) {
        String[] split = dto.getKey().split("\\:");
        reverseDeepTraverse(map, split, 0, dto.getValue());
    }
}
public static void reverseDeepTraverse(Map<String, Object> map, String[] split, int start, String value) {
     // 最后一级key
     if (start == split.length - 1) {
         map.put(split[start], value);
         return;
     }
     Map<String, Object> childMap;
     // 说明key已经被存储过
     if (map.containsKey(split[start])) {
         childMap = (Map<String, Object>) map.get(split[start]);
     } else {
         // key没被存储过
         childMap = new LinkedHashMap<>();
         map.put(split[start], childMap);
     }
     reverseDeepTraverse(childMap, split, ++start, value);
 }

json-flattener处理（含数组处理）

String unflatten = JsonUnflattener.unflatten(json);

转换回这样的json字符串

{
   "a": "a1",
   "b": {
   	"b1": "b11"
   },
   "c": ["c1", "c2", "c3"],
   "d": [{
   		"d1": "d2"
   	}
   }
}

fastJson处理（含数组处理）

引入maven依赖

<dependency>
     <groupId>com.alibaba</groupId>
     <artifactId>fastjson</artifactId>
     <version>2.0.10</verison>
 </dependency>

代码处理

List<JsDTO> jsList = getJsList();
// 传入true表示存的顺序和取的顺序是一致的
JSONObject jsonObject = new JSONObject(Boolean.TRUE);
for (JsDTO jsDTO : jsList) {
  JSONPath.set(jsonObject, jsDTO.getKey(), jsDTO.getValue());
}
System.out.println(jsonObject);

JSDTO实体类的两个字段key和value是这样的数据

{
   key : value
   "a:b" : "b",
   "a:c": "c",
   "d:e:f": "f",
   "d:e:g": "g",
   "d:h" : "h"
}

注意

json-flattener 转换成的json数据的key默认是.隔开,fastJson的key默认是:隔开

参考链接

https://blog.csdn.net/Revivedsun/article/details/117875828
https://github.com/wnameless/json-flattener