play - ¿Cuál es la forma más sencilla de analizar JSON en Scala?

playframework ws

Question

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?

Answer 1

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:

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)
}

sphere-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)
}

argonaut

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)
}

circe

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?

Answer 2

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] 

Más ejemplos: https://github.com/lift/lift/blob/master/framework/lift-base/lift-json/src/test/scala/net/liftweb/json/ExtractionExamples.scala

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)))