Question

在JsonWriter[T]的实例上调用toJson时，

spray-json依赖于范围内隐式T的存在。

假设我有一个具有几个具体子类型的特征，每个子类型都有一个JsonWriter：

trait Base
case class Foo(a: Int) extends Base
case class Bar(a: Int, b: Int) extends Base
implicit val FooFormat = jsonFormat1(Foo)
implicit val BarFormat = jsonFormat2(Bar)

def go(o: Base) = {
    o.toJson
}

go无法编译，因为没有适用于Base的JsonWriter，即使是所有具体子类型的编写者。

如何重新组织此代码，使Base的通用函数使用适当的json格式化程序？

Answer 1

您可以使用带有类型和上下文边界的泛型方法。像这样：

def go[T <: Base : JsonWriter](t: T) = t.toJson

Answer 2

编组Base需要JsonFormat。以下是解决上述问题的方法之一。

import spray.json._

object BaseJsonProtocol extends DefaultJsonProtocol {
  implicit val FooFormat = jsonFormat1(Foo)
  implicit val BarFormat = jsonFormat2(Bar)

  implicit object BaseJsonFormat extends RootJsonFormat[Base] {
    def write(obj: Base) = obj match {
      case x: Foo ⇒ x.toJson
      case y: Bar ⇒ y.toJson
      case unknown @ _ => serializationError(s"Marshalling issue with ${unknown}")
    }

    def read(value: JsValue) = {
      value.asJsObject.getFields("a","b") match {
        case Seq(JsNumber(a)) => Foo(a.toInt)
        case Seq(JsNumber(a), JsNumber(b)) => Bar(a.toInt, b.toInt)
        case unknown @ _ => deserializationError(s"Unmarshalling issue with ${unknown} ")
    }
  }
 }
}

因此，BaseJsonProtocol可用于编组Base的实例，如下所示。

import BaseJsonProtocol._

def go(o: Base) =  o.toJson

assert (go(Foo(10)).convertTo[Foo] == Foo(10))
assert (go(Foo(10).asInstanceOf[Base]).convertTo[Foo] == Foo(10))
assert (go(Bar(10,100)).convertTo[Bar] == Bar(10, 100))

希望它有所帮助！

Answer 3

我意识到一个解决方案是使go成为带有类型绑定的泛型函数，并声明隐含值...＆＃34;明确＆＃34;

def go[T <: Base](t: T)(implicit fmt: JsonWriter[T]) =
    t.toJson

现在该函数可以编译，因为JsonWriter被承诺为函数参数，并且每个调用站点可以根据上下文（JsonWriter[T]或{引入FooFormat的具体实现。 {1}}）。

spray-json：序列化一般特征

3 个答案: