İki JSON nesnesini Java'daki çocuk sırasını yoksayarak eşitlik açısından sınama

Özellikle bir web hizmetinden dönen birim test JSON, çocuk sırasını görmezden iki JSON nesneleri karşılaştırma destekleyen bir JSON ayrıştırma kitaplığı arıyorum.

Büyük JSON kütüphanelerinden herhangi biri bunu destekliyor mu? Org.json kütüphanesi basitçe bir referans karşılaştırması yapar.

Genel bir mimari nokta olarak, genellikle belirli bir serileştirme formatına bağımlılıkların depolama / ağ katmanınızın dışına taşmasına izin vermemenizi öneririm; bu nedenle, önce kendi uygulama nesneleriniz arasında JSON tezahürleri yerine eşitliği test etmeyi düşünmenizi tavsiye ederim.

Ben şu anda büyük bir hayranıyım, söyledikten Jackson onların benim hızlı okuma ObjectNode.equals () uygulaması set üyelik karşılaştırma istiyor önerir:

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;
}

Skyscreamer'ın JSONAssert'ini deneyin .

Onun olmayan sıkı modu daha az kırılgan hale iki önemli avantajı vardır:

• Nesne genişletilebilirliği (örneğin, beklenen {id: 1} değeri ile bu yine de geçecektir: {id: 1, moredata: 'x'} .)
• Gevşek dizi sırası (ör. ['Köpek', 'kedi'] == ['kedi', 'köpek'])

Katı modda daha çok json-lib'in test sınıfı gibi davranır.

Bir test şöyle görünür:

@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);
}

JSONAssert.assertEquals () çağrısındaki parametreler beklenirJSONString , actualDataString ve isStrict .

Sonuç mesajları oldukça açıktır, bu da gerçekten büyük JSON nesnelerini karşılaştırırken önemlidir.

GSON kullanma

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);

Düzenleme: GSON v2.8.6 beri örnek yöntemi JsonParser.parsekullanımdan kaldırıldı. Statik yöntemi kullanmanız gerekir JsonParser.parseString:

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

Aşağıdakileri yaparım,

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);

Json- lib'in JSONAssert sınıfını kullanmayı deneyebilirsiniz :

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

verir:

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

Bu kütüphaneyi kullanın: https://github.com/lukas-krecan/JsonUnit

pom:

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

IGNORING_ARRAY_ORDER - dizilerdeki sıralamayı yok sayar

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

Zaten JUnit kullanıyorsanız, en son sürümde şimdi Hamcrest kullanılmaktadır. Yeni eşleştiriciler oluşturmak için genişletilebilen genel bir eşleştirme çerçevesidir (özellikle birim testi için yararlıdır).

hamcrest-jsonJSON uyumlu eşleşmelerle adlandırılan küçük bir açık kaynak kitaplığı var . İyi belgelenmiştir, test edilmiştir ve desteklenmektedir. Aşağıda bazı yararlı bağlantılar verilmiştir:

• Kaynak kodu
• Ana Sayfa
• Ana eşleştirici için Javadoc'lar :

JSON kitaplığındaki nesneleri kullanan örnek kod org.json.simple:

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

İsteğe bağlı olarak, (1) "herhangi bir sıraya uygun" dizilere izin verebilir ve (2) fazladan alanları yoksayabilirsiniz.

Java için JSON kütüphaneleri (çeşitli olduğundan Jackson, GSON, json-libvs.), bu yararlı olduğunu hamcrest-jsondestekler JSON metni (olarak java.lang.String), Douglas Crockford JSON kitaplığından yanı sıra doğal destekleyici nesneler org.json.

Son olarak, JUnit kullanmıyorsanız, iddialar için doğrudan Hamcrest'i kullanabilirsiniz. ( Burada yazdım. )

JsonUnit'i deneyebilirsiniz . İki JSON nesnesini karşılaştırabilir ve farklılıkları rapor edebilir. Jackson'ın üzerine inşa edilmiştir.

Örneğin

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

Sonuçları

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

Yaptığım ve harikalar yaratan bir şey, her iki nesneyi HashMap'e okumak ve daha sonra normal bir assertEquals () ile karşılaştırmaktır. İçindeki tüm nesneleri özyinelemeli olarak karşılaştıracak olan hashmaps'in equals () yöntemini çağıracaktır (ya diğer hashmaps'lar ya da dize ya da tamsayı gibi bazı tek değerli nesneler olacaktır). Bu, Codehaus'un Jackson JSON ayrıştırıcısı kullanılarak yapıldı.

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

JSON nesnesi bunun yerine bir dizi ise benzer bir yaklaşım kullanılabilir.

Bunu kullanıyorum ve benim için iyi çalışıyor (org.json ile. *):

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;
        }
    }
}

Org.json için JSONObject örnekleriyle karşılaştırılan kendi yöntemimi sundum. Bu projede karmaşık JSON nesneleri ile çalışmadı, bu yüzden tüm senaryolarda çalışıp çalışmadığını bilmiyorum. Ayrıca, bunu birim testlerde kullandığım için, optimizasyon için çaba göstermedim. İşte burada:

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;
}

RFC 6902'ye (JSON Yaması) göre diff bilgisini sunan zjsonpatch kütüphanesini kullanabilirsiniz . Kullanımı çok kolay. Kullanımı için lütfen açıklama sayfasını ziyaret edin

Kütüphaneyi http://json.org/java/ adresinden alıp, equalsderin bir eşitlik testi yapmak için JSONObject ve JSONArray yöntemini değiştirirdim . Çocukların sırasına göre yeniden çalıştığından emin olmak için yapmanız gereken tek şey iç haritayı a ile değiştirmek TreeMapveya benzeri bir şey kullanmaktır Collections.sort().

Bunu dene:

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;
    }

Genellikle sadece test için kabul edildiğini biliyorum ama Hamcrest JSON'da Hamcrest JSON karşılaştırıcısıSameJSONAs'ı kullanabilirsiniz .

Hamcrest JSON SameJSONA'lar

Karate tam olarak aradığınız şey. İşte bir örnek:

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

(feragat: dev burada)

Jsons'ları karşılaştırmak için JSONCompare kullanmanızı tavsiye ederim: 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

Benim gibi Jackson ile bunu yapmak isteyenler için json-unit kullanabilirsiniz .

JsonAssert.assertJsonEquals(jsonNode1, jsonNode2);

Hatalar, uyumsuzluğun türü hakkında yararlı geri bildirimler sağlar:

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

Başka hiçbir şey oldukça doğru görünmüyordu, bu yüzden şunu yazdım:

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;
}

Aşağıdaki kod, iki JsonObject, JsonArray, JsonPrimitive ve JasonElements'i karşılaştırmak için daha yararlı olacaktır.

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

Cevaplara baktığımda JSONAssert'i denedim ama başarısız oldu. Bu yüzden Jackson'ı zjsonpatch ile kullandım. Burada SO cevabına detaylar gönderdim .

Benim için bu çözüm, iş çok iyi:

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

Umarım bu başkalarına yardım eder.