Pourquoi `Long` et `Double` plutôt que `long` et `double` ?

Parce qu’un champ JSON peut être nul, et un primitif non. Décoder `{"score": null}` dans un `double` lève une exception ou donne 0.0 en silence, selon la bibliothèque et ses réglages. Les types boxés rendent l’absence représentable — et ce sont aussi ceux qu’exigent les génériques si la valeur atterrit dans une `List`.

D’où vient le `@JsonProperty` ?

Du fait que la clé ne survit pas au voyage. `content-type` ne peut pas être un nom de composant : il devient `contentType`, et Jackson cherche alors `contentType` dans le JSON sans rien trouver. L’annotation fixe la clé d’origine. Elle manquait : le record cessait en silence de lire le document dont il venait. C’était un vrai défaut, corrigé.

J’utilise Gson, pas Jackson. Qu’est-ce qui change ?

L’annotation. Gson veut `@SerializedName("content-type")` au même endroit, et JSON-B veut `@JsonbProperty`. Les noms de composants et les types sont identiques dans les deux cas : un remplacement de l’annotation et de son import suffit à l’adaptation.

JSON en Java — des records que Jackson décode

Transformez un échantillon JSON en records Java. Types boxés et annotation Jackson dès qu’un nom devait changer : le payload se décode tel qu’écrit.

Instantané Privé Zéro cookie

Nom racine

Entrée JSON

Sortie Java

Ce que fait cet outil

Un échantillon JSON devient des records Java, un par objet.

{ "id": 1, "firstName": "Ada", "address": { "city": "Paris" } }

public record Root(
    Long id,
    String firstName,
    Address address
) {}

public record Address(
    String city
) {}

Les records sont la façon la plus courte d’exprimer « des données et rien d’autre » en Java moderne : constructeur, accesseurs, equals, hashCode et toString viennent avec. Il faut Java 16 ou plus.

La clé survit au renommage

Un nom de composant suit les règles de Java : pas de tiret, pas de chiffre initial, pas de mot réservé. content-type devient contentType, class devient class_, 2fa devient f2fa. Chaque fois que le nom doit changer, la clé d’origine l’accompagne :

import com.fasterxml.jackson.annotation.JsonProperty;

public record Root(
    @JsonProperty("content-type") String contentType,
    @JsonProperty("class") Long class_,
    Boolean ok
) {}

Sans cette annotation, Jackson cherche contentType et ne trouve rien — le record ne lit plus le document dont il a été engendré. Elle manquait jusqu’à l’écriture de cette page ; le défaut est corrigé, et l’annotation n’apparaît que là où le nom a réellement changé, avec son import.

Des types boxés, et pourquoi

Chaque nombre est un Long ou un Double, chaque booléen un Boolean. JSON a le null, les primitifs Java non, et un double qui reçoit un null devient 0.0 — une valeur qu’on ne distingue plus d’un vrai zéro. Les types boxés gardent le null représentable, ce que le format autorise.

Pour la même raison, null et les valeurs inconnues deviennent Object, et un tableau d’entre elles une List<Object>.

Ce qu’un échantillon ne peut pas dire

Rien n’est optionnel et rien n’est annoté @Nullable : chaque composant est là parce que le document le contenait. Les records sont immuables en surface : un champ dont vous déciderez plus tard qu’il peut manquer est un changement de forme, pas un drapeau.

Un scalaire à la racine — 42, "texte" — est refusé : Java n’a pas d’alias de type, il n’y a donc rien à nommer. Un tableau JSON d’objets vous rend le record de son élément, qui est la forme que vous liez réellement à une List<Root>.

Confidentiel par conception

Tout s’exécute localement dans votre navigateur en JavaScript. Vos données ne sont jamais envoyées sur un serveur, ce qui rend l’outil sûr pour des contenus sensibles, et il fonctionne hors ligne.

Questions fréquentes

Pourquoi `Long` et `Double` plutôt que `long` et `double` ?: Parce qu’un champ JSON peut être nul, et un primitif non. Décoder `{"score": null}` dans un `double` lève une exception ou donne 0.0 en silence, selon la bibliothèque et ses réglages. Les types boxés rendent l’absence représentable — et ce sont aussi ceux qu’exigent les génériques si la valeur atterrit dans une `List`.
D’où vient le `@JsonProperty` ?: Du fait que la clé ne survit pas au voyage. `content-type` ne peut pas être un nom de composant : il devient `contentType`, et Jackson cherche alors `contentType` dans le JSON sans rien trouver. L’annotation fixe la clé d’origine. Elle manquait : le record cessait en silence de lire le document dont il venait. C’était un vrai défaut, corrigé.
J’utilise Gson, pas Jackson. Qu’est-ce qui change ?: L’annotation. Gson veut `@SerializedName("content-type")` au même endroit, et JSON-B veut `@JsonbProperty`. Les noms de composants et les types sont identiques dans les deux cas : un remplacement de l’annotation et de son import suffit à l’adaptation.