Java 17环境下对比同类型实例变量差异的替代方案求助

针对大量Java类实例的字段对比需求，且无法使用JAXB（Java 17环境），以下是几种可行的替代方案：

1. 基于Java反射API的自定义实现 #

直接通过反射遍历类的字段，调用Getter方法获取值并对比，无需依赖第三方库，灵活性高。

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;

public class ObjectComparator {
    public static <T> List<String> compareObjects(T a, T b) throws Exception {
        List<String> diffs = new ArrayList<>();
        if (a == null || b == null || !a.getClass().equals(b.getClass())) {
            diffs.add("对象为空或类型不匹配");
            return diffs;
        }

        Class<?> clazz = a.getClass();
        java.lang.reflect.Field[] fields = clazz.getDeclaredFields();
        
        for (java.lang.reflect.Field field : fields) {
            // 构造Getter方法名（假设遵循JavaBean规范）
            String getterName = "get" + Character.toUpperCase(field.getName().charAt(0)) + field.getName().substring(1);
            Method getter = clazz.getMethod(getterName);
            
            Object valueA = getter.invoke(a);
            Object valueB = getter.invoke(b);
            
            // 处理null值的相等性判断
            boolean isEqual = (valueA == null && valueB == null) 
                || (valueA != null && valueA.equals(valueB));
            
            if (!isEqual) {
                diffs.add(String.format("字段不相等：%s，取值为a.%s='%s' - b.%s='%s'",
                        field.getName(), field.getName(), valueA, field.getName(), valueB));
            }
        }
        return diffs;
    }

    // 测试用例
    public static void main(String[] args) throws Exception {
        DummyClass a = new DummyClass("foo", "bar");
        DummyClass b = new DummyClass("foo", "rab");
        compareObjects(a, b).forEach(System.out::println);
    }
}

class DummyClass {
    private String name;
    private String surname;

    public DummyClass(String name, String surname) {
        this.name = name;
        this.surname = surname;
    }

    public String getName() { return name; }
    public String getSurname() { return surname; }
}

2. 使用ModelMapper的差异对比功能 #

ModelMapper提供了开箱即用的对象差异检测能力，无需手动处理反射，支持嵌套对象对比，Java 17兼容。

import org.modelmapper.ModelMapper;
import org.modelmapper.diff.DiffResult;
import java.util.List;
import java.util.stream.Collectors;

public class ModelMapperComparator {
    public static <T> List<String> compareObjects(T a, T b) {
        ModelMapper mapper = new ModelMapper();
        DiffResult diffResult = mapper.diff(a, b);
        
        return diffResult.getDifferences().stream()
                .map(diff -> String.format("字段不相等：%s，取值为a.%s='%s' - b.%s='%s'",
                        diff.getPropertyName(), diff.getPropertyName(),
                        diff.getLeftValue(), diff.getPropertyName(), diff.getRightValue()))
                .collect(Collectors.toList());
    }

    // 测试用例
    public static void main(String[] args) {
        DummyClass a = new DummyClass("foo", "bar");
        DummyClass b = new DummyClass("foo", "rab");
        compareObjects(a, b).forEach(System.out::println);
    }
}

3. 基于Jackson转JSON的对比方案 #

将对象转为JSON节点后对比差异，适合需要处理复杂嵌套结构的场景，Jackson完全兼容Java 17。

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ObjectNode;
import java.util.ArrayList;
import java.util.List;
import java.util.Iterator;
import java.util.Map;

public class JacksonComparator {
    private static final ObjectMapper mapper = new ObjectMapper();

    public static <T> List<String> compareObjects(T a, T b) throws Exception {
        List<String> diffs = new ArrayList<>();
        JsonNode nodeA = mapper.valueToTree(a);
        JsonNode nodeB = mapper.valueToTree(b);
        compareNodes("", nodeA, nodeB, diffs);
        return diffs;
    }

    private static void compareNodes(String fieldPath, JsonNode nodeA, JsonNode nodeB, List<String> diffs) {
        if (nodeA.isObject() && nodeB.isObject()) {
            ObjectNode objA = (ObjectNode) nodeA;
            ObjectNode objB = (ObjectNode) nodeB;

            // 遍历A的所有字段，对比B的对应字段
            Iterator<Map.Entry<String, JsonNode>> aFields = objA.fields();
            while (aFields.hasNext()) {
                Map.Entry<String, JsonNode> entry = aFields.next();
                String fieldName = entry.getKey();
                String currentPath = fieldPath.isEmpty() ? fieldName : fieldPath + "." + fieldName;
                JsonNode valueB = objB.get(fieldName);

                if (valueB == null) {
                    diffs.add(String.format("字段不相等：%s，a.%s='%s' - b.%s不存在", currentPath, currentPath, entry.getValue(), currentPath));
                } else {
                    compareNodes(currentPath, entry.getValue(), valueB, diffs);
                }
            }

            // 检查B存在但A不存在的字段
            Iterator<Map.Entry<String, JsonNode>> bFields = objB.fields();
            while (bFields.hasNext()) {
                Map.Entry<String, JsonNode> entry = bFields.next();
                String fieldName = entry.getKey();
                if (!objA.has(fieldName)) {
                    String currentPath = fieldPath.isEmpty() ? fieldName : fieldPath + "." + fieldName;
                    diffs.add(String.format("字段不相等：%s，a.%s不存在 - b.%s='%s'", currentPath, currentPath, currentPath, entry.getValue()));
                }
            }
        } else if (!nodeA.equals(nodeB)) {
            diffs.add(String.format("字段不相等：%s，取值为a.%s='%s' - b.%s='%s'",
                    fieldPath, fieldPath, nodeA.asText(), fieldPath, nodeB.asText()));
        }
    }

    // 测试用例
    public static void main(String[] args) throws Exception {
        DummyClass a = new DummyClass("foo", "bar");
        DummyClass b = new DummyClass("foo", "rab");
        compareObjects(a, b).forEach(System.out::println);
    }
}

以上方案均无需依赖JAXB，适配Java 17环境，可直接用于大量类的实例对比，无需逐个实现compareTo方法。

内容的提问来源于stack exchange，提问作者Antonio