Java JSON avec Jackson | W3Docs Learn Java

Jackson est la bibliothèque JSON de référence pour Java. Le JDK ne fournit aucune API JSON native, aussi presque toutes les applications Spring, Quarkus ou Micronaut utilisent Jackson pour convertir des objets Java en texte JSON et inversement. Son point d'entrée est une seule classe polyvalente — ObjectMapper — qui gère les deux opérations toujours nécessaires : la sérialisation (objet Java → JSON) et la désérialisation (JSON → objet Java).

Si vous débutez avec JSON en Java, commencez par l'introduction au JSON ; pour une bibliothèque alternative plus légère, consultez le chapitre sur Gson. Cette page couvre l'ajout de Jackson, les trois niveaux de son API, le data binding, le modèle arborescent et les annotations qui contrôlent le mapping.

Ajouter Jackson à votre projet

Jackson ne fait pas partie du JDK, il faut donc le déclarer comme dépendance. L'artefact jackson-databind tire les deux autres modules principaux (jackson-core et jackson-annotations) de manière transitive.

<!-- Maven -->
<dependency>
  <groupId>com.fasterxml.jackson.core</groupId>
  <artifactId>jackson-databind</artifactId>
  <version>2.17.1</version>
</dependency>

// Gradle
implementation 'com.fasterxml.jackson.core:jackson-databind:2.17.1'

Les trois façons de travailler avec JSON

Jackson expose les mêmes données de trois manières différentes. Choisissez le niveau adapté à la tâche :

Approche	Type principal	Quand l'utiliser
Data binding	`ObjectMapper.readValue` / `writeValue`	Vous avez un POJO ou un record qui reflète le JSON — le cas le plus courant
Modèle arborescent	`JsonNode` via `readTree`	La structure est dynamique ou vous n'avez besoin que de quelques champs
Streaming	`JsonParser` / `JsonGenerator`	Documents volumineux qu'on ne peut pas charger entièrement en mémoire

Le data binding est utilisé 90 % du temps ; les deux autres sont des solutions de secours.

Data binding : des objets en entrée, du JSON en sortie

ObjectMapper.writeValueAsString sérialise tout objet Java en lisant ses getters (ou ses composants de record) ; readValue fait l'inverse, en associant les noms des champs JSON à vos champs. Un record est la cible la plus propre — Jackson 2.12+ se lie à son constructeur canonique automatiquement, sans avoir à écrire de getters ni de constructeur sans argument.

import com.fasterxml.jackson.databind.ObjectMapper;

record User(String name, int age, boolean active) {}

ObjectMapper mapper = new ObjectMapper();

// serialize: Java -> JSON
User ada = new User("Ada", 36, true);
String json = mapper.writeValueAsString(ada);
// {"name":"Ada","age":36,"active":true}

// deserialize: JSON -> Java
User back = mapper.readValue(json, User.class);
System.out.println(back.name()); // Ada

Pour les collections et les génériques, passez à Jackson une TypeReference afin que le type d'élément survive à l'effacement de type :

import com.fasterxml.jackson.core.type.TypeReference;

List<User> users = mapper.readValue(jsonArray, new TypeReference<List<User>>() {});

Le modèle arborescent : quand la structure est inconnue

Lorsque vous n'avez pas (ou ne souhaitez pas) de classe correspondante, analysez le JSON dans un arbre générique JsonNode et naviguez-y par clé. Cela ressemble à ce que ferait un parseur Map/List artisanal, mais avec des accesseurs typés comme asInt() et asText().

import com.fasterxml.jackson.databind.JsonNode;

JsonNode root = mapper.readTree(json);
String name = root.get("name").asText();
int age     = root.get("age").asInt();
JsonNode first = root.get("languages").get(0); // array access by index

Contrôler le mapping avec les annotations

Les noms de champs JSON correspondent rarement parfaitement aux conventions Java. Quelques annotations comblent cet écart sans modifier vos noms de champs :

Annotation	Effet
`@JsonProperty("user_name")`	Associer un champ à une clé JSON différente
`@JsonIgnore`	Exclure un champ dans les deux sens
`@JsonInclude(NON_NULL)`	Supprimer les champs `null` de la sortie
`@JsonCreator` / `@JsonFormat`	Construction personnalisée / formatage de date

record Account(
    @JsonProperty("user_name") String userName,
    @JsonIgnore String passwordHash) {}

Un exemple complet : sérialiser, analyser et lier manuellement

Jackson n'est pas disponible sur le classpath de ce runner, le programme ci-dessous reproduit donc les mêmes concepts — un writer JSON, un parseur récursif dans un arbre Map/List, et la liaison dans un record — en utilisant uniquement java.util. C'est exactement ce que fait ObjectMapper sous le capot : parcourir un graphe d'objets pour émettre du texte, et tokeniser le texte pour reconstruire un arbre.

java— editable, runs on the server

import java.util.LinkedHashMap;
import java.util.Map;
import java.util.List;
import java.util.ArrayList;

public class JacksonDemo {
  // A tiny JSON model: objects are Map<String,Object>, arrays are List<Object>.
  // Real code uses Jackson's ObjectMapper; here we model the same data binding by hand.

public static void main(String[] args) {
    // 1. SERIALIZE: build an object graph, then render it as JSON text.
    Map<String, Object> user = new LinkedHashMap<>();
    user.put("name", "Ada");
    user.put("age", 36);
    user.put("active", true);
    List<Object> langs = new ArrayList<>();
    langs.add("Java");
    langs.add("Ada");
    user.put("languages", langs);

String json = writeJson(user);
    System.out.println("serialized   : " + json);

// 2. PARSE: read JSON text back into the same Map/List tree (tree model).
    String input = "{\"name\":\"Grace\",\"age\":42,\"active\":false,\"languages\":[\"COBOL\",\"Java\"]}";
    Object tree = new Parser(input).parse();
    System.out.println("parsed type  : " + tree.getClass().getSimpleName());

// 3. NAVIGATE the tree, the way ObjectMapper.readTree() + JsonNode.get() do.
    @SuppressWarnings("unchecked")
    Map<String, Object> parsed = (Map<String, Object>) tree;
    System.out.println("name field   : " + parsed.get("name"));
    System.out.println("age field    : " + parsed.get("age") + " (" + parsed.get("age").getClass().getSimpleName() + ")");

// 4. BIND into a typed record, the way ObjectMapper.readValue(json, User.class) does.
    @SuppressWarnings("unchecked")
    List<Object> plist = (List<Object>) parsed.get("languages");
    List<String> typed = new ArrayList<>();
    for (Object o : plist) typed.add((String) o);
    User bound = new User((String) parsed.get("name"), (int) parsed.get("age"), typed);
    System.out.println("bound record : " + bound);

// 5. ROUND-TRIP: re-serialize the parsed tree and confirm it survives.
    System.out.println("round-trip   : " + writeJson(parsed));
  }

record User(String name, int age, List<String> languages) {}

// ---- minimal JSON writer ----
  static String writeJson(Object value) {
    StringBuilder sb = new StringBuilder();
    write(value, sb);
    return sb.toString();
  }

@SuppressWarnings("unchecked")
  static void write(Object value, StringBuilder sb) {
    if (value == null) { sb.append("null"); return; }
    if (value instanceof String s) { sb.append('"').append(s).append('"'); return; }
    if (value instanceof Boolean || value instanceof Number) { sb.append(value); return; }
    if (value instanceof Map<?, ?> m) {
      sb.append('{');
      boolean first = true;
      for (Map.Entry<?, ?> e : m.entrySet()) {
        if (!first) sb.append(',');
        first = false;
        sb.append('"').append(e.getKey()).append("\":");
        write(e.getValue(), sb);
      }
      sb.append('}');
      return;
    }
    if (value instanceof List<?> list) {
      sb.append('[');
      for (int i = 0; i < list.size(); i++) {
        if (i > 0) sb.append(',');
        write(list.get(i), sb);
      }
      sb.append(']');
      return;
    }
    throw new IllegalArgumentException("unsupported: " + value.getClass());
  }

// ---- minimal recursive-descent JSON parser ----
  static class Parser {
    private final String s;
    private int i = 0;
    Parser(String s) { this.s = s; }

Object parse() { skip(); return value(); }

private Object value() {
      skip();
      char c = s.charAt(i);
      return switch (c) {
        case '{' -> object();
        case '[' -> array();
        case '"' -> string();
        case 't', 'f' -> bool();
        case 'n' -> nul();
        default -> number();
      };
    }

private Map<String, Object> object() {
      Map<String, Object> m = new LinkedHashMap<>();
      i++; // {
      skip();
      if (s.charAt(i) == '}') { i++; return m; }
      while (true) {
        skip();
        String key = string();
        skip();
        i++; // :
        m.put(key, value());
        skip();
        char c = s.charAt(i++);
        if (c == '}') break;
      }
      return m;
    }

private List<Object> array() {
      List<Object> list = new ArrayList<>();
      i++; // [
      skip();
      if (s.charAt(i) == ']') { i++; return list; }
      while (true) {
        list.add(value());
        skip();
        char c = s.charAt(i++);
        if (c == ']') break;
      }
      return list;
    }

private String string() {
      StringBuilder sb = new StringBuilder();
      i++; // opening quote
      while (s.charAt(i) != '"') sb.append(s.charAt(i++));
      i++; // closing quote
      return sb.toString();
    }

private Object number() {
      int start = i;
      while (i < s.length() && "-+.eE0123456789".indexOf(s.charAt(i)) >= 0) i++;
      String num = s.substring(start, i);
      if (num.contains(".") || num.contains("e") || num.contains("E"))
        return Double.parseDouble(num);
      return Integer.parseInt(num);
    }

private Boolean bool() {
      if (s.charAt(i) == 't') { i += 4; return Boolean.TRUE; }
      i += 5; return Boolean.FALSE;
    }

private Object nul() { i += 4; return null; }

private void skip() { while (i < s.length() && Character.isWhitespace(s.charAt(i))) i++; }
  }
}

Ce qu'il faut retenir de l'exécution :

La sérialisation parcourt un graphe d'objets et émet du texte. La ligne serialized montre un Map/List imbriqué rendu en {"name":"Ada",...,"languages":["Java","Ada"]} — un tableau dans un objet. ObjectMapper.writeValueAsString effectue le même parcours récursif sur les getters de votre POJO ou les composants d'un record.
L'analyse reconstruit d'abord un arbre générique. Le type d'exécution de la valeur analysée est LinkedHashMap, pas User — exactement le modèle arborescent de Jackson, où readTree vous donne un JsonNode que vous naviguez par clé avant qu'une classe soit impliquée.
Les nombres JSON deviennent des nombres Java, avec un choix de type. Le champ age est revenu comme Integer (42) parce que le texte n'avait pas de virgule décimale ; le parseur a choisi Integer plutôt que Double. Jackson fait le même choix, c'est pourquoi un champ int se lie proprement tandis que 3.14 atterrirait comme Double.
L'accès aux champs se fait par nom, et l'ordre est préservé. L'utilisation de LinkedHashMap a conservé les clés dans l'ordre d'insertion, donc name est lu avant age. Jackson préserve l'ordre des clés d'objet de la même façon, c'est pourquoi le JSON après un aller-retour ressemble à l'original.
L'aller-retour est sans perte quand le modèle correspond. La dernière ligne a re-sérialisé l'arbre analysé vers le même JSON d'origine, et le record typé User a lié correctement name, age et languages — tout l'intérêt du data binding : texte en entrée, objet en sortie, texte à nouveau, sans dérive.

Pratique

Avec Jackson, vous recevez une réponse JSON dont vous ne contrôlez pas la structure et vous n'avez besoin de lire que deux champs dans un document volumineux et profondément imbriqué. Quelle approche convient le mieux ?

L'analyser dans un arbre 'JsonNode' avec 'ObjectMapper.readTree' et extraire les deux champs avec 'get(...)'Créer une classe Java complète reflétant chaque champ du document et utiliser 'readValue' pour le data bindingConcaténer les chaînes JSON brutes et extraire les valeurs avec 'String.substring'Utiliser un 'DatagramSocket' pour diffuser le JSON et lire les champs depuis le flux