Wandle Java-Klassen in JSON um!

Füge Java-Code (class·record) ein und erhalte ein Beispiel-JSON! Unterstützt Jackson @JsonProperty, @JsonIgnore, Lombok. Praktisch für API-Dokumentation und Test-Request-Bodys (mock request body).
Java
Ergebnis
 

Wandle Java-Klassen in JSON um!

Gib Java-Quelltext eines DTO, POJO oder record ein und erhalte das JSON, das das Standard-Jackson-Setup von Spring Boot höchstwahrscheinlich erzeugen würde. Die Keys stammen aus den deklarierten Feldern, wobei @JsonProperty, @JsonIgnore, @JsonIgnoreProperties und die Ausschlüsse für static/transient angewendet werden.

Damit erzeugst du aus dem Request- oder Response-DTO eines Controllers ein Swagger-Beispiel oder einen Beispiel-Payload fürs Frontend, oder du prüfst einfach, welche Keys eine Lombok-Klasse mit @Data ausgibt.

So funktioniert es

  1. Füge den DTO-Quelltext unverändert ein. Imports, Lombok-Annotationen, Konstruktoren und Methoden dürfen bleiben.
  2. Nimm verschachtelte static class-, record- und enum-Deklarationen in dieselbe Eingabe auf, damit Felder, die darauf verweisen, mit ihrer Struktur befüllt werden.
  3. Steht Wurzeltyp auf Automatisch, wird die Klasse gewählt, die keine andere Klasse als Feldtyp verwendet. Verweisen Entities gegenseitig aufeinander, wählst du die gewünschte aus der Liste.
  4. Kopiere die Ausgabe in @Schema(example = ...), ein REST-Docs-Snippet oder einen MockMvc-Request-Body.

Beispiel

Eingabe (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) {}
}
Ausgabe (JSON)
{
  "memberId": 0,
  "nick_name": "",
  "grade": "SILVER",
  "birthDate": "1970-01-01",
  "addresses": [
    {
      "zipCode": "",
      "city": "",
      "primary": false
    }
  ]
}

password wird durch das @JsonIgnoreProperties({"password"}) auf Klassenebene entfernt, und die static final-Konstante serialVersionUID taucht nie auf. Der Initialisierer Grade.SILVER wird gelesen, daher ist grade gleich "SILVER" und nicht die erste Konstante des Enums. Das verschachtelte record Address wird zu einem Array von Objekten aufgeklappt.

Unterstützte Funktionen

  • Feldnamen werden zu Keys, überschrieben durch @JsonProperty("x") oder @JsonProperty(value = "x").
  • Ausgeschlossen werden @JsonIgnore-Felder, in einem @JsonIgnoreProperties({...}) auf Klassenebene aufgeführte Keys sowie static- und transient-Felder.
  • Unterstützt record-Komponenten ab Java 16, verschachtelte static class-Deklarationen und über extends geerbte Felder (Felder der Elternklasse zuerst).
  • Enum-Felder enthalten die erste Konstante als String oder die im Feldinitialisierer genannte Konstante; @JsonProperty("x") an einer Konstante ändert den String zu x.
  • Datumswerte folgen der Standard-Jackson-Ausgabe von Spring Boot: LocalDateTime → 1970-01-01T00:00:00, LocalDate → 1970-01-01, Instant/OffsetDateTime/ZonedDateTime → ISO-String mit Z am Ende, java.util.Date/Timestamp → 1970-01-01T00:00:00.000+00:00.
  • Numerische Wrapper wie BigDecimal und Long werden zu 0, Optional<T> wird zu T ausgepackt, byte[] wird zu einem Base64-String, und UUID sowie MongoDB-ObjectId bekommen wohlgeformte Werte.
  • List, Set und Arrays bekommen ein Beispielelement; eine Map mit numerischem Key wie Map<Long, V> verwendet "0", sonst "key".

Anwendungsfälle

Beispiele für springdoc / Swagger befüllen

Von Hand geschriebene example-Werte veralten jedes Mal, wenn ein Feld zum DTO hinzukommt. Erzeuge das JSON aus dem DTO-Quelltext und verfeinere die Werte von dort aus, damit kein Key fehlt oder falsch geschrieben ist.

Request-Bodies für MockMvc- oder RestAssured-Tests

Erstelle das Request-JSON direkt aus dem @RequestBody-DTO und füge es in einen Textblock (""") in deinem Test ein. Mit @JsonProperty umbenannte Keys sind bereits angewendet, passend zum echten Binding.

Die Antwortstruktur mit dem Frontend teilen

Frontend-Entwickler, die den Backend-Code nicht lesen, bekommen die JSON-Struktur des Endpoints direkt, statt eine Java-Klasse interpretieren zu müssen.

Hinweise und Einschränkungen

  • Feldinitialisierer werden verwendet, wenn sie ein Literal (= "guest", = 100, = true) oder eine Enum-Konstante (= Grade.SILVER) sind; alles andere, etwa new ArrayList<>() oder ein Methodenaufruf, fällt auf den Platzhalter des Typs zurück.
  • Getter ohne passendes Feld wie getFullName() oder boolean isVip() werden wie bei Jackson als Properties hinzugefügt, unter Beachtung von @JsonIgnore/@JsonProperty an diesem Getter. Umgekehrt gilt ein private-Feld ohne Getter als sichtbar (wie bei Lombok @Getter/@Data).
  • Globale Benennungsregeln (@JsonNaming(SnakeCaseStrategy.class), spring.jackson.property-naming-strategy) und @JsonFormat-Datumsmuster werden nicht angewendet.
  • @JsonValue-Methoden an Enums werden nicht ausgewertet, solche Enums zeigen also weiterhin die Konstante (oder ihren @JsonProperty-Namen).
  • Felder vom Typ Page<T>/Slice<T> aus Spring Data werden zu einem Array von Elementen vereinfacht; die echte Page-Serialisierung ist ein Objekt mit content, pageable und mehr.

Häufige Fragen

Funktioniert es, wenn Lombok @Data oder @Getter die Accessoren erzeugt?

Ja. Die Keys werden aus den deklarierten Feldern gebildet, die von Lombok zur Compile-Zeit erzeugten Getter und Setter müssen also nicht im Quelltext stehen.

Warum ist LocalDateTime ein String und kein Array aus Zahlen?

Spring Boot registriert jackson-datatype-jsr310 und deaktiviert standardmäßig WRITE_DATES_AS_TIMESTAMPS, was ISO-Strings ergibt; das Beispiel folgt dieser Voreinstellung. Ein nackter Jackson-ObjectMapper schreibt stattdessen womöglich ein Array wie [1970,1,1,0,0].

Kann ich eine JPA-Entity einfügen?

Entities haben dieselbe Feldstruktur und werden problemlos geparst. Bidirektionale Assoziationen wie @OneToMany würden eine Schleife bilden, daher werden sie einmal aufgeklappt und dann mit null oder einem leeren Array abgeschnitten. Es gibt außerdem eine eigene Seite Spring Boot JPA → JSON.

Was, wenn @JsonIgnore an einem Setter oder am Getter eines vorhandenen Feldes sitzt?

Annotationen an einer Felddeklaration gelten immer, Annotationen an einem Getter nur, wenn kein Feld dieses Namens existiert. @JsonIgnore an einem Setter oder am Getter eines deklarierten Feldes wird nicht angewendet; verschiebe es ans Feld, um die Wirkung zu sehen.