Best way to compare two JSON files in Java

Question

How would you suggest this task is approached?

The challenge as i see it is in presenting diff information intelligently. Before i go reinventing the wheel, is there an accepted approach of how such a comparison should be handled?

In this [answer](https://stackoverflow.com/a/50969020/1426227) you will find a solution with Jackson/Gson and Guava. — cassiomolin, Jul 23 '18 at 08:34
Json Compare [Json-Compare](https://github.com/fslev/json-compare) — Slev Florin, Jan 04 '21 at 14:45

score 33 · Answer 1 · edited Jul 14 '23 at 17:38

33

I recommend the zjsonpatch library, which presents the diff information in accordance with RFC 6902 (JSON Patch). You can use it with Jackson:

import com.fasterxml.jackson.databind.{ObjectMapper, JsonNode}
JsonNode beforeNode = jacksonObjectMapper.readTree(beforeJsonString);
JsonNode afterNode = jacksonObjectMapper.readTree(afterJsonString);

import com.flipkart.zjsonpatch.JsonDiff
JsonNode patch = JsonDiff.asJson(beforeNode, afterNode);
String diffs = patch.toString();

This library is better than fge-json-patch (which was mentioned in another answer) because it can detect items being inserted/removed from arrays. Fge-json-patch cannot handle that (if an item is inserted into the middle of an array, it will think that item and every item after that was changed since they are all shifted over by one).

edited Jul 14 '23 at 17:38

Richard Gomes

5,675
2
44
50

answered Jun 26 '15 at 15:59

pacoverflow

3,726
11
41
71

1

This only compares the structure of the json documents. – Ean V Oct 04 '16 at 23:32
2

Its comparing both keys and values. How to make it only for keys ? – Saagar May 27 '19 at 13:14
The code didn't work for me. You probably need to make a new `ObjectMapper` first: ```java ObjectMapper mapper = new ObjectMapper(); JsonNode beforeNode = jacksonObjectMapper.readTree(beforeJsonString); JsonNode afterNode = jacksonObjectMapper.readTree(afterJsonString); JsonNode patch = JsonDiff.asJson(beforeNode, afterNode); String diffs = patch.toString(); ``` – kohane15 Oct 28 '20 at 08:42

score 15 · Answer 2 · answered Nov 02 '15 at 16:08

15

I've done good experience with JSONAssert.

import org.junit.Test;
import org.apache.commons.io.FileUtils;
import org.skyscreamer.jsonassert.JSONAssert;
import org.skyscreamer.jsonassert.JSONCompareMode;

... 
@Test
public void myTest() {
  String expectedJson = FileUtils.readFileToString("/expectedFile");
  String actualJson = FileUtils.readFileToString("/actualFile");
  JSONAssert.assertEquals(expectedJson, actualJson, JSONCompareMode.STRICT);
}
...

answered Nov 02 '15 at 16:08

Cengiz

5,375
6
52
77

1

Thanks! This is the only library I could find that gives you the option to ignore the order of items in lists. – Saeid Nourian Oct 09 '19 at 13:57
This did not work as advertised and when I emailed them, the email address was no longer valid. Abandonware?? – likejudo May 27 '20 at 16:20
1

see https://stackoverflow.com/questions/62048635/finding-json-diff-fails-using-jsonassert – likejudo May 27 '20 at 17:10

Ean V · Answer 3 · 2017-03-03T09:35:51.040

15

The easiest way to compare json strings is using JSONCompare from JSONAssert library. The advantage is, it's not limited to structure only and can compare values if you wish:

JSONCompareResult result = 
     JSONCompare.compareJSON(json1, json2, JSONCompareMode.STRICT);
System.out.println(result.toString());

which will output something like:

Expected: VALUE1
     got: VALUE2
 ; field1.field2

edited Mar 03 '17 at 09:35

answered Sep 28 '16 at 01:00

Ean V

5,091
5
31
39

i am getting compile time error as: The type org.json.JSONArray cannot be resolved. It is indirectly referenced from required .class files – Vikas Suryawanshi Feb 07 '18 at 06:39
1

A general rule, if u wanna use a lib, include all its dependencies or use maven to get the dependencies automatically. – Ean V Mar 28 '18 at 04:42
This did not work as advertised and when I emailed them, the email address was no longer valid. Abandonware?? – likejudo May 27 '20 at 16:20
see https://stackoverflow.com/questions/62048635/finding-json-diff-fails-using-jsonassert – likejudo May 27 '20 at 17:09

score 12 · Answer 4 · edited Feb 12 '16 at 18:32

12

This only addresses equality, not differences.

With Jackson.

ObjectMapper mapper = new ObjectMapper();

JsonNode tree1 = mapper.readTree(jsonInput1);
JsonNode tree2 = mapper.readTree(jsonInput2);

boolean areTheyEqual = tree1.equals(tree2);

From the JavaDoc for JsonNode.equals:

Equality for node objects is defined as full (deep) value equality. This means that it is possible to compare complete JSON trees for equality by comparing equality of root nodes.

edited Feb 12 '16 at 18:32

Luis

3,451
1
27
41

answered Jun 29 '11 at 20:52

Programmer Bruce

64,977
7
99
97

13

`mapper.readTree` do not works if json fields has different order. – Cherry Jun 23 '14 at 05:07
2

And only compares the structure of the json documents. – Ean V Oct 04 '16 at 23:33
Its comparing both keys and values. How to make it only for keys ? – Saagar May 27 '19 at 13:13
1

@EanV and also Cherry not true. it compares the values and even if members are out of order.. – likejudo May 27 '20 at 15:14
1

@Cherry json fields _can_ have a different order. But two *list elements* are only compared as equal if they have the same values in the exact same order. – dr0i Nov 30 '20 at 07:38

score 5 · Accepted Answer · edited May 23 '17 at 12:34

5

You could try the XStream's architecture, handling of JSON mappings

Also, take a look at this post: Comparing two XML files & generating a third with XMLDiff in C#. It's in C# but the logic is the same.

edited May 23 '17 at 12:34

Community

1
1

answered Jun 29 '11 at 20:55

Jean-François Beaulieu

4,305
22
74
107

score 4 · Answer 6 · edited May 06 '13 at 06:43

4

I had a similar problem and ended up writing my own library:

https://github.com/algesten/jsondiff

It does both diffing/patching.

Diffs are JSON-objects themselves and have a simple syntax for object merge/replace and array insert/replace.

Example:

original
{
   a: { b: 42 }
}

patch
{
  "~a": { c: 43 }
}

The ~ indicates an object merge.

result
{
   a: { b: 42, c: 43 }
}

edited May 06 '13 at 06:43

Mithun Satheesh

27,240
14
77
101

answered Nov 05 '11 at 15:34

Martin Algesten

13,052
4
54
77

Limited to the structure of the documents only. – Ean V Oct 04 '16 at 23:34
2

no. it compares values too. but I don't recommend using it since I ran into hard solved edge cases and lost interest. – Martin Algesten Oct 05 '16 at 03:29

score 2 · Answer 7 · answered Mar 10 '22 at 04:13

You can use below dependancy to compare Json with STRICT,LENIENT,IGNORE_ORDER etc.

<dependency>
    <groupId>org.skyscreamer</groupId>
    <artifactId>jsonassert</artifactId>
    <version>1.5.0</version>
    <scope>test</scope>
</dependency>

  public static boolean isTwoJsonEquals(JSONObject firstObj,JSONObject secondObj, JSONCompareMode compareMode){
    try {
      JSONCompareResult result = JSONCompare.compareJSON(firstObj, secondObj, compareMode);

      return result.passed();
    } catch (JSONException e) {
      e.printStackTrace();
    }
    return false;
  }

score 1 · Answer 8 · answered Oct 09 '14 at 14:27

1

For people who are already using Jackson, I recommend json-patch

final JsonNode patchNode = JsonDiff.asJson(firstNode, secondNode);
System.out.println("Diff=" + m.writeValueAsString(patchNode));

answered Oct 09 '14 at 14:27

Didac Montero

2,046
19
27

1

I went to their site and find it is licensed under LGPLv3. correct me if I am mistaken but isn't LGPL very restrictive for corporations to use? – likejudo May 27 '20 at 17:08

score 1 · Answer 9 · answered Jun 29 '11 at 20:51

json-lib

What I would do is parse the json data using json-lib. This will result in regular java objects which you can compare using the equals methods. This is only valid though assuming the guys from json-lib properly implemented the equals method, but that you can easily test.

score 0 · Answer 10 · edited Oct 24 '20 at 10:39

In case if want to compare two JSON Ignoring the order of elements/object, see if this library helps you.

Usage:

List<Diff> diff = new DnjsonDiff().getDiff(String left, String right)
Left =[{"name":"Bob","businessKey":"4444"},{"name":"John","businessKey":"5555"}]
Right = [{"name":"Bob","businessKey":"6666"},{"name":"John", "businessKey":"4444"}]

Diff:

[
    {
        "op": "replace",
        "configuredValue": "John",
        "intendedValue": "Bob",
        "businessKey": "4444"
    },
    {
        "op": "remove",
        "configuredValue": null,
        "intendedValue": "{\"name\":\"John\",\"businessKey\":\"5555\"}",
        "businessKey": "5555"
    },
    {
        "op": "add",
        "configuredValue": "{\"name\":\"Bob\",\"businessKey\":\"6666\"}",
        "intendedValue": null,
        "businessKey": "null"
    }
]

score 0 · Answer 11 · answered Jan 24 '23 at 07:45

0

Using Google's Guava library for comparison. Check this answer which has detailed explanation on how to use this.

https://stackoverflow.com/a/50969020/17762303

answered Jan 24 '23 at 07:45

KRISH C

21
4

Best way to compare two JSON files in Java

11 Answers11

json-lib

Linked

Related