Quelle est la façon la plus simple de parser JSON à Scala?

je travaille sur une application web simple avec Scala. Le plan est d'obtenir des données JSON d'une API externe, et de les insérer dans un modèle (malheureusement, l'obtention des données en XML n'est pas une option).

j'ai essayé de travailler avec la bibliothèque scala-json de Twitter, mais je n'arrive pas à le compiler correctement (le code sur github ne se met pas à jour dans sbt, disant standard-project 7.10 n'est pas disponible et je ne l'ai pas encore résolu).

lift-json semble impressionnant, mais semble être beaucoup plus élaboré que j'ai besoin maintenant.

essayer d'importer une bibliothèque avec laquelle j'ai travaillé en Java, jsonic, entraîne diverses erreurs d'arcane. C'est dommage parce que j'aime plutôt comment jsonic est simple.

j'ai fait un peu de progrès avec le construit en scala.util.parsing.json.JSON, mais je ne sais pas comment accéder aux éléments. Je suis un peu nouveau à Scala, comme vous avez pu le noter. Comment avez-vous accès les propriétés de JSONObjects?

scala.util.parsing.json.JSON a beaucoup d'informations, mais est-il un simple tutoriel sur la façon de l'utiliser n'importe où?

Je ne suis vraiment intéressé par la desérialisation de JSON qu'en ce moment, à L'envers, aux cordes, aux cartes et aux listes. Je n'ai pas besoin de sérialiser les objets ou de faire entrer les objets désérialisés dans une classe pour le moment.

est-ce que quelqu'un peut me montrer comment travailler avec l'une des bibliothèques mentionnées ci-dessus, ou m'aider à me mettre en place avec une bibliothèque Java qui fera ce que je veux?

17
demandé sur Mario Galic 2010-11-13 00:24:29

2 réponses

Lift JSON fournit plusieurs styles différents de deserializing JSON. Chacun ont leurs avantages et leurs inconvénients.

val json = JsonParser.parse(""" { "foo": { "bar": 10 }} """)

LINQ style query understanding:

scala> for { JField("bar", JInt(x)) <- json } yield x 

res0: List[BigInt] = List(10)

autres exemples: http://github.com/lift/lift/blob/master/framework/lift-base/lift-json/src/test/scala/net/liftweb/json/QueryExamples.scala

Extraire des valeurs avec des classes de cas

implicit val formats = net.liftweb.json.DefaultFormats 
case class Foo(foo: Bar) 
case class Bar(bar: Int) 
json.extract[Foo] 

autres exemples: https://github.com/lift/lift/blob/master/framework/lift-base/lift-json/src/test/scala/net/liftweb/json/ExtractionExamples.scala

XPath style

scala> val JInt(x) = json \ "foo" \ "bar"

x: BigInt = 10

Non-type des valeurs sûres

scala> json.values

res0: Map((foo,Map(bar -> 10)))
31
répondu Joni 2011-06-06 04:54:25

Voici des exemples rapides de la desérialisation de la chaîne brute JSON en modèle de classe de cas pour différentes bibliothèques JSON Scala:

play-JSON

import play.api.libs.json._

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

object User {
  implicit val codec = Json.format[User]
}

object PlayJson extends App {
  val string = """{"id": 124, "name": "John"}"""
  val json = Json.parse(string)
  val user = json.as[User]
  println(user)
}

lift-json

import net.liftweb.json._

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

object LiftJson extends App {
  implicit val codec = DefaultFormats
  val string = """{"id": 124, "name": "John"}"""
  val json = parse(string)
  val user = json.extract[User]
  println(user)
}

spray-json

import spray.json._
import DefaultJsonProtocol._

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

object UserJsonProtocol extends DefaultJsonProtocol {
  implicit val codec = jsonFormat2(User)
}

object SprayJson extends App {
  import UserJsonProtocol._
  val string = """{"id": 124, "name": "John"}"""
  val json = string.parseJson
  val user = json.convertTo[User]
  println(user)
}

sphère-json

import io.sphere.json.generic._
import io.sphere.json._

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

object SphereJson extends App {
  implicit val codec = deriveJSON[User]
  val string = """{"id": 124, "name": "John"}"""
  val user = fromJSON[User](string)
  println(user)
}

Argonaute

import argonaut._ 
import Argonaut._

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

object ArgonautJson extends App {
  implicit def codec = casecodec2(User.apply, User.unapply)("id", "name")
  val string = """{"id": 124, "name": "John"}"""
  val user = string.decodeOption[User]
  println(user)
}

circé

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

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

object CirceJson extends App {
  val string = """{"id": 124, "name": "John"}"""
  val user = decode[User](string)
  println(user)
}

voici les dépendances pour les exemples ci-dessus:

resolvers += Resolver.bintrayRepo("commercetools", "maven")

libraryDependencies ++= Seq(

  "com.typesafe.play" %% "play-json"      % "2.6.7",
  "net.liftweb"       %% "lift-json"      % "3.1.1",
  "io.spray"          %% "spray-json"     % "1.3.3",
  "io.sphere"         %% "sphere-json"    % "0.9.0",
  "io.argonaut"       %% "argonaut"       % "6.2",
  "io.circe"          %% "circe-core"     % "0.8.0",
  "io.circe"          %% "circe-generic"  % "0.8.0",
  "io.circe"          %% "circe-parser"   % "0.8.0"
)

ce billet a été inspiré par l'article suivant: une visite rapide des bibliothèques JSON à Scala

ainsi question liée: quelle bibliothèque JSON utiliser dans Scala?

0
répondu Mario Galic 2017-11-02 21:42:37