48

我需要以最少的仪式获得一个简单的 JSON 序列化解决方案。所以我很高兴找到这个即将推出的 Play 2.2 库。这与普通案例类完美配合，例如

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]

但以下失败：

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

我将如何设置据称丢失的提取器Foo？

或者您会推荐任何其他或多或少完全自动处理我的案例的独立库？我不在乎是在编译时使用宏还是在运行时使用反射，只要它开箱即用。

4

4 回答 4

26

于 2015 年 9 月 22 日修订

库play-json-extra包括play-json-variants策略，还包括 [play-json-extensions] 策略（案例对象的扁平字符串与案例类的对象混合，除非需要，否则没有额外的 $variant 或 $type）。它还为基于 macramé 的枚举提供序列化器和反序列化 器。

上一个答案 现在有一个名为play-json-variants的库，它允许您编写：

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

这将自动生成相应的格式，它还将通过添加 $variant 属性（相当于 0__ 的class属性）来处理以下情况的消歧

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

会产生

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`
于 2013-12-16T16:57:31.750 回答
24

这是Foo伴随对象的手动实现：

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!

确认：

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)

或者直接格式定义：

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

现在理想情况下，我想自动生成applyandunapply方法。看来我需要使用反射或深入研究宏。

于 2013-06-17T10:28:46.917 回答
4

玩 2.7

sealed traits支持play-json。

object Foo{
  implicit val format = Json.format[Foo]
}

玩 2.6

现在可以使用play-json-derived-codecs优雅地完成此操作

只需添加以下内容：

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

整个例子见这里：ScalaFiddle

于 2018-09-18T07:04:28.060 回答
4

0__ 关于直接格式定义的先前答案的一个小修复 - 读取方法不起作用，这是我对它的重构，也变得更加惯用 -

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
}
于 2017-10-20T20:26:02.787 回答