play - ¿Cuál es la forma más sencilla de analizar JSON en Scala?
playframework ws (2)
Estos son ejemplos rápidos de deserialización de JSON de cadena sin procesar en el modelo de clase de caso para diferentes bibliotecas JSA de Scala:
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)
}
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)
}
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)
}
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)
}
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)
}
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)
}
Aquí están las dependencias para los ejemplos anteriores:
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"
)
Este post se inspiró en el siguiente artículo: Un recorrido rápido por las bibliotecas JSON en Scala
Pregunta SO relacionada: ¿Qué biblioteca JSON usar en Scala?
Estoy trabajando en una aplicación web simple con Scala. El plan es obtener datos JSON de una API externa e insertarlos en una plantilla (desafortunadamente, obtener los datos en XML no es una opción).
He intentado trabajar con la biblioteca scala-json de Twitter, pero no puedo compilarlo correctamente (el código en github no se actualiza en sbt, diciendo que standard-project 7.10 no está disponible y todavía no lo he resuelto. ).
lift-json se ve impresionante, pero parece ser mucho más elaborado de lo que necesito ahora.
Al intentar importar una biblioteca con la que he trabajado en Java, jsonic, se producen varios errores arcanos. Esto es muy malo porque me gusta lo sencillo que es jsonic.
He hecho un poco de progreso con el scala.util.parsing.json.JSON integrado, pero en realidad no puedo decir cómo acceder a los elementos. Soy algo nuevo en Scala, como habrás notado. ¿Cómo accedes a las propiedades de JSONObjects?
scala.util.parsing.json.JSON tiene mucha información, pero ¿hay un tutorial sencillo sobre cómo usar esto en cualquier lugar?
Estoy realmente solo interesado en deserializar JSON en este momento, a Ints, Strings, Maps y Lists. No tengo la necesidad de serializar objetos o hacer que los objetos deserializados encajen en una clase en este momento.
¿Alguien puede indicarme formas de trabajar con una de las bibliotecas mencionadas anteriormente, o ayudarme a configurarme con una biblioteca Java que haga lo que quiero?
Lift JSON proporciona varios estilos diferentes de deserialización de JSON. Cada uno tiene sus pros y sus contras.
val json = JsonParser.parse(""" { "foo": { "bar": 10 }} """)
Comprensión de consulta de estilo LINQ:
scala> for { JField("bar", JInt(x)) <- json } yield x
res0: List[BigInt] = List(10)
Más ejemplos: http://github.com/lift/lift/blob/master/framework/lift-base/lift-json/src/test/scala/net/liftweb/json/QueryExamples.scala
Extraer valores con clases de casos.
implicit val formats = net.liftweb.json.DefaultFormats
case class Foo(foo: Bar)
case class Bar(bar: Int)
json.extract[Foo]
Estilo XPath
scala> val JInt(x) = json / "foo" / "bar"
x: BigInt = 10
Valores seguros no tipográficos
scala> json.values
res0: Map((foo,Map(bar -> 10)))