记录json对比工具类
/**
* @program: bedrock
* @description: 复杂对象比较工具类
* @author:
* @create: 2022-01-26 22:49
**/
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import org.apache.commons.lang3.StringUtils;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
/**
* @description: 对象对比工具类
* @author: guo-coffee
*/
public class ComparedUtils {
/**
* 示例说明(更多事例可查看main方法)：
* 对比json:{"id":"tom","username":"tom","age":18,"address":[{"province":"上海市"},{"city":"上海市"},{"disrtict":"静安区"},{"id":"静安区"}]}
*
* 示例一：调用compareJson(JSONObject json1, JSONObject json2, List<String> compareList)
* 假设指定username、address_province两列对比，compareList中需要放入username、address、address_province。
* 解释：若compareList集合中不放address，则表示整个address均不会进入比较，所以json嵌套多层时，将父key也需要放入compareList中
*
* 事例二：调用compareJson(JSONObject json1, JSONObject json2, List<String> filterList,boolean flag)
* 1、假设指定username、address_province两列不进行对比，filterList中需要放入username、address_province即可
* 2、假设整个address均不进行比对，filterList中需要放入username、address即可
*/
/**
* 默认过滤列名(由于项目会继承一些基类[例如ID、操作人、操作时间、修改人、修改时间等]，基类中属性对比无任何意义，可以过滤掉)
*/
private static final List<String> DEFAULT_FILTER_COLUMNS = Arrays.asList("id","createDate","updateDate","createPersonId","createPersonName","updatePersonId","updatePersonName","concurrencyVersion","delflag","tendId");
/**
* json嵌套多层时，父子key拼接字符
*/
private static final String SEPARATOR = "->";
/**
* 两个对象对比(全部列对比)
* @param json1 对比对象,必传
* @param json2 对比对象,必传
* @return
*/
public static Map<String,List<String>> compareJson(JSONObject json1, JSONObject json2){
return compareJson(json1,json2,false);
}
/**
* 两个对象对比
* @param json1 对比对象,必传
* @param json2 对比对象,必传
* @param flag 是否采用默认过滤策略-->true:采用 false：不采用
* @return
*/
public static Map<String,List<String>> compareJson(JSONObject json1, JSONObject json2, boolean flag){
return compareJson(json1,json2,null,null,flag,null,null,new ArrayList<>(),new ArrayList<>());
}
/**
* 两个对象对比
* @param json1 对比对象,必传
* @param json2 对比对象,必传
* @param compareList 要比较的列
* @return
*/
public static Map<String,List<String>> compareJson(JSONObject json1, JSONObject json2, List<String> compareList){
return compareJson(json1,json2,compareList,null,false,null,null,new ArrayList<>(),new ArrayList<>());
}
/**
* 两个对象对比
* @param json1 对比对象,必传
* @param json2 对比对象,必传
* @param filterList 不需要比较的列
* @param flag 是否需要过滤默认列-->true:需要 false：不需要
* @return
*/
public static Map<String,List<String>> compareJson(JSONObject json1, JSONObject json2, List<String> filterList,boolean flag){
return compareJson(json1,json2,null,filterList,flag,null,null,new ArrayList<>(),new ArrayList<>());
}
/**
* 父类递归
* @param json1 对比对象
* @param json2 对比对象
* @param compareList 要比较的列
* @param filterList 不需要比较的列
* @param flag 是否需要过滤默认列-->true:需要 false：不需要
* @param key 当前比较的key,默认传null,主要用于递归时使用
* @param parentKey 拼接父类key,避免json嵌套多层时，返回key一致问题,默认传null，主要用于递归时使用
* @param equalsList 相同列,默认传new ArrayList<String>(),主要用于递归使用
* @param diffList 不同列,默认传传new ArrayList<String>(),主要用于递归使用
* @return
*/
private static Map<String,List<String>> compareJson(JSONObject json1, JSONObject json2,List<String> compareList,List<String> filterList,boolean flag, String key,String parentKey,List<String> equalsList,List<String> diffList) {
Map<String,List<String>> map = new HashMap<>(2);
Iterator i = json1.keySet().iterator();
while (i.hasNext()) {
// 当前比较的列
key = (String) i.next();
// 嵌套JSONArray时，当前key拼接父类key
String str = StringUtils.isBlank(parentKey) ? key : parentKey + SEPARATOR + key;
if (
// 比较全部
((compareList == null || compareList.isEmpty()) && (filterList == null || filterList.isEmpty()) && !flag)
// 在【要比较的列】中
|| (compareList != null && !compareList.isEmpty() && compareList.contains(str))
// 不默认过滤 并且 不在【不需要比较的列】中
|| (filterList != null && !filterList.isEmpty() && !filterList.contains(str) && !flag)
// 过滤默认 并且 不在默认列 并且 不在【不需要比较的列】中
|| (filterList != null && !filterList.isEmpty() && !filterList.contains(str) && flag && !DEFAULT_FILTER_COLUMNS.contains(key))
// 只过滤默认
|| ((filterList == null || filterList.isEmpty()) && flag && !DEFAULT_FILTER_COLUMNS.contains(key))
) {
/**
* 调用-->Object
*/
if (json1.get(key) != null && json2.get(key) != null){
compareJson(json1.get(key), json2.get(key), compareList, filterList, flag, key, parentKey, equalsList, diffList);
} else if (json1.get(key) == null && json2.get(key) == null) {
equalsList.add(key);
} else {
diffList.add(key);
}
}
}
// 嵌套JSONArray时，只要有一列不一致，均为不一致
equalsList.removeAll(diffList);
// 嵌套JSONArray时，存在列明重复情况，集合去重处理
map.put("equalsList",equalsList.stream().distinct().collect(Collectors.toList()));
map.put("diffList",diffList.stream().distinct().collect(Collectors.toList()));
return map;
}
/**
* Object
*/
private static void compareJson(Object json1, Object json2,List<String> compareList,List<String> filterList,boolean flag, String key,String parentKey,List<String> equalsList,List<String> diffList) {
if (json1 instanceof JSONObject) {
// 拼接父类key,避免json嵌套多层时，返回key一致问题
parentKey = StringUtils.isBlank(parentKey)?key:parentKey+SEPARATOR+key;
/**
* 调用-->父类递归
*/
compareJson((JSONObject) json1, (JSONObject) json2, compareList,filterList, flag, key ,parentKey,equalsList,diffList);
} else if (json1 instanceof JSONArray) {
/**
* 调用-->jsonArray
*/
compareJson((JSONArray) json1, (JSONArray) json2, compareList, filterList, flag, key ,parentKey,equalsList,diffList);
} else if (json1 instanceof String) {
try {
String json1ToStr = json1.toString();
String json2ToStr = json2.toString();
/**
* 调用-->json字符串
*/
compareJson(json1ToStr, json2ToStr, key , parentKey,equalsList,diffList);
} catch (Exception e) {
System.out.println("转换发生异常 key:" + key);
e.printStackTrace();
}
} else {
/**
* 调用-->json字符串
*/
compareJson(json1.toString(), json2.toString(), key , parentKey,equalsList,diffList);
}
}
/**
* json字符串
*/
private static void compareJson(String str1, String str2, String key,String parentKey,List<String> equalsList,List<String> diffList) {
// 拼接父类key,避免json嵌套多层时，返回key一致问题
parentKey = StringUtils.isBlank(parentKey)?key:parentKey+SEPARATOR+key;
if (!str1.equals(str2)) {
// 不一致的key
diffList.add(parentKey);
} else {
// 一致
equalsList.add(parentKey);
}
}
/**
* jsonArray
*/
private static void compareJson(JSONArray json1, JSONArray json2,List<String> compareList,List<String> filterList,boolean flag, String key, String parentKey,List<String> equalsList,List<String> diffList) {
// 拼接父类key,避免json嵌套多层时，返回key一致问题
if (json1 != null && json2 != null && json1.size() == json2.size()) {
Iterator i1 = json1.iterator();
Iterator i2 = json2.iterator();
while (i1.hasNext()) {
/**
* 调用-->Object
*/
compareJson(i1.next(), i2.next(),compareList,filterList, flag, key , parentKey , equalsList,diffList);
}
} else {
// JSONArray只要有一个为null则会不一致
diffList.add(parentKey);
}
}
/**
* 测试方法
* @param args
*/
public static void main(String[] args) {
String st1 = "{\"id\":\"tom\",\"username\":\"tom\",\"age\":18,\"address\":[{\"province\":\"上海市\"},{\"city\":\"上海市\"},{\"disrtict\":\"静安区\"},{\"id\":\"静安区\"}],\"details\":{\"sex\":\"男\",\"mobile\":\"13811112222\"}}";
String st2 = "{\"id\":\"tom\",\"username\":\"tom1\",\"age\":18,\"address\":[{\"province\":\"上海市1\"},{\"city\":\"上海市\"},{\"disrtict\":\"静安区1\"},{\"id\":\"静安区\"}],\"details\":{\"sex\":\"男\",\"mobile\":\"13811113333\"}}";
JSONObject jsonObject1 = JSONObject.parseObject(st1);
JSONObject jsonObject2 = JSONObject.parseObject(st2);
System.out.println("全部对比：");
Map<String,List<String>> map = compareJson(jsonObject1, jsonObject2);
System.out.println("相同列==>"+map.get("equalsList"));
System.out.println("不同列==>"+map.get("diffList"));
System.out.println("默认过滤策略(id存在于默认策略，所以被过滤掉了)：");
Map<String,List<String>> map1 = compareJson(jsonObject1, jsonObject2,true);
System.out.println("相同列==>"+map1.get("equalsList"));
System.out.println("不同列==>"+map1.get("diffList"));
System.out.println("指定列对比(只对比username、province)：");
// 注：要比较province，必须将address也放入集合中
Map<String,List<String>> map2 = compareJson(jsonObject1, jsonObject2,Arrays.asList("username","address","address_province"));
System.out.println("相同列==>"+map2.get("equalsList"));
System.out.println("不同列==>"+map2.get("diffList"));
System.out.println("指定列不对比(不对比username、province)：");
Map<String,List<String>> map3 = compareJson(jsonObject1, jsonObject2,Arrays.asList("username","address_province"),false);
System.out.println("相同列==>"+map3.get("equalsList"));
System.out.println("不同列==>"+map3.get("diffList"));
System.out.println("指定列不对比+默认过滤策略(不对比username、province+默认过滤策略)：");
Map<String,List<String>> map4 = compareJson(jsonObject1, jsonObject2,Arrays.asList("username","address_province"),true);
System.out.println("相同列==>"+map4.get("equalsList"));
System.out.println("不同列==>"+map4.get("diffList"));
System.out.println("指定列不对比+默认过滤策略(不对比username、address+默认过滤策略)：");
Map<String,List<String>> map5 = compareJson(jsonObject1, jsonObject2,Arrays.asList("username","address"),true);
System.out.println("相同列==>"+map5.get("equalsList"));
System.out.println("不同列==>"+map5.get("diffList"));
}
}
3564
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
