Travailler avec JSON en Java : parsing et sérialisation en pratique

Introduction au travail avec JSON en Java

JSON (JavaScript Object Notation) est un format léger d'échange de données largement utilisé dans les applications web modernes, les API et les microservices. En Java, travailler avec JSON est une partie intégrante du développement : de la lecture des fichiers de configuration à l'interaction avec les services RESTful. Dans cet article, nous allons voir en pratique comment effectuer le parsing (conversion de JSON en objets Java) et la sérialisation (conversion d'objets Java en JSON) à l'aide des deux bibliothèques les plus populaires : Jackson et Gson.

Nous examinerons des exemples de code réels, apprendrons à traiter des structures imbriquées et analyserons les erreurs typiques. À la fin de cet article, vous serez en mesure de travailler avec JSON en toute confiance dans n'importe quel projet Java.

1. Bibliothèques principales pour travailler avec JSON

Jackson vs Gson : que choisir ?

Sur le marché Java, il existe plusieurs bibliothèques pour travailler avec JSON, mais deux d'entre elles sont devenues le standard de facto :

\n
• Jackson — une bibliothèque plus performante et fonctionnelle. Elle prend en charge les annotations, le traitement par flux et les sérialiseurs personnalisés. Recommandée pour les projets d'entreprise.
\n
• Gson — une bibliothèque simple et légère de Google. Idéale pour les petits projets et le prototypage rapide.
\n

Pour utiliser l'une ou l'autre, il suffit d'ajouter la dépendance dans pom.xml (Maven) ou build.gradle (Gradle).

Ajout de Jackson (Maven)

<dependency>\n    <groupId>com.fasterxml.jackson.core</groupId>\n    <artifactId>jackson-databind</artifactId>\n    <version>2.15.2</version>\n</dependency>

Ajout de Gson (Maven)

<dependency>\n    <groupId>com.google.code.gson</groupId>\n    <artifactId>gson</artifactId>\n    <version>2.10.1</version>\n</dependency>

2. Parsing JSON : de la chaîne à l'objet Java

Le parsing est le processus de conversion d'une chaîne JSON en un objet Java. Examinons les deux approches avec l'exemple d'une classe simple User.

Création du modèle de données

public class User {\n    private String name;\n    private int age;\n    private String email;\n\n    // Un constructeur vide est obligatoire !\n    public User() {}\n\n    // Getters et setters\n    public String getName() { return name; }\n    public void setName(String name) { this.name = name; }\n    public int getAge() { return age; }\n    public void setAge(int age) { this.age = age; }\n    public String getEmail() { return email; }\n    public void setEmail(String email) { this.email = email; }\n}

Parsing avec Jackson

import com.fasterxml.jackson.databind.ObjectMapper;\n\npublic class JacksonParsingExample {\n    public static void main(String[] args) throws Exception {\n        String json = "{\\"name\\":\\"Ivan\\",\\"age\\":30,\\"email\\":\\"ivan@example.com\\"}";\n        \n        ObjectMapper mapper = new ObjectMapper();\n        User user = mapper.readValue(json, User.class);\n        \n        System.out.println("Nom : " + user.getName());\n        System.out.println("Âge : " + user.getAge());\n    }\n}

Parsing avec Gson

import com.google.gson.Gson;\n\npublic class GsonParsingExample {\n    public static void main(String[] args) {\n        String json = "{\\"name\\":\\"Maria\\",\\"age\\":25,\\"email\\":\\"maria@example.com\\"}";\n        \n        Gson gson = new Gson();\n        User user = gson.fromJson(json, User.class);\n        \n        System.out.println("Nom : " + user.getName());\n        System.out.println("Email : " + user.getEmail());\n    }\n}

3. Sérialisation : de l'objet Java au JSON

La sérialisation est le processus inverse : nous prenons un objet Java et le convertissons en une chaîne JSON. Cela est nécessaire, par exempl