package com.cwq.demo02;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
public class JsonUtil {
public static Set<String> set = new HashSet<>();
static {
set.add("String");
set.add("Integer");
set.add("Double");
}
public static <T>T str2Obj(String json, Class<T> clazz) {
Gson gson = new GsonBuilder()
.disableHtmlEscaping()
.serializeNulls()
.create();
return gson.fromJson(json, clazz);
}
public static String obj2Str(Object obj) {
Gson gson = new GsonBuilder()
.disableHtmlEscaping()
.serializeNulls()
.create();
return gson.toJson(obj);
}
public static Map jsonCompare(String currentJson, String expectJson) {
Map<String, String> result = new HashMap<>();
Map<String, Object> curr = str2Obj(currentJson, Map.class);
Map<String, Object> exp = str2Obj(expectJson, Map.class);
mapProc(curr, exp, result, "");
return result;
}
public static void mapProc(Map<String, Object> curr, Map<String, Object> exp, Map<String, String> result, String keyStr) {
if (curr.size() != exp.size()) {
result.put(keyStr == "" ? "首层":keyStr, String.format("key=[%s]Map字段个数不一致,期望为[%s],但当前为[%s]", keyStr == "" ? "首层":keyStr, exp.size(), curr.size()));
}
for (String currKey : curr.keySet()) {
String keyStrCopy = keyStr + "."+ currKey;
if (keyStrCopy.indexOf(".") == 0) {
keyStrCopy = keyStrCopy.substring(1);
}
Object currObj = curr.get(currKey);
if (currObj == null) {
Object expObj = exp.get(currKey);
if (expObj != null) {
result.put(keyStrCopy, String.format("key=[%s]期望为[%s],但当前为[%s]", keyStrCopy, expObj, currObj));
}
continue;
}
Object expObj = exp.get(currKey);
if (expObj == null) {
result.put(keyStrCopy, String.format("key=[%s]期望为[%s],但当前为[%s]", keyStrCopy, expObj, currObj));
continue;
}
if (!expObj.getClass().getSimpleName().equals(currObj.getClass().getSimpleName())) {
result.put(keyStrCopy, String.format("key=[%s]类型不匹配,期望为[%s],但当前为[%s]", keyStrCopy, expObj.getClass().getSimpleName(), currObj.getClass().getSimpleName()));
continue;
}
if (set.contains(currObj.getClass().getSimpleName())) {
if (!expObj.equals(currObj)) {
result.put(keyStrCopy, String.format("key=[%s]期望为[%s],但当前为[%s]", keyStrCopy, expObj, currObj));
}
}
else if (currObj instanceof List) {
List currList = (List)currObj;
List expList = (List)expObj;
if (currList.size() != expList.size()) {
result.put(keyStrCopy, String.format("key=[%s]List结果条数不一致,期望为[%s],但当前为[%s]", keyStrCopy, expList.size(), currList.size()));
continue;
}
for (int i = 0; i < currList.size(); i++) {
Object currListObj = currList.get(i);
Object expListObj = expList.get(i);
if (!currListObj.getClass().getSimpleName().equals(expListObj.getClass().getSimpleName())) {
result.put(keyStrCopy, String.format("key=[%s]List中泛型的类型不匹配,期望为[%s],但当前为[%s]", keyStrCopy,
expListObj.getClass().getSimpleName(), currListObj.getClass().getSimpleName()));
break;
}
if (currListObj instanceof Map) {
Map<String, Object> currListMap = (Map)currListObj;
Map<String, Object> expListMap = (Map)expListObj;
mapProc(currListMap, expListMap, result, keyStrCopy+"-"+ i +"");
}
else if (set.contains(currListObj.getClass().getSimpleName())) {
if (!expListObj.equals(currListObj)) {
result.put(keyStrCopy+"-"+i+"", String.format("key=[%s]期望为[%s],但当前为[%s]", keyStrCopy+"-"+ i +"", expListObj, currListObj));
}
}
else {
result.put(keyStrCopy+"-"+ i +"", String.format("key=[%s]List中泛型的类型为[%s],目前未支持,期望为[%s],但当前为[%s]", keyStrCopy+"-"+ i +"", currListObj.getClass().getSimpleName(), expListObj, currListObj));
}
}
}
else if (currObj instanceof Map) {
Map<String, Object> currListMap = (Map)currObj;
Map<String, Object> expListMap = (Map)expObj;
mapProc(currListMap, expListMap, result, keyStrCopy);
}
else {
result.put(keyStrCopy, String.format("key=[%s]类型为[%s],目前未支持,期望为[%s],但当前为[%s]", keyStrCopy, currObj.getClass().getSimpleName(), expObj, currObj));
}
}
exp.forEach((key, value) -> {
if(){
}
});
}
public static void main(String[] args) {
Map<String, Object> result = new HashMap<>();
result.putAll(test03());
for (String key : result.keySet()) {
System.out.println(key + " <---> " + result.get(key));
}
}
public static Map test03() {
System.out.println("==================测试多层json-List==========================");
Map<String, Object> exp = new HashMap<>();
List<Map<String, Object>> expList = new ArrayList<>();
List<Object> expListSimple = new ArrayList<>();
Map<String, Object> exp01 = new HashMap<>();
exp01.put("AA", "-aa");
exp01.put("AB", 22);
exp01.put("AC", 33);
expList.add(exp01);
Map<String, Object> exp02 = new HashMap<>();
exp02.put("AA", "-aa");
exp02.put("AB", 22);
exp02.put("AC", 33);
expList.add(exp02);
expListSimple.add(2);
expListSimple.add("3");
expListSimple.add(true);
exp.put("A", "aa");
exp.put("B", expList);
exp.put("C", expList);
exp.put("D", expListSimple);
Map<String, Object> curr = new HashMap<>();
List<Map<String, Object>> currList = new ArrayList<>();
List<Object> currListSimple = new ArrayList<>();
Map<String, Object> curr01 = new HashMap<>();
curr01.put("AB", 22);
curr01.put("AC", 22);
currList.add(curr01);
Map<String, Object> curr02 = new HashMap<>();
curr02.put("AA", "-aa");
curr02.put("AB", 22);
curr02.put("AC", 33);
currList.add(curr02);
currListSimple.add(2);
currListSimple.add("3");
currListSimple.add(true);
curr.put("B", currList);
curr.put("C", new ArrayList<>());
curr.put("D", currListSimple);
String expectJson = obj2Str(exp);
String currentJson = obj2Str(curr);
Map jsonCompare = jsonCompare(currentJson, expectJson);
return jsonCompare;
}
public static Map test02() {
System.out.println("==================测试多层json-Map==========================");
Map<String, Object> exp = new HashMap<>();
Map<String, Object> exp01 = new HashMap<>();
exp01.put("AA", "-aa");
exp01.put("AB", 22);
exp01.put("AC", 33);
exp.put("A", "aa");
exp.put("B", exp01);
exp.put("C", exp01);
Map<String, Object> curr = new HashMap<>();
Map<String, Object> curr01 = new HashMap<>();
curr01.put("AB", 22);
curr01.put("AC", 22);
curr.put("B", curr01);
curr.put("C", new ArrayList<>());
String expectJson = obj2Str(exp);
String currentJson = obj2Str(curr);
Map jsonCompare = jsonCompare(currentJson, expectJson);
return jsonCompare;
}
public static Map test01() {
System.out.println("==================测试单层json==========================");
Map<String, Object> exp = new HashMap<>();
exp.put("A", "aa");
exp.put("B", "ba");
exp.put("C", 2);
exp.put("D", null);
exp.put("E", null);
exp.put("F", 2);
Map<String, Object> curr = new HashMap<>();
curr.put("B", "bb");
curr.put("C", "2");
curr.put("D", "2");
curr.put("E", null);
curr.put("F", null);
String expectJson = obj2Str(exp);
String currentJson = obj2Str(curr);
Map jsonCompare = jsonCompare(currentJson, expectJson);
return jsonCompare;
}
}