devbox
寸_铁
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Java实现JSON数据的差异对比（转载）_比较两个json对象字段的差异

作者：寸_铁 | 2024-08-22 04:45:20

赞

踩

比较两个json对象字段的差异

原文链接：https://blog.csdn.net/hi_bigbai/article/details/128162687

背景
        之前有类似接口diff对比，数据对比的测试需求，涉及到json格式的数据对比，调研了几个大神们分享的代码，选了一个最符合自己需求的研究了下。（可惜原文链接找不到了，原始作者看到了可以私信我下）

说明
这个对比方法，支持JsonObject和JsonArray类型的数据对比，支持：

深度的对比：list变化（个数、内容）、层级结构变化
字段的对比：新增、修改、删除数据可察觉，能找到对应的旧数据
支持特定字段忽略对比
输出的对比结果格式为：

源码分为JsonCompareUtils， JsonAndMapSortUtils两个类，对比入口是compareTwoJson方法

核心逻辑在JsonCompareUtils类中，JsonAndMapSortUtils主要做过程中的数据排序功能，相对独立。

源码

 JsonCompareUtils 类

  1. package com.xhzyqa.transcodetest.utils;
  2.  
  3.  
  4. import com.alibaba.fastjson.JSON;
  5. import com.alibaba.fastjson.JSONArray;
  6. import com.alibaba.fastjson.JSONObject;
  7. import org.apache.commons.lang.ArrayUtils;
  8. import org.apache.commons.lang.StringUtils;
  9.  
  10. import java.util.HashMap;
  11. import java.util.Iterator;
  12. import java.util.LinkedHashMap;
  13. import java.util.Map;
  14. import java.util.stream.Stream;
  15.  
  16. public class JsonCompareUtils {
  17.  
  18.     //标志位：对json报文中含有JsonArray类型的数据是否进行排序
  19.     private static boolean isSort;
  20.  
  21.     private Map<String, Object> oldJsonToMap = new LinkedHashMap<>();
  22.     private Map<String, Object> newJsonToMap = new LinkedHashMap<>();
  23.  
  24.     //每一个实体里的排序字段
  25.     private static Map<String, String> filedNameMap = new HashMap<>();
  26.  
  27.     static {
  28.         filedNameMap.put("dogs", "dogNo");
  29.         filedNameMap.put("cats", "catNo");
  30.     }
  31.  
  32.     //可以跳过比对的字段
  33. //    private static String[] skipCompareFiledNameMap = {"dogAge", "catAge", "catName"};
  34.     private static String[] skipCompareFiledNameMap = {"key3"};
  35.  
  36.     /**
  37.      * 两json报文比对入口
  38.      *
  39.      * @param oldJsonStr
  40.      * @param newJsonStr
  41.      * @return
  42.      */
  43.     public String compareTwoJson(String oldJsonStr, String newJsonStr) {
  44.         /**
  45.          * 递归遍历json对象所有的key-value，以map形式的path:value进行存储
  46.          * 然后对两个map进行比较
  47.          */
  48.         convertJsonToMap(JSON.parseObject(oldJsonStr), "", false);
  49.         convertJsonToMap(JSON.parseObject(newJsonStr), "", true);
  50.         //获取比较结果
  51.         Map<String, Object> differenceMap = compareTwoMaps(oldJsonToMap, newJsonToMap);
  52.         String diffJsonResult = convertMapToJson(differenceMap);
  53.         return diffJsonResult;
  54.     }
  55.  
  56.     /**
  57.      * 将json数据转换为map存储--用于后续比较map
  58.      *
  59.      * @param json
  60.      * @param root
  61.      * @param isNew 区别新旧报文
  62.      */
  63.     private void convertJsonToMap(Object json, String root, boolean isNew) {
  64.         if (json instanceof JSONObject) {
  65.             JSONObject jsonObject = ((JSONObject) json);
  66.             Iterator iterator = jsonObject.keySet().iterator();
  67.             while (iterator.hasNext()) {
  68.                 Object key = iterator.next();
  69.                 Object value = jsonObject.get(key);
  70.                 String newRoot = "".equals(root) ? key + "" : root + "." + key;
  71.                 fillInResultMap(value, newRoot, isNew);
  72.             }
  73.         } else if (json instanceof JSONArray) {
  74.             JSONArray jsonArray = (JSONArray) json;
  75.             //将jsonArray进行排序
  76.             if (isSort) {
  77.                 //需要排序
  78.                 String sortEntityName = root.substring(root.lastIndexOf(".") + 1);
  79.                 String sortFiledName = filedNameMap.get(sortEntityName);//需要排序 获取排序字段
  80.                 if (!StringUtils.isEmpty(sortFiledName)) {
  81.                     jsonArray = JsonAndMapSortUtils.jsonArrayToSort(jsonArray, sortFiledName, true);
  82.                 }
  83.             }
  84.             final JSONArray jsonArray1 = jsonArray;
  85.             Stream.iterate(0, integer -> integer + 1).limit(jsonArray1.size()).forEach(index -> {
  86.                 Object value = jsonArray1.get(index);
  87.                 String newRoot = "".equals(root) ? "[" + index + "]" : root + ".[" + index + "]";
  88.                 fillInResultMap(value, newRoot, isNew);
  89.             });
  90.         }
  91.     }
  92.  
  93.     /**
  94.      * 封装json转map后的数据
  95.      *
  96.      * @param value
  97.      * @param newRoot
  98.      * @param isNew   区别新旧json
  99.      */
  100.     public void fillInResultMap(Object value, String newRoot, boolean isNew) {
  101.         if (value instanceof JSONObject || value instanceof JSONArray) {
  102.             convertJsonToMap(value, newRoot, isNew);
  103.         } else {
  104.             //设置跳过比对的字段，直接不装入map
  105.             boolean check = ArrayUtils.contains(JsonCompareUtils.skipCompareFiledNameMap, newRoot);
  106.             if (!check){
  107.                 if (!isNew) {
  108.                     oldJsonToMap.put(newRoot, value);
  109.                 } else {
  110.                     newJsonToMap.put(newRoot, value);
  111.                 }
  112.             }
  113.         }
  114.     }
  115.  
  116.     /**
  117.      * 比较两个map，将不同的数据以map形式存储并返回
  118.      *
  119.      * @param oldJsonMap
  120.      * @param newJsonMap
  121.      * @return
  122.      */
  123.     private Map<String, Object> compareTwoMaps(Map<String, Object> oldJsonMap, Map<String, Object> newJsonMap) {
  124.         //1.将newJsonMap的不同数据装进oldJsonMap，同时删除oldJsonMap中与newJsonMap相同的数据
  125.         newJsonMap.forEach((k, v) -> {
  126.             Map<String, Object> differenceMap = new HashMap<>();
  127.             String lastFieldKey = k.substring(k.lastIndexOf(".") + 1);
  128. //            boolean check = ArrayUtils.contains(JsonCompareUtils.skipCompareFiledNameMap, lastFieldKey);
  129. //            if (!check){
  130.             if (oldJsonMap.containsKey(k)) {
  131. //                boolean check = ArrayUtils.contains(JsonCompareUtils.skipCompareFiledNameMap, lastFieldKey);
  132.                 Object oldValue = oldJsonMap.get(k);
  133.                 if (v.equals(oldValue)) {
  134.                     oldJsonMap.remove(k);
  135.                 } else {
  136.                     differenceMap.put("oldValue", oldValue);
  137.                     differenceMap.put("newValue", v);
  138.                     oldJsonMap.put(k, differenceMap);
  139.                 }
  140.             } else {
  141.                 differenceMap.put("oldValue", "no exists " + k);
  142.                 differenceMap.put("newValue", v);
  143.                 oldJsonMap.put(k, differenceMap);
  144.             }
  145. //            }else {
  146. //                oldJsonMap.remove(k);
  147. //            }
  148.         });
  149.         //2.统一oldJsonMap中newMap不存在的数据的数据结构，便于解析
  150.         oldJsonMap.forEach((k, v) -> {
  151.             String lastFieldKey = k.substring(k.lastIndexOf(".") + 1);
  152. //            boolean check = ArrayUtils.contains(JsonCompareUtils.skipCompareFiledNameMap, lastFieldKey);
  153. //            if (!check && !(v instanceof Map)) {
  154.             if (!(v instanceof Map)) {
  155.                 Map<String, Object> differenceMap = new HashMap<>();
  156.                 differenceMap.put("oldValue", v);
  157.                 differenceMap.put("newValue", "no exists " + k);
  158.                 oldJsonMap.put(k, differenceMap);
  159.             }
  160.         });
  161.         return oldJsonMap;
  162.     }
  163.  
  164.     /**
  165.      * 将已经找出不同数据的map根据key的层级结构封装成json返回
  166.      *
  167.      * @param map
  168.      * @return
  169.      */
  170.     private String convertMapToJson(Map<String, Object> map) {
  171.         JSONObject resultJSONObject = new JSONObject();
  172.         for (Iterator<Map.Entry<String, Object>> it = map.entrySet().iterator(); it.hasNext(); ) {
  173.             Map.Entry<String, Object> item = it.next();
  174.             String key = item.getKey();
  175.             Object value = item.getValue();
  176.             String[] paths = key.split("\\.");
  177.             int i = 0;
  178.             Object remarkObject = null;//用於深度標識對象
  179.             int indexAll = paths.length - 1;
  180.             while (i <= paths.length - 1) {
  181.                 String path = paths[i];
  182.                 if (i == 0) {
  183.                     //初始化对象标识
  184.                     if (resultJSONObject.containsKey(path)) {
  185.                         remarkObject = resultJSONObject.get(path);
  186.                     } else {
  187.                         if (indexAll > i) {
  188.                             if (paths[i + 1].matches("\\[[0-9]+\\]")) {
  189.                                 remarkObject = new JSONArray();
  190.                             } else {
  191.                                 remarkObject = new JSONObject();
  192.                             }
  193.                             resultJSONObject.put(path, remarkObject);
  194.                         } else {
  195.                             resultJSONObject.put(path, value);
  196.                         }
  197.                     }
  198.                     i++;
  199.                     continue;
  200.                 }
  201.                 if (path.matches("\\[[0-9]+\\]")) {//匹配集合对象
  202.                     int startIndex = path.lastIndexOf("[");
  203.                     int endIndext = path.lastIndexOf("]");
  204.                     int index = Integer.parseInt(path.substring(startIndex + 1, endIndext));
  205.                     if (indexAll > i) {
  206.                         if (paths[i + 1].matches("\\[[0-9]+\\]")) {
  207.                             while (((JSONArray) remarkObject).size() <= index) {
  208.                                 if (((JSONArray) remarkObject).size() == index) {
  209.                                     ((JSONArray) remarkObject).add(index, new JSONArray());
  210.                                 } else {
  211.                                     ((JSONArray) remarkObject).add(null);
  212.                                 }
  213.                             }
  214.                         } else {
  215.                             while (((JSONArray) remarkObject).size() <= index) {
  216.                                 if (((JSONArray) remarkObject).size() == index) {
  217.                                     ((JSONArray) remarkObject).add(index, new JSONObject());
  218.                                 } else {
  219.                                     ((JSONArray) remarkObject).add(null);
  220.                                 }
  221.                             }
  222.                         }
  223.                         remarkObject = ((JSONArray) remarkObject).get(index);
  224.                     } else {
  225.                         while (((JSONArray) remarkObject).size() <= index) {
  226.                             if (((JSONArray) remarkObject).size() == index) {
  227.                                 ((JSONArray) remarkObject).add(index, value);
  228.                             } else {
  229.                                 ((JSONArray) remarkObject).add(null);
  230.                             }
  231.                         }
  232.                     }
  233.                 } else {
  234.                     if (indexAll > i) {
  235.                         if (paths[i + 1].matches("\\[[0-9]+\\]")) {
  236.                             if (!((JSONObject) remarkObject).containsKey(path)) {
  237.                                 ((JSONObject) remarkObject).put(path, new JSONArray());
  238.                             }
  239.                         } else {
  240.                             if (!((JSONObject) remarkObject).containsKey(path)) {
  241.                                 ((JSONObject) remarkObject).put(path, new JSONObject());
  242.                             }
  243.                         }
  244.                         remarkObject = ((JSONObject) remarkObject).get(path);
  245.                     } else {
  246.                         ((JSONObject) remarkObject).put(path, value);
  247.                     }
  248.                 }
  249.                 i++;
  250.             }
  251.         }
  252.         return JSON.toJSONString(resultJSONObject);
  253.     }
  254.  
  255.     public boolean isSort() {
  256.         return isSort;
  257.     }
  258.  
  259.     public void setSort(boolean sort) {
  260.         isSort = sort;
  261.     }
  262.  
  263.     public static void main(String[] args) {
  264.         String oldStr = "{key1:'aaa',key2:'bbb'}";
  265.         String newStr = "{key1:'aaa',key2:'bbb',key3:'c'}";
  266.         System.out.println(new JsonCompareUtils().compareTwoJson(oldStr, newStr));
  267.         System.out.println("\n========测试复杂json的比对============");
  268.     }
  269.  
  270.     /**
  271.      * 测试类
  272.     static class JsonCompareTest {
  273.         public static void compareTest() {
  274.             String oldJson = MakeJsonCompareDatas.getJsonDataOldStr();
  275.             String newJson = MakeJsonCompareDatas.getJsonDataNewStr();
  276.             //对json报文中含有JsonArray类型的数据是否进行排序
  277.             JsonCompareUtils.isSort = true;
  278.             String compareResult = new JsonCompareUtils().compareTwoJson(oldJson, newJson);
  279.             System.out.println("oldJson==>" + oldJson);
  280.             System.out.println("newJson==>" + newJson);
  281.             System.out.println("\nisSort==" + isSort + "-->compareResult==>\n" + compareResult);
  282.         }
  283.     }
  284.      */
  285. }

JsonAndMapSortUtils 类

  1. package com.xhzyqa.transcodetest.utils;
  2.  
  3.  
  4. import com.alibaba.fastjson.JSONArray;
  5. import com.alibaba.fastjson.JSONObject;
  6. import sun.misc.ASCIICaseInsensitiveComparator;
  7.  
  8. import java.util.*;
  9. import java.util.function.Function;
  10. import java.util.stream.Collectors;
  11.  
  12. public class JsonAndMapSortUtils {
  13.  
  14.     /**
  15.      * map排序
  16.      * @param map
  17.      * @param keySort
  18.      * @param <k>
  19.      * @param <v>
  20.      * @return
  21.      */
  22.     public static <k,v> List mapByKeyToSort(Map<k,v> map , final Comparator keySort){
  23.         List<Map.Entry<k,v>> entryList = new ArrayList<Map.Entry<k, v>>(map.entrySet());
  24.         Collections.sort(entryList, new Comparator<Map.Entry<k, v>>() {
  25.             public int compare(Map.Entry<k, v> o1, Map.Entry<k, v> o2) {
  26.                 return keySort.compare(o1.getKey(),o2.getKey());
  27.             }
  28.         });
  29.         //return (Map<k,v>)entryList.stream().collect(Collectors.toMap(Map.Entry<k,v>::getKey, Function.identity(), (key1, key2) -> key2));
  30.         Map<String,String> afterToSortMap = new HashMap<>();
  31.         /*for (Map.Entry<k,v> m : entryList){
  32.             System.out.println(m.getKey()+"===>"+m.getValue());
  33.         }*/
  34.         System.out.println("排序=====");
  35.         entryList.forEach(m->{
  36.             System.out.println(m.getKey()+"===>"+m.getValue());
  37.         });
  38.         return entryList;
  39.     }
  40.  
  41.     /**
  42.      * JSONArray排序
  43.      * @param jsonArray
  44.      * @param fildName
  45.      * @param isAsc
  46.      * @return
  47.      */
  48.     public static JSONArray jsonArrayToSort(JSONArray jsonArray,final String fildName,final boolean isAsc){
  49.         JSONArray afterSortJsonArray = new JSONArray();
  50.         List<JSONObject> objectList = new ArrayList<JSONObject>();
  51.         jsonArray.forEach(obj ->{
  52.             objectList.add((JSONObject)obj);
  53.         });
  54.         Collections.sort(objectList, new Comparator<JSONObject>() {
  55.             @Override
  56.             public int compare(JSONObject o1, JSONObject o2) {
  57.                 String fildValueA = o1.getString(fildName);
  58.                 String fildValueB = o2.getString(fildName);
  59.                 if (isAsc)
  60.                     return fildValueA.compareTo(fildValueB);
  61.                 return fildValueB.compareTo(fildValueA);
  62.             }
  63.         });
  64.         objectList.forEach(obj->{
  65.             afterSortJsonArray.add(obj);
  66.         });
  67.         return afterSortJsonArray;
  68.     }
  69.  
  70.     /**
  71.      *准备map测试数据
  72.      */
  73.     public static Map<String,String> getMapData(){
  74.         LinkedHashMap<String,String> map = new LinkedHashMap<>();
  75.         map.put("key1","麦兜");
  76.         map.put("key3","贝塔");
  77.         map.put("key5","酥妮");
  78.         map.put("key2","小H");
  79.         map.put("key4","小O");
  80.         return map;
  81.     }
  82.     /**
  83.      *准备json测试数据
  84.      */
  85.     public static JSONArray getJsonArrayData(){
  86.         JSONArray jsonArray = new JSONArray();
  87.         JSONObject jsonObject1 = new JSONObject();
  88.         jsonObject1.put("userId","1001");
  89.         jsonObject1.put("name","麦兜");
  90.         jsonArray.add(jsonObject1);
  91.  
  92.         JSONObject jsonObject3 = new JSONObject();
  93.         jsonObject3.put("userId","1003");
  94.         jsonObject3.put("name","酥妮");
  95.         jsonArray.add(jsonObject3);
  96.  
  97.         JSONObject jsonObject2 = new JSONObject();
  98.         jsonObject2.put("userId","1002");
  99.         jsonObject2.put("name","贝塔");
  100.         jsonArray.add(jsonObject2);
  101.  
  102.         return jsonArray;
  103.     }
  104.  
  105.     public static void main(String[] args) {
  106.         Map<String,String> map = JsonAndMapSortUtils.getMapData();
  107.         JSONArray jsonArray = JsonAndMapSortUtils.getJsonArrayData();
  108.         List afterSortMap = JsonAndMapSortUtils.mapByKeyToSort(map,new ASCIICaseInsensitiveComparator());
  109.  
  110.         JSONArray afterSortJsonArray_isAsc = JsonAndMapSortUtils.jsonArrayToSort(jsonArray,"userId",true);
  111.         JSONArray afterSortJsonArray_noAsc = JsonAndMapSortUtils.jsonArrayToSort(jsonArray,"userId",false);
  112.  
  113.         System.out.println("map排序前："+map);
  114.         System.out.println("map排序后："+afterSortMap+"\n");
  115.  
  116.         System.out.println("JsonArray排序前："+jsonArray);
  117.         System.out.println("JsonArray排序后==》升序："+afterSortJsonArray_isAsc);
  118.         System.out.println("JsonArray排序后==》降序："+afterSortJsonArray_noAsc);
  119.     }
  120.  
  121. }

源码走读

整个源码调用链路如下图，简单来说过程就是：object拆分解析-新旧数据逐个对比-结果信息组装三个步骤

其他

原始代码中有些小bug，已修复。目前这个工具主要被我拿来用在了一个接口数据对比工具中，来检测迭代前后的接口协议数据变更，以完善迭代变更范围来确认测试范围。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/寸_铁/article/detail/1014744
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号