Analyser la chaîne JSON en objet dans Kotlin

1. Créer un nouveau projet et ajouter des dépendances
2. Analyser la chaîne JSON en objet dans Kotlin à l’aide de la bibliothèque kotlinx.serialization
3. Analyser la chaîne JSON en objet dans Kotlin à l’aide de la bibliothèque org.json
4. Analyser la chaîne JSON en objet dans Kotlin à l’aide de la bibliothèque Gson
5. Analyser la chaîne JSON en objet dans Kotlin à l’aide de la bibliothèque Jackson
6. Conclusion

JSON signifie JavaScript Object Notation, un format d’échange de données utilisé par les architectures client-serveur pour transférer des données entre ordinateurs ou stocker des données dans une base de données.

Les données JSON sont consommées à l’aide d’API REST qui envoient des requêtes HTTP aux serveurs pour effectuer des opérations CRUD sur les données stockées dans la base de données. Par exemple, lorsque nous chargeons dynamiquement des données sur une page Web ou une application mobile, nous récupérons généralement ces données de la base de données au format JSON, analysons les données en objets et affichons chaque variable d’objet dans la vue.

Dans ce didacticiel, nous apprendrons les différentes façons d’analyser les données JSON en objets dans Kotlin.

Créer un nouveau projet et ajouter des dépendances

Pour créer un nouveau projet, allez dans Intellij et sélectionnez File > New > Project. Dans la fenêtre qui s’ouvre, saisissez kotlinSerialization comme nom de projet, sélectionnez Kotlin dans la section Language et Gradle dans la section Build System.

Appuyez sur le bouton Create pour générer un nouveau projet. Une fois le projet généré, allez dans le fichier build.gradle.kts et assurez-vous d’avoir les dépendances suivantes.

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"))
}

Chaque dépendance fournit des API que nous utilisons pour créer chaque implémentation, alors assurez-vous d’avoir toutes les dépendances pour éviter les erreurs de référence non résolues.

Analyser la chaîne JSON en objet dans Kotlin à l’aide de la bibliothèque kotlinx.serialization

Dans cet exemple, nous devons nous assurer que nous avons les plugins suivants dans la section Plugins du fichier build.gradle.kts.

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

Créez la structure de dossiers com/serialize sous le dossier kotlin du projet où nos fichiers Kotlin seront créés.

Créez un fichier nommé UsingKotlinx.kt dans le dossier serialize, puis copiez et collez le code suivant dans le fichier.

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);
}

Dans le code ci-dessus, nous avons créé un texte multiligne de notre objet JSON en utilisant le texte entre guillemets triples de Kotlin pour représenter notre objet employé. La méthode trimIndent() supprime une indentation commune de toutes les lignes d’entrée et supprime la première et la dernière lignes si elles sont vides.

Nous avons ensuite créé une classe Employee et l’avons annotée avec l’annotation @Serializable. La classe Employee est une classe de données avec les paramètres firstName, lastName et email.

Ces paramètres vont stocker nos données, d’où le mot clé data. Lorsque nous utilisons une classe de données, nous obtenons certaines méthodes telles que toString() sans les déclarer, ce qui est crucial lorsque vous souhaitez enregistrer les données dans la console.

L’annotation @Serializable rend la classe Employee sérialisable, ce qui signifie que nous pouvons la modifier dans un format pouvant être stocké dans une base de données, un fichier ou transféré sur le réseau.

Pour analyser notre objet JSON en un objet Kotlin, nous invoquons la méthode générique decodeFromString() à partir de Json. Puisque nous voulons retourner un objet employé, nous passons la classe Employee au paramètre type et notre chaîne JSON comme argument de la méthode.

L’instruction print enregistre l’objet analysé dans la console. Exécutez le code et notez que l’objet est enregistré en tant que chaîne dans la console, comme indiqué ci-dessous.

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

Analyser la chaîne JSON en objet dans Kotlin à l’aide de la bibliothèque org.json

Dans cet exemple, nous utiliserons l’API JSONObject, qui est fournie par la bibliothèque org.json. Notez que cette bibliothèque a été incluse dans notre application lors de l’ajout des dépendances.

Créez un fichier nommé UsingJSONObject.kt dans le dossier serialize et copiez et collez le code suivant dans le fichier.

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);
    }

}

La première et la deuxième étapes sont similaires à celle que nous avons couverte dans l’exemple précédent, mais cette classe crée un tableau d’objets JSON et utilise une classe Kotlin normale. Comme nous n’utilisons pas de classe de données dans cet exemple, nous devons créer notre méthode personnalisée toString() en utilisant les champs firstName, lastName et email.

Pour récupérer le tableau JSON, nous invoquons le constructeur JSONObject() et passons la chaîne JSON comme argument du constructeur. Le constructeur crée un objet JSON à partir d’une chaîne commençant par { et se terminant par } ; il lève une JSONException s’il y a une erreur dans la chaîne.

L’accès à l’objet JSON nous permet de récupérer n’importe quelle propriété que nous voulons en passant cette propriété comme argument. Pour récupérer le tableau des utilisateurs, nous invoquons la méthode getJSONArray() à partir de l’objet retourné et passons User comme argument de la méthode.

La méthode retourne un JSONArray des utilisateurs de l’objet.

La création d’objets Kotlin à partir du JSONArray se fait manuellement à l’aide d’une boucle. On récupère chaque objet du tableau à l’aide de la méthode getJSONObject() en passant l’index de l’objet comme argument de la méthode.

A partir de cet objet, nous récupérons chaque variable et l’affectons à un nouvel objet Kotlin créé pour chaque itération. Exécutez l’application pour vérifier qu’elle génère les objets de chaîne suivants.

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

Analyser la chaîne JSON en objet dans Kotlin à l’aide de la bibliothèque Gson

Créez un fichier UsingGson.kt dans le dossier serialize et copiez-collez le code suivant dans le fichier.

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);
}

Nous sommes sûrs que vous avez compris que la première étape crée une représentation JSON de notre objet, et la deuxième étape crée une classe qui sera utilisée pour créer un objet Kotlin à partir de la chaîne.

La méthode main invoque le constructeur Gson() pour créer un objet Gson avec la configuration par défaut.

Pour mapper notre chaîne JSON à un objet Kotlin, appelez la méthode fromJson() à partir de l’objet Gson et transmettez la chaîne JSON comme premier argument de la méthode et class comme deuxième paramètre de la méthode.

Notez que la méthode fromJson() est générique et renvoie le type d’objet passé en deuxième argument de la méthode. La méthode est également surchargée pour fournir d’autres implémentations, telles que la lecture de l’objet JSON à partir d’un fichier.

Exécutez le programme et notez qu’il enregistre l’objet chaîne suivant dans la console.

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

Analyser la chaîne JSON en objet dans Kotlin à l’aide de la bibliothèque Jackson

Créez un fichier nommé UsingJackson.kt dans le dossier serialize et copiez et collez le code suivant dans le fichier.

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);
}

Dans ce code, nous avons créé une chaîne représentant notre objet JSON et une classe qui sera utilisée pour mapper la chaîne à un objet Kotlin. Les propriétés créées dans la classe doivent être identiques aux clés de la chaîne JSON.

Pour utiliser la bibliothèque Jackson, nous invoquons le jacksonObjectMapper() dans la méthode principale pour créer un ObjectMapper. Ensuite, nous appelons la méthode readValue() de ObjectMapper et passons la chaîne JSON comme premier argument et la class mappée comme deuxième argument.

La méthode readValue() désérialise la chaîne JSON et renvoie le type d’objet passé en deuxième argument de la méthode.

Exécutez le code pour vérifier qu’il consigne l’objet suivant sous forme de chaîne dans la console.

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

Conclusion

Dans ce didacticiel, nous avons appris à analyser un objet JSON en un objet Kotlin. Les approches que nous avons couvertes incluent : l’utilisation de la bibliothèque kotlix.serialization, la bibliothèque org.json, la bibliothèque Gson et la bibliothèque Jackson.

Notez que ce ne sont pas les seules bibliothèques que nous pouvons utiliser pour atteindre le même objectif, alors n’hésitez pas à implémenter votre application avec d’autres bibliothèques.