比较两个JSON之间的差异_json对比

作者：木道寻08 | 2024-07-18 15:22:32

踩

json对比

网上找到的比较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));
    }

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321

以上测试方法结果为：

{
    "b": {
        "newValue": "bb",
        "oldValue": "bbb"
    },
    "c": {
        "newValue": "",
        "oldValue": "aaa"
    },
    "d": {
        "newValue": "",
        "oldValue": "bbb"
    },
    "e": {
        "newValue": "bb",
        "oldValue": ""
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

参考链接：【Java】Java对比两个JSON对象(深度广度比较)

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