स्कैन में JSON लाइब्रेरी का क्या उपयोग है? [बन्द है]


125

मुझे JSON स्ट्रिंग बनाने की आवश्यकता है, कुछ इस तरह से:

[
  { 'id': 1, 'name': 'John'},
  { 'id': 2, 'name': 'Dani'}
]

val jArray = JsArray();
jArray += (("id", "1"), ("name", "John"))
jArray += (("id", "2"), ("name", "Dani"))
println(jArray.dump)

मैं करने के लिए पंक्तियों को जोड़ने में सक्षम होने की जरूरत है jArray, कुछ इस तरहjArray += ...

इसके लिए निकटतम पुस्तकालय / समाधान क्या है?


जवाबों:


219

दुर्भाग्य से एक JSON लाइब्रेरी लिखना टोला सूची ऐप को कोड करने के लिए स्काला समुदाय का संस्करण है।

काफी सारे विकल्प हैं। मैं उन्हें नोटों के साथ किसी विशेष क्रम में सूचीबद्ध नहीं करता:

  1. parsing.json.JSON - चेतावनी यह लाइब्रेरी केवल स्केल संस्करण 2.9.x तक उपलब्ध है (नए संस्करणों में हटा दी गई है)
  2. स्प्रे- json - स्प्रे प्रोजेक्ट से निकाला गया
  3. जेरक्सन ks - एक अच्छी लाइब्रेरी (जावा जैक्सन के शीर्ष पर निर्मित) को चेतावनी दें, लेकिन अब परित्यक्त। यदि आप इसका उपयोग करने जा रहे हैं, तो शायद स्केलिंग प्रोजेक्ट के उदाहरण का अनुसरण करें और backchat.io कांटा का उपयोग करें
  4. sjson - देबाशीष घोष द्वारा
  5. Lif -json - लिफ्ट परियोजना से अलग से इस्तेमाल किया जा सकता है
  6. json4s 💣 § ± - लिफ्ट json, एक मानक JSON एएसटी जो अन्य JSON पुस्तकालयों का उपयोग कर सकते हैं बनाने के लिए प्रयास कर रहा है, जो एक निष्कर्षण। एक जैक्सन समर्थित कार्यान्वयन शामिल है
  7. Argonaut 💣 § - एक एफपी उन्मुख JSON स्काला के लिए पुस्तकालय, Scalaz के पीछे लोगों से
  8. play-json Now - अब उपलब्ध स्टैंडअलोन, विवरण के लिए यह उत्तर देखें
  9. dijon - एक आसान, सुरक्षित और कुशल JSON लाइब्रेरी, हुड के नीचे jsoniter-scala का उपयोग करती है।
  10. sonofjson - JSON लाइब्रेरी एक सुपर- सिम्पल API के लिए लक्ष्य करती है
  11. जौन - जैक्सन पुस्तकालय एरिक ओसिम द्वारा जैक्सन-या-तेज गति के लिए लक्ष्य
  12. Rapture JSON ± - एक JSON फ्रंट-एंड जो 2, 4, 5, 6, 7, 11 या जैक्सन का उपयोग बैक-एंड कर सकता है
  13. circe ir - अर्गोनॉट का कांटा, जो खोपड़ी के बजाय बिल्लियों के ऊपर बनाया गया था
  14. jsoniter-scala - अल्ट्रा-फास्ट JSON कोडेक्स के संकलन-समय पीढ़ी के लिए स्काला मैक्रो
  15. जैक्सन-मॉड्यूल-स्काला - जैक्सन के लिए स्काला-विशिष्ट डेटाैटिप्स का समर्थन करने के लिए ऐड-ऑन मॉड्यूल
  16. बोरर - कुशल सीबीओआर और जेएसएन (डी) स्काला में क्रमबद्धता

💣 = ने सुरक्षा भेद्यता तय नहीं की है, 💣 = में स्कैल्ज़ एकीकरण है, inter = जैक्सन के साथ इंटरोप का समर्थन करता है JsonNode

में Snowplow हम जैक्सन पीठ के अंत के साथ json4s का उपयोग करें; हमें अरगोनाट के साथ भी अच्छे अनुभव थे।


8
यह सच नहीं है कि लिफ्ट-जसन को बड़े LIft प्रोजेक्ट के भीतर बांधा गया है, आप बस लिफ्ट-json पर निर्भर हो सकते हैं और लिफ्ट परियोजना से कुछ और आपके प्रोजेक्ट में नहीं आएगा।
fmpwizard

3
@AlexDean: parsing.json.JSON के बारे में इतना बुरा क्या है?
मथायस ब्रौन

ऐसा लगता है कि प्ले-
क्रिश्चियन

2
@BjornTipling - अच्छी बात है, 2.11 में अब इसका कोई उल्लेख नहीं किया जा सकता है। उस टिप्पणी को हटा दिया गया
एलेक्स डीन

2
सूची में शीर्ष पर जैकसन-मॉड्यूल-स्कैला होना चाहिए , जो प्रदर्शन, सादगी, रखरखाव और समर्थन के लिए सबसे अच्छा है।
गीतू

17

Lift-json 2.6 संस्करण में है और यह वास्तव में अच्छी तरह से काम करता है (और यह बहुत अच्छी तरह से समर्थित है, अनुचर किसी भी बग को ठीक करने के लिए हमेशा तैयार रहता है जो उपयोगकर्ताओं को मिल सकता है। आप github रिपॉजिटरी पर इसका उपयोग करके उदाहरण पा सकते हैं।

अनुरक्षक (जोनी फ्रीमैन) हमेशा लिफ्ट मेलिंग सूची पर उपलब्ध है। मेलिंग सूची में अन्य उपयोगकर्ता भी हैं जो बहुत उपयोगी हैं।

जैसा कि @Alexey बताते हैं, यदि आप अन्य स्कैला संस्करण के साथ पुस्तकालय का उपयोग करना चाहते हैं, तो कहिए 2.11.x, परिवर्तन scalaVersionऔर उपयोग %%निम्नानुसार है:

scalaVersion := "2.11.5" 

"net.liftweb" %% "lift-json" % "2.6"

समय बीतने के साथ नवीनतम संस्करण का पता लगाने के लिए आप Lifweb.net साइट की जांच कर सकते हैं ।


3
मैं लिफ्ट-जसन का भी उपयोग करता हूं और यह प्रतिज्ञा कर सकता हूं कि यह एक महान पुस्तकालय है। यह JSON को पार्स करने और उत्पन्न करने / बनाने दोनों को बहुत आसान बनाता है।
दान शमौन

1
+1 के लिए "net.liftweb"% "लिफ्ट-json_2.10"% "2.5.1"
डायलन होग

2
और स्कैला 2.11 के लिए: "net.liftweb"% "लिफ़्ट- json_2.11"% "2.6-M4"
एलेक्सी

15

मेरा सुझाव है कि जर्कसन का उपयोग करते हुए , यह सबसे बुनियादी प्रकार के रूपांतरणों का समर्थन करता है:

scala> import com.codahale.jerkson.Json._

scala> val l = List( 
                 Map( "id" -> 1, "name" -> "John" ),
                 Map( "id" -> 2, "name" -> "Dani")
               )

scala> generate( l )

res1: String = [{"id":1,"name":"John"},{"id":2,"name":"Dani"}]

2
इसमें केस क्लासेस के लिए कुछ बहुत ही बढ़िया समर्थन है जो कुछ बहुत ही सुंदर और टाइप-सुरक्षित JSON हैंडलिंग के लिए बना सकते हैं ।
थॉमस लॉकनी

9
इस पुस्तकालय को लेखक द्वारा छोड़ दिया गया है, क्या इसका कोई विकल्प है?
zjffdu

1
चलो rapture.io के बारे में नहीं भूलना चाहिए , जो " आईए / ओ, क्रिप्टोग्राफी और जेएसएन और एक्सएमएल प्रसंस्करण के साथ काम करने जैसे सामान्य प्रोग्रामिंग कार्यों के लिए सुंदर मुहावरेदार स्काला एपीआई प्रदान करने वाली स्काला लाइब्रेरी का परिवार है।"
पायो

12

सूची में नंबर 7 जैक्सन का उपयोग नहीं करते हुए जैक्सन है। इसमें स्काला ऑब्जेक्ट्स, (केस क्लासेस आदि) के लिए समर्थन है।

नीचे एक उदाहरण है कि मैं इसका उपयोग कैसे करता हूं।

object MyJacksonMapper extends JacksonMapper
val jsonString = MyJacksonMapper.serializeJson(myObject)
val myNewObject = MyJacksonMapper.deserializeJson[MyCaseClass](jsonString)

यह इसे बहुत सरल बनाता है। इसके अलावा XmlSerializer है और JAXB एनोटेशन के लिए समर्थन बहुत आसान है।

यह ब्लॉग पोस्ट बताता है कि इसका उपयोग JAXB एनोटेशन और प्ले फ्रेमवर्क के साथ किया जाता है।

http://krasserm.blogspot.co.uk/2012/02/using-jaxb-for-xml-and-json-apis-in.html

यहाँ मेरा वर्तमान जैक्सनमैपर है।

trait JacksonMapper {

  def jsonSerializer = {
    val m = new ObjectMapper()
    m.registerModule(DefaultScalaModule)
    m
  }

  def xmlSerializer = {
    val m = new XmlMapper()
    m.registerModule(DefaultScalaModule)
    m
  }

  def deserializeJson[T: Manifest](value: String): T = jsonSerializer.readValue(value, typeReference[T])
  def serializeJson(value: Any) = jsonSerializer.writerWithDefaultPrettyPrinter().writeValueAsString(value)
  def deserializeXml[T: Manifest](value: String): T = xmlSerializer.readValue(value, typeReference[T])
  def serializeXml(value: Any) = xmlSerializer.writeValueAsString(value)

  private[this] def typeReference[T: Manifest] = new TypeReference[T] {
    override def getType = typeFromManifest(manifest[T])
  }

  private[this] def typeFromManifest(m: Manifest[_]): Type = {
     if (m.typeArguments.isEmpty) { m.erasure }
     else new ParameterizedType {
       def getRawType = m.erasure

       def getActualTypeArguments = m.typeArguments.map(typeFromManifest).toArray

       def getOwnerType = null
     }
  }
}   

8

शायद मुझे थोड़ी देर हो गई है, लेकिन आपको वास्तव में प्ले फ्रेमवर्क से जसन लाइब्रेरी का उपयोग करने की कोशिश करनी चाहिए। आप दस्तावेज़ देख सकते हैं । वर्तमान 2.1.1 रिलीज में आप पूरे प्ले 2 के बिना अलग से इसका उपयोग नहीं कर सकते थे, इसलिए निर्भरता इस तरह दिखाई देगी:

val typesaferepo  = "TypeSafe Repo" at "http://repo.typesafe.com/typesafe/releases"
val play2 = "play" %% "play" % "2.1.1"

यह आपको बोर्ड पर सभी सामानों के साथ पूरे खेल की रूपरेखा लाएगा।

लेकिन जैसा कि मुझे पता है कि टाइपसेफ़ के लोग इसे 2.2 रिलीज में अलग करने की योजना बना रहे हैं। तो, 2.2-स्नैपशॉट से स्टैंडअलोन प्ले-जेन है।


2
: जानकारी के लिए: प्ले के JSON पुस्तकालय पहले से ही typesafe स्नैपशॉट में उपलब्ध रेपो है repo.typesafe.com/typesafe/snapshots/com/typesafe/play/...
Tvaroh

... आप जोड़ सकते हैं जो इतनी तरह
bluenote10

यह आधिकारिक तौर पर sbt ट्यूटोरियल
सर्व-इन

5

आपको गेंसन की जांच करानी चाहिए । यह सिर्फ काम करता है और स्काला में मौजूदा विकल्पों में से अधिकांश का उपयोग करना बहुत आसान है। यह तेज़ है, कुछ अन्य कामों (jodatime, json4s DOM api ...) के साथ कई विशेषताएं और एकीकरण हैं।

बिना किसी फैंसी कोड के जैसे बिना किसी काल्पनिक कोड के, कस्टम रीडर / बेसिक केस के लिए लेखक, ऑपरेटर ओवरलोड के कारण il अदृश्य एपीआई ...

इसका उपयोग करना उतना ही आसान है:

import com.owlike.genson.defaultGenson_

val json = toJson(Person(Some("foo"), 99))
val person = fromJson[Person]("""{"name": "foo", "age": 99}""")

case class Person(name: Option[String], age: Int)

डिस्क्लेमर: मैं गेंसन लेखक हूं, लेकिन ऐसा नहीं है कि मैं उद्देश्य नहीं हूं :)


बहुत अच्छा बांध, शर्म की बात है कि इसका एक मुद्दा है github.com/owlike/genson/issues/82
samthebest

5

यहाँ लेखन का मूल कार्यान्वयन है और फिर jsonफ़ाइल का उपयोग करके पढ़ना json4s

import org.json4s._
import org.json4s.jackson.JsonMethods._
import org.json4s.JsonDSL._
import java.io._
import scala.io.Source


object MyObject { def main(args: Array[String]) {

  val myMap = Map("a" -> List(3,4), "b" -> List(7,8))

  // writing a file 
  val jsonString = pretty(render(myMap))

  val pw = new PrintWriter(new File("my_json.json"))
  pw.write(jsonString)
  pw.close()

  // reading a file 
  val myString = Source.fromFile("my_json.json").mkString
  println(myString)

  val myJSON = parse(myString)

  println(myJSON)

  // Converting from JOjbect to plain object
  implicit val formats = DefaultFormats
  val myOldMap = myJSON.extract[Map[String, List[Int]]]

  println(myOldMap)
 }
}

4

Jala Scala में एक बहुत ही लचीली JSON पार्सर लाइब्रेरी है। यह कस्टम एएसटी की पीढ़ी को भी अनुमति देता है; आपको केवल एएसटी के नक्शे पर एक छोटे से लक्षण के साथ इसे आपूर्ति करने की आवश्यकता है।

एक हालिया प्रोजेक्ट के लिए बहुत अच्छा काम किया, जिसमें JSON पार्सिंग की थोड़ी जरूरत थी।


4

जवाबों की सूची में उत्साह गायब है। इसे http://rapture.io/ से प्राप्त किया जा सकता है और आपको (अन्य बातों के अलावा) की अनुमति देता है:

  • JSON बैक-एंड का चयन करें, जो बहुत उपयोगी है यदि आप पहले से ही एक का उपयोग करते हैं (आयात में)
  • अगर आप कोशिश, भविष्य, विकल्प, या तो, आदि के साथ काम करते हैं (यह भी आयात में) तय करें
  • कोड की एक पंक्ति में बहुत काम करते हैं।

मैं पृष्ठ से Rapture उदाहरणों को कॉपी / पेस्ट नहीं करना चाहता। Rapture की विशेषताओं के बारे में एक अच्छी प्रस्तुति जॉन प्रिटी ने SBTB 2014 में दी: https://www.youtube.com/watch?v=ka5-OLJgybI


3

@ AlaxDean के # 7 जवाब है, Argonaut केवल एक ही है कि मैं एसबीटी और IntelliJ साथ जल्दी से काम कर प्राप्त करने में सक्षम था। वास्तव में json4s में भी बहुत कम समय लगता है लेकिन कच्चे एएसटी के साथ काम करना वह नहीं है जो मैं चाहता था। मुझे अपनी बिल्ड.st में एक ही लाइन में काम करने के लिए अरगोनाट मिला:

libraryDependencies += "io.argonaut" %% "argonaut" % "6.0.1"

और फिर यह देखने के लिए एक सरल परीक्षण कि क्या मुझे JSON मिल सकता है:

package mytest


import scalaz._, Scalaz._
import argonaut._, Argonaut._

object Mytest extends App {

  val requestJson  =
    """
    {
      "userid": "1"
    }
    """.stripMargin

  val updatedJson: Option[Json] = for {
    parsed <- requestJson.parseOption
  } yield ("name", jString("testuser")) ->: parsed

  val obj = updatedJson.get.obj
  printf("Updated user: %s\n", updatedJson.toString())
  printf("obj : %s\n", obj.toString())
  printf("userid: %s\n", obj.get.toMap("userid"))
}

और तब

$ sbt
> run
Updated user: Some({"userid":"1","name":"testuser"})
obj : Some(object[("userid","1"),("name","testuser")])
userid: "1"

सुनिश्चित करें कि आप उस विकल्प से परिचित हैं जो सिर्फ एक मूल्य है जो शून्य भी हो सकता है (अशक्त सुरक्षित मेरा अनुमान है)। अर्गोनॉट स्कैलाज़ का उपयोग करता है, इसलिए यदि आप कुछ ऐसा देखते हैं जो आपको प्रतीक \/(या एक ऑपरेशन) की तरह समझ में नहीं आता है तो यह शायद स्कैलाज़ है।


2

आप यह कोशिश कर सकते हैं: https://github.com/momodi/Json4Scala

यह सरल है, और इसमें 300 लाइनों से कम कोड वाली केवल एक स्काला फ़ाइल है।

नमूने हैं:

test("base") {
    assert(Json.parse("123").asInt == 123)
    assert(Json.parse("-123").asInt == -123)
    assert(Json.parse("111111111111111").asLong == 111111111111111l)
    assert(Json.parse("true").asBoolean == true)
    assert(Json.parse("false").asBoolean == false)
    assert(Json.parse("123.123").asDouble == 123.123)
    assert(Json.parse("\"aaa\"").asString == "aaa")
    assert(Json.parse("\"aaa\"").write() == "\"aaa\"")

    val json = Json.Value(Map("a" -> Array(1,2,3), "b" -> Array(4, 5, 6)))
    assert(json("a")(0).asInt == 1)
    assert(json("b")(1).asInt == 5)
}
test("parse base") {
    val str =
        """
          {"int":-123, "long": 111111111111111, "string":"asdf", "bool_true": true, "foo":"foo", "bool_false": false}
        """
    val json = Json.parse(str)
    assert(json.asMap("int").asInt == -123)
    assert(json.asMap("long").asLong == 111111111111111l)
    assert(json.asMap("string").asString == "asdf")
    assert(json.asMap("bool_true").asBoolean == true)
    assert(json.asMap("bool_false").asBoolean == false)
    println(json.write())
    assert(json.write().length > 0)
}
test("parse obj") {
    val str =
        """
           {"asdf":[1,2,4,{"bbb":"ttt"},432]}
        """
    val json = Json.parse(str)
    assert(json.asMap("asdf").asArray(0).asInt == 1)
    assert(json.asMap("asdf").asArray(3).asMap("bbb").asString == "ttt")
}
test("parse array") {
    val str =
        """
           [1,2,3,4,{"a":[1,2,3]}]
        """
    val json = Json.parse(str)
    assert(json.asArray(0).asInt == 1)
    assert(json(4)("a")(2).asInt == 3)
    assert(json(4)("a")(2).isInt)
    assert(json(4)("a").isArray)
    assert(json(4)("a").isMap == false)
}
test("real") {
    val str = "{\"styles\":[214776380871671808,214783111085424640,214851869216866304,214829406537908224],\"group\":100,\"name\":\"AO4614【金宏达电子】现货库存 质量保证 欢迎购买@\",\"shopgrade\":8,\"price\":0.59,\"shop_id\":60095469,\"C3\":50018869,\"C2\":50024099,\"C1\":50008090,\"imguri\":\"http://img.geilicdn.com/taobao10000177139_425x360.jpg\",\"cag\":50006523,\"soldout\":0,\"C4\":50006523}"
    val json = Json.parse(str)
    println(json.write())
    assert(json.asMap.size > 0)
}

मुझे यह पसंद है - छोटे उपयोग के मामलों के लिए उत्कृष्ट - किसी भी पुस्तकालय की आवश्यकता नहीं है।
सामिक आर

2

मैं uPickle का उपयोग करता हूं जिसका बड़ा फायदा है कि यह नेस्टेड केस क्लासेस को स्वचालित रूप से हैंडल करेगा:

object SerializingApp extends App {

  case class Person(name: String, address: Address)

  case class Address(street: String, town: String, zipCode: String)

  import upickle.default._

  val john = Person("John Doe", Address("Elm Street 1", "Springfield", "ABC123"))

  val johnAsJson = write(john)
  // Prints {"name":"John Doe","address":{"street":"Elm Street 1","town":"Springfield","zipCode":"ABC123"}}
  Console.println(johnAsJson)

  // Parse the JSON back into a Scala object
  Console.println(read[Person](johnAsJson))  
}

build.sbtUPickle का उपयोग करने के लिए इसे अपने साथ जोड़ें :

libraryDependencies += "com.lihaoyi" %% "upickle" % "0.4.3"

0

मैं प्ले JSON लाइब्रेरी का उपयोग करता हूं आप केवल JSON लाइब्रेरी के लिए मावन रेपो पा सकते हैं यहां संपूर्ण रूपरेखा नहीं है

    val json = "com.typesafe.play" %% "play-json" % version
    val typesafe = "typesafe.com" at "http://repo.typesafe.com/typesafe/releases/"

उनका उपयोग कैसे करें, इसके बारे में एक बहुत अच्छा ट्यूटोरियल यहां उपलब्ध हैं:

http://mandubian.com/2012/09/08/unveiling-play-2-dot-1-json-api-part1-jspath-reads-combinators/

http://mandubian.com/2012/10/01/unveiling-play-2-dot-1-json-api-part2-writes-format-combinators/

http://mandubian.com/2012/10/29/unveiling-play-2-dot-1-json-api-part3-json-transformers/


JSON Play पहले से ही ऊपर उल्लेख किया गया था।
bluenote10

0

मैं आपको JSON संस्करण का पुत्र भी देता हूं :

import nl.typeset.sonofjson._

arr(
  obj(id = 1, name = "John)
  obj(id = 2, name = "Dani)
)

मैं इसका उपयोग करना पसंद करूंगा लेकिन यह नहीं समझ सकता कि इसे अपनी निर्भरता में कैसे जोड़ा जाए क्योंकि यह मावेन में नहीं है।
जेसन वोलोसोनोविच

0

Play फ्रेमवर्क, Play WS से स्वतंत्र रूप से JSON से निपटने के लिए इसके मॉड्यूल को प्ले करें

उस बारे में एक ब्लॉग पोस्ट बनाया, इसे http://pedrorijo.com/blog/scala-json/ पर देखें

केस कक्षाओं का उपयोग करना, और Play WS (पहले से ही Play फ्रेमवर्क में शामिल) आप केस को एक साधारण लाइनर के साथ जोंस और केस कक्षाओं के बीच परिवर्तित करते हैं।

case class User(username: String, friends: Int, enemies: Int, isAlive: Boolean)

object User {
  implicit val userJsonFormat = Json.format[User]
}
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.