Plongez dans Jackson pour JSON en Java : comprendre JsonNode, ArrayNode et ObjectMapper

Hé, amis développeurs Java ! ?

Vous êtes-vous déjà retrouvé à regarder des données JSON et à vous demander : "Comment diable puis-je travailler avec cela en Java ?" Ne vous inquiétez pas - vous n'êtes pas seul ! Qu'il s'agisse de créer des API, de les consommer ou simplement de gérer des données, gérer JSON est presque inévitable. Mais voici la bonne nouvelle : Jackson vous soutient !

Dans cet article, je vais vous présenter quelques bases de Jackson, comme JsonNode, ArrayNode et ObjectMapper. Nous resterons simples, avec des exemples de code et des résultats simples pour vous montrer exactement comment les choses fonctionnent.

Ça sonne bien ? Allons-y ! ?

Configurer Jackson dans un projet Spring Boot

Avant de plonger dans les exemples, expliquons rapidement comment configurer Jackson dans un projet Spring Boot. Bonne nouvelle : Spring Boot intègre Jackson, ce qui nécessite une configuration minimale. ?

Lorsque vous créez un nouveau projet Spring Boot, Jackson est la bibliothèque JSON par défaut pour la sérialisation et la désérialisation. Si vous souhaitez ajouter explicitement Jackson, assurez-vous que la dépendance suivante se trouve dans votre pom.xml :

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.18.0</version> <!-- You can use the latest version -->
</dependency>

Cela ajoutera les fonctionnalités de base de Jackson, y compris ObjectMapper, pour la gestion JSON.

Bonus : configuration de Spring Boot
Spring Boot fournit une configuration prête à l'emploi pour Jackson, mais vous pouvez également la personnaliser via le fichier application.properties ou application.yml.

Par exemple, pour configurer la jolie-impression de JSON, vous pouvez ajouter :

spring.jackson.serialization.indent_output=true

Ou dans application.yml :

spring:
  jackson:
    serialization:
      indent_output: true

Désormais, chaque fois que votre application Spring Boot sérialise JSON, elle sera bien formatée !

Une fois cette configuration effectuée, vous êtes prêt à travailler avec JSON dans votre application Spring Boot à l'aide de Jackson.

Alors, qu'est-ce que Jackson ?

Jackson est comme un couteau suisse pour travailler avec JSON en Java. Vous pouvez l'utiliser pour :

• 1. Convertir les objets Java en JSON (sérialisation).
• 2. Convertir JSON en objets Java (désérialisation).
• 3. Gérez JSON dans une structure arborescente avec JsonNode.

Nous allons explorer certaines de ces fonctionnalités aujourd'hui, alors préparez-vous à rendre la gestion JSON beaucoup moins effrayante !

JsonNode : votre premier pas dans JSON

Considérez JsonNode comme une clé magique qui vous permet d'explorer et de manipuler les données JSON. C'est une manière de représenter différentes parties d'une structure JSON en Java.

Imaginez que vous ayez ces simples données JSON :

{
  "name": "Samarth",
  "age": 30,
  "city": "New York"
}

Comment lire cela en Java ? Voyons !

Voici le code :

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;

public class JsonNodeExample {
    public static void main(String[] args) throws Exception {
        String jsonString = "{\"name\":\"Samarth\", \"age\":30, \"city\":\"New York\"}";

        // Step 1: Create an ObjectMapper
        ObjectMapper objectMapper = new ObjectMapper();

        // Step 2: Parse the JSON string into a JsonNode
        JsonNode jsonNode = objectMapper.readTree(jsonString);

        // Step 3: Access values from the JsonNode
        System.out.println("Name: " + jsonNode.get("name").asText());
        System.out.println("Age: " + jsonNode.get("age").asInt());
        System.out.println("City: " + jsonNode.get("city").asText());
    }
}

Et le résultat :

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.18.0</version> <!-- You can use the latest version -->
</dependency>

Que se passe-t-il ici ?

1. ObjectMapper est l'assistant principal de Jackson. C'est celui qui traduit entre JSON et Java.
2. readTree() lit le JSON et le convertit en un objet JsonNode.
3. Nous utilisons .get() pour accéder aux champs individuels - "nom", "âge" et "ville" - à partir du JSON.

Plutôt cool, non ? Vous commencez maintenant à voir à quel point il est facile de travailler avec JSON en Java !

ArrayNode : Gestion des tableaux JSON

Mais que se passe-t-il si votre JSON est un tableau ? Ne vous inquiétez pas, Jackson s'en occupe également ! Disons que vous avez ce tableau JSON :

spring.jackson.serialization.indent_output=true

Nous pouvons utiliser ArrayNode pour lire et travailler avec ce tableau d'objets.

Voici le code :

spring:
  jackson:
    serialization:
      indent_output: true

Et le résultat :

{
  "name": "Samarth",
  "age": 30,
  "city": "New York"
}

Que se passe-t-il ici ?

1. **ArrayNode **est un type spécial de **JsonNode ** qui représente un tableau d'objets JSON.
2. Nous parcourons chaque élément du tableau et imprimons le "nom" de chaque personne.

Facile, non ? Avec ArrayNode, Jackson facilite la gestion des tableaux JSON !

ObjectMapper : le cœur de Jackson

Maintenant, parlons de ObjectMapper - le cœur et l'âme de Jackson. C'est votre outil incontournable pour convertir des objets Java en JSON et vice versa.

Sérialisation d'objets Java en JSON
La sérialisation n'est qu'une manière élégante de dire : « transformez mon objet Java en une chaîne JSON ». Disons que vous avez une simple classe Person :

Code :

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;

public class JsonNodeExample {
    public static void main(String[] args) throws Exception {
        String jsonString = "{\"name\":\"Samarth\", \"age\":30, \"city\":\"New York\"}";

        // Step 1: Create an ObjectMapper
        ObjectMapper objectMapper = new ObjectMapper();

        // Step 2: Parse the JSON string into a JsonNode
        JsonNode jsonNode = objectMapper.readTree(jsonString);

        // Step 3: Access values from the JsonNode
        System.out.println("Name: " + jsonNode.get("name").asText());
        System.out.println("Age: " + jsonNode.get("age").asInt());
        System.out.println("City: " + jsonNode.get("city").asText());
    }
}

Sortie :

Name: Samarth  
Age: 30  
City: New York

Que se passe-t-il ici ?

1. **ObjectMapper **prend l'objet Person et le convertit en chaîne JSON à l'aide de writeValueAsString().
2. La méthode writeValueAsString() crée une représentation JSON de l'objet Java.
3. Le résultat est une chaîne JSON valide que vous pouvez envoyer à une API ou stocker dans une base de données.

Désérialiser JSON en un objet Java

Et ça marche aussi dans l’autre sens ! Vous pouvez prendre JSON et le transformer en objet Java. C'est ce qu'on appelle la désérialisation.

Voici le code :

[
  {"name": "Samarth"},
  {"name": "Ujjwal"},
  {"name": "Gaurav"}
]

Et le résultat :

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ArrayNode;

public class ArrayNodeExample {
    public static void main(String[] args) throws Exception {
        String jsonArrayString = "[{\"name\":\"Samarth\"}, {\"name\":\"Ujjwal\"}, {\"name\":\"Gaurav\"}]";

        // Step 1: Create an ObjectMapper
        ObjectMapper objectMapper = new ObjectMapper();

        // Step 2: Parse the JSON array into an ArrayNode
        ArrayNode arrayNode = (ArrayNode) objectMapper.readTree(jsonArrayString);

        // Step 3: Loop through each element in the array
        for (JsonNode jsonNode : arrayNode) {
            System.out.println("Name: " + jsonNode.get("name").asText());
        }
    }
}

Que se passe-t-il ici ?

Nous utilisons à nouveau **ObjectMapper **, mais cette fois, il lit une chaîne JSON et la reconvertit en objet Person.
Cela se fait à l'aide de readValue(), et le résultat est un objet Java complet prêt à être utilisé dans votre code.

Conclusion

Et voilà ! Nous avons parcouru beaucoup de terrain :

• JsonNode : Comment lire et manipuler les données JSON.
• ArrayNode : Comment gérer les tableaux JSON.
• ObjectMapper : Comment sérialiser et désérialiser des objets Java vers et depuis JSON.

J'espère que ce guide rendra Jackson un peu moins intimidant et beaucoup plus amusant à utiliser ! Une fois que vous aurez compris, vous gérerez JSON comme un pro en un rien de temps.

Mais bon, ne vous arrêtez pas là ! Gardez un œil sur mon prochain article dans lequel nous approfondirons les fonctionnalités plus avancées de Jackson et les meilleures pratiques pour les applications du monde réel.

À la prochaine fois ! Bon codage ! ?

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!