Question

我有这个：

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

“serializeBlock”的定义：

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中混合这些块时将其视为泛型类型Block，因此我正在做模式匹配每种可能的块类型（隐式转换？）。如果我只是在地图播放中调用“Json.toJson”，则抱怨没有为“块”类型找到读者/作者。

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

“大”JSON ：

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

块

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

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

修改

我为每个块都有一个Reader / Writer，如下所示：

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”是'wildcard'参数，我在这里用来定义我的JSON结构。每个区块都有不同的参数。

Answer 1

无形'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的每个成员都必须具有可用于该类型的隐式Writer。如果没有，你得到的错误并没有太大的帮助：

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，您将收到类似的错误。

获取案例类

1 个答案: