Scala 2.10 + Json de sérialisation et de désérialisation

Jackson est une bibliothèque Java pour traiter JSON rapide. Le Jerkson projet enveloppements Jackson, mais semble être abandonnée. J'ai passé à Jackson Scala Module pour la sérialisation et la désérialisation natif Scala structures de données.

Pour l'obtenir, inclure les éléments suivants dans votre build.sbt:

libraryDependencies ++= Seq(
  "com.fasterxml.jackson.module" %% "jackson-module-scala" % "2.1.3",
   ...
)

Alors votre exemples de travail textuellement avec la suite de Jackson wrapper (j'ai extrait de jackson-module-scala fichiers de test):

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

D'autres Scala 2.10 JSON options incluent Twitter scala-json basé sur la Programmation Scala livre-c'est simple, au détriment des performances. Il est également spray-json, qui utilise étuvé pour l'analyse. Enfin, Jouer JSON manutention a l'air sympa, mais il n'est pas facile de dissocier de la pièce de projet.

Je peux vous recommander chaudement argonaut pour la prise en charge de json en scala. Tout ce que vous devez le configurer pour sérialiser vos Client de l'objet est une ligne:

implicit lazy val CodecCustomer: CodecJson[Customer] =
casecodec6(Customer.apply, Customer.unapply)("id","name","address","city","state","user_id")

Qui permettra de customiser votre classe pour lui donner un .asJson méthode qui le transforme en une chaîne de caractères. Il sera également pimp la classe string pour lui donner une méthode .decodeOption[List[Customer]] analyser les chaînes. Il gère les options de votre classe d'amende. Ici, c'est un travail de classe avec un test de passage et une méthode main qui vous pouvez vous déplacer dans un git clone de argonaut de voir que tout fonctionne 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 = "Stackoverflow 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}")
}
}

Les développeurs sont également utiles et adaptés pour les gens de commencer.

Sur la base de l'absence d'un message d'erreur et le mauvais exemple de code, je suis soupçonner c'est plus une question de juste ne pas comprendre comment l'ascenseur-json extraction des œuvres. Si j'ai mal compris, de faire un commentaire et laissez-moi savoir. Donc, si je suis à droite, puis voici ce que vous devez.

Pour sérialiser:

import net.liftweb.json._
import Extraction._
implicit val formats = DefaultFormats
case class Person(...)
val person = Person(...)
val personJson = decompose(person) //Results in a JValue

Puis d'inverser le processus, vous feriez quelque chose comme:

//Person Json is a JValue here.
personJson.extract[Person]

Si ce n'est pas la partie que vous êtes d'avoir des ennuis avec, alors faites-le moi savoir et je peux essayer de modifier ma réponse pour être plus utile.