Javers对比复杂JSONObject返回错误差异，如何正确校验内部值？

I’ve run into this exact issue before—Javers can trip up with complex JSON structures if you don’t tweak its default configuration to handle deep value comparisons properly. Here’s how to get accurate "no changes" results when your JSON objects are logically identical:

1. Fix JSON Type Handling & Register a Custom Value Comparator #

Javers doesn’t always handle JSON types (like org.json.JSONObject or Jackson’s JsonNode) out-of-the-box as you’d expect—especially if your library’s default equals() checks rely on field order or reference equality instead of deep value matching.

For example, if you’re using Jackson’s JsonNode, create a custom comparator that leverages Jackson’s built-in deep equality check:

import com.fasterxml.jackson.databind.JsonNode;
import org.javers.core.comparison.ValueComparator;

public class JsonNodeDeepComparator implements ValueComparator<JsonNode> {
    @Override
    public boolean equals(JsonNode a, JsonNode b) {
        if (a == null && b == null) return true;
        if (a == null || b == null) return false;
        // Use Jackson's native deep equality check
        return a.equals(b);
    }

    @Override
    public String toString(JsonNode value) {
        return value.toString();
    }
}

Then register it with your Javers instance:

Javers javers = JaversBuilder.javers()
    .registerValueComparator(new JsonNodeDeepComparator())
    .build();

If you’re using org.json.JSONObject, note its default equals() is order-sensitive. You’ll need a comparator that ignores field order:

import org.json.JSONObject;
import org.javers.core.comparison.ValueComparator;

public class JSONObjectUnorderedComparator implements ValueComparator<JSONObject> {
    @Override
    public boolean equals(JSONObject a, JSONObject b) {
        if (a == null && b == null) return true;
        if (a == null || b == null) return false;
        if (a.length() != b.length()) return false;
        // Check all keys and values, ignoring order
        for (String key : a.keySet()) {
            if (!b.has(key) || !a.get(key).equals(b.get(key))) {
                return false;
            }
        }
        return true;
    }

    @Override
    public String toString(JSONObject value) {
        return value.toString();
    }
}

2. Adjust List/Array Comparison Strategy #

If your JSON contains arrays that are logically identical but ordered differently, Javers will flag them as changes unless you switch to a set-based comparison strategy:

Javers javers = JaversBuilder.javers()
    .withListCompareStrategy(ListCompareStrategy.AS_SET)
    .registerValueComparator(new JsonNodeDeepComparator())
    .build();

Note: Only use this if your arrays don’t rely on order—if order matters, stick with the default AS_LIST strategy.

3. Convert JSON to POJOs (The Most Reliable Approach) #

If your JSON structure is consistent, mapping it to plain old Java objects (POJOs) is the most robust way to avoid JSON-specific comparison quirks. Javers is designed to work seamlessly with POJOs, and it will accurately detect changes at the field level without worrying about serialization oddities.

For example, use Jackson to deserialize your JSON into a DTO:

ObjectMapper mapper = new ObjectMapper();
MyDto dto1 = mapper.readValue(jsonString1, MyDto.class);
MyDto dto2 = mapper.readValue(jsonString2, MyDto.class);

// Compare the POJOs with Javers
Diff diff = javers.compare(dto1, dto2);

4. Ignore Dynamic/Irrelevant Fields #

If your JSON includes auto-generated fields (like timestamps, version IDs, or UUIDs) that shouldn’t be considered in the diff, use Javers’ ignore rules:

• Add @DiffIgnore to the corresponding fields in your POJO (if using POJOs).
• Or configure Javers to ignore specific fields programmatically:

Javers javers = JaversBuilder.javers()
    .registerValueComparator(new JsonNodeDeepComparator())
    .withIgnoredProperties("timestamp", "version")
    .build();

These steps should resolve most cases where Javers incorrectly reports changes between logically identical JSON objects.

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