播放 Scala JSON 写入和继承

Question

//Item.scala

package model
trait Item {val id: String}

class MItem(override val id: String, val name: String) extends Item

class DItem(override val id: String, override val name: String, val name2: String)
  extends MItem(valid, name, name2)

object ItemWrites {

  implicit  val MItemWrites = new Writes[MItem] {
    def writes(dItem: MItem) = Json.obj(
      "id" -> mItem.id,
      "name" -> mItem.name
    )
  }

  implicit  val DItemWrites = new Writes[DItem] {
    def writes(dItem: DItem) = Json.obj(
      "id" -> dItem.id,
      "name" -> dItem.name,
      "name2" -> dItem.name2
    )
  }

}

//Response.scala

package model
import ItemWrites.MItemWrites
import ItemWRites.DItemWrites

trait Response {
  val title : String,
  val items : Seq[Item],
}

case class MResponse(title: String, items: Seq[MItem]) extends Response

case class DResponse(title: String, items: Seq[DItem]) extends Response

object ResponseWrites  {

  implicit val mResponseWrite = new Writes[MResponse] {

    def writes(mResponse: MResponse) = Json.obj(
      "title" -> mResponse.title,
      "items" -> mResponse.items
    )
  }

  implicit val dResponseWrite = new Writes[DResponse] {

    def writes(dResponse: DResponse) = Json.obj(
      "title" -> dResponse.title,
      "items" -> dResponse.items // **compile time error**
    )
  }

}

我在 dResponse.items 行出现编译时错误。

> [error]  Note: implicit value dtcTopicPageResponseWrite is not
> applicable here because it comes after the application point and it
> lacks an explicit result type
> [error] "items" -> dResponse.items

似乎发生这种情况是因为 DItem 继承了 MItem 形式，并且编译在子类和超类之间变得混乱。我该如何解决这个问题。

Answer 1

通过明确说明您在 ItemWrites 中声明的 Writes 的类型，我能够在 Scala 2.11、Play 2.5.x 中编译您的代码 - 即：

object ItemWrites {

  implicit val MItemWrites:Writes[MItem] = new Writes[MItem] {
    def writes(mItem: MItem) = Json.obj(
      "id" -> mItem.id,
      "name" -> mItem.name
    )
  }

  implicit val DItemWrites:Writes[DItem] = new Writes[DItem] {
    def writes(dItem: DItem) = Json.obj(
      "id" -> dItem.id,
      "name" -> dItem.name,
      "name2" -> dItem.name2
    )
  }
}

一旦我这样做了，Scala 就能够找出哪个隐式是正确的。

Answer 2

您应该明确设置要使用的 Writer[T]，因为它们使用继承。我没有测试下面的代码，但它应该可以编译和工作；

implicit val dResponseWrite = new Writes[DResponse] {

    import ItemWrites.DItemWrites

    def writes(dResponse: DResponse) = Json.obj(
      "title" -> dResponse.title,
      "items" -> Json.toJson(dResponse.items) // **compile time error**
    )
  }

Answer 3

我认为对你来说最好有一个超类型 Item 的 Writes，它只会匹配大小写以检查它的类型并执行 toJson。不要忘记隐式导入它

object ItemWrites {

  implicit  val MItemWrites = new Writes[MItem] {
    def writes(dItem: MItem) = Json.obj(
      "id" -> mItem.id,
      "name" -> mItem.name
    )
  }

  implicit  val DItemWrites = new Writes[DItem] {
    def writes(dItem: DItem) = Json.obj(
      "id" -> dItem.id,
      "name" -> dItem.name,
      "name2" -> dItem.name2
    )
  }

  implicit  val ItemWrites = new Writes[Item] {
    def writes(item: Item) = item match {
     case i: DItem => i.toJson //code for converting DItem to Json
     case i: MItem => i.toJson //code to convert MItem to Json
     case _ => throws new RuntimeException("Unsupported Type.")
   }
  }
}