Bruit gratuit format JSON pour les scellés des traits Jouer 2.2 bibliothèque

J'ai besoin d'obtenir un simple sérialisation JSON solution avec un minimum de cérémonie. J'ai donc été très heureux de trouver ce prochain Jeu 2.2 bibliothèque. Cela fonctionne parfaitement avec la plaine des classes de cas, par exemple,

import play.api.libs.json._

sealed trait Foo
case class Bar(i: Int) extends Foo
case class Baz(f: Float) extends Foo

implicit val barFmt = Json.format[Bar]
implicit val bazFmt = Json.format[Baz]

Mais la suivante échoue:

implicit val fooFmt = Json.format[Foo]   //"No unapply function found"

Comment puis-je configurer le prétendu manque d'extracteur pour Foo?

Ou voulez-vous recommander de toute autre bibliothèque autonome qui s'occupe de mon cas, plus ou moins complètement automatiquement? Je ne m'inquiète pas de savoir si c'est avec des macros au moment de la compilation ou de réflexion au moment de l'exécution, tant qu'il fonctionne hors de la boîte.

  • Est-il un code manquant? Est la seule chose que la définition de Foo la sealed trait Foo ligne? Qu'attendez-vous d'arriver, alors? Je suppose que Json.format pourrait fonctionner pour les classes ordinaires si elles ont un apply() et unapply() méthode.
  • Jouer json, ainsi que ascenseur json devrait être ok. Vous voyez, vous essayez d'obtenir un format d'un trait, mais presque toutes les bibliothèques qui fournissent des transparents de sérialisation sont basés sur les classes de cas. Juste en cas d'utilisation des classes et le pattern matching et vous devriez être bien.
  • J'ai besoin d'être en mesure de sérialiser les classes de type. Donc j'ai besoin d'un format pour un scellé trait qui est prolongée par un certain nombre de classes de cas. Devrait être assez scénario.
  • L'automatique Json.format ne semble pas possible avec les traits, mais vous pouvez leur écrire: stackoverflow.com/questions/14145432/... ; aussi, j'ai trébuché à travers cette question, qui pourrait être d'intérêt pour vous: stackoverflow.com/questions/6891393/...
  • J'ai récemment écrit un JSON macro qui génère jackson code pour toute la structure de l'objet à l'aide de la compilation des informations de type. La macro est en mesure de générer un match de déclaration pour tous les sous-types d'un type scellé par le biais de l'api reflection knownDirectSubclasses, vu ici: scala-lang.org/api/current/.... Je ne connais pas d'autre librairie Json qui fait cela, et pourtant...
  • avez-vous l'esprit de partage de code?
  • Si vous pouvez attendre une semaine, je peux voir à propos de le faire sur GitHub. Avertissement: Il a été écrit pour notre cas d'utilisation au travail et non pas comme générique de la bibliothèque.
  • Pas de problème. J'ai écrit à mi-chemin de ma propre mise en œuvre dès maintenant. Le writer fonctionne déjà, encore quelques problèmes à résoudre avec les objets singleton dans la reader partie.
  • en fonction de vos objectifs, nous pouvons peut-être combiner les forces de
  • Oui, bien sûr, projet -- en effet, je pense que ce doit être tiré en jeu-json par la suite.

InformationsquelleAutor 0__ | 2013-06-10
  1. 23

    Voici un manuel de mise en œuvre de la Foo compagnon de l'objet:

    implicit val barFmt = Json.format[Bar]
implicit val bazFmt = Json.format[Baz]

object Foo {
  def unapply(foo: Foo): Option[(String, JsValue)] = {
    val (prod: Product, sub) = foo match {
      case b: Bar => (b, Json.toJson(b)(barFmt))
      case b: Baz => (b, Json.toJson(b)(bazFmt))
    }
    Some(prod.productPrefix -> sub)
  }

  def apply(`class`: String, data: JsValue): Foo = {
    (`class` match {
      case "Bar" => Json.fromJson[Bar](data)(barFmt)
      case "Baz" => Json.fromJson[Baz](data)(bazFmt)
    }).get
  }
}
sealed trait Foo
case class Bar(i: Int  ) extends Foo
case class Baz(f: Float) extends Foo

implicit val fooFmt = Json.format[Foo]   //ça marche!

    De vérification:

    val in: Foo = Bar(33)
val js  = Json.toJson(in)
println(Json.prettyPrint(js))

val out = Json.fromJson[Foo](js).getOrElse(sys.error("Oh no!"))
assert(in == out)

    Sinon directe de la définition du format:

    implicit val fooFmt: Format[Foo] = new Format[Foo] {
  def reads(json: JsValue): JsResult[Foo] = json match {
    case JsObject(Seq(("class", JsString(name)), ("data", data))) =>
      name match {
        case "Bar"  => Json.fromJson[Bar](data)(barFmt)
        case "Baz"  => Json.fromJson[Baz](data)(bazFmt)
        case _      => JsError(s"Unknown class '$name'")
      }

    case _ => JsError(s"Unexpected JSON value $json")
  }

  def writes(foo: Foo): JsValue = {
    val (prod: Product, sub) = foo match {
      case b: Bar => (b, Json.toJson(b)(barFmt))
      case b: Baz => (b, Json.toJson(b)(bazFmt))
    }
    JsObject(Seq("class" -> JsString(prod.productPrefix), "data" -> sub))
  }
}

    Maintenant idéalement, je voudrais générer automatiquement le apply et unapply méthodes. Il semble que j'ai besoin d'utiliser la réflexion ou de la plongée dans les macros.

    • à mon avis les appliquer/annuler approche est assez dangereuse. Si la classe json nom n'est pas épuisé (mal formé json) les obtenir de l'appel va sauter et vous n'aurez pas de json journalisation des erreurs de ce.
    • C'est le même problème, je vais avoir... cependant, l'exemple de code dans la réponse ne parvient pas pour moi... est-ce encore de l'approche préférée?
    • pour moi, c'est de donner à l'Erreur à cette ligne case "Bar" => Json.fromJson[Bar](data)(barFmt) en raison de l'inadéquation au Réel : JsValue[Bar] et Attendu : JsValue[Foo]
    InformationsquelleAutor 0__
  2. 22

    MODIFIÉ 2015-09-22

    La bibliothèque jouer-json-extra comprend la jouer-json-variantes stratégie, mais aussi la [play-json-extensions] stratégie (chaîne de télévision pour le cas des objets mélangés avec des objets pour les classes de cas sans supplément de $variante ou $type, sauf si nécessaire). Il fournit également sérialiseurs et deserializers pour macramé en fonction des enums.

    Réponse précédente
    Il y a maintenant une bibliothèque appelée jouer-json-variantes qui vous permet d'écrire :

    implicit val format: Format[Foo] = Variants.format[Foo]

    Cela va générer le correspondant formats automatiquement, il permettra également de gérer l'ambiguïté du cas suivant en ajoutant un $variante de l'attribut (l'équivalent de 0__ 's class attribut)

    sealed trait Foo
case class Bar(x: Int) extends Foo
case class Baz(s: String) extends Foo
case class Bah(s: String) extends Foo

    serait de générer des 

    val bahJson = Json.obj("s" -> "hello", "$variant" -> "Bah") //This is a `Bah`
val bazJson = Json.obj("s" -> "bye", "$variant" -> "Baz") //This is a `Baz`
val barJson = Json.obj("x" -> "42", "$variant" -> "Bar") //And this is a `Bar`
    • Merci pour la réponse. Je ne comprends pas pourquoi l'auteur arrive à la réécriture de ce que j'ai fait, mais bon... Nous allons avoir le même problème avec knownDirectSubclasses pas en toute sécurité fournis par le système de macro (et la confirmation que ce sera le pas être fixé tout moment bientôt)
    • Très probablement, il ne savait pas à ce sujet ... tout comme moi 🙂
    • vous ne savez pas d'une bibliothèque qui crée des formats avec des valeurs par défaut pour les propriétés manquantes (voir stackoverflow.com/questions/20616677/... pour plus de détails)
    • vous pourriez mettre que comme une demande de fonctionnalité dans mon projet. Je ne veux pas générer des valeurs par défaut toujours, mais je ne pouvais imaginer que ce soit une option, comme AutoFormat[Foo](defaults = true)
    • Je ne voudrais pas les valeurs par défaut de la génération de tous les temps. Idéalement, il y aurait 2 sigs : 1 par défaut de toutes les valeurs, qui peut être affichée par défaut et un withDefault(clé, valeur) que le second s'assurer de la keyname existe, et la condition valeur par défaut est le type correct. J'ai commencé à écrire la demande de fonctionnalité quand j'ai réalisé, j'ai besoin de ce "normal" des classes de cas non seulement pour les scellés traits dérivés de ceux ...
    • knownDirectSubclasses est cassé, voir 16) @ docs.scala-lang.org/overviews/macros/...
    • Le jeu-json-extra lien est rompu.
    • merci pour le rapport, j'ai corrigé le lien. Malheureusement, le rendu du site est down (remise à apache de la page de destination), mais la doc est disponible sur le repo

    InformationsquelleAutor Jean
  3. 3

    Un petit correctif pour la réponse précédente par 0__ au sujet de la directe de la définition de format - le lit de la méthode n'a pas fonctionné, et voici mon refactoriser, à le aussi devenue plus idiomatiques -

    def reads(json: JsValue): JsResult[Foo] = {

  def from(name: String, data: JsObject): JsResult[Foo] = name match {
    case "Bar"  => Json.fromJson[Bar](data)(barFmt)
    case "Baz"  => Json.fromJson[Baz](data)(bazFmt)
    case _ => JsError(s"Unknown class '$name'")
  }

  for {
    name <- (json \ "class").validate[String]
    data <- (json \ "data").validate[JsObject]
    result <- from(name, data)
  } yield result
}
    InformationsquelleAutor ori danus
  4. 2

    Jouer 2.6 /2.7

    Ce qui peut être fait maintenant élégamment avec jouer-json-dérivés-codecs

    Juste ajouter ceci:

    object Foo{
    implicit val jsonFormat: OFormat[Foo] = derived.oformat[Foo]()
}

    Voir ici pour l'ensemble de l'exemple: ScalaFiddle

    InformationsquelleAutor pme