Analizar cadenas JSON en Scala

1. Use Opción para analizar cadenas JSON en Scala
2. Use API para analizar cadenas JSON en Scala
3. Conclusión

Este artículo nos enseñará cómo analizar cadenas JSON en el lenguaje de programación Scala.

JSON es un formato común para intercambiar desde y hacia un servidor web. Entonces, el objetivo aquí es que dada una cadena JSON con una matriz de objetos, queremos deserializarla en objetos Scala para poder usarla en nuestra aplicación.

Podemos analizar el JSON usando los métodos y funciones simples de Scala o usar diferentes API y bibliotecas para analizar archivos JSON como la biblioteca Lift-JSON y Circe.

Use Opción para analizar cadenas JSON en Scala

Podemos usar Opción junto con la coincidencia de patrones en Scala para analizar una cadena JSON. Supongamos que tenemos la siguiente cadena JSON:

{
        "languages": [{
            "name": "English",
            "is_active": true,
            "completeness": 4.5
        }, {
            "name": "Japanese",
            "is_active": true,
            "completeness": 1.4
        }]
}

Podemos usar el siguiente código para mapearlo a objetos Scala:

class parse[T]
{
    def unapply(X:Option[Any]):Option[T] = if(X.isEmpty) {
        None
    } else {
        Some(X.get.asInstanceOf[T])
    }
}

object A extends parse[Map[String,Any]]
object B extends parse[List[Any]]
object C extends parse[String]
object D extends parse[Double]
object E extends parse[Boolean]

for{
    A(mp) <- List(JSON.parseFull(str))
    B(languages) = mp.get("languages")
    language<-languages
    A(temp) = Some(language)
    C(store_name) = temp.get("name")
    E(check_active) = temp.get("is_active")
    D(completeness_level) = temp.get("completeness")
}
yield{
    (store_name,check_active,completeness_level)
}

Use API para analizar cadenas JSON en Scala

Podemos usar una biblioteca Lift-JSON conocida para analizar la cadena JSON. Esta biblioteca contiene muchos métodos que podrían usarse para deserializar la cadena JSON en objetos Scala.

Código de ejemplo:

import net.liftweb.json.DefaultFormats
import net.liftweb.json._

case class Employee(
    Name: String,
    id: Int,
    username: String,
    password: String,
    DepartmentsWorking: List[String]
)

object ParseJsonArray extends App {
    implicit val formats = DefaultFormats

    val str ="""
    {
      "employees": [
    { "Account": {
      "Name": "YMail",
      "id": 3,
      "username": "srj",
      "password": "123456srj",
      "DepartmentsWorking": ["sales", "IT", "HR"]
    }},
    ]}
    """

    val json = parse(str)
    val contents = (json \\ "Account").children
    for (temp <- contents) {
        val m = temp.extract[Employee]
        println(s"Employee: ${m.Name}, ${m.id}")
        println(" Departments working: " + m.DepartmentsWorking.mkString(","))
    }
}

En el código anterior, hemos creado una clase de caso Empleado para que coincida con los datos JSON.

La ventaja de usar API es que nos ayudan a escribir código más conciso y brindan muchas funcionalidades que los métodos primitivos de Scala podrían no brindar.

Conclusión

En este artículo, vimos dos métodos, uno en el que usamos métodos simples de Scala y otro en el que usamos otro método en el que usamos una API conocida para analizar la cadena JSON. Y entendimos que las API siempre se prefieren durante el análisis debido a la simplicidad de escritura y sus funcionalidades.