跳过 Json 序列化中的键

Question

I have the following case class specification

case class A(messages: Vector[SomeClass])

I would like to avoid to have a serialization result like the following:

{ 
    "messages":[{...},{...}]
}

I would like to skip the JsonObject specification and serialize the contents directly. So the result would look like:

[
    {
        "key":"a"
    },
    {
        "key":"b"
    }
]

I have tried specifying an implicit converter like the following

object A {
    implicit val writes:[Writes] = (o: A) => JsArray(o.messages.map(Json.toJson(_)))
    // also tried this Json.arr(o.messages.map(Json.toJson(_))) which has the same result 
}

but this produces an array inside an array

[
    [
        {
            "key":"a"
        },
        {
            "key":"b"
        }
    ]
]

SomeClass is a sealed trait and its extensions are properly serialized and deserialized. My problem is with the array nesting of case class A . Any ideas?

Answer 1

You can use Writes.contramap and Reads.map , with Writes.seq and Reads.seq .

import play.api.libs.json._

case class SomeClass(foo: String)

implicit val format1: OFormat[SomeClass] = Json.format

case class A(messages: Vector[SomeClass])

// Writes
implicit def writes(implicit w: OWrites[SomeClass]): Writes[A] =
  Writes.seq[SomeClass].contramap[A](_.messages)

Json.toJson(A(Vector(SomeClass("bar"))))
// play.api.libs.json.JsValue = [{"foo":"bar"}]

// Reads
implicit def reads(implicit r: Reads[SomeClass]): Reads[A] =
  Reads.seq[SomeClass].map { seq => A(seq.toVector) }

Json.parse("""[{"foo":"bar"}]""").validate[A]
// play.api.libs.json.JsResult[A] = JsSuccess(A(Vector(SomeClass(bar))),)

Answer 2

Just extract the Vector with your case class first:

import play.api.libs.json._

val a: A = ???
Json.toJson(a.messages)

What you would need is the format for SomeClass :

object SomeClass {
  implicit val jsonFormat: Format[SomeClass] = Json.format[SomeClass]
}