Analizar cadena JSON a objeto en Kotlin

1. Crear un nuevo proyecto y agregar dependencias
2. Parse JSON String to Object en Kotlin usando la biblioteca kotlinx.serialization
3. Parse JSON String to Object en Kotlin usando la biblioteca org.json
4. Parse JSON String to Object en Kotlin usando la biblioteca Gson
5. Parse JSON String to Object en Kotlin usando la biblioteca Jackson
6. Conclusión

JSON significa JavaScript Object Notation, un formato de intercambio de datos utilizado por las arquitecturas cliente-servidor para transferir datos entre computadoras o almacenar datos en una base de datos.

Los datos JSON se consumen mediante API REST que emiten solicitudes HTTP a los servidores para realizar operaciones CRUD en los datos almacenados en la base de datos. Por ejemplo, cuando cargamos datos dinámicamente en una página web o una aplicación móvil, generalmente recuperamos estos datos de la base de datos como JSON, analizamos los datos en objetos y mostramos cada variable de objeto en la vista.

En este tutorial, aprenderemos las diferentes formas que podemos usar para analizar datos JSON en objetos en Kotlin.

Crear un nuevo proyecto y agregar dependencias

Para crear un nuevo proyecto, vaya a Intellij y seleccione Archivo > Nuevo > Proyecto. En la ventana que se abre, ingrese kotlinSerialization como nombre del proyecto, seleccione Kotlin en la sección Idioma y Gradle en la sección Sistema de compilación.

Pulse el botón Create para generar un nuevo proyecto. Una vez que se genera el proyecto, vaya al archivo build.gradle.kts y asegúrese de tener las siguientes dependencias.

dependencies {
    implementation ("com.fasterxml.jackson.module:jackson-module-kotlin:2.13.3")
    implementation ("com.google.code.gson:gson:2.9.0")
    implementation("org.json:json:20220320")
    implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.3.3")
    testImplementation(kotlin("test"))
}

Cada dependencia proporciona las API que usamos para crear cada implementación, así que asegúrese de tener todas las dependencias para evitar los errores de referencia sin resolver.

Parse JSON String to Object en Kotlin usando la biblioteca kotlinx.serialization

En este ejemplo, debemos asegurarnos de tener los siguientes complementos en la sección Complementos del archivo build.gradle.kts.

plugins {
    kotlin("jvm") version "1.7.0"
    kotlin("plugin.serialization") version "1.7.0"
}

Cree la estructura de carpetas com/serialize en la carpeta kotlin del proyecto donde se crearán nuestros archivos Kotlin.

Cree un archivo llamado UsingKotlinx.kt en la carpeta serialize, y copie y pegue el siguiente código en el archivo.

package com.serialize

import kotlinx.serialization.Serializable
import kotlinx.serialization.decodeFromString
import kotlinx.serialization.json.Json

val employeeJSON = """
    {
       "firstName": "john",
       "lastName": "doe",
       "email": "john@gmail.com"
    }
""".trimIndent()

@Serializable
data class Employee(val firstName: String,
                    val lastName: String,
                    val email: String)

fun main(args: Array<String>){
    //Decode employee from string
    val employeeObject = Json.decodeFromString<Employee>(employeeJSON);
    println(employeeObject);
}

En el código anterior, hemos creado un texto de varias líneas de nuestro objeto JSON utilizando el texto entre comillas triples de Kotlin para representar nuestro objeto empleado. El método trimIndent() elimina una sangría común de todas las líneas de entrada y elimina la primera y la última línea si están en blanco.

Luego creamos una clase Employee y la anotamos con la anotación @Serializable. La clase Employee es una clase de datos con los parámetros firstName, lastName y email.

Estos parámetros almacenarán nuestros datos, de ahí la palabra clave data. Cuando usamos una clase de datos, obtenemos algunos métodos como toString() sin declararlos, y esto es crucial cuando desea registrar los datos en la consola.

La anotación @Serializable hace que la clase Employee sea serializable, lo que significa que podemos cambiarla a un formato que pueda almacenarse en una base de datos, un archivo o transferirse a través de la red.

Para analizar nuestro objeto JSON en un objeto Kotlin, invocamos el método genérico decodeFromString() de Json. Como queremos devolver un objeto empleado, pasamos la clase Employee al parámetro de tipo y nuestra cadena JSON como argumento del método.

La instrucción print registra el objeto analizado en la consola. Ejecute el código y observe que el objeto se registra como una cadena en la consola, como se muestra a continuación.

Employee(firstName=john, lastName=doe, email=john@gmail.com)

Parse JSON String to Object en Kotlin usando la biblioteca org.json

En este ejemplo, utilizaremos la API JSONObject, que proporciona la biblioteca org.json. Tenga en cuenta que esta biblioteca se incluyó en nuestra aplicación al agregar las dependencias.

Cree un archivo llamado UsingJSONObject.kt en la carpeta serialize y copie y pegue el siguiente código en el archivo.

package com.serialize

import org.json.JSONObject

val usersArray = """
    {
       "User":[
          {
            "firstName": "john",
            "lastName": "doe",
            "email": "john@gmail.com"
          },
          {
            "firstName": "mary",
            "lastName": "public",
            "email": "mary@gmail.com"
          }

       ]
    }
""".trimIndent()

class User{
    var firstName: String? = null;
    var lastName: String? = null;
    var email: String? = null

    override fun toString(): String {
        return "User(firstName=$firstName, lastName=$lastName, email=$email)"
    }

}

fun main() {
    val userJsonObject =
        JSONObject(usersArray)

    val userObject = userJsonObject
        .getJSONArray("User");

    for (i in 0 until(userObject!!.length())){
        val theUser = User();

        val firstName = userObject
            .getJSONObject(i)
            .getString("firstName");
        theUser.firstName = firstName

        val lastName = userObject
            .getJSONObject(i)
            .getString("lastName")
        theUser.lastName = lastName

        val email = userObject
            .getJSONObject(i)
            .getString("email")

        theUser.email = email;

        println(theUser);
    }

}

El primer y el segundo paso son similares al que cubrimos en el ejemplo anterior, pero esta clase crea una matriz de objetos JSON y usa una clase normal de Kotlin. Como no estamos usando una clase de datos en este ejemplo, tenemos que crear nuestro método personalizado toString() usando los campos firstName, lastName y email.

Para recuperar la matriz JSON, invocamos el constructor JSONObject() y pasamos la cadena JSON como argumento del constructor. El constructor crea un objeto JSON a partir de una cadena que comienza con { y termina con }; lanza una JSONException si hay un error en la cadena.

El acceso al objeto JSON nos permite recuperar cualquier propiedad que queramos pasando esa propiedad como argumento. Para recuperar la matriz de Usuarios, invocamos el método getJSONArray() del objeto devuelto y pasamos User como argumento del método.

El método devuelve un JSONArray de usuarios del objeto.

La creación de objetos Kotlin a partir de JSONArray se realiza manualmente mediante un bucle. Recuperamos cada objeto de la matriz utilizando el método getJSONObject() pasando el índice del objeto como argumento del método.

De este objeto, recuperamos cada variable y la asignamos a un nuevo objeto Kotlin creado para cada iteración. Ejecute la aplicación para verificar que genera los siguientes objetos de cadena.

User(firstName=john, lastName=doe, email=john@gmail.com)
User(firstName=mary, lastName=public, email=mary@gmail.com)

Parse JSON String to Object en Kotlin usando la biblioteca Gson

Cree un archivo UsingGson.kt en la carpeta serialize y copie y pegue el siguiente código en el archivo.

package com.serialize

import com.google.gson.Gson

val customerObject = """
    {
       "firstName": "john",
       "lastName": "doe",
       "email": "john@gmail.com"
    }
""".trimIndent()

class Customer{
    private val firstName: String? = null;
    private val lastName: String? = null;
    private val email: String? = null;

    override fun toString(): String {
        return "Customer(firstName=$firstName, lastName=$lastName, email=$email)"
    }

}

fun main() {
    val theGson = Gson();
    val customer = theGson
        .fromJson(customerObject, Customer::class.java);
    println(customer);
}

Estamos seguros de que has entendido que el primer paso crea una representación JSON de nuestro objeto, y el segundo paso crea una clase que se usará para crear un objeto Kotlin a partir de la cadena.

El método principal invoca al constructor Gson() para crear un objeto Gson con la configuración por defecto.

Para asignar nuestra cadena JSON a un objeto Kotlin, invoque el método fromJson() desde el objeto Gson y pase la cadena JSON como primer argumento del método y class como segundo parámetro del método.

Tenga en cuenta que el método fromJson() es genérico y devuelve el tipo de objeto pasado como segundo argumento del método. El método también está sobrecargado para proporcionar otras implementaciones, como leer el objeto JSON de un archivo.

Ejecute el programa y observe que registra el siguiente objeto de cadena en la consola.

Customer(firstName=john, lastName=doe, email=john@gmail.com)

Parse JSON String to Object en Kotlin usando la biblioteca Jackson

Cree un archivo llamado UsingJackson.kt en la carpeta serialize y copie y pegue el siguiente código en el archivo.

package com.serialize

import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper

val vehicleObject = """
    {
      "vehicleName": "Toyota",
      "vehicleColor": "white",
      "vehiclePrice": 10000
    }
""".trimIndent()

data class Vehicle(private val vehicleName: String,
                   private val vehicleColor: String,
                   private val vehiclePrice: Int)

fun main() {
    val jacksonMapper = jacksonObjectMapper();

    val vehicle = jacksonMapper
        .readValue(vehicleObject, Vehicle::class.java)

    println(vehicle);
}

En este código, hemos creado una cadena que representa nuestro objeto JSON y una clase que se usará para asignar la cadena a un objeto Kotlin. Las propiedades creadas en la clase deben ser las mismas que las claves en la cadena JSON.

Para usar la biblioteca Jackson, invocamos el jacksonObjectMapper() en el método main para crear un ObjectMapper. Luego, llamamos al método readValue() del ObjectMapper y pasamos la cadena JSON como primer argumento y la clase que se está mapeando como segundo argumento.

El método readValue() deserializa la cadena JSON y devuelve el tipo de objeto pasado como segundo argumento del método.

Ejecute el código para verificar que registra el siguiente objeto como una cadena en la consola.

Vehicle(vehicleName=Toyota, vehicleColor=white, vehiclePrice=10000)

Conclusión

En este tutorial, hemos aprendido cómo analizar un objeto JSON en un objeto Kotlin. Los enfoques que hemos cubierto incluyen: el uso de la biblioteca kotlix.serialization, la biblioteca org.json, la biblioteca Gson y la biblioteca Jackson.

Tenga en cuenta que estas no son las únicas bibliotecas que podemos usar para lograr el mismo objetivo, así que no dude en implementar su aplicación con otras bibliotecas.