streamalism.org

1. Áttekintés

Ebben a cikkben két JSON objektumot fogunk összehasonlítani Jackson - egy JSON Java-feldolgozó könyvtár használatával.

2. Maven-függőség

Először tegyük hozzá a jackson-databind Maven-függőség:

 com.fasterxml.jackson.core jackson-databind 2.11.1 

3. Jackson használata két JSON-objektum összehasonlításához

Használjuk a ObjectMapper osztály egy objektumot a-ként olvasni JsonNode.

Hozzunk létre egy ObjectMapper:

ObjectMapper mapper = új ObjectMapper ();

3.1. Két egyszerű JSON-objektum összehasonlítása

Kezdjük azzal, hogy JsonNode.egyenlő módszer. A egyenlő () módszer teljes (mély) összehasonlítást végez.

Tegyük fel, hogy van egy JSON karakterláncunk, amelyet a s1 változó:

{"alkalmazott": {"id": "1212", "fullName": "John Miles", "kor": 34}}

És szeretnénk összehasonlítani egy másik JSON-nal, s2:

{"alkalmazott": {"id": "1212", "életkor": 34, "fullName": "John Miles"}}

Olvassuk el a JSON bemenetet JsonNode és hasonlítsa össze:

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

Fontos megjegyezni annak ellenére, hogy az input JSON változókban az attribútumok sorrendje s1 és s2 nem ugyanaz, a egyenlő () A módszer figyelmen kívül hagyja a sorrendet, és egyenlőnek tekinti őket.

3.2. Két JSON-objektum összehasonlítása beágyazott elemmel

Ezután megtudjuk, hogyan lehet összehasonlítani két beágyazott elemet tartalmazó JSON-objektumot.

Kezdjük egy JSON-val, amelyet a következőként definiálunk s1 változó:

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

Mint láthatjuk, a JSON beágyazott elemet tartalmaz kapcsolatba lépni. Összehasonlítani szeretnénk egy másik által definiált JSON-nal s2:

{"alkalmazott": {"id": "1212", "életkor": 34, "fullName": "John Miles", "contact": {"email": "[email protected]", "phone": " 9999999999 "}}}

Olvassuk el a JSON bemenetet JsonNode és hasonlítsa össze:

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

Ismét észre kell vennünk ezt egyenlő () két bemeneti JSON objektumot is be lehet hasonlítani beágyazott elemekkel.

3.3. Hasonlítson össze két listaelemet tartalmazó JSON-objektumot

Hasonlóképpen összehasonlíthatunk két JSON-objektumot is, amelyek tartalmaznak egy listaelemet.

Tekintsük ezt a JSON-t definiáltnak s1:

{"alkalmazott": {"id": "1212", "fullName": "John Miles", "kor": 34, "készségek": ["Java", "C ++", "Python"]}}

Összehasonlítjuk egy másik JSON-nal s2:

{"alkalmazott": {"id": "1212", "kor": 34, "fullName": "John Miles", "készségek": ["Java", "C ++", "Python"]}}

Olvassuk el a JSON bemenetet JsonNode és hasonlítsa össze:

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

Fontos ezt tudni két listaelemet csak akkor hasonlítunk egyenlőnek, ha ugyanazon értékek vannak pontosan ugyanabban a sorrendben.

4. Hasonlítsa össze a két JSON-objektumot az egyéni összehasonlítóval

JsonNode.egyenlő az esetek többségében elég jól működik. Jackson azt is biztosítja JsonNode.equals (összehasonlító, JsonNode) egyéni Java C konfigurálásáhozösszehasonlító tárgy. Értsük meg, hogyan kell használni a szokásokat Összehasonlító.

4.1. Egyéni összehasonlító a numerikus értékek összehasonlításához

Értsük meg, hogyan kell használni a szokásokat Összehasonlító két numerikus értékű JSON elem összehasonlítására.

Ezt a JSON-t fogjuk használni bemenetként s1:

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

Hasonlítsuk össze egy másik JSON-val, amelyet definiáltunk s2:

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

Ezt meg kell figyelnünk az attribútum értékei pontszám bemenetben s1 és s2 nem ugyanazok.

Olvassuk el a JSON bemenetet JsonNode és hasonlítsa össze:

JsonNode actualObj1 = mapper.readTree (s1); JsonNode actualObj2 = mapper.readTree (s2); assertNotEquals (ténylegesObj1, ténylegesObj2);

Mint észrevehetjük, a két objektum nem egyenlő. A szabvány egyenlő () A módszer az 5.0 és 5 értékeket különbözõnek tekinti.

Azonban, használhatunk egy szokást Összehasonlító összehasonlítani az 5. és 5.0 értékeket, és egyenlőnek tekinteni őket.

Először hozzunk létre egy Összehasonlító kettőt összehasonlítani NumericNode tárgyak:

public class NumericNodeComparator implementálja a Comparator {@Orride public int Compare (JsonNode o1, JsonNode o2) {if (o1.egyenlő (o2)) {return 0; } if ((a NumericNode o1 példánya) && (NumericNode o2 példánya)) {Double d1 = ((NumericNode) o1) .asDouble (); Dupla d2 = ((NumericNode) o2) .asDouble (); if (d1.compareTo (d2) == 0) {visszatér 0; }} return 1; }}

Ezután nézzük meg, hogyan kell ezt használni Összehasonlító:

NumericNodeComparator cmp = new NumericNodeComparator (); assertTrue (ténylegesObj1.egyenlő (cmp, ténylegesObj2));

4.2. Egyéni összehasonlító a szövegértékek összehasonlításához

Lássunk egy másikat példa egy szokásra Összehasonlító eset-érzéketlen összehasonlításhoz két JSON-érték közül.

Ezt a JSON-t fogjuk használni bemenetként s1:

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

Hasonlítsuk össze egy másik JSON-val, amelyet definiáltunk s2:

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

Amint láthatjuk az attribútumot név kisbetűs a bevitelben s1 és nagybetűvel s2.

Először hozzunk létre egy Összehasonlító kettőt összehasonlítani TextNode tárgyak:

public class TextNodeComparator megvalósítja a Comparator {@Orride public int Compare (JsonNode o1, JsonNode o2) {if (o1.egyenlő (o2)) {return 0; } if ((a TextNode o1 példánya) && (TextNode o2 példánya)) {String s1 = ((TextNode) o1) .asText (); Karakterlánc s2 = ((TextNode) o2) .asText (); if (s1.equalsIgnoreCase (s2)) {visszatér 0; }} return 1; }}

Lássuk, hogyan lehet összehasonlítani s1 és s2 felhasználásával TextNodeComparator:

JsonNode actualObj1 = mapper.readTree (s1); JsonNode actualObj2 = mapper.readTree (s2); TextNodeComparator cmp = new TextNodeComparator (); assertNotEquals (ténylegesObj1, ténylegesObj2); assertTrue (ténylegesObj1.egyenlő (cmp, ténylegesObj2));

Végül láthatjuk egy egyedi összehasonlító objektum használatát, miközben összehasonlítjuk két JSON objektumot nagyon hasznos lehet, ha a bemeneti JSON elem értéke nem teljesen azonos, de továbbra is egyenlőnek akarjuk kezelni őket.

5. Következtetés

Ebben a gyors oktatóanyagban láthattuk, hogyan lehet Jackson segítségével összehasonlítani két JSON-objektumot, és egyéni összehasonlítót használni.

Természetesen, mint mindig, az itt tárgyalt összes példa teljes forráskódja megtalálható a GitHubon.