Jackson : désérialisation d'un tableau d'objets en Java en 2025 — guide pour les pros

Formateur Python en ligne pour débutants

Apprenez Python facilement sans surcharge théorique. Résolvez des tâches pratiques avec vérification automatique et écrivez du code directement dans le navigateur.

Start Course

Introduction : pourquoi chaque développeur Java devrait connaître cette astuce

Imaginez : vous recevez un JSON du serveur, contenant des dizaines d'objets du même type. Clients, produits, logs — peu importe. Vous prenez ObjectMapper, vous écrivez readValue(json, MyClass[].class) — et tout fonctionne. Mais un mois plus tard, le code plante avec une ClassCastException parce que quelqu'un a remplacé le tableau par une List. Cela vous dit quelque chose ?

La question « How to use Jackson to deserialise an array of objects » sur Stack Overflow a recueilli des dizaines de milliers de vues. Et ce n'est pas un hasard : la désérialisation d'un tableau d'objets en Java est l'une de ces tâches qui semblent simples jusqu'à ce que vous soyez confronté aux génériques et à l'effacement de type (Type Erasure). En 2025, Jackson reste le standard de facto pour travailler avec JSON, mais les meilleures pratiques ont évolué. Dans cet article, nous aborderons non seulement les approches de base, mais aussi les techniques modernes qui vous éviteront bien des maux de tête.

Approche de base : tableau ou liste ?

La méthode la plus simple consiste à utiliser un tableau. Jackson comprend parfaitement que MyClass[].class est un tableau d'objets :

ObjectMapper mapper = new ObjectMapper();String json = "[{\\"id\\":1,\\"name\\":\\"Alice\\"},{\\"id\\":2,\\"name\\":\\"Bob\\"}]";MyClass[] array = mapper.readValue(json, MyClass[].class);

Ça marche ? Oui. Mais cette approche présente des inconvénients :

Le tableau a une taille fixe — peu pratique pour des données dynamiques.
Pas de méthodes de collections (stream(), filter(), remove()).
Plus difficile à étendre si vous avez besoin d'une List par la suite.

C'est pourquoi dans 90 % des cas, vous voudrez obtenir une List<MyClass>. Et c'est là que les choses deviennent intéressantes — l'effacement de type (Type Erasure) en Java. Si vous écrivez :

List<MyClass> list = mapper.readValue(json, List.class); // warning: unchecked

Le compilateur émettra un avertissement, et à l'exécution vous obtiendrez une List<LinkedHashMap>, et non une List<MyClass>. Les génériques sont effacés, et Jackson ne sait pas en quoi mapper les éléments.

TypeReference : la méthode correcte pour List

La solution consiste à utiliser TypeReference. Il s'agit d'une classe interne anonyme qui conserve les informations sur les génériques via la réflexion :

List<MyClass> list = mapper.readValue(json, new TypeReference<List<MyClass>>() {});

Notez les {} — cela crée une classe anonyme qui capture le type. Jackson, via TypeFactory, comprend qu'il doit désérialiser une List de MyClass. Cette approche est le standard en or en 2025.

Quand TypeReference est-il peu pratique ?

Si vous construisez le type dynamiquement (par exemple, à partir d'une configuration).
Si vous devez désérialiser plusieurs fois la même chose — créer une classe anonyme à chaque fois peut être coûteux.

Pour ces cas, il existe une alternative — CollectionType.

CollectionType : la puissance de JavaType

Jackson fournit TypeFactory pour construire des types complexes :

JavaType type = mapper.getTypeFactory()    .constructCollectionType(List.class, MyClass.class);List<MyClass> list = mapper.readValue(json, type);

Cette méthode :

Ne crée pas de classes anonymes (moins de surcharge).
Permet de construire des types dynamiquement : constructParametricType(Map.class, String.class, MyClass.class).
Idéale pour les bibliothèques et frameworks où les types sont inconnus à la compilation.

Meilleure pratique 2025 : utilisez TypeReference pour les cas simples, CollectionType lorsque vous avez besoin de flexibilité ou de performance.