使用Gson比较两个JSON对象

1. Overview

JSON is a string representation of data. We may wish to compare this data in our algorithms or tests. And though it’s possible to compare strings containing JSON, string comparison is sensitive to differences in representation, rather than content.

To overcome this and compare JSON data semantically, we need to load the data into a structure in memory that’s not affected by things like whitespace or by the order of an object’s keys.

In this short tutorial, we’ll solve this using Gson, a JSON serialization\deserialization library that can do a deep comparison between JSON objects.

2. Semantically Identical JSON in Different Strings

Let’s take a closer look at the problem we’re trying to solve.

Assume we have two strings, representing the same JSON data, but one of them has some extra spaces at the end of it:

String string1 = "{\"fullName\": \"Emily Jenkins\", \"age\": 27    }";
String string2 = "{\"fullName\": \"Emily Jenkins\", \"age\": 27}";

Although the content of the JSON objects is equal, comparing the above as strings will show a difference:

assertNotEquals(string1, string2);

The same would happen if the order of keys in an object was varied, even though JSON is not usually sensitive to this:

String string1 = "{\"fullName\": \"Emily Jenkins\", \"age\": 27}";
String string2 = "{\"age\": 27, \"fullName\": \"Emily Jenkins\"}";
assertNotEquals(string1, string2);

This is why it’s we’d benefit from using a JSON processing library to compare JSON data.

3. Maven Dependency

To use Gson, let’s first add the Gson Maven dependency:

<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.10.1</version>
</dependency>

4. Parsing JSON into Gson Objects

Before we dive into comparing objects, let’s have a look at how Gson represents JSON data in Java.

When working with JSON in Java, we first need to convert the JSON String into a Java object. Gson provides JsonParser which parses source JSON into a JsonElement tree:

String objectString = "{\"customer\": {\"fullName\": \"Emily Jenkins\", \"age\": 27 }}";
String arrayString = "[10, 20, 30]";

JsonElement json1 = JsonParser.parseString(objectString);
JsonElement json2 = JsonParser.parseString(arrayString);

JsonElement is an abstract class, representing an element of JSON. The parse method returns an implementation of JsonElement; either a JsonObject, JsonArray, JsonPrimitive or JsonNull:

assertTrue(json1.isJsonObject());
assertTrue(json2.isJsonArray());

Each of those subclasses (JsonObject, JsonArray, etc.) overrides the Object.equals method, providing an effective deep JSON comparison.

5. Gson Comparison Use Cases

5.1. Compare Two Simple JSON Objects

Suppose we have two strings, representing simple JSON objects, where the order of keys is different:

The first object has fullName earlier than age:

{
    "customer": {
        "id": 44521,
        "fullName": "Emily Jenkins",
        "age": 27
    }
}

The second reverses the order:

{
    "customer": {
        "id": 44521,
        "age": 27,
        "fullName": "Emily Jenkins"
    }
}

We can simply parse and compare them:

assertEquals(parser.parse(string1), parser.parse(string2));

In this case, the JsonParser returns a JsonObject, whose equals implementation is not order-sensitive.

5.2. Compare Two JSON Arrays

In a case of JSON arrays, JsonParser will return a JsonArray.

If we have one array in one order:

[10, 20, 30]

assertTrue(JsonParser.parseString(string1).isJsonArray());

We can compare it to another in a different order:

[20, 10, 30]

Unlike JsonObject, JsonArray‘s equals method is order-sensitive, so these arrays are not equal, which is semantically correct:

assertNotEquals(JsonParser.parseString(string1), JsonParser.parseString(string2));

5.3. Compare Two Nested JSON Objects

As we saw earlier, JsonParser can parse the tree-like structure of JSON. Each JsonObject and JsonArray contain other JsonElement objects, which can, themselves be of type JsonObject or JsonArray.

When we use equals, it compares all the members recursively, which means nested objects are also comparable:

If this is string1:

{
  "customer": {
    "id": "44521",
    "fullName": "Emily Jenkins",
    "age": 27,
    "consumption_info": {
      "fav_product": "Coke",
      "last_buy": "2012-04-23"
    }
  }
}

And this JSON is string2:

{
  "customer": {
    "fullName": "Emily Jenkins",
    "id": "44521",
    "age": 27,
    "consumption_info": {
      "last_buy": "2012-04-23",
      "fav_product": "Coke"
   }
  }
}

Then we can still use the equals method to compare them:

assertEquals(JsonParser.parseString(string1), JsonParser.parseString(string2));

6. Conclusion

In this short article, we’ve looked at the challenges of comparing JSON as a String. We’ve seen how Gson allows us to parse those strings into an object structure that supports comparison.

As always, the source code of the examples above can be found over on GitHub.

Persistence

REST

Security