17

我经常需要序列化/反序列化 sum 类型（如Either[S,T]），但我还没有找到通用或优雅的方法来做到这一点。这是一个示例类型（基本上等同于Either）

sealed trait OutcomeType
case class NumericOutcome(units: String)              extends OutcomeType
case class QualitativeOutcome(outcomes: List[String]) extends OutcomeType

这是我在实现序列化的伴随对象上的最大努力。它可以工作，但是为每种 sum 类型一遍又一遍地写这些东西是非常令人厌烦的。有什么建议可以让它更好和/或更通用吗？

import play.api.libs.json._
import play.api.libs.functional.syntax._

object OutcomeType {

  val fmtNumeric     = Json.format[NumericOutcome]
  val fmtQualitative = Json.format[QualitativeOutcome]

  implicit object FormatOutcomeType extends Format[OutcomeType] {
    def writes(o: OutcomeType) = o match {
      case n@NumericOutcome(_)     => Json.obj("NumericOutcome"     -> Json.toJson(n)(fmtNumeric))
      case q@QualitativeOutcome(_) => Json.obj("QualitativeOutcome" -> Json.toJson(q)(fmtQualitative))
    }

    def reads(json: JsValue) = (
      Json.fromJson(json \ "NumericOutcome")(fmtNumeric) orElse
      Json.fromJson(json \ "QualitativeOutcome")(fmtQualitative)
    )
  }
}
4

3 回答 3

1

我认为这很简单，如果您想避免为每个显式子类型编写代码，也许您可​​以使用反射来完成，直接使用 jackson 或其他支持反射的 json 库。或者编写您自己的宏以从子类型列表中生成格式。

于 2013-08-27T14:58:48.530 回答
0

对于我的 json 酸洗库Prickle中序列化总和类型的问题，我有一个系统的解决方案。Play 也可以采用类似的想法。仍然需要一些配置代码，但它的高信号/噪声，例如最终代码，如：

implicit val fruitPickler = CompositePickler[Fruit].concreteType[Apple].concreteType[Lemon]

与超类型关联的CompositePickler为每个已知子类型配置一个PicklerPair（即总和类型选项）。关联是在配置时设置的。

在酸洗期间，一个描述符被发送到描述记录是哪个子类型的 json 流中。

在unpickling期间，从 json 中读取描述符，然后用于定位适合Unpickler子类型的描述符

于 2015-11-30T10:23:27.593 回答
0

为 play 2.5 更新的示例：

object TestContact extends App {

  sealed trait Shape

  object Shape {
    val rectFormat = Json.format[Rect]
    val circleFormat = Json.format[Circle]

    implicit object ShapeFormat extends Format[Shape] {
      override def writes(shape: Shape): JsValue = shape match {
        case rect: Rect =>
          Json.obj("Shape" ->
            Json.obj("Rect" ->
              Json.toJson(rect)(rectFormat)))
        case circle: Circle =>
          Json.obj("Shape" ->
            Json.obj("Circle" ->
              Json.toJson(circle)(circleFormat)))
      }

      override def reads(json: JsValue): JsResult[Shape] = {
        json \ "Shape" \ "Rect" match {
          case JsDefined(rectJson) => rectJson.validate[Rect](rectFormat)
          case _ => json \ "Shape" \ "Circle" match {
            case JsDefined(circleJson) => circleJson.validate[Circle](circleFormat)
            case _ => JsError("Not a valide Shape object.")
          }
        }
      }
    }

  }

  case class Rect(width: Double, height: Double) extends Shape

  case class Circle(radius: Double) extends Shape

  val circle = Circle(2.1)
  println(Json.toJson(circle))
  val rect = Rect(1.3, 8.9)
  println(Json.toJson(rect))

  var json = Json.obj("Shape" -> Json.obj("Circle" -> Json.obj("radius" -> 4.13)))
  println(json.validate[Shape])
  json =
    Json.obj("Shape" ->
      Json.obj("Rect" ->
        Json.obj("width" -> 23.1, "height" -> 34.7)))
  println(json.validate[Shape])
}
于 2017-03-22T13:50:07.527 回答