Kiểm tra hai đối tượng JSON để tìm sự bình đẳng bỏ qua thứ tự con trong Java

Tôi đang tìm kiếm một thư viện phân tích cú pháp JSON hỗ trợ so sánh hai đối tượng JSON bỏ qua thứ tự con, đặc biệt để kiểm tra đơn vị trả về JSON từ một dịch vụ web.

Có bất kỳ thư viện JSON chính nào hỗ trợ điều này không? Thư viện org.json chỉ đơn giản là so sánh tham chiếu.

Là một điểm kiến ​​trúc chung, tôi thường khuyên không nên để phụ thuộc vào một định dạng tuần tự hóa cụ thể chảy ra ngoài lớp lưu trữ / mạng của bạn; do đó, trước tiên tôi khuyên bạn nên xem xét kiểm tra sự bình đẳng giữa các đối tượng ứng dụng của riêng bạn thay vì các biểu hiện JSON của chúng.

Phải nói rằng, tôi hiện là một fan hâm mộ lớn của Jackson mà tôi đã đọc nhanh về triển khai ObjectNode.equals () của họ cho thấy việc so sánh thành viên mà bạn muốn:

public boolean equals(Object o)
{
    if (o == this) return true;
    if (o == null) return false;
    if (o.getClass() != getClass()) {
        return false;
    }
    ObjectNode other = (ObjectNode) o;
    if (other.size() != size()) {
        return false;
    }
    if (_children != null) {
        for (Map.Entry<String, JsonNode> en : _children.entrySet()) {
            String key = en.getKey();
            JsonNode value = en.getValue();

            JsonNode otherValue = other.get(key);

            if (otherValue == null || !otherValue.equals(value)) {
                return false;
            }
        }
    }
    return true;
}

Hãy dùng thử JSONAssert của chọc trời .

Chế độ không nghiêm ngặt của nó có hai ưu điểm chính khiến nó ít giòn hơn:

• Khả năng mở rộng đối tượng (ví dụ: Với giá trị dự kiến ​​là {id: 1} , điều này vẫn sẽ vượt qua: {id: 1, moredata: 'x'} .)
• Sắp xếp mảng lỏng lẻo (ví dụ: ['dog', 'cat'] == ['cat', 'dog'])

Trong chế độ nghiêm ngặt, nó hoạt động giống như lớp kiểm tra của json-lib.

Một bài kiểm tra trông giống như thế này:

@Test
public void testGetFriends() {
    JSONObject data = getRESTData("/friends/367.json");
    String expected = "{friends:[{id:123,name:\"Corby Page\"}"
        + ",{id:456,name:\"Solomon Duskis\"}]}";
    JSONAssert.assertEquals(expected, data, false);
}

Các thông số trong JSONAssert.assertEquals () gọi được expectedJSONString , actualDataString , và isStrict .

Các thông báo kết quả khá rõ ràng, điều này rất quan trọng khi so sánh các đối tượng JSON thực sự lớn.

Sử dụng GSON

JsonParser parser = new JsonParser();
JsonElement o1 = parser.parse("{a : {a : 2}, b : 2}");
JsonElement o2 = parser.parse("{b : 2, a : {a : 2}}");
assertEquals(o1, o2);

Chỉnh sửa: Vì GSON v2.8.6 , phương thức cá thể JsonParser.parsekhông được dùng nữa. Bạn phải sử dụng phương thức tĩnh JsonParser.parseString:

JsonElement o1 = JsonParser.parseString("{a : {a : 2}, b : 2}");
JsonElement o2 = JsonParser.parseString("{b : 2, a : {a : 2}}");
assertEquals(o1, o2);

Tôi sẽ làm như sau

JSONObject obj1 = /*json*/;
JSONObject obj2 = /*json*/;

ObjectMapper mapper = new ObjectMapper();

JsonNode tree1 = mapper.readTree(obj1.toString());
JsonNode tree2 = mapper.readTree(obj2.toString());

return tree1.equals(tree2);

Bạn có thể thử sử dụng lớp JSONAssert của json-lib :

JSONAssert.assertEquals(
  "{foo: 'bar', baz: 'qux'}",
  JSONObject.fromObject("{foo: 'bar', baz: 'xyzzy'}")
);

Cung cấp:

junit.framework.ComparisonFailure: objects differed at key [baz]; expected:<[qux]> but was:<[xyzzy]>

Sử dụng thư viện này: https://github.com/lukas-krecan/JsonUnit

Bưởi:

<dependency>
    <groupId>net.javacrumbs.json-unit</groupId>
    <artifactId>json-unit</artifactId>
    <version>1.5.0</version>
    <scope>test</scope>
</dependency>

IGNORING_ARRAY_ORDER - bỏ qua thứ tự trong mảng

assertJsonEquals("{\"test\":[1,2,3]}",
  "{\"test\":  [3,2,1]}",
  when(IGNORING_ARRAY_ORDER)
);

Nếu bạn đã sử dụng JUnit, phiên bản mới nhất hiện sử dụng Hamcrest. Đó là một khung kết hợp chung (đặc biệt hữu ích cho thử nghiệm đơn vị) có thể được mở rộng để xây dựng các đối sánh mới.

Có một thư viện mã nguồn mở nhỏ được gọi hamcrest-jsonvới các đối sánh nhận biết JSON. Nó là tài liệu tốt, thử nghiệm và hỗ trợ. Dưới đây là một số liên kết hữu ích:

• Mã nguồn
• Trang chủ
• Javadocs cho trình so khớp chính :

Mã ví dụ sử dụng các đối tượng từ thư viện JSON org.json.simple:

Assert.assertThat(
    jsonObject1.toJSONString(),
    SameJSONAs.sameJSONAs(jsonObject2.toJSONString()));

Tùy chọn, bạn có thể (1) cho phép mảng "bất kỳ thứ tự" và (2) bỏ qua các trường bổ sung.

Vì có rất nhiều thư viện JSON cho Java ( Jackson, GSON, json-lib, vv), nó rất hữu ích mà hamcrest-jsonhỗ trợ JSON văn bản (như java.lang.String), cũng như nguyên bản hỗ trợ các đối tượng từ thư viện JSON Douglas Crockfordorg.json .

Cuối cùng, nếu bạn không sử dụng JUnit, bạn có thể sử dụng Hamcrest trực tiếp để xác nhận. ( Tôi đã viết về nó ở đây. )

Bạn có thể thử JsonUnit . Nó có thể so sánh hai đối tượng JSON và báo cáo sự khác biệt. Nó được xây dựng trên đỉnh Jackson.

Ví dụ

assertJsonEquals("{\"test\":1}", "{\n\"test\": 2\n}");

Kết quả trong

java.lang.AssertionError: JSON documents are different:
Different value found in node "test". Expected 1, got 2.

Một điều tôi đã làm và nó hoạt động kỳ diệu là đọc cả hai đối tượng vào HashMap và sau đó so sánh với một assertEquals () thông thường. Nó sẽ gọi phương thức equals () của hashmap, sẽ so sánh đệ quy tất cả các đối tượng bên trong (chúng sẽ là các hashtag khác hoặc một số đối tượng giá trị đơn lẻ như một chuỗi hoặc số nguyên). Điều này đã được thực hiện bằng cách sử dụng trình phân tích cú pháp Jackson JSON của Codehaus.

assertEquals(mapper.readValue(expectedJson, new TypeReference<HashMap<String, Object>>(){}), mapper.readValue(actualJson, new TypeReference<HashMap<String, Object>>(){}));

Một cách tiếp cận tương tự có thể được sử dụng nếu đối tượng JSON là một mảng thay thế.

Tôi đang sử dụng cái này và hoạt động tốt với tôi (với org.json. *):

package com.project1.helpers;

import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;

import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class JSONUtils {

    public static boolean areEqual(Object ob1, Object ob2) throws JSONException {
        Object obj1Converted = convertJsonElement(ob1);
        Object obj2Converted = convertJsonElement(ob2);
        return obj1Converted.equals(obj2Converted);
    }

    private static Object convertJsonElement(Object elem) throws JSONException {
        if (elem instanceof JSONObject) {
            JSONObject obj = (JSONObject) elem;
            Iterator<String> keys = obj.keys();
            Map<String, Object> jsonMap = new HashMap<>();
            while (keys.hasNext()) {
                String key = keys.next();
                jsonMap.put(key, convertJsonElement(obj.get(key)));
            }
            return jsonMap;
        } else if (elem instanceof JSONArray) {
            JSONArray arr = (JSONArray) elem;
            Set<Object> jsonSet = new HashSet<>();
            for (int i = 0; i < arr.length(); i++) {
                jsonSet.add(convertJsonElement(arr.get(i)));
            }
            return jsonSet;
        } else {
            return elem;
        }
    }
}

Đối với org.json, tôi đã đưa ra giải pháp của riêng mình, một phương thức so sánh với các trường hợp JSONObject. Tôi đã không làm việc với các đối tượng JSON phức tạp trong dự án đó, vì vậy tôi không biết liệu điều này có hoạt động trong tất cả các kịch bản hay không. Ngoài ra, do tôi sử dụng điều này trong các bài kiểm tra đơn vị, tôi đã không nỗ lực tối ưu hóa. Đây là:

public static boolean jsonObjsAreEqual (JSONObject js1, JSONObject js2) throws JSONException {
    if (js1 == null || js2 == null) {
        return (js1 == js2);
    }

    List<String> l1 =  Arrays.asList(JSONObject.getNames(js1));
    Collections.sort(l1);
    List<String> l2 =  Arrays.asList(JSONObject.getNames(js2));
    Collections.sort(l2);
    if (!l1.equals(l2)) {
        return false;
    }
    for (String key : l1) {
        Object val1 = js1.get(key);
        Object val2 = js2.get(key);
        if (val1 instanceof JSONObject) {
            if (!(val2 instanceof JSONObject)) {
                return false;
            }
            if (!jsonObjsAreEqual((JSONObject)val1, (JSONObject)val2)) {
                return false;
            }
        }

        if (val1 == null) {
            if (val2 != null) {
                return false;
            }
        }  else if (!val1.equals(val2)) {
            return false;
        }
    }
    return true;
}

Bạn có thể sử dụng thư viện zjsonpatch , trình bày thông tin khác theo RFC 6902 (Bản vá JSON). Nó rất dễ sử dụng. Vui lòng truy cập trang mô tả của nó để sử dụng

Tôi sẽ lấy thư viện tại http://json.org/java/ và sửa đổi equalsphương thức JSONObject và JSONArray để thực hiện một bài kiểm tra công bằng sâu sắc. Để chắc chắn rằng nó hoạt động không theo thứ tự của trẻ em, tất cả những gì bạn cần làm là thay thế bản đồ bên trong bằng một TreeMaphoặc sử dụng một cái gì đó như Collections.sort().

Thử cái này:

public static boolean jsonsEqual(Object obj1, Object obj2) throws JSONException

    {
        if (!obj1.getClass().equals(obj2.getClass()))
        {
            return false;
        }

        if (obj1 instanceof JSONObject)
        {
            JSONObject jsonObj1 = (JSONObject) obj1;

            JSONObject jsonObj2 = (JSONObject) obj2;

            String[] names = JSONObject.getNames(jsonObj1);
            String[] names2 = JSONObject.getNames(jsonObj1);
            if (names.length != names2.length)
            {
                return false;
            }

            for (String fieldName:names)
            {
                Object obj1FieldValue = jsonObj1.get(fieldName);

                Object obj2FieldValue = jsonObj2.get(fieldName);

                if (!jsonsEqual(obj1FieldValue, obj2FieldValue))
                {
                    return false;
                }
            }
        }
        else if (obj1 instanceof JSONArray)
        {
            JSONArray obj1Array = (JSONArray) obj1;
            JSONArray obj2Array = (JSONArray) obj2;

            if (obj1Array.length() != obj2Array.length())
            {
                return false;
            }

            for (int i = 0; i < obj1Array.length(); i++)
            {
                boolean matchFound = false;

                for (int j = 0; j < obj2Array.length(); j++)
                {
                    if (jsonsEqual(obj1Array.get(i), obj2Array.get(j)))
                    {
                        matchFound = true;
                        break;
                    }
                }

                if (!matchFound)
                {
                    return false;
                }
            }
        }
        else
        {
            if (!obj1.equals(obj2))
            {
                return false;
            }
        }

        return true;
    }

Tôi biết nó thường được coi là chỉ để thử nghiệm nhưng bạn có thể sử dụng hamcrest JSON comparitorSameJSONAs trong hamcrest JSON.

Hamcrest JSON SameJSONAs

Karate chính xác là những gì bạn đang tìm kiếm. Đây là một ví dụ:

* def myJson = { foo: 'world', hey: 'ho', zee: [5], cat: { name: 'Billie' } }
* match myJson = { cat: { name: 'Billie' }, hey: 'ho', foo: 'world', zee: [5] }

(từ chối trách nhiệm: dev ở đây)

Để so sánh jsons tôi khuyên bạn nên sử dụng JSONCompare: https://github.com/fslev/json-compare

// Compare by regex
String expected = "{\"a\":\".*me.*\"}";
String actual = "{\"a\":\"some text\"}";
JSONCompare.assertEquals(expected, actual);  // True

// Check expected array has no extra elements
String expected = "[1,\"test\",4,\"!.*\"]";
String actual = "[4,1,\"test\"]";
JSONCompare.assertEquals(expected, actual);  // True

// Check expected array has no numbers
String expected = "[\"\\\\\\d+\"]";
String actual = "[\"text\",\"test\"]";
JSONCompare.assertEquals(expected, actual);  // True

// Check expected array has no numbers
String expected = "[\"\\\\\\d+\"]";
String actual = "[2018]";
JSONCompare.assertNotEquals(expected, actual);  // True

Đối với những người như tôi muốn làm điều này với Jackson, bạn có thể sử dụng json-unit .

JsonAssert.assertJsonEquals(jsonNode1, jsonNode2);

Các lỗi cung cấp phản hồi hữu ích về loại không khớp:

java.lang.AssertionError: JSON documents have different values:
Different value found in node "heading.content[0].tag[0]". Expected 10209, got 10206.

Không có gì khác có vẻ hoạt động hoàn toàn đúng, vì vậy tôi đã viết điều này:

private boolean jsonEquals(JsonNode actualJson, JsonNode expectJson) {
    if(actualJson.getNodeType() != expectJson.getNodeType()) return false;

    switch(expectJson.getNodeType()) {
    case NUMBER:
        return actualJson.asDouble() == expectJson.asDouble();
    case STRING:
    case BOOLEAN:
        return actualJson.asText().equals(expectJson.asText());
    case OBJECT:
        if(actualJson.size() != expectJson.size()) return false;

        Iterator<String> fieldIterator = actualJson.fieldNames();
        while(fieldIterator.hasNext()) {
            String fieldName = fieldIterator.next();
            if(!jsonEquals(actualJson.get(fieldName), expectJson.get(fieldName))) {
                return false;
            }
        }
        break;
    case ARRAY:
        if(actualJson.size() != expectJson.size()) return false;
        List<JsonNode> remaining = new ArrayList<>();
        expectJson.forEach(remaining::add);
        // O(N^2)   
        for(int i=0; i < actualJson.size(); ++i) {
            boolean oneEquals = false;
            for(int j=0; j < remaining.size(); ++j) {
                if(jsonEquals(actualJson.get(i), remaining.get(j))) {
                    oneEquals = true;
                    remaining.remove(j);
                    break;
                }
            }
            if(!oneEquals) return false;
        }
        break;
    default:
        throw new IllegalStateException();
    }
    return true;
}

Mã sau sẽ hữu ích hơn để so sánh hai JsonObject, JsonArray, JsonPrimitive và JasonElements.

private boolean compareJson(JsonElement json1, JsonElement json2) {
        boolean isEqual = true;
        // Check whether both jsonElement are not null
        if (json1 != null && json2 != null) {

            // Check whether both jsonElement are objects
            if (json1.isJsonObject() && json2.isJsonObject()) {
                Set<Entry<String, JsonElement>> ens1 = ((JsonObject) json1).entrySet();
                Set<Entry<String, JsonElement>> ens2 = ((JsonObject) json2).entrySet();
                JsonObject json2obj = (JsonObject) json2;
                if (ens1 != null && ens2 != null) {
                    // (ens2.size() == ens1.size())
                    // Iterate JSON Elements with Key values
                    for (Entry<String, JsonElement> en : ens1) {
                        isEqual = isEqual && compareJson(en.getValue(), json2obj.get(en.getKey()));
                    }
                } else {
                    return false;
                }
            }

            // Check whether both jsonElement are arrays
            else if (json1.isJsonArray() && json2.isJsonArray()) {
                JsonArray jarr1 = json1.getAsJsonArray();
                JsonArray jarr2 = json2.getAsJsonArray();
                if (jarr1.size() != jarr2.size()) {
                    return false;
                } else {
                    int i = 0;
                    // Iterate JSON Array to JSON Elements
                    for (JsonElement je : jarr1) {
                        isEqual = isEqual && compareJson(je, jarr2.get(i));
                        i++;
                    }
                }
            }

            // Check whether both jsonElement are null
            else if (json1.isJsonNull() && json2.isJsonNull()) {
                return true;
            }

            // Check whether both jsonElement are primitives
            else if (json1.isJsonPrimitive() && json2.isJsonPrimitive()) {
                if (json1.equals(json2)) {
                    return true;
                } else {
                    return false;
                }
            } else {
                return false;
            }
        } else if (json1 == null && json2 == null) {
            return true;
        } else {
            return false;
        }
        return isEqual;
    }

JSON.areEqual(json1, json2); //using BlobCity Java Commons

https://tech.blobcity.com/2018/09/02/json-equals-in-java-to-compare-two-jsons

Nhìn vào các câu trả lời, tôi đã thử JSONAssert nhưng không thành công. Vì vậy, tôi đã sử dụng Jackson với zjsonpatch. Tôi đã đăng chi tiết trong câu trả lời SO ở đây .

Giải pháp này cho tôi, công việc rất tốt:

try {           
                // Getting The Array "Courses" from json1 & json2   
                Courses1 =json1.getJSONArray(TAG_COURSES1);
                Courses2 = json2.getJSONArray(TAG_COURSES);

                //LOOP FOR JSON1
                for(int i = 0; i < Courses1.length(); i++){
                    //LOOP FOR JSON2
                    for(int ii = 0; ii < Courses2.length(); ii++){
                        JSONObject courses1 = Courses1.getJSONObject(i);
                        JSONObject courses2 = Courses2.getJSONObject(ii);

                        // Storing each json1 item in variable
                        int courseID1 = courses1.getInt(TAG_COURSEID1);
                        Log.e("COURSEID2:", Integer.toString(courseID1));
                        String Rating1 = courses1.getString(TAG_RATING1);
                        int Status1 = courses1.getInt(TAG_STATUS1);
                        Log.e("Status1:", Integer.toString(Status1));      //Put the actual value for Status1 in log.             

                        // Storing each json2 item in variable
                        int courseID2 = courses2.getInt(TAG_COURSEID);
                        Log.e("COURSEID2:", Integer.toString(courseID));   //Put the actual value for CourseID in log
                        String Title2 = courses2.getString(TAG_TITLE);                      
                        String instructor2 = courses2.getString(TAG_INSTRUCTOR);
                        String length2 = courses2.getString(TAG_LENGTH);
                        String rating2 = courses2.getString(TAG_RATING);
                        String subject2 = courses2.getString(TAG_SUBJECT);
                        String description2 = courses2.getString(TAG_DESCRIPTION);

                        //Status1 = 5 from json1; Incomplete, Status1 =-1 Complete 
                        if(Status1 == 5 && courseID2 == courseID1){                                  

                        // creating new HashMap
                        HashMap<String, String> map = new HashMap<String, String>();         
                        //Storing the elements if condition is true.
                        map.put(TAG_COURSEID, Integer.toString(courseID2)); //pend for compare
                        map.put(TAG_TITLE, Title2);
                        map.put(TAG_INSTRUCTOR, instructor2);
                        map.put(TAG_LENGTH, length2);
                        map.put(TAG_RATING, rating2);
                        map.put(TAG_SUBJECT, subject2); //show it
                        map.put(TAG_DESCRIPTION, description2);

                        //adding HashList to ArrayList
                        contactList.add(map);
                        }//if
                    }//for2 (json2)
                } //for1 (json1)                
            }//Try

Hy vọng điều này sẽ giúp người khác.