una - Serialización y deserialización de Scala 2.10+Json
serializar y deserializar json c# (5)
Ahora hay un tenedor de Jerkson que admite Scala 2.10 en https://github.com/randhindi/jerkson .
Scala 2.10 parece haber roto algunas de las bibliotecas antiguas (al menos por el momento) como Jerkson y lift-json.
La usabilidad del objetivo es la siguiente:
case class Person(name: String, height: String, attributes: Map[String, String], friends: List[String])
//to serialize
val person = Person("Name", ....)
val json = serialize(person)
//to deserialize
val sameperson = deserialize[Person](json)
Pero estoy teniendo problemas para encontrar buenas formas existentes de generar y deserializar Json que funcionen con Scala 2.10.
¿Hay formas de mejores prácticas para hacer esto en Scala 2.10?
Entonces, basado en la ausencia de un mensaje de error y el código de muestra incorrecto, sospecho que esto es más un problema de simplemente no entender cómo funciona la extracción de lift-json. Si he entendido mal, comenta y avísame. Entonces, si estoy en lo cierto, esto es lo que necesitas.
Para serializar:
import net.liftweb.json._
import Extraction._
implicit val formats = DefaultFormats
case class Person(...)
val person = Person(...)
val personJson = decompose(person) // Results in a JValue
Luego, para invertir el proceso, harías algo como:
// Person Json is a JValue here.
personJson.extract[Person]
Si esa no es la parte con la que estás teniendo problemas, házmelo saber y puedo tratar de revisar mi respuesta para ser más útil.
Puedo recomendar encarecidamente argonaut para apoyo json en Scala. Todo lo que necesita para configurarlo para serializar su objeto Cliente es una línea:
implicit lazy val CodecCustomer: CodecJson[Customer] =
casecodec6(Customer.apply, Customer.unapply)("id","name","address","city","state","user_id")
Eso dominará a tu clase para darle un método .asJson que lo convierta en una cadena. También introducirá la clase de cadena para darle un método .decodeOption[List[Customer]] para analizar las cadenas. Maneja bien las opciones en su clase. Aquí hay una clase trabajadora con una prueba de aprobación y un método principal en ejecución que puedes colocar en un clon git de argonauta para ver si todo funciona bien:
package argonaut.example
import org.specs2.{ScalaCheck, Specification}
import argonaut.CodecJson
import argonaut.Argonaut._
case class Customer(id: Int, name: String, address: Option[String],
city: Option[String], state: Option[String], user_id: Int)
class CustomerExample extends Specification with ScalaCheck {
import CustomerExample.CodecCustomer
import CustomerExample.customers
def is = " question 12591457 example" ^
"round trip customers to and from json strings " ! {
customers.asJson.as[List[Customer]].toOption must beSome(customers)
}
}
object CustomerExample {
implicit lazy val CodecCustomer: CodecJson[Customer] =
casecodec6(Customer.apply, Customer.unapply)("id","name","address","city","state","user_id")
val customers = List(
Customer(1,"one",Some("one street"),Some("one city"),Some("one state"),1)
, Customer(2,"two",None,Some("two city"),Some("two state"),2)
, Customer(3,"three",Some("three address"),None,Some("three state"),3)
, Customer(4,"four",Some("four address"),Some("four city"),None,4)
)
def main(args: Array[String]): Unit = {
println(s"Customers converted into json string:/n ${customers.asJson}")
val jsonString =
"""[
| {"city":"one city","name":"one","state":"one state","user_id":1,"id":1,"address":"one street"}
| ,{"city":"two city","name":"two","state":"two state","user_id":2,"id":2}
| ,{"name":"three","state":"three state","user_id":3,"id":3,"address":"three address"}
| ,{"city":"four city","name":"four","user_id":4,"id":4,"address":"four address"}
|]""".stripMargin
var parsed: Option[List[Customer]] = jsonString.decodeOption[List[Customer]]
println(s"Json string turned back into customers:/n ${parsed.get}")
}
}
Los desarrolladores también son útiles y receptivos con la gente que está comenzando.
Jackson es una biblioteca de Java para procesar JSON rápidamente. El proyecto de Jerkson envuelve a Jackson, pero parece estar abandonado. Cambié al Módulo Scala de Jackson para serialización y deserialización a estructuras de datos nativas de Scala.
Para obtenerlo, incluye lo siguiente en tu build.sbt :
libraryDependencies ++= Seq(
"com.fasterxml.jackson.module" %% "jackson-module-scala" % "2.1.3",
...
)
Entonces sus ejemplos funcionarán literalmente con el siguiente envoltorio de Jackson (lo extraje de los archivos de prueba de jackson-module-scala):
import java.lang.reflect.{Type, ParameterizedType}
import com.fasterxml.jackson.databind.ObjectMapper
import com.fasterxml.jackson.module.scala.DefaultScalaModule
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.core.`type`.TypeReference;
object JacksonWrapper {
val mapper = new ObjectMapper()
mapper.registerModule(DefaultScalaModule)
def serialize(value: Any): String = {
import java.io.StringWriter
val writer = new StringWriter()
mapper.writeValue(writer, value)
writer.toString
}
def deserialize[T: Manifest](value: String) : T =
mapper.readValue(value, typeReference[T])
private [this] def typeReference[T: Manifest] = new TypeReference[T] {
override def getType = typeFromManifest(manifest[T])
}
private [this] def typeFromManifest(m: Manifest[_]): Type = {
if (m.typeArguments.isEmpty) { m.erasure }
else new ParameterizedType {
def getRawType = m.erasure
def getActualTypeArguments = m.typeArguments.map(typeFromManifest).toArray
def getOwnerType = null
}
}
}
Otras opciones de Scala 2.10 JSON incluyen el scala-json Twitter basado en el libro Programming Scala: es simple, a costa del rendimiento. También hay spray-json , que usa parboiled para analizar. Finalmente, el manejo JSON de Play se ve bien, pero no se desacopla fácilmente del proyecto Play.