I-convert ang mga Java class sa JSON!

I-paste ang Java (class·record) na code at kumuha ng halimbawang JSON! Sinusuportahan ang Jackson @JsonProperty, @JsonIgnore, Lombok. Magagamit sa API docs at test request body (mock request body).
Java
Resulta
 

I-convert ang mga Java class sa JSON!

Bigyan ito ng source ng Java DTO, POJO o record at makukuha mo ang JSON na malamang na ilalabas ng default na Jackson setup ng Spring Boot. Galing sa mga naka-declare na field ang mga key, at ina-apply ang @JsonProperty, @JsonIgnore, @JsonIgnoreProperties at ang pag-exclude sa static/transient.

Gamitin ito para gumawa ng Swagger example o sample payload para sa frontend mula sa request o response DTO ng isang controller, o para lang i-check kung aling mga key ang ilalabas ng isang Lombok @Data class.

Paano gamitin

  1. I-paste ang source ng DTO nang ganoon lang. Puwedeng iwan ang mga import, Lombok annotation, constructor at method.
  2. Isama sa parehong input ang mga nested na static class, record at enum declaration para mapunan ng istruktura nila ang mga field na nagre-reference sa kanila.
  3. Kapag Awtomatiko ang Root type, ang class na hindi ginagamit ng ibang class bilang field type ang pinipili. Kapag nagre-reference sa isa't isa ang mga entity, piliin mula sa listahan ang gusto mo.
  4. Kopyahin ang output papunta sa @Schema(example = ...), isang REST Docs snippet o MockMvc request body.

Halimbawa

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

Tinatanggal ang password ng class-level na @JsonIgnoreProperties({"password"}), at hindi kailanman lumalabas ang static final na serialVersionUID. Binabasa ang initializer na Grade.SILVER, kaya "SILVER" ang grade sa halip na ang unang constant ng enum. Lumalawak bilang array ng object ang nested na record Address.

Mga sinusuportahang feature

  • Nagiging key ang mga field name, at napapalitan ito ng @JsonProperty("x") o @JsonProperty(value = "x").
  • Hindi kasama: mga field na may @JsonIgnore, mga key na nakalista sa class-level na @JsonIgnoreProperties({...}), at mga field na static o transient.
  • Suportado ang mga component ng record ng Java 16+, mga nested na static class declaration at mga field na minana gamit ang extends (nauuna ang mga field ng parent).
  • Hawak ng mga enum field ang unang constant bilang string, o ang constant na pinangalanan sa field initializer; pinapalitan ng @JsonProperty("x") sa isang constant ang string sa x.
  • Sinusunod ng mga petsa ang default na Jackson output ng Spring Boot: LocalDateTime → 1970-01-01T00:00:00, LocalDate → 1970-01-01, Instant/OffsetDateTime/ZonedDateTime → ISO string na nagtatapos sa Z, java.util.Date/Timestamp → 1970-01-01T00:00:00.000+00:00.
  • Nagiging 0 ang mga numeric wrapper gaya ng BigDecimal at Long, ina-unwrap sa T ang Optional<T>, nagiging Base64 string ang byte[], at may maayos na anyong value ang UUID at ang ObjectId ng MongoDB.
  • May isang sample element ang List, Set at mga array; gumagamit ng "0" ang map na may numeric key gaya ng Map<Long, V>, at "key" naman kung hindi.

Mga gamit

Pagpuno ng mga springdoc / Swagger example

Lumalayo sa totoo ang mga mano-manong isinulat na example value tuwing may idinadagdag na field sa DTO. I-generate ang JSON mula sa source ng DTO at doon na ayusin ang mga value, para walang key na nawawala o mali ang spelling.

Mga request body para sa MockMvc o RestAssured test

Gawin ang request JSON nang direkta mula sa @RequestBody DTO at i-paste ito sa isang text block (""") sa test mo. Naka-apply na ang mga key na pinalitan ng pangalan gamit ang @JsonProperty, tugma sa totoong binding.

Pagbabahagi ng hugis ng response sa frontend

Direktang nakukuha ng mga frontend developer na hindi nagbabasa ng backend code ang JSON structure ng endpoint, sa halip na kailangan pa nilang intindihin ang isang Java class.

Mga paalala at limitasyon

  • Ginagamit ang mga field initializer kapag literal sila (= "guest", = 100, = true) o enum constant (= Grade.SILVER); ang iba pa, gaya ng new ArrayList<>() o method call, ay bumabalik sa placeholder ng type.
  • Idinadagdag bilang property ang mga getter na walang katugmang field, gaya ng getFullName() o boolean isVip(), gaya ng ginagawa ng Jackson, at sinusunod ang @JsonIgnore/@JsonProperty sa getter na iyon. Sa kabaligtaran, ipinapalagay na visible ang private field na walang getter (gaya ng sa Lombok @Getter/@Data).
  • Hindi ina-apply ang mga global naming rule (@JsonNaming(SnakeCaseStrategy.class), spring.jackson.property-naming-strategy) at ang mga date pattern ng @JsonFormat.
  • Hindi ini-evaluate ang mga @JsonValue method sa mga enum, kaya ipinapakita pa rin ng ganoong enum ang constant (o ang pangalan nito sa @JsonProperty).
  • Pinapasimple bilang array ng mga element ang mga field na Page<T>/Slice<T> ng Spring Data; sa totoong Page serialization, object ito na may content, pageable at iba pa.

Mga madalas itanong

Gumagana ba ito kapag Lombok @Data o @Getter ang gumagawa ng mga accessor?

Oo. Binubuo ang mga key mula sa mga naka-declare na field, kaya hindi kailangang nasa source ang mga getter at setter na ginagawa ng Lombok sa compile time.

Bakit string ang LocalDateTime at hindi array ng mga numero?

Nire-register ng Spring Boot ang jackson-datatype-jsr310 at dina-disable ang WRITE_DATES_AS_TIMESTAMPS bilang default, kaya ISO string ang lumalabas; sinusunod ng sample ang default na iyon. Ang isang bare na Jackson ObjectMapper naman ay puwedeng magsulat ng array gaya ng [1970,1,1,0,0].

Puwede ba akong mag-paste ng JPA entity?

Parehong field structure ang mga entity, kaya maayos silang napa-parse. Mag-loo-loop ang mga bidirectional association gaya ng @OneToMany, kaya pinapalawak sila nang isang beses at saka pinuputol gamit ang null o empty array. May hiwalay ring page na Spring Boot JPA → JSON.

Paano kung nasa setter o sa getter ng isang existing na field ang @JsonIgnore?

Laging ina-apply ang mga annotation sa field declaration, at ina-apply lang ang mga annotation sa getter kapag walang field na ganoon ang pangalan. Hindi ina-apply ang @JsonIgnore sa setter, o sa getter ng isang naka-declare na field, kaya ilipat ito sa field para makita ang epekto nito.