השווה שני אובייקטים של JSON עם ג'קסון

1. סקירה כללית

במאמר זה נבחן השוואה בין שני אובייקטים JSON באמצעות ג'קסון - ספריית עיבוד JSON עבור Java.

2. תלות של Maven

ראשית, נוסיף את jackson-databind תלות במייבון:

 com.fasterxml.jackson.core jackson-databind 2.11.1 

3. שימוש בג'קסון להשוואה בין שני אובייקטים JSON

נשתמש ב- ObjectMapper בכיתה לקרוא אובייקט כ- JsonNode.

בואו ניצור ObjectMapper:

ממפה ObjectMapper = ObjectMapper חדש ();

3.1. השווה בין שני אובייקטים פשוטים של JSON

נתחיל באמצעות JsonNode.equals שיטה. ה שווים() השיטה מבצעת השוואה מלאה (עמוקה).

נניח שיש לנו מחרוזת JSON המוגדרת כ- s1 מִשְׁתַנֶה:

{"עובד": {"id": "1212", "fullName": "ג'ון מיילס", "גיל": 34}}

ואנחנו רוצים להשוות את זה עם JSON אחר, s2:

{"עובד": {"id": "1212", "גיל": 34, "fullName": "ג'ון מיילס"}}

בואו נקרא את קלט JSON כ JsonNode והשווה:

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

חשוב לציין זאת למרות שסדר התכונות במשתני JSON קלט s1 ו s2 אינו זהה, ה שווים() השיטה מתעלמת מהסדר ומתייחסת אליהם כשווים.

3.2. השווה בין שני אובייקטים JSON עם אלמנט מקונן

לאחר מכן נראה כיצד ניתן להשוות בין שני אובייקטים JSON בעלי אלמנטים מקוננים.

נתחיל ב- JSON המוגדר כ- s1 מִשְׁתַנֶה:

{"עובד": {"id": "1212", "fullName": "ג'ון מיילס", "גיל": 34, "contact": {"דוא"ל": "[מוגן באמצעות דוא"ל]", "טלפון": " 9999999999 "}}}

כפי שאנו רואים, ה- JSON מכיל אלמנט מקונן איש קשר. אנו רוצים להשוות אותו עם JSON אחר שהוגדר על ידי s2:

{"עובד": {"id": "1212", "age": 34, "fullName": "John Miles", "contact": {"email": "[email protected]", "phone": " 9999999999 "}}}

בואו נקרא את קלט JSON כ JsonNode והשווה:

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

שוב, עלינו לשים לב לכך שווים() יכול גם להשוות שני אובייקטים של קלט JSON עם אלמנטים מקוננים.

3.3. השווה בין שני אובייקטים JSON המכילים אלמנט רשימה

באופן דומה, אנו יכולים גם להשוות בין שני אובייקטים JSON המכילים אלמנט רשימה.

בואו ניקח בחשבון את ה- JSON הזה המוגדר כ- s1:

{"עובד": {"id": "1212", "fullName": "ג'ון מיילס", "גיל": 34, "skills": ["Java", "C ++", "Python"]}}

אנחנו משווים את זה עם JSON אחר s2:

{"עובד": {"id": "1212", "age": 34, "fullName": "John Miles", "skills": ["Java", "C ++", "Python"]}}

בואו נקרא את קלט JSON כ JsonNode והשווה:

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

חשוב לדעת זאת שני רכיבי רשימה מושווים כשווים רק אם יש להם אותם ערכים באותו סדר בדיוק.

4. השווה שני אובייקטים של JSON עם משווה מותאם אישית

JsonNode.equals עובד די טוב ברוב המקרים. ג'קסון מספק גם JsonNode.equals (משווה, JsonNode) כדי לקבוע תצורה של Java C מותאם אישיתomparator לְהִתְנַגֵד. בואו להבין כיצד להשתמש בהתאמה אישית משווה.

4.1. השוואה מותאמת אישית להשוואה בין ערכים מספריים

בואו נבין כיצד להשתמש בהתאמה אישית משווה להשוות שני אלמנטים JSON בעלי ערכים מספריים.

נשתמש ב- JSON זה כקלט s1:

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

בואו נשווה עם JSON אחר שהוגדר כ- s2:

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

עלינו להתבונן בכך את ערכי התכונה ציון בתשומות s1 ו s2 לא אותו הדבר.

בואו נקרא את קלט JSON כ JsonNode והשווה:

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

כפי שאנו יכולים להבחין, שני האובייקטים אינם שווים. הסטנדרט שווים() השיטה רואה בערכים 5.0 ו -5 שונים.

למרות זאת, אנחנו יכולים להשתמש בהתאמה אישית משווה להשוות בין ערכים 5 ו -5.0 ולהתייחס אליהם כשווים.

בואו ניצור תחילה a משווה להשוות בין שניים NumericNode חפצים:

מחלקה ציבורית NumericNodeComparator מיישם את Comparator {@Override public int השווה (JsonNode o1, JsonNode o2) {if (o1.equals (o2)) {return 0; } אם ((o1 מופע של NumericNode) && (o2 מופע של NumericNode)) {כפול d1 = ((NumericNode) o1) .asDouble (); כפול d2 = ((NumericNode) o2) .asDouble (); אם (d1.compareTo (d2) == 0) {להחזיר 0; }} להחזיר 1; }}

לאחר מכן, בואו נראה כיצד להשתמש בזה משווה:

NumericNodeComparator cmp = NumericNodeComparator חדש (); assertTrue (actualObj1.equals (cmp, actualObj2));

4.2. השוואה מותאמת אישית להשוואת ערכי טקסט

בוא נראה עוד דוגמה למנהג משווה להשוואה שאיננה רגישה לאותיות רישיות של שני ערכי JSON.

נשתמש ב- JSON זה כקלט s1:

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

בואו נשווה עם JSON אחר שהוגדר כ- s2:

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

כפי שאנו יכולים לראות את התכונה שֵׁם הוא באותיות קטנות בקלט s1 ואותיות גדולות ב s2.

בואו ניצור תחילה a משווה להשוות בין שניים TextNode חפצים:

מחלקה ציבורית TextNodeComparator מיישם את Comparator {@Override public int השווה (JsonNode o1, JsonNode o2) {if (o1.equals (o2)) {return 0; } אם ((o1 מופע של TextNode) && (o2 מופע של TextNode)) {מחרוזת s1 = ((TextNode) o1). asText (); מחרוזת s2 = ((TextNode) o2) .asText (); אם (s1.equalsIgnoreCase (s2)) {להחזיר 0; }} להחזיר 1; }}

בואו נראה איך להשוות s1 ו s2 באמצעות TextNodeComparator:

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

לבסוף, אנו יכולים לראות שימוש באובייקט השוואה מותאם אישית תוך השוואה בין שני אובייקטים JSON יכול להיות שימושי מאוד כאשר ערך אלמנט הקלט JSON אינו זהה לחלוטין אך אנו עדיין רוצים להתייחס אליהם כשווים.

5. מסקנה

במדריך מהיר זה, ראינו כיצד להשתמש בג'קסון כדי להשוות שני אובייקטים של JSON ולהשתמש במשווה מותאם אישית.

כמובן שכמו תמיד ניתן למצוא את קוד המקור המלא של כל הדוגמאות הנדונות כאן ב- GitHub.