universitaria - Scala 2.10, su impacto en las bibliotecas JSON y la creación/validación de clases de casos

formato json ejemplo

Question

En Scala 2.10 aparentemente estamos mejorando la reflexión.

¿Cómo afectará esto a lift-json, jerkson, sjson y amigos? Además, ¿podemos esperar en un futuro no muy lejano un lenguaje JSON incorporado en el excelente GSON de la Groovy en Scala?

La razón por la que pregunto es que me encantaría hacer:

case class Foo(a: String, b: Int, bar: Bar)
case class Bar(c: Int)
val foo = Foo("hey", 10, Bar(23))
val json = foo.toJson

sin saltos de aro (es decir, trabajo de preparación de calderas), incluso con gráficos de objetos arbitrariamente complejos. Tal vez estoy pidiendo demasiado, pero uno siempre puede soñar. Rompa mis sueños de 2.10 o ilumíneme sobre qué nuevas vías se están abriendo con el lanzamiento tan esperado de Scala.

Además, en lo que respecta a las clases de casos, parece que para la validación / creación, la validación de Scalaz es el arma de elección. Parece bastante maravilloso, actuando como un proxy seguro para la creación de objetos o como un recolector de errores. Como Scewbie, sin embargo, encuentro a Scalaz un tanto desafiante, y estoy resistiendo el lado oscuro de Fing a pesar de su poder obvio ;-)

En cualquier caso, el punto aquí es que, con la reflexión 2.10, deberíamos poder vincular en tiempo de ejecución los campos, por ejemplo, una publicación de formulario, a las propiedades de una clase de caso y realizar una validación básica basada únicamente en el tipo de propiedad (es decir, no tendrá para especificar una lógica de validación separada que especifique que la propiedad foo debe ser una cadena, ya que su tipo ya está definido en la clase de caso en la que ahora podemos reflejar correctamente)

Entonces, ¿viene un nuevo mundo valiente o las herramientas existentes son el pilar del futuro previsible?

Answer 1

Prólogo

Permítame darle una solución diferente que no se basa en ninguna biblioteca basada en Java, sino solo en una Scala pura.

En realidad, como se comentó en los comentarios de los resultados de @ Steve, la versión scala de Play 2 estaba usando Jerkson para des / serializar a Json al modelo de dominio. Donde Jerkson es una envoltura DSL alrededor de una biblioteca Java muy buena para manejar Json.

Responder

¡Lo anterior no respondía a tu pregunta, ya que estabas preguntando si se había imaginado utilizar la reflexión y las características macro de Scala 2.10 para facilitar esta tarea! Al eliminar la mayoría de los calderos.

Y fue una muy buena idea, de hecho, porque desde la versión Play 2.1, la API de Json Scala ya no usa Jerkson sino su propio mecanismo.

De hecho, este mecanismo está aprovechando las ventajas de esta nueva versión 2.10 de Scala al introducir una nueva API basada en dos cosas:

• una construcción funcional (Applicative Builder) adaptada para poder leer y escribir instancias Json o Domain. Estos constructores se utilizan para pegar combinadores en conjunto (tanto para lectura como para escribir) para definir estructuras de grano grueso (como hacemos con los combinadores de analizadores)
• un grupo de macros que son capaces de descubrir qué combinadores están implícitamente disponibles y construirán complejos para las Clases de Casos (o al menos los tipos que tienen métodos de apply y no unapply ).

Al final del día, esto es lo que podríamos hacer usando esta API:

import play.api.libs.json._
import play.api.libs.functional.syntax._
case class Person(name: String, age: Int, lovesChocolate: Boolean)
implicit val personReads = Json.format[Person] //a format is a Reader and a Writer
//this format will be implicitly used by the following from/toJson functions
val person:JsResult[Person] = Json.fromJson(json) //JsResult is like JsSucces/JsError
val jsObject = Json.toJson(person)

Código copiado y adaptado de: JSON Inception (basado en macros Scala 2.10)

Una pequeña nota: la nueva API es lo suficientemente inteligente como para poder validar una "lectura" acumulando errores ...

Referencias

Hay una serie de blogs de @mandubian que recomendaría desde aquí, ¡porque son muy ilustrativos!

• JsPath & Reads Combinators: http://mandubian.com/2012/09/08/unveiling-play-2-dot-1-json-api-part1-jspath-reads-combinators/
• Combinadores de escrituras / formatos: http://mandubian.com/2012/10/01/unveiling-play-2-dot-1-json-api-part2-writes-format-combinators/
• JSON Transformers: http://mandubian.com/2012/10/29/unveiling-play-2-dot-1-json-api-part3-json-transformers/
• JSON Inception (Basado en macros de Scala 2.10): http://mandubian.com/2012/11/11/JSON-inception/

Nota final

Lo que es triste es que la modularización de Play 2 ... ¡no nos permite usar esta API sola! Por lo tanto, debe usarse desde el juego lib como un todo: / Esto podría cambiar en el futuro ...

EDITAR

Y el futuro se está acercando ahora, ya que Pascal tiene este repo que nos permite usar la API play-json.

Entonces, uno puede usar este repositorio hasta que se lance Play 2.2. De hecho, esta versión se desacoplará por completo con varias API como json o iteratees y, por lo tanto, podremos usar el repositorio playframework directamente.

Answer 2

Hice una publicación de blog sobre eso, échale un vistazo a http://pedrorijo.com/blog/scala-json/

Usando clases de casos, y Play WS (ya incluido en Play Framework), puede convertir casos entre json y clases de casos con un simple implícito de una línea.

case class User(username: String, friends: Int, enemies: Int, isAlive: Boolean)
object User {
implicit val userJsonFormat = Json.format[User]
}

Answer 3

Jerkson encarga de su caso de uso hoy!

Json.generate(foo)

También es compatible con las lecturas y escrituras de transmisión que utilizamos ampliamente en la producción.

Json.generate(foo, outputStream)
Json.parse[Foo](inputStream)

Originalmente utilizamos lift-json, pero su falta de soporte de transmisión por secuencias para las clases de casos lo hacía inutilizable para leer y escribir grandes documentos json. Jerkson también es súper rápido y maneja perfectamente las clases de casos anidados.