Tengo dos JsValue creado a partir del caso de la clase, es decir, de libros y de detalle

val bookJson = Json.tojson(Book)
val bookDetailJson = Json.tojson(BookDetail)

y el formato sería:

//Book
{
  id: 1,
  name: "A Brief History of Time"
}

//BookDetail
{
  bookId: 1,
  author: "Steven Hawking",
  publicationDate: 1988,
  pages: 256
}

¿Cómo puedo combinar en un único Json en los play-marco 2.10? es decir,

//Book with detail
{
  id: 1,
  name: "A Brief History of Time",
  bookId: 1,
  author: "Steven Hawking",
  publicationDate: 1988,
  pages: 256
}

Yo estaba tratando de la transformación y no para iterar a través de la segunda JsValue:

val mapDetail = (__).json.update(
                  __.read[JsObject].map { o =>
                  o.deepMerge( JsObject(Seq(("detail", bookDetailJson))) )
                })

bookJson.validate(mapDetail).get

Se convertiría en la planta de abajo, que en realidad no quiero.

//Book with detail
{
  id: 1,
  name: "A Brief History of Time",
  detail: {
            bookId: 1,
            author: "Steven Hawking",
            publicationDate: 1988,
            pages: 256
          }
}

Por favor, hágamelo saber si cualquier truco podría proporcionar en este Json transformar. Muchas Gracias!

Parece que el JsObject clase admite el ++ método para combinar dos JsObjects. ¿Has probado de fundición a JsObject (si es que ya no se de que tipo) y, a continuación, utilizando ++?
Ese fue mi primer intento de lo que me dio el mismo resultado. De hecho, pensé deepMerge me daría una mejor respuesta.
El verdadero problema es cuando hago la conversión de un JsValue a JsObject, sólo puedo usar JsObject(Seq((«detalles», detailsJson))) que generaría este: detalle: { bookId: 1, autor: «stephen Hawking», publicationDate: 1988, páginas: 256 }
De nuevo, si usted vota tanto a JsObject, usted debería ser capaz de copiar los campos desde una a la otra, así: val newObj = a.copy(fields = fields ++ b.fields).
Lo siento por trivial que se trate. ¿Cuál es la mejor manera de lanzar un JsValue a JsObject?

OriginalEl autor Joyfulvillage | 2013-07-11

2 Comentarios

  1. 15

    El juego tiene un montón de nuevas características para JSON ahora. Este sería un buen escaparate para la Format[A] rasgo (ver Scala Json Inicio), que podría incluir implícitamente como voy a mostrar, o explícitamente a los métodos que requieren una implícita Format[A]/Reads[A]/Writes[A].

    Crear un caso de la clase para representar sus objetos JSON,

    case class Book(id: Int, name: String)
    case class BookDetail(id: Int, author: String, publicationDate: Int, pages: Int)

    Crear compañero de objetos que contienen implícito Format[A] para que Format/Reads/Writes será automáticamente en su alcance cuando usted los necesita.

    object Book { 
      implicit val fmt: Format[Book] = Json.format[Book] 
    }
    
    object BookDetail { 
      implicit val fmt: Format[BookDetail] = Json.format[BookDetail] 
    }

    Ahora se podría hacer algo como esto,

    val bookJson = Json.toJson(Book(1, "A Brief History Of Time"))
    val bookDetailJson = Json.toJson(BookDetail(1, "Steven Hawking", 1988, 256))
    bookJson.as[JsObject].deepMerge(bookDetailJson.as[JsObject])

    Y usted tendrá un objeto como este,

    {
      id: 1,
      name: "A Brief History Of Time",
      author: "Steven Hawking",
      publicationDate: 1988,
      pages: 256
    }

    He intentado esto en el REPL pero no funciona, en una aplicación de Juego que lo hace bien aunque. También en un escenario de producción es probable que el uso de asOpt[T] en lugar de as[T].

    Aquí es un ejemplo de por qué asOpt[T] puede ser más adecuado, supongamos que en lugar de un objeto JSON válido para el libro que usted consigue,

    val bookJson = Json.toJson("not a book")

    Usted va a terminar con un

    [JsResultException: JsResultException(errors:List((,List(ValidationError(validate.error.expected.jsobject,WrappedArray())))))]

    Pero supongamos que en lugar de cambiar su método para utilizar asOpt[T],

    bookJson.asOpt[JsObject].getOrElse(Json.obj()).deepMerge(bookDetailJson.asOpt[JsObject].getOrElse(Json.obj()))

    Ahora usted va a terminar con al menos un parcial de objeto JSON,

    {
      id: 1,
      author: "Steven Hawking",
      publicationDate: 1988,
      pages: 256
    }

    Por lo que dependiendo de cómo quieres que se manejan incorrectamente con formato JSON usted puede elegir cualquiera de las opciones.

    +1 Gracias soo mucho deepMerge era exactamente lo que yo estaba buscando, pero la Scala api es tan grande que es fácil pasar por alto!

    OriginalEl autor tysonjh

  2. 2

    JsObject es subtipo de JsValue.

    JsValue pueden ser simples convertido a la JsObject utilizando como o asOpt métodos de JsValue.
    Ejemplo:

    val someJsValue = ....
    val asObject:JsObject = someJsValue.as[JsObject]
    val asObjectMaybe:Option[JsObject] = v.asOpt[JsObject]

    En el caso de JsArray no se puede utilizar el código de arriba.
    Si utiliza el juego y analizar JSON con la matriz, a continuación, Json.toJson(…) produce JsValue que es JsArray realidad.
    Usted necesita para convertir JsArray de la siguiente manera:

    val someJsValueButArray = ....
    val asJsArray:JsArray = Json.toJson(someJsValueButArray).as[JsArray]
    val asSeqOfJsObjects:Seq[JsObject] = asJsArray.value.map(_.as[JsObject])

    OriginalEl autor albgorski

Dejar respuesta

Please enter your comment!
Please enter your name here