【java 后端JSON串的对比差异】

变更实体类

public class ChangeRecord {
    private String field;      // 变更的字段路径
    private Object oldValue;   // 旧值
    private Object newValue;   // 新值
    private ChangeType type;   // 变更类型

    public ChangeRecord(String field, Object oldValue, Object newValue, ChangeType type) {
        this.field = field;
        this.oldValue = oldValue;
        this.newValue = newValue;
        this.type = type;
    }

    // Getters and setters
    public String getField() { return field; }
    public Object getOldValue() { return oldValue; }
    public Object getNewValue() { return newValue; }
    public ChangeType getType() { return type; }

    @Override
    public String toString() {
        return "字段: " + field +
                ", 类型: " + type +
                ", 旧值: " + oldValue +
                ", 新值: " + newValue;
    }
}

枚举类

public enum ChangeType {
    ADD, DELETE, MODIFY, REPLACE
}

比较两个JSON字符串斌返回差异

public  List<ChangeRecord> compareJson(Object oldJsonStr, Object newJsonStr) {
        List<ChangeRecord> changes = new ArrayList<>();
        ObjectMapper mapper = new ObjectMapper();
        try {
            JSONObject oldJson = JSONObject.parseObject(mapper.writeValueAsString(oldJsonStr));
            JSONObject newJson = JSONObject.parseObject(mapper.writeValueAsString(newJsonStr));
            compareValues("", oldJson, newJson, changes);
        } catch (Exception e) {
            e.printStackTrace();
            // 处理JSON解析异常
        }

        return changes;
    }

递归比较两个JSON值

// 递归比较两个JSON值
    private static void compareValues(String path, Object oldValue, Object newValue, List<ChangeRecord> changes) {
        // 处理两者均为null的情况
        if (oldValue == null && newValue == null) {
            return;
        }

        // 处理一方为null的情况
        if (oldValue == null) {
            changes.add(new ChangeRecord(path, null, newValue, ChangeType.ADD));
            return;
        }

        if (newValue == null) {
            changes.add(new ChangeRecord(path, oldValue, null, ChangeType.DELETE));
            return;
        }

        // 获取两者的实际类型
        Class<?> oldClass = oldValue.getClass();
        Class<?> newClass = newValue.getClass();

        // 如果类型不同，视为值被替换
        if (!oldClass.equals(newClass)) {
            changes.add(new ChangeRecord(path, oldValue, newValue, ChangeType.REPLACE));
            return;
        }

        // 处理JSON对象
        if (oldValue instanceof JSONObject) {// 判断是不是JSON对象
            JSONObject oldObj = (JSONObject) oldValue;
            JSONObject newObj = (JSONObject) newValue;
            // 检查所有旧键
            for (String key : oldObj.keySet()) {
                String newPath = path.isEmpty() ? key : path + "." + key;
                Object oldObjValue = oldObj.get(key);
                Object newObjValue = newObj.get(key);
                if (newObj.containsKey(key)) {
                    compareValues(newPath, oldObjValue, newObjValue, changes);// 进行递归调用
                } else {
                    changes.add(new ChangeRecord(newPath, oldObjValue, null, ChangeType.DELETE));
                }
            }
            // 检查所有新增的键
            for (String key : newObj.keySet()) {
                if (!oldObj.containsKey(key)) {
                    String newPath = path.isEmpty() ? key : path + "." + key;
                    changes.add(new ChangeRecord(newPath, null, newObj.get(key), ChangeType.ADD));
                }
            }
        }
        // 处理JSON数组
        else if (oldValue instanceof JSONArray) {// 判断变量 oldValue 是否为 JSON 数组类型
            JSONArray oldArr = (JSONArray) oldValue;
            JSONArray newArr = (JSONArray) newValue;
            // 简单按索引比较元素
            int maxLength = Math.max(oldArr.size(), newArr.size());
            for (int i = 0; i < maxLength; i++) {
                String newPath = path.isEmpty() ? "[" + i + "]" : path + "[" + i + "]";

                Object oldArrValue = i < oldArr.size() ? oldArr.get(i) : null;
                Object newArrValue = i < newArr.size() ? newArr.get(i) : null;

                compareValues(newPath, oldArrValue, newArrValue, changes);
            }
        }
        // 处理基本类型
        else {
            if (!oldValue.equals(newValue)) {
                changes.add(new ChangeRecord(path, oldValue, newValue, ChangeType.MODIFY));
            }
        }
    }

获取方法中的http的路径

private String getHttpPath(Method method) {
        // 检查方法上的HTTP注解
        if (method.isAnnotationPresent(RequestMapping.class)) {
            RequestMapping mapping = method.getAnnotation(RequestMapping.class);
            return String.join("/", mapping.value());
        }
        if (method.isAnnotationPresent(GetMapping.class)) {
            GetMapping mapping = method.getAnnotation(GetMapping.class);
            return String.join(",", mapping.value());
        }
        if (method.isAnnotationPresent(PostMapping.class)) {
            PostMapping mapping = method.getAnnotation(PostMapping.class);
            return String.join("/", mapping.value());
        }
        return null;
    }