2

我有两个类，用户和地址。

case class User(
  id: Pk[Long] = NotAssigned,
  name: String = "",
  email: String = "",
  addresses: Seq[Address])

case class Address(
  id: Pk[Long] = NotAssigned,
  userId: Long,
  city: String)

我必须从我的控制器发送所有用户及其地址，例如Map[User, List[Address]]. 我可以使用 anorm (mysql) 提取它们，但是我需要将它们作为 json 发送。您能否就如何实现上述的写入和读取提供帮助Map[User, List[Address]]，谢谢。

4

3 回答 3

5

那应该有帮助

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


case class User(
  id: Pk[Long] = NotAssigned,
  name: String = "",
  email: String = "",
  addresses: Seq[Address])

case class Address(
  id: Pk[Long] = NotAssigned,
  userId: Long,
  city: String)

// Play does not provide Format[Pk[A]], so you need to define it
implicit def pkReads[A](implicit r: Reads[Option[A]]): Reads[Pk[A]] = r.map {  _.map(Id(_)).getOrElse(NotAssigned)  }
implicit def pkWrites[A](implicit w: Writes[Option[A]]): Writes[Pk[A]] =  Writes(id => w.writes(id.toOption))

implicit val addrFormat = Json.format[Address]
implicit val userFormat = Json.format[User]

现在您可以轻松地序列化用户：

val as = Seq(Address(Id(2), 1, "biim"))
val u = User(Id(1), "jto", "jto@foo.bar", as)

scala> Json.toJson(u)
res6: play.api.libs.json.JsValue = {"id":1,"name":"jto","email":"jto@foo.bar","addresses":[{"id":2,"userId":1,"city":"biim"}]}

正如 Julien 所说，你不能只序列化一个Map[User, Seq[Address]]. 这只是没有意义，因为用户不能成为 Json 对象中的键。

于 2013-08-02T09:44:37.043 回答
4

您可以通过将您的转换Map[User, List[Address]]为 a来解决此问题List[User]，并且 JsonWriter 将变得易于编写。

就像是：

list.map {
  case (user, address) => user.copy(addresses = address.toSeq)
}
于 2013-07-29T08:31:57.407 回答
2

User 中的“地址”包含地址，因此您实际上不需要将 Map[User, List[Address]] 发送回客户端。Json 将是一系列序列化的用户对象，地址是其中的一部分。如果您确实想发回 Map，那么 Map[String, List[Address]] 类型在 Json 序列化上下文中更有意义。这是为 List[User] 生成 Json 的代码。输出看起来像这样

[
{
    "id": 1,
    "name": "John Doe",
    "email": "john@email.com",
    "addresses": [
        {
            "id": 1001,
            "userId": 1,
            "city": "Chicago"
        },
        {
            "id": 1002,
            "userId": 1,
            "city": "New York"
        }
    ]
},
{
    "id": 2,
    "name": "Jane Doe",
    "email": "jane@email.com",
    "addresses": [
        {
            "id": 1012,
            "userId": 1,
            "city": "Dallas"
        }
    ]
}

]

这是您控制器中的代码。它具有 Json.toJson 使用的隐式 Json 格式化程序。

      implicit object PkWrites extends Writes[Pk[Long]] {
    def writes(key: Pk[Long]) = Json.toJson(key.toOption)
  }

  implicit object PkReads extends Reads[Pk[Long]] {
    def reads(json: JsValue) = json match {
      case l: JsNumber => JsSuccess(Id(l.value.toLong))
      case _ => JsSuccess(NotAssigned)
    }
  }

  implicit val AddressWrites: Writes[Address] = (
    (JsPath \ "id").write[Pk[Long]] and
      (JsPath \ "userId").write[Long] and
      (JsPath \ "city").write[String]
    )(unlift(Address.unapply))

  implicit val AddressReads: Reads[Address] = (
    (JsPath \ "id").read[Pk[Long]] and
      (JsPath \ "userId").read[Long] and
      (JsPath \ "city").read[String]
    )(Address.apply _)

  implicit val UserWrites: Writes[User] = (
    (JsPath \ "id").write[Pk[Long]] and
      (JsPath \ "name").write[String] and
      (JsPath \ "email").write[String] and
      (JsPath \ "addresses").write[List[Address]]
    )(unlift(User.unapply))

  def makeJson() = Action {
    val johnAddr1 = Address(Id(1001), 1, "Chicago")
    val johnAddr2 = Address(Id(1002), 1, "New York")
    val janeAddr1 = Address(Id(1012), 1, "Dallas")
    val john = User(Id(1), "John Doe", "john@email.com", List(johnAddr1, johnAddr2))
    val jane = User(Id(2), "Jane Doe", "jane@email.com", List(janeAddr1))
    Ok(Json.toJson(List(john, jane)))
    //    Ok(Json.toJson(map))
  }
于 2013-08-04T15:31:20.310 回答