3

我有这个：

sealed trait Block

sealed case class Header(param1: String,
                                      param2: String,
                                      ...) extends Block

... 
(more sealed case classes that follows the same pattern)

稍后，我将这些块分组到 Seq 中，如下所示：

val blocks: Seq[Block with Product with Serializable] = Seq(structure.header, structure.body, ...)

而且我想将每个块序列化为 Json（使用 Play）。我这样做如下：

blocks.map{
      x =>
          serializeBlock(x)
    }

“序列化块”的定义：

def serializeBlock[A<:Block](block:A): String = {
    block match {
        case block: Header => Json.toJson(block).toString()
        case block: Body => Json.toJson(block).toString()
        ... n-times for every possible case class that mixes the block trait
    }
}

我有每个具体块（标题，正文......）的读者和作家，但是，正如你所看到的，当我在 Seq Scala 中混合这些块时，将其视为通用类型块，因此我正在做模式匹配每个可能的块类型（隐式转换？）。如果我只是在 Map Play 中调用“Json.toJson”，则会抱怨找不到“块”类型的读取器/写入器。

“块”是相对较大的 JSON 的片段。我正在获取 JSON，我将其拆分为合格的“块”，然后将其作为字符串保存在数据库中：

“大” JSON：

{
    "header" : {
        "param1" : "",
        ...
    },
    "body" : {
        "param1" : "",
        ...
    }
    ...
}

块

{
    "param1" : "",
    ...
}

我的问题是：有没有办法在不重复 n 次“块：类型”模式的情况下进行序列化？我的意思是：有没有办法获得该块的具体类型（知道 Seq 被键入为超类“块”而不是该块的“具体”类型）？

编辑

我为每个块都有一个读取器/写入器，如下所示：

implicit val headerReader: Reads[Header] = (
    (JsPath \ "param1").read[String] and
    (JsPath \ "param2").read[String] and
    ...
)(Header.apply _)

implicit val headerWriter: Writes[Header] = (
    (JsPath \ "param1").write[String] and
    (JsPath \ "param2").write[String] and
    ...
)(unlift(Header.unapply))

编辑2：

Shapeless是解决这个问题的方法吗？

编辑 3：

正如 Andrzej Jozwik 所说：“param1”和“param2”是我在这里用来定义我的 JSON 结构的“通配符”参数。每个块都有不同的参数。

4

1 回答 1

1

shapeless' HList 对您来说似乎是一个可能的解决方案。这是一个看起来非常接近您想要做的示例：

import shapeless._

sealed trait Block
case class Test1(a: String, b: String) extends Block
object Test1 {
  implicit val writes = (
    (JsPath \ "a").write[String] and
    (JsPath \ "b").write[String]
  )(unlift(Test1.unapply))
}

case class Test2(c: String, d: String) extends Block
object Test2 {
  implicit val writes =(
    (JsPath \ "c").write[String] and
    (JsPath \ "d").write[String]
  )(unlift(Test2.unapply))
}

object serializeBlock extends Poly1 {
  implicit def default[T <: Block](implicit w: Writes[T]) = at[T] { x =>
    Json.toJson(x).toString
  }
}

val blocks = Test1("hi", "hello") :: Test2("what", "why") :: HNil

blocks.map(serializeBlock).toList // List[String]({"a": "hi", "b": "hello"}, {"c": "what", "d": "why"})

请注意，HList 的每个成员都必须具有可用于该类型的隐式写入。如果它不是你得到的错误不是很有帮助：

val list = Test1("hi", "hello") :: Test2("a", "b") :: NoWrites("wrong") :: HNil
list.map(serializeBlock)

出现错误：

could not find implicit value for parameter mapper: shapeless.ops.hlist.Mapper[serializeBlock.type,shapeless.::[Test1,shapeless.::[Test2,shapeless.::[NoWrites,shapeless.HNil]]]]

这只是意味着无法为您调用 map 的 HList 的某些成员调用 serializeBlock 。

在这种情况下，它不能在 NoWrites 对象上调用 serializeBlock，因为在当前范围内没有可用的隐式 Writes[NoWrites]。

如果 HList 中的任何对象未扩展 Block，您将收到类似的错误。

于 2015-08-17T21:32:46.010 回答