Scala Language => JSON

JSON स्प्रे-json के साथ

JSON के साथ काम करने के लिए स्प्रे-जसन एक आसान तरीका प्रदान करता है। निहित स्वरूपों का उपयोग करते हुए, सब कुछ "पर्दे के पीछे" होता है:

लाइब्रेरी को एसबीटी के साथ उपलब्ध कराएं

एसबीटी प्रबंधित पुस्तकालय निर्भरता के साथ spray-json का प्रबंधन करने के लिए:

libraryDependencies += "io.spray" %% "spray-json" % "1.3.2"

ध्यान दें कि अंतिम पैरामीटर, संस्करण संख्या ( 1.3.2 ), विभिन्न परियोजनाओं में भिन्न हो सकती है।

spray-json लाइब्रेरी repo.spray.io पर होस्ट की गई है ।

पुस्तकालय आयात करें

import spray.json._
import DefaultJsonProtocol._

डिफ़ॉल्ट JSON प्रोटोकॉल DefaultJsonProtocol में सभी बुनियादी प्रकारों के प्रारूप हैं। कस्टम प्रकार के लिए JSON कार्यक्षमता प्रदान करने के लिए, या तो प्रारूपों के लिए सुविधा बिल्डरों का उपयोग करें या स्पष्ट रूप से प्रारूप लिखें।

JSON पढ़ें

// generates an intermediate JSON representation (abstract syntax tree)
val res = """{ "foo": "bar" }""".parseJson // JsValue = {"foo":"bar"}

res.convertTo[Map[String, String]] // Map(foo -> bar)

JSON लिखें

val values = List("a", "b", "c")
values.toJson.prettyPrint // ["a", "b", "c"]

डीएसएल

DSL समर्थित नहीं है।

पढ़ें- केस क्लासेस को लिखें

निम्न उदाहरण दिखाता है कि JSON प्रारूप में केस क्लास ऑब्जेक्ट को कैसे क्रमांकित किया जाए।

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

// create the formats and provide them implicitly
implicit val addressFormat = jsonFormat2(Address)
implicit val personFormat = jsonFormat2(Person)

// serialize a Person
Person("Fred", Address("Awesome Street 9", "SuperCity"))
val fredJsonString = fred.toJson.prettyPrint

इसका परिणाम निम्न JSON में मिलता है:

{
  "name": "Fred",
  "address": {
    "street": "Awesome Street 9",
    "city": "SuperCity"
  }
}

वह JSON, बदले में, वस्तु में वापस deserialized हो सकता है:

val personRead = fredJsonString.parseJson.convertTo[Person] 
//Person(Fred,Address(Awesome Street 9,SuperCity))

कस्टम प्रारूप

एक कस्टम JsonFormat लिखें यदि एक प्रकार का विशेष क्रमांकन आवश्यक है। उदाहरण के लिए, यदि फ़ील्ड नाम JSON की तुलना में स्काला में भिन्न हैं। या, यदि इनपुट के आधार पर विभिन्न ठोस प्रकारों को त्वरित किया जाता है।

implicit object BetterPersonFormat extends JsonFormat[Person] {
    // deserialization code
    override def read(json: JsValue): Person = {
        val fields = json.asJsObject("Person object expected").fields
        Person(
            name = fields("name").convertTo[String],
            address = fields("home").convertTo[Address]
        )
    }

    // serialization code
    override def write(person: Person): JsValue = JsObject(
        "name" -> person.name.toJson,
        "home" -> person.address.toJson
    )
}

CSONce के साथ JSON

Circe केस कक्षाओं में en / decode json के लिए संकलन-समय व्युत्पन्न कोडेक्स प्रदान करता है। एक साधारण उदाहरण इस तरह दिखता है:

import io.circe._
import io.circe.generic.auto._
import io.circe.parser._
import io.circe.syntax._

case class User(id: Long, name: String)

val user = User(1, "John Doe")

// {"id":1,"name":"John Doe"}
val json = user.asJson.noSpaces

// Right(User(1L, "John Doe"))
val res: Either[Error, User] = decode[User](json)

प्ले-ज्सन के साथ JSON

प्ले-जसन अन्य जॅसन फ्रेमवर्क के रूप में निहित स्वरूपों का उपयोग करता है

एसबीटी निर्भरता: libraryDependencies += ""com.typesafe.play" %% "play-json" % "2.4.8" निर्भरता libraryDependencies += ""com.typesafe.play" %% "play-json" % "2.4.8"

import play.api.libs.json._
import play.api.libs.functional.syntax._ // if you need DSL

DefaultFormat में सभी बुनियादी प्रकारों को पढ़ने / लिखने के लिए डिफॉल प्रारूप हैं। अपने स्वयं के प्रकारों के लिए JSON कार्यक्षमता प्रदान करने के लिए, आप या तो प्रारूपों के लिए सुविधा बिल्डरों का उपयोग कर सकते हैं या स्पष्ट रूप से प्रारूप लिख सकते हैं।

जोंस पढ़ो

// generates an intermediate JSON representation (abstract syntax tree)
val res = Json.parse("""{ "foo": "bar" }""") // JsValue = {"foo":"bar"}

res.as[Map[String, String]]                  // Map(foo -> bar)
res.validate[Map[String, String]]            //JsSuccess(Map(foo -> bar),)

जीसन लिखो

val values = List("a", "b", "c")
Json.stringify(Json.toJson(values))          // ["a", "b", "c"]

डीएसएल

val json = parse("""{ "foo": [{"foo": "bar"}]}""")
(json \ "foo").get                    //Simple path: [{"foo":"bar"}]
(json \\ "foo")                       //Recursive path:List([{"foo":"bar"}], "bar")
(json \ "foo")(0).get                  //Index lookup (for JsArrays): {"foo":"bar"}

जैसा कि हमेशा JsSuccess / JsError विरुद्ध मिलान करने वाले पैटर्न को JsSuccess JsError और .get , array(i) कॉल से बचने का प्रयास करें।

केस क्लास पढ़ें और लिखें

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

// create the formats and provide them implicitly
implicit val addressFormat = Json.format[Address]
implicit val personFormat = Json.format[Person]

// serialize a Person
val fred = Person("Fred", Address("Awesome Street 9", "SuperCity"))
val fredJsonString = Json.stringify(Json.toJson(Json.toJson(fred)))

val personRead = Json.parse(fredJsonString).as[Person] //Person(Fred,Address(Awesome Street 9,SuperCity))

खुद का प्रारूप

आप अपने खुद के JsonFormat लिख सकते हैं यदि आपको अपने प्रकार के एक विशेष क्रमांकन की आवश्यकता होती है (उदाहरण के लिए अलग-अलग क्षेत्रों को स्कैला में नाम दें और Json या इनपुट के आधार पर विभिन्न ठोस प्रकारों को तुरंत लिखें)

case class Address(street: String, city: String)

// create the formats and provide them implicitly
implicit object AddressFormatCustom extends Format[Address] {
  def reads(json: JsValue): JsResult[Address] = for {
    street <- (json \ "Street").validate[String]
    city <- (json \ "City").validate[String]
  } yield Address(street, city)

  def writes(x: Address): JsValue = Json.obj(
    "Street" -> x.street,
    "City" -> x.city
  )
}
// serialize an address
val address = Address("Awesome Street 9", "SuperCity")
val addressJsonString = Json.stringify(Json.toJson(Json.toJson(address)))
//{"Street":"Awesome Street 9","City":"SuperCity"}

val addressRead = Json.parse(addressJsonString).as[Address] 
//Address(Awesome Street 9,SuperCity)

विकल्प

अगर isAlive आपके केस क्लास फील्ड्स से बिल्कुल मेल नहीं खाता है (केस क्लास में is_alive बनाम is_alive in json):

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

object User {

  import play.api.libs.functional.syntax._
  import play.api.libs.json._

  implicit val userReads: Reads[User] = (
      (JsPath \ "username").read[String] and
      (JsPath \ "friends").read[Int] and
      (JsPath \ "enemies").read[Int] and
      (JsPath \ "is_alive").read[Boolean]
    ) (User.apply _)
}

वैकल्पिक क्षेत्रों के साथ Json

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

object User {

  import play.api.libs.functional.syntax._
  import play.api.libs.json._

  implicit val userReads: Reads[User] = (
      (JsPath \ "username").read[String] and
      (JsPath \ "friends").read[Int] and
      (JsPath \ "enemies").read[Int] and
      (JsPath \ "is_alive").readNullable[Boolean]
    ) (User.apply _)
}

Json से टाइमस्टैम्प पढ़ना

कल्पना कीजिए कि आपके पास एक Jix ऑब्जेक्ट है, एक यूनिक्स टाइमस्टैम्प क्षेत्र के साथ:

{
  "field": "example field",
  "date": 1459014762000
}

समाधान:

case class JsonExampleV1(field: String, date: DateTime)
object JsonExampleV1{
  implicit val r: Reads[JsonExampleV1] = (
    (__ \ "field").read[String] and
      (__ \ "date").read[DateTime](Reads.DefaultJodaDateReads)
    )(JsonExampleV1.apply _)
}

कस्टम केस क्लासेस पढ़ना

अब, यदि आप टाइप सेफ्टी के लिए अपने ऑब्जेक्ट आइडेंटिफ़ायर को लपेटते हैं, तो आपको इसमें मज़ा आएगा। निम्नलिखित json वस्तु देखें:

{
  "id": 91,
  "data": "Some data"
}

और इसी मामले वर्गों:

case class MyIdentifier(id: Long)

case class JsonExampleV2(id: MyIdentifier, data: String)

अब आपको बस आदिम प्रकार (लंबा) पढ़ने की जरूरत है, और अपने आइडेनियर के लिए मैप करें:

object JsonExampleV2 {
  implicit val r: Reads[JsonExampleV2] = (
      (__ \ "id").read[Long].map(MyIdentifier) and
    (__ \ "data").read[String]
    )(JsonExampleV2.apply _)
}

कोड https://github.com/pedrorijo91/scala-play-json-examples पर

JSON4s के साथ JSON

json4s अन्य json चौखटे के रूप में निहित स्वरूपों का उपयोग करता है।

SBT निर्भरता:

libraryDependencies += "org.json4s" %% "json4s-native" % "3.4.0"
//or
libraryDependencies += "org.json4s" %% "json4s-jackson" % "3.4.0"

आयात

import org.json4s.JsonDSL._
import org.json4s._
import org.json4s.native.JsonMethods._

implicit val formats = DefaultFormats

DefaultFormats में सभी बुनियादी प्रकारों को पढ़ने / लिखने के लिए डिफ़ॉल्ट प्रारूप हैं।

जोंस पढ़ो

// generates an intermediate JSON representation (abstract syntax tree)
val res = parse("""{ "foo": "bar" }""")           // JValue = {"foo":"bar"}
res.extract[Map[String, String]]                  // Map(foo -> bar)

जीसन लिखो

val values = List("a", "b", "c")
compact(render(values))         // ["a", "b", "c"]

डीएसएल

json \ "foo"       //Simple path: JArray(List(JObject(List((foo,JString(bar))))))
json \\ "foo"      //Recursive path: ~List([{"foo":"bar"}], "bar")
(json \ "foo")(0)  //Index lookup (for JsArrays): JObject(List((foo,JString(bar))))
("foo" -> "bar") ~ ("field" -> "value")    // {"foo":"bar","field":"value"}

केस क्लास पढ़ें और लिखें

import org.json4s.native.Serialization.{read, write}

case class Address(street: String, city: String)
val addressString = write(Address("Awesome stree", "Super city")) 
// {"street":"Awesome stree","city":"Super city"}

read[Address](addressString) // Address(Awesome stree,Super city)
//or
parse(addressString).extract[Address]

विषम सूची पढ़ें और लिखें

क्रमबद्ध करने और एक विषम (या बहुरूपी) सूची का वर्णन करने के लिए, विशिष्ट प्रकार के संकेत प्रदान करने की आवश्यकता है।

trait Location
case class Street(name: String) extends Location
case class City(name: String, zipcode: String) extends Location
case class Address(street: Street, city: City) extends Location
case class Locations (locations : List[Location])

implicit val formats = Serialization.formats(ShortTypeHints(List(classOf[Street], classOf[City], classOf[Address])))

val locationsString = write(Locations(Street("Lavelle Street"):: City("Super city","74658")))

read[Locations](locationsString)