Convertissez des classes Java en JSON !

Collez du code Java (class·record) et obtenez un JSON d'exemple ! Compatible avec Jackson @JsonProperty, @JsonIgnore, Lombok. Pratique pour documenter une API et créer des corps de requête de test (mock request body).
Java
Résultat
 

Convertissez des classes Java en JSON !

Donnez-lui le source d'un DTO, d'un POJO ou d'un record Java et obtenez le JSON que produirait vraisemblablement la configuration Jackson par défaut de Spring Boot. Les clés viennent des champs déclarés, en appliquant @JsonProperty, @JsonIgnore, @JsonIgnoreProperties et l'exclusion des champs static/transient.

Utilisez-le pour produire un exemple Swagger ou un payload d'exemple pour le frontend à partir du DTO de requête ou de réponse d'un contrôleur, ou simplement pour vérifier quelles clés émettra une classe Lombok @Data.

Mode d'emploi

  1. Collez le source du DTO tel quel. Imports, annotations Lombok, constructeurs et méthodes peuvent rester.
  2. Incluez les déclarations imbriquées static class, record et enum dans la même entrée pour que les champs qui y font référence soient remplis avec leur structure.
  3. Avec Type racine sur Automatique, c'est la classe qu'aucune autre n'utilise comme type de champ qui est choisie. Quand des entités se référencent mutuellement, choisissez celle que vous voulez dans la liste.
  4. Copiez la sortie dans @Schema(example = ...), un snippet REST Docs ou un corps de requête MockMvc.

Exemple

Entrée (Java)
@Data
@JsonIgnoreProperties({"password"})
public class MemberResponse {
    private Long memberId;
    @JsonProperty("nick_name")
    private String nickname;
    private String password;
    private Grade grade = Grade.SILVER;
    private LocalDate birthDate;
    private List<Address> addresses;
    private static final long serialVersionUID = 1L;

    public enum Grade { BRONZE, SILVER, GOLD }

    public record Address(String zipCode, String city, boolean primary) {}
}
Sortie (JSON)
{
  "memberId": 0,
  "nick_name": "",
  "grade": "SILVER",
  "birthDate": "1970-01-01",
  "addresses": [
    {
      "zipCode": "",
      "city": "",
      "primary": false
    }
  ]
}

password est retiré par le @JsonIgnoreProperties({"password"}) placé sur la classe, et le serialVersionUID static final n'apparaît jamais. L'initialiseur Grade.SILVER est lu, donc grade vaut "SILVER" plutôt que la première constante de l'enum. Le record Address imbriqué se développe en tableau d'objets.

Fonctionnalités prises en charge

  • Les noms de champs deviennent des clés, remplacées par @JsonProperty("x") ou @JsonProperty(value = "x").
  • Exclus : les champs @JsonIgnore, les clés listées dans un @JsonIgnoreProperties({...}) de classe, et les champs static ou transient.
  • Prend en charge les composants de record Java 16+, les déclarations static class imbriquées et les champs hérités via extends (champs du parent en premier).
  • Les champs enum contiennent la première constante sous forme de chaîne, ou la constante nommée dans l'initialiseur du champ ; @JsonProperty("x") sur une constante change la chaîne en x.
  • Les dates suivent la sortie Jackson par défaut de Spring Boot : LocalDateTime → 1970-01-01T00:00:00, LocalDate → 1970-01-01, Instant/OffsetDateTime/ZonedDateTime → chaîne ISO terminée par Z, java.util.Date/Timestamp → 1970-01-01T00:00:00.000+00:00.
  • Les wrappers numériques comme BigDecimal et Long deviennent 0, Optional<T> est déballé en T, byte[] devient une chaîne Base64, et UUID ainsi que l'ObjectId MongoDB reçoivent des valeurs bien formées.
  • List, Set et les tableaux reçoivent un élément d'exemple ; une map comme Map<Long, V> à clé numérique utilise "0", sinon "key".

Cas d'utilisation

Remplir les exemples springdoc / Swagger

Les valeurs example écrites à la main divergent à chaque ajout de champ dans un DTO. Générez le JSON à partir du source du DTO et peaufinez les valeurs ensuite : aucune clé ne manque ni n'est mal orthographiée.

Corps de requête pour les tests MockMvc ou RestAssured

Créez le JSON de requête directement à partir du DTO @RequestBody et collez-le dans un text block (""") de votre test. Les clés renommées avec @JsonProperty sont déjà appliquées, comme lors du vrai binding.

Partager la forme d'une réponse avec le frontend

Les développeurs frontend qui ne lisent pas le code backend obtiennent directement la structure JSON de l'endpoint, sans avoir à interpréter une classe Java.

Remarques et limites

  • Les initialiseurs de champs sont utilisés quand ce sont des littéraux (= "guest", = 100, = true) ou une constante d'enum (= Grade.SILVER) ; tout le reste, comme new ArrayList<>() ou un appel de méthode, retombe sur la valeur par défaut du type.
  • Les getters sans champ correspondant, comme getFullName() ou boolean isVip(), sont ajoutés comme propriétés à la manière de Jackson, en respectant @JsonIgnore/@JsonProperty sur ce getter. À l'inverse, un champ private sans getter est supposé visible (comme avec Lombok @Getter/@Data).
  • Les règles de nommage globales (@JsonNaming(SnakeCaseStrategy.class), spring.jackson.property-naming-strategy) et les motifs de date @JsonFormat ne sont pas appliqués.
  • Les méthodes @JsonValue des enums ne sont pas évaluées : ces enums affichent donc toujours la constante (ou son nom @JsonProperty).
  • Les champs Spring Data Page<T>/Slice<T> sont simplifiés en tableau d'éléments ; la vraie sérialisation d'une Page est un objet avec content, pageable et d'autres.

FAQ

Est-ce que ça marche quand Lombok @Data ou @Getter génère les accesseurs ?

Oui. Les clés sont construites à partir des champs déclarés : les getters et setters générés par Lombok à la compilation n'ont pas besoin de figurer dans le source.

Pourquoi LocalDateTime est-il une chaîne et non un tableau de nombres ?

Spring Boot enregistre jackson-datatype-jsr310 et désactive WRITE_DATES_AS_TIMESTAMPS par défaut, ce qui donne des chaînes ISO ; l'exemple suit ce comportement par défaut. Un ObjectMapper Jackson nu peut au contraire écrire un tableau comme [1970,1,1,0,0].

Puis-je coller une entité JPA ?

Les entités ont la même structure de champs, donc elles sont bien analysées. Les associations bidirectionnelles comme @OneToMany boucleraient : elles sont développées une fois puis coupées avec null ou un tableau vide. Il existe aussi une page dédiée Spring Boot JPA → JSON.

Et si @JsonIgnore est placé sur un setter ou sur le getter d'un champ existant ?

Les annotations sur une déclaration de champ s'appliquent toujours, et celles sur un getter seulement s'il n'existe aucun champ de ce nom. @JsonIgnore sur un setter, ou sur le getter d'un champ déclaré, n'est pas appliqué : déplacez-le sur le champ pour en voir l'effet.