streamalism.org

1. Overzicht

In dit artikel gaan we kijken hoe we twee JSON-objecten met Jackson vergelijken: een JSON-verwerkingsbibliotheek voor Java.

2. Maven Afhankelijkheid

Laten we eerst de jackson-databind Maven-afhankelijkheid:

 com.fasterxml.jackson.core jackson-databind 2.11.1 

3. Jackson gebruiken om twee JSON-objecten te vergelijken

We gebruiken de ObjectMapper klasse om een ​​object te lezen als een JsonNode.

Laten we een ObjectMapper:

ObjectMapper-mapper = nieuwe ObjectMapper ();

3.1. Vergelijk twee eenvoudige JSON-objecten

Laten we beginnen met de JsonNode.equals methode. De is gelijk aan () methode voert een volledige (diepe) vergelijking uit.

Stel dat we een JSON-string hebben gedefinieerd als de s1 variabele:

{"employee": {"id": "1212", "fullName": "John Miles", "age": 34}}

En we willen het vergelijken met een andere JSON, S2:

{"employee": {"id": "1212", "age": 34, "fullName": "John Miles"}}

Laten we de invoer JSON lezen als JsonNode en vergelijk:

assertEquals (mapper.readTree (s1), mapper.readTree (s2));

Het is belangrijk om dat op te merken ook al is de volgorde van attributen in invoer JSON-variabelen s1 en S2 is niet hetzelfde, de is gelijk aan () methode negeert de volgorde en behandelt ze als gelijk.

3.2. Vergelijk twee JSON-objecten met een genest element

Vervolgens zullen we zien hoe we twee JSON-objecten met geneste elementen kunnen vergelijken.

Laten we beginnen met een JSON gedefinieerd als de s1 variabele:

{"employee": {"id": "1212", "fullName": "John Miles", "age": 34, "contact": {"email": "[email protected]", "phone": " 9999999999 "}}}

Zoals we kunnen zien, bevat de JSON een genest element contact. We willen het vergelijken met een andere JSON gedefinieerd door S2:

{"employee": {"id": "1212", "age": 34, "fullName": "John Miles", "contact": {"email": "[email protected]", "phone": " 9999999999 "}}}

Laten we de invoer JSON lezen als JsonNode en vergelijk:

assertEquals (mapper.readTree (s1), mapper.readTree (s2)); 

Nogmaals, dat moeten we opmerken is gelijk aan () kan ook twee invoer JSON-objecten vergelijken met geneste elementen.

3.3. Vergelijk twee JSON-objecten die een lijstelement bevatten

Op dezelfde manier kunnen we ook twee JSON-objecten vergelijken die een lijstelement bevatten.

Laten we deze JSON beschouwen, gedefinieerd als s1:

{"employee": {"id": "1212", "fullName": "John Miles", "age": 34, "skills": ["Java", "C ++", "Python"]}}

We vergelijken het met een andere JSON S2:

{"employee": {"id": "1212", "age": 34, "fullName": "John Miles", "skills": ["Java", "C ++", "Python"]}}

Laten we de invoer JSON lezen als JsonNode en vergelijk:

assertEquals (mapper.readTree (s1), mapper.readTree (s2));

Het is belangrijk dat te weten twee lijstelementen worden alleen als gelijk vergeleken als ze dezelfde waarden in exact dezelfde volgorde hebben.

4. Vergelijk twee JSON-objecten met een aangepaste vergelijker

JsonNode.equals werkt in de meeste gevallen redelijk goed. Jackson biedt ook JsonNode.equals (vergelijker, JsonNode) om een ​​aangepaste Java C te configurerenomparator voorwerp. Laten we begrijpen hoe we een gewoonte kunnen gebruiken Comparator.

4.1. Aangepaste vergelijker om numerieke waarden te vergelijken

Laten we begrijpen hoe we een gewoonte kunnen gebruiken Comparator om twee JSON-elementen met numerieke waarden te vergelijken.

We gebruiken deze JSON als invoer s1:

{"name": "John", "score": 5.0}

Laten we het vergelijken met een andere JSON die is gedefinieerd als S2:

{"name": "John", "score": 5}

Daar moeten we op letten de waarden van attribuut score in ingangen s1 en S2 zijn niet hetzelfde.

Laten we de invoer JSON lezen als JsonNode en vergelijk:

JsonNode actualObj1 = mapper.readTree (s1); JsonNode actualObj2 = mapper.readTree (s2); assertNotEquals (actualObj1, actualObj2);

Zoals we kunnen zien, zijn de twee objecten niet gelijk. De standaard is gelijk aan () methode beschouwt waarden 5.0 en 5 als verschillend.

Echter, we kunnen een gewoonte gebruiken Comparator om waarden 5 en 5.0 te vergelijken en ze als gelijk te behandelen.

Laten we eerst een Comparator om twee te vergelijken NumericNode voorwerpen:

openbare klasse NumericNodeComparator implementeert Comparator {@Override public int vergelijken (JsonNode o1, JsonNode o2) {if (o1.equals (o2)) {return 0; } if ((o1 exemplaar van NumericNode) && (o2 exemplaar van NumericNode)) {Double d1 = ((NumericNode) o1) .asDouble (); Double d2 = ((NumericNode) o2) .asDouble (); if (d1.compareTo (d2) == 0) {return 0; }} terugkeer 1; }}

Laten we vervolgens kijken hoe we dit kunnen gebruiken Comparator:

NumericNodeComparator cmp = nieuwe NumericNodeComparator (); assertTrue (actualObj1.equals (cmp, actualObj2));

4.2. Aangepaste vergelijker om tekstwaarden te vergelijken

Laten we een andere zien voorbeeld van een gewoonte Comparator voor een hoofdletterongevoelige vergelijking van twee JSON-waarden.

We gebruiken deze JSON als invoer s1:

{"name": "john", "score": 5}

Laten we het vergelijken met een andere JSON die is gedefinieerd als S2:

{"name": "JOHN", "score": 5}

Zoals we het attribuut kunnen zien naam is kleine letters in de invoer s1 en hoofdletters in S2.

Laten we eerst een Comparator om twee te vergelijken TextNode voorwerpen:

public class TextNodeComparator implementeert Comparator {@Override public int Compare (JsonNode o1, JsonNode o2) {if (o1.equals (o2)) {return 0; } if ((o1 exemplaar van TextNode) && (o2 exemplaar van TextNode)) {String s1 = ((TextNode) o1) .asText (); String s2 = ((TextNode) o2) .asText (); if (s1.equalsIgnoreCase (s2)) {return 0; }} terugkeer 1; }}

Laten we eens kijken hoe we het kunnen vergelijken s1 en S2 gebruik makend van TextNodeComparator:

JsonNode actualObj1 = mapper.readTree (s1); JsonNode actualObj2 = mapper.readTree (s2); TextNodeComparator cmp = nieuwe TextNodeComparator (); assertNotEquals (actualObj1, actualObj2); assertTrue (actualObj1.equals (cmp, actualObj2));

Ten slotte kunnen we zien dat we een aangepast vergelijkingsobject gebruiken tijdens het vergelijken van twee JSON-objecten kan erg handig zijn als de invoerwaarde van het JSON-element niet exact hetzelfde is, maar we ze toch als gelijk willen behandelen.

5. Conclusie

In deze korte tutorial hebben we gezien hoe je Jackson kunt gebruiken om twee JSON-objecten te vergelijken en een aangepaste comparator te gebruiken.

Natuurlijk, zoals altijd, is de volledige broncode van alle hier besproken voorbeelden te vinden op GitHub.