Convertir objeto JSON en Lista seleccionada

Question

Quiero convertir el objeto JSON en otro formato. Mi objeto JSON parece. {  schema : [ {  name :  cust_id ,  data_type :  String ,  nullable : true }, {  name :  source_type ,  data_type :  String ,  nullable : true } ] } Quiero la salida siguiente: val colType = List(( cust_id , String ,true),( source_type , String ,true)) Quiero la conversión en Scala.

devdynamox · Accepted Answer

También puede utilizar spray.json.

Añadir dependencia en la construcción. Sbt

libraryDependencies += "io.spray" %% "spray-json" % "1.3.6"

Aplicación:

import spray.json._

//create your model classes
case class MyItem(name: String, data_type: String, nullable: Boolean)
case class MySchema(schema: Seq[MyItem])

//prepare JSON protocol
trait MyJsonProtocol extends DefaultJsonProtocol {
  //MyItem has 3 fields, so you have to use jsonFormat3
  implicit val myItemFormat: RootJsonFormat[MyItem] = jsonFormat3(MyItem)

  //MySchema has 1 field, so you have to use jsonFormat1
  implicit val mySchemaFormat: RootJsonFormat[MySchema] = jsonFormat1(MySchema)
}

//extends your application with your JSON protocol
object MyApplication extends App with MyJsonProtocol {
  val json =
    """{
      |"schema": [{
      |        "name": "cust_id",
      |        "data_type": "String",
      |        "nullable": true
      |    },
      |    {
      |        "name": "source_type",
      |        "data_type": "String",
      |        "nullable": true
      |    }
      |]
      |}""".stripMargin
  
  //execute parsing
  val parsed = json.parseJson.convertTo[MySchema]

  //true
  println(parsed.schema == List(MyItem("cust_id","String",true), MyItem("source_type","String",true)))
}

Respondida el Dec 18, 2020 a las 05:42 - por devdynamox

codemasterx · Answer

¿Qué tal usar? Circe?

import io.circe._, io.circe.generic.auto._, io.circe.parser._, io.circe.syntax._
import cats.syntax.show._

case class Schema(schema: List[Container])
case class Container(name:String, data_type: String, nullable: Boolean)

val json = """
{
"schema": [{
        "name": "cust_id",
        "data_type": "String",
        "nullable": true
    },
    {
        "name": "source_type",
        "data_type": "String",
        "nullable": true
    }
]
}"""

decode[Schema](json) match {
  case Right(result) => println(result.schema.map{case Container(a,b,c) => (a,b,c)})
  case Left(failure) => println(failure.show)
    
}

Respondida el Dec 18, 2020 a las 05:47 - por codemasterx

rubyrogue · Answer

Demostraré cómo se puede lograr usando eso play-json. En caso de que quieras serializarlo en una clase de caso, como se demuestra en las otras respuestas, puedes definir las clases y sus serilizadores:

case class Schema(name: String, data_type: String, nullable: Boolean)

object Schema {
  implicit val format: OFormat[Schema] = Json.format[Schema]
}

case class Schemas(schema: Seq[Schema])

object Schemas {
  implicit val format: OFormat[Schemas] = Json.format[Schemas]
}

y luego llama:

println(Json.parse(jsonString).as[Schemas])

Código Scastie.

Pero si realmente quieres lista de tuples, puedes hacer:

val path = JsPath \ "schema"

val schemas = path(Json.parse(jsonString)) match {
  case List(arr) =>
    arr match {
      case arr: JsArray =>
        arr.value.map(_.validate[JsObject] match {
          case JsSuccess(value, _) =>
            value.values.toList match {
              case List(a, b, c) =>
                (a, b, c)
              case _ => ???
            }
          case JsError(errors) =>
            ??? // Error handling
        }).toList
      case _ => ??? // Error handling
    }
  case _ => ??? // Error handling
}

Código Scastie

Respondida el Dec 18, 2020 a las 05:52 - por rubyrogue

Gpt · Answer

Para convertir el objeto JSON en la lista deseada en Scala, puedes hacer uso de la librería play-json que facilita el manejo de JSON en Scala.

Aquí tienes un ejemplo de cómo hacer la conversión en Scala:

scala
import play.api.libs.json._

// JSON de entrada
val json = Json.parse("""
{
    "schema": [
        {
            "name": "cust_id",
            "data_type": "String",
            "nullable": true
        },
        {
            "name": "source_type",
            "data_type": "String",
            "nullable": true
        }
    ]
}
""")

// Obtener la lista de columnas
val schema = (json \ "schema").as[List[JsValue]]

val colType = schema.map { column =>
  val name = (column \ "name").as[String]
  val dataType = (column \ "data_type").as[String]
  val nullable = (column \ "nullable").as[Boolean]
  (name, dataType, nullable)
}

// Imprimir la lista de columnas
println(colType)

Este código primero parsea la entrada JSON, luego extrae la lista de objetos schema, y finalmente mapea

Respondida el Dec 19, 2020 a las 05:38 - por Gpt

Gemini · Answer

Conversión en Scala scala import org.json4s._ import org.json4s.jackson.JsonMethods._ // Definir el objeto JSON val jsonStr =     {  schema : [ {  name :  cust_id ,  data_type :  String ,  nullable : true }, {  name :  source_type ,  data_type :  String ,  nullable : true } ] }     // Parsear el objeto JSON val json = parse(jsonStr) // Extraer el esquema del objeto JSON val schema = (json    schema ).extract[List[Map[String, Any]]] // Convertir el esquema a la lista deseada val colType = schema.map(m => (m( name ).toString, m( data_type ).toString, m( nullable ).toString.toBoolean)) Resultado: List((cust_id,String,true), (source_type,String,true))

Convertir objeto JSON en Lista seleccionada

5 Respuestas: