网上找到的比较JSON工具类，比较两个JSON对象之间的差异，并将差异字段按照原JSON对象的树状结构展现出来，方便对数据进行对比。对原有方法进行了部分优化。
package com.summer.toolkit.util;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.CollectionUtils;
import java.util.*;
/**
* @author author
*/
@Slf4j
public class CompareJsonUtils {
/**
* 正则表达式，匹配数组下标，如：[0]、[1]
*/
public static final String PATTERN = "\\[[0-9]+\\]";
/**
* 分隔符
*/
public static final String REGEX = "\\.";
/**
* 连接符
*/
public static final String CONNECTOR = ".";
/**
* 旧的数据Key值
*/
public static final String OLD_VALUE_KEY = "oldValue";
/**
* 新的数据Key值
*/
public static final String NEW_VALUE_KEY = "newValue";
/**
* 将两个JSON对象进行比较
*
* @param oldJsonStr 旧的JSON字符串
* @param newJsonStr 新的JSON字符串
* @return 比较结果转换为JSON字符串
*/
public static String compareJsonObject(String oldJsonStr, String newJsonStr) {
// 默认不排除字段
List<String> excludes = new ArrayList<>();
return CompareJsonUtils.compareJsonObject(oldJsonStr, newJsonStr, excludes);
}
/**
* 比较两个JSON对象，排除指定字段后的差异
*
* @param oldJsonStr 旧的JSON字符串
* @param newJsonStr 新的JSON字符串
* @param excludes 需要排除比较的字段列表
* @return 返回排除指定字段后的差异JSON对象
*/
public static String compareJsonObject(String oldJsonStr, String newJsonStr, List<String> excludes) {
// 将字符串转换为json对象
JSON oldJson = JSON.parseObject(oldJsonStr);
JSON newJson = JSON.parseObject(newJsonStr);
// 递归遍历json对象所有的key-value，将其封装成path:value格式进行比较
Map<String, Object> oldMap = new LinkedHashMap<>(32);
Map<String, Object> newMap = new LinkedHashMap<>(32);
CompareJsonUtils.convertJsonToMap(oldJson, "", oldMap);
CompareJsonUtils.convertJsonToMap(newJson, "", newMap);
// 去掉不需要对比的字段
CompareJsonUtils.excludeFields(oldMap, excludes);
CompareJsonUtils.excludeFields(newMap, excludes);
// 比较两个map，返回不同数据
Map<String, Object> temp = new LinkedHashMap<>(oldMap);
Map<String, Object> differenceMap = CompareJsonUtils.compareMap(temp, newMap);
// 将最终的比较结果把不相同的转换为json对象返回
JSONObject result = CompareJsonUtils.convertMapToJson(differenceMap);
log.info("对比JSON结果为：{}", result);
return JSON.toJSONString(result);
}
/**
* 从给定的Map中排除指定的字段
*
* @param map 包含字段的Map
* @param excludes 要排除的字段列表
*/
public static void excludeFields(Map<String, Object> map, List<String> excludes) {
if (Objects.nonNull(map) && CollectionUtils.isNotEmpty(excludes)) {
Iterator<Map.Entry<String, Object>> iterator = map.entrySet().iterator();
while (iterator.hasNext()) {
Map.Entry<String, Object> entry = iterator.next();
if (Objects.nonNull(entry)) {
if (excludes.contains(entry.getKey())) {
iterator.remove();
}
}
}
}
}
/**
* 将json数据转换为map存储用于比较
*
* @param json JSON对象
* @param root 根对象名称
* @param resultMap 结果
*/
private static void convertJsonToMap(Object json, String root, Map<String, Object> resultMap) {
if (json instanceof JSONObject) {
JSONObject jsonObject = ((JSONObject) json);
for (String key : jsonObject.keySet()) {
Object value = jsonObject.get(key);
String newRoot = "".equals(root) ? key + "" : root + CompareJsonUtils.CONNECTOR + key;
if (value instanceof JSONObject || value instanceof JSONArray) {
CompareJsonUtils.convertJsonToMap(value, newRoot, resultMap);
} else {
resultMap.put(newRoot, value);
}
}
} else if (json instanceof JSONArray) {
JSONArray jsonArray = (JSONArray) json;
for (int i = 0; i < jsonArray.size(); i++) {
Object value = jsonArray.get(i);
String newRoot = "".equals(root) ? "[" + i + "]" : root + ".[" + i + "]";
if (value instanceof JSONObject || value instanceof JSONArray) {
CompareJsonUtils.convertJsonToMap(value, newRoot, resultMap);
} else {
resultMap.put(newRoot, value);
}
}
}
}
/**
* 比较两个map，返回不同数据
*
* @param oldMap 旧数据MAP对象
* @param newMap 新数据MAP对象
* @return 返回值，两者的差异
*/
private static Map<String, Object> compareMap(Map<String, Object> oldMap, Map<String, Object> newMap) {
// 遍历newMap，将newMap的不同数据装进oldMap，同时删除oldMap中与newMap相同的数据
CompareJsonUtils.compareNewToOld(oldMap, newMap);
// 将旧的有新的没有的数据封装数据结构存在旧的里面
CompareJsonUtils.compareOldToNew(oldMap);
return oldMap;
}
/**
* 将旧的有新的没有的数据封装数据结构存在旧的里面
*
* @param oldMap 旧数据结构
*/
private static void compareOldToNew(Map<String, Object> oldMap) {
// 统一oldMap中newMap不存在的数据的数据结构，便于解析
for (Map.Entry<String, Object> item : oldMap.entrySet()) {
String key = item.getKey();
Object value = item.getValue();
if (!(value instanceof Map)) {
// 此处并没有添加数据，而是将key值对应的value值进行修改，所以并没有改变map的数量
Map<String, Object> differenceMap = CompareJsonUtils.buildDifferenceMap(value, "");
oldMap.put(key, differenceMap);
}
}
}
/**
* 将新的map与旧的比较，并将数据统一存在旧的里面
*
* @param oldMap 旧数据
* @param newMap 新数据
*/
private static void compareNewToOld(Map<String, Object> oldMap, Map<String, Object> newMap) {
for (Map.Entry<String, Object> item : newMap.entrySet()) {
String key = item.getKey();
Object newValue = item.getValue();
if (oldMap.containsKey(key)) {
Object oldValue = oldMap.get(key);
if (newValue.equals(oldValue)) {
oldMap.remove(key);
} else {
Map<String, Object> differenceMap = CompareJsonUtils.buildDifferenceMap(oldValue, newValue);
oldMap.put(key, differenceMap);
}
} else {
Map<String, Object> differenceMap = CompareJsonUtils.buildDifferenceMap("", newValue);
oldMap.put(key, differenceMap);
}
}
}
/**
* 将已经找出不同数据的map根据key的层级结构封装成json返回
*
* @param map 入参
* @return 返回值
*/
private static JSONObject convertMapToJson(Map<String, Object> map) {
JSONObject resultJsonObject = new JSONObject();
for (Map.Entry<String, Object> item : map.entrySet()) {
String key = item.getKey();
Object value = item.getValue();
String[] paths = key.split(CompareJsonUtils.REGEX);
int i = 0;
// 用于深度标识对象
Object remarkObject = null;
int indexAll = paths.length - 1;
while (i <= paths.length - 1) {
String path = paths[i];
if (i == 0) {
// 初始化对象标识
if (resultJsonObject.containsKey(path)) {
remarkObject = resultJsonObject.get(path);
} else {
if (indexAll > i) {
if (paths[i + 1].matches(CompareJsonUtils.PATTERN)) {
remarkObject = new JSONArray();
} else {
remarkObject = new JSONObject();
}
resultJsonObject.put(path, remarkObject);
} else {
resultJsonObject.put(path, value);
}
}
i++;
continue;
}
// 匹配集合对象
if (path.matches(CompareJsonUtils.PATTERN)) {
int startIndex = path.lastIndexOf("[");
int endIndext = path.lastIndexOf("]");
int index = Integer.parseInt(path.substring(startIndex + 1, endIndext));
if (indexAll > i) {
if (paths[i + 1].matches(CompareJsonUtils.PATTERN)) {
while (((JSONArray) remarkObject).size() <= index) {
if (((JSONArray) remarkObject).size() == index) {
((JSONArray) remarkObject).add(index, new JSONArray());
} else {
//((JSONArray) remarkObject).add(null);
((JSONArray) remarkObject).add(new JSONObject());
}
}
} else {
while (((JSONArray) remarkObject).size() <= index) {
if (((JSONArray) remarkObject).size() == index) {
((JSONArray) remarkObject).add(index, new JSONObject());
} else {
//((JSONArray) remarkObject).add(null);
((JSONArray) remarkObject).add(new JSONObject());
}
}
}
remarkObject = ((JSONArray) remarkObject).get(index);
} else {
while (Objects.nonNull(remarkObject) && ((JSONArray) remarkObject).size() <= index) {
if (((JSONArray) remarkObject).size() == index) {
((JSONArray) remarkObject).add(index, value);
} else {
//((JSONArray) remarkObject).add(null);
((JSONArray) remarkObject).add(new JSONObject());
}
}
}
} else {
if (indexAll > i) {
if (paths[i + 1].matches(CompareJsonUtils.PATTERN)) {
if (!((JSONObject) remarkObject).containsKey(path)) {
((JSONObject) remarkObject).put(path, new JSONArray());
}
} else {
if (!((JSONObject) remarkObject).containsKey(path)) {
((JSONObject) remarkObject).put(path, new JSONObject());
}
}
remarkObject = ((JSONObject) remarkObject).get(path);
} else if (Objects.nonNull(remarkObject)) {
((JSONObject) remarkObject).put(path, value);
}
}
i++;
}
}
return resultJsonObject;
}
/**
* 构建差异Map，用于比较旧值和新值之间的差异
*
* @param oldValue 旧值
* @param newValue 新值
* @return differenceMap 差异Map，包含'oldValue'和'newValue'两个键值对
*/
public static Map<String, Object> buildDifferenceMap(Object oldValue, Object newValue) {
Map<String, Object> differenceMap = new HashMap<>(4);
differenceMap.put(CompareJsonUtils.OLD_VALUE_KEY, oldValue);
differenceMap.put(CompareJsonUtils.NEW_VALUE_KEY, newValue);
return differenceMap;
}
/**
* 比较两个JSON对象并返回它们之间的差异
*/
public static void main(String[] args) {
String oldStr = "{a:'aaa',b:'bbb',c:'aaa',d:'bbb'}";
String newStr = "{a:'aa',b:'bb',e:'bb'}";
System.out.println(CompareJsonUtils.compareJsonObject(oldStr, newStr));
}
}
以上测试方法结果为：
{
"b": {
"newValue": "bb",
"oldValue": "bbb"
},
"c": {
"newValue": "",
"oldValue": "aaa"
},
"d": {
"newValue": "",
"oldValue": "bbb"
},
"e": {
"newValue": "bb",
"oldValue": ""
}
}
参考链接：【Java】Java对比两个JSON对象(深度广度比较)
