Vergleichen Sie JSON-Gleichheit in Scala

Question

Wie kann ich vergleichen, wenn zwei JSON-Strukturen in Scala identisch sind?

Zum Beispiel, wenn ich habe:

{ 
    resultCount: 1, 
    results: [ 
    { 
     artistId: 331764459, 
     collectionId: 780609005 
    } 
    ] 
} 

und

{ 
    results: [ 
    { 
     collectionId: 780609005, 
     artistId: 331764459 
    } 
    ], 
    resultCount: 1 
} 

Sie sollten

Answer 1

Sie gleich betrachtet werden sollte der Lage sein, einfach zu tun json1 == json2, wenn die json Bibliotheken sind richtig geschrieben. Funktioniert das nicht für dich?

Dies ist mit spray-json, obwohl ich das gleiche von jeder json Bibliothek erwarten:

import spray.json._ 
import DefaultJsonProtocol._ 
Welcome to Scala version 2.10.4 (OpenJDK 64-Bit Server VM, Java 1.7.0_51). 
Type in expressions to have them evaluated. 
Type :help for more information. 

scala> val json1 = """{ "a": 1, "b": [ { "c":2, "d":3 } ] }""".parseJson 
json1: spray.json.JsValue = {"a":1,"b":[{"c":2,"d":3}]} 

scala> val json2 = """{ "b": [ { "d":3, "c":2 } ], "a": 1 }""".parseJson 
json2: spray.json.JsValue = {"b":[{"d":3,"c":2}],"a":1} 

scala> json1 == json2 
res1: Boolean = true 

Spray-json verwendet ein unveränderliches scala Map ein JSON-Objekt in dem abstrakten Syntaxbaum aus einem Parse resultierenden darstellen, Es ist also nur Map Gleichheits Semantik, die diese Arbeit machen.

Answer 2

Der Aufruf der Methode compare_2Json(str1,str2) gibt einen booleschen Wert zurück. Bitte stellen Sie sicher, dass die beiden String-Parameter json sind. Willkommen zu verwenden und zu testen.

 def compare_2Json(js1:String,js2:String): Boolean = { 
     var js_str1 = js1 
     var js_str2 = js2 

     js_str1=js_str1.replaceAll(" ","") 
     js_str2=js_str2.replaceAll(" ","") 
     var issame = false 
     val arrbuff1 = ArrayBuffer[String]() 
     val arrbuff2 = ArrayBuffer[String]() 
     if(js_str1.substring(0,1)=="{" && js_str2.substring(0,1)=="{" || js_str1.substring(0,1)=="["&&js_str2.substring(0,1)=="["){ 
      for(small_js1 <- split_JsonintoSmall(js_str1);small_js2 <- split_JsonintoSmall((js_str2))) { 
      issame = compare_2Json(small_js1,small_js2) 
      if(issame == true){ 
       js_str1 = js_str1.substring(0,js_str1.indexOf(small_js1))+js_str1.substring(js_str1.indexOf(small_js1)+small_js1.length) 
       js_str2 = js_str2.substring(0,js_str2.indexOf(small_js2))+js_str2.substring(js_str2.indexOf(small_js2)+small_js2.length) 
      } 
      } 
      js_str1 = js_str1.substring(1,js_str1.length-1) 
      js_str2 = js_str2.substring(1,js_str2.length-1) 

      for(str_js1 <- js_str1.split(","); str_js2 <- js_str2.split(",")){ 
      if(str_js1!="" && str_js2!="") 
       if(str_js1 == str_js2){ 
       js_str1 = js_str1.substring(0,js_str1.indexOf(str_js1))+js_str1.substring(js_str1.indexOf(str_js1)+str_js1.length) 
       js_str2 = js_str2.substring(0,js_str2.indexOf(str_js2))+js_str2.substring(js_str2.indexOf(str_js2)+str_js2.length) 
       } 
      } 
      js_str1=js_str1.replace(",","") 
      js_str2=js_str2.replace(",","") 

      if(js_str1==""&&js_str2=="")return true 
      else return false 
     } 
     else return false 
     } 

     def split_JsonintoSmall(js_str: String):ArrayBuffer[String]={ 
     val arrbuff = ArrayBuffer[String]() 

     var json_str = js_str 
     while(json_str.indexOf("{",1)>0 || json_str.indexOf("[",1)>0){ 
      if (json_str.indexOf("{", 1) < json_str.indexOf("[", 1) && json_str.indexOf("{",1)>0 || json_str.indexOf("{", 1) > json_str.indexOf("[", 1) && json_str.indexOf("[",1)<0) { 
      val right = findrealm(1, json_str, '{', '}') 
      arrbuff += json_str.substring(json_str.indexOf("{", 1), right + 1) 
      json_str = json_str.substring(0,json_str.indexOf("{",1))+json_str.substring(right+1) 
      } 
      else { 
      if(json_str.indexOf("[",1)>0) { 
       val right = findrealm(1, json_str, '[', ']') 
       arrbuff += json_str.substring(json_str.indexOf("[", 1), right + 1) 
       json_str = json_str.substring(0, json_str.indexOf("[", 1)) + json_str.substring(right + 1) 
      } 
      } 
     } 
     arrbuff 
     } 

    def findrealm(begin_loc: Int, str: String, leftch: Char, rightch: Char): Int = { 
    var left = str.indexOf(leftch, begin_loc) 
    var right = str.indexOf(rightch, left) 
    left = str.indexOf(leftch, left + 1) 
    while (left < right && left > 0) { 
     right = str.indexOf(rightch, right + 1) 
     left = str.indexOf(leftch, left + 1) 
    } 
    right 
    } 

Answer 3

spray-json ist auf jeden Fall groß, aber ich benutze Gson da ich bereits die Abhängigkeit von Gson Bibliothek auf meinem Projekt hatte. Ich benutze diese in meinen Unit-Tests, funktioniert gut für einfache JSON.

import com.google.gson.{JsonParser} 
import org.apache.flume.event.JSONEvent 
import org.scalatest.FunSuite 

class LogEnricherSpec extends FunSuite { 
    test("compares json to json") { 

    val parser = new JsonParser() 

    assert(parser.parse(""" 
     { 
      "eventType" : "TransferItems", 
      "timeMillis" : "1234567890", 
      "messageXml":{ 
      "TransferId" : 123456 
      } 
     } """.stripMargin) 
     == 
     parser.parse(""" 
     { 
      "timeMillis" : "1234567890", 
      "eventType" : "TransferItems", 
      "messageXml":{ 
      "TransferId" : 123456 
      } 
     } 
     """.stripMargin)) 
}