JSON to Java DTO Generator

JSON to Java DTO: Generating POJOs and Records from JSON Payloads

Java's verbosity is notorious for DTOs — a six-field class can easily span 80 lines with private fields, constructor, getters, setters, equals(), hashCode(), and toString(). Generating the boilerplate from a JSON payload lets you focus on the fields you actually need. Java 16+ records eliminate most of this ceremony for immutable DTOs, and Lombok handles the rest for mutable cases.

Live Example: API Response to POJO

// Input JSON
{
  "product_id": "prd_7721",
  "name": "Wireless Keyboard",
  "price_usd": 89.99,
  "stock_count": 142,
  "is_available": true,
  "category": "electronics",
  "description": null
}

// Generated Java POJO
import org.jetbrains.annotations.Nullable;

public class Root {
    private String product_id;
    private String name;
    private double price_usd;
    private double stock_count;
    private boolean is_available;
    private String category;
    @Nullable private String description;

    public Root() {}

    public String getProduct_id() { return product_id; }
    public void setProduct_id(String product_id) { this.product_id = product_id; }

    public String getName() { return name; }
    public void setName(String name) { this.name = name; }

    public double getPrice_usd() { return price_usd; }
    public void setPrice_usd(double price_usd) { this.price_usd = price_usd; }

    public double getStock_count() { return stock_count; }
    public void setStock_count(double stock_count) { this.stock_count = stock_count; }

    public boolean getIs_available() { return is_available; }
    public void setIs_available(boolean is_available) { this.is_available = is_available; }

    public String getCategory() { return category; }
    public void setCategory(String category) { this.category = category; }

    @Nullable
    public String getDescription() { return description; }
    public void setDescription(@Nullable String description) { this.description = description; }
}

The Modern Alternative: Java Records (Java 16+)

Java records auto-generate the constructor, accessors, equals(), hashCode(), and toString(). For immutable DTOs, records are cleaner than POJOs or Lombok:

import com.fasterxml.jackson.annotation.JsonProperty;

// Java record — immutable, all fields final
public record ProductDto(
    @JsonProperty("product_id")  String productId,
    String name,
    @JsonProperty("price_usd")   double priceUsd,
    @JsonProperty("stock_count") int stockCount,     // int not double for counts
    @JsonProperty("is_available") boolean isAvailable,
    String category,
    @JsonProperty("description") String description  // null if absent in JSON
) {}

// Spring Boot: @RequestBody auto-deserializes with Jackson
@PostMapping("/products")
public ResponseEntity<ProductDto> createProduct(@RequestBody ProductDto dto) {
    // dto.productId(), dto.name(), dto.priceUsd() — accessor methods, not getters
    return ResponseEntity.ok(productService.create(dto));
}

Lombok: The Pragmatic Middle Ground

// build.gradle
dependencies {
    compileOnly 'org.projectlombok:lombok:1.18.32'
    annotationProcessor 'org.projectlombok:lombok:1.18.32'
    implementation 'com.fasterxml.jackson.core:jackson-databind:2.17.0'
}

import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.Builder;
import lombok.Data;

@Data           // generates getters, setters, equals, hashCode, toString
@Builder        // generates builder pattern
public class ProductDto {
    @JsonProperty("product_id")
    private String productId;

    private String name;

    @JsonProperty("price_usd")
    private double priceUsd;

    @JsonProperty("stock_count")
    private int stockCount;

    @JsonProperty("is_available")
    private boolean isAvailable;

    private String category;
    private String description;  // null if not present

    // Usage with builder
    // ProductDto dto = ProductDto.builder()
    //     .productId("prd_7721")
    //     .name("Wireless Keyboard")
    //     .priceUsd(89.99)
    //     .build();
}

Bean Validation: jakarta.validation Annotations

import jakarta.validation.constraints.*;

public record CreateProductRequest(
    @NotBlank
    @JsonProperty("product_id")
    String productId,

    @NotBlank @Size(max = 200)
    String name,

    @Positive
    @JsonProperty("price_usd")
    double priceUsd,

    @PositiveOrZero
    @JsonProperty("stock_count")
    int stockCount,

    @NotNull
    String category
) {}

// Spring Boot: @Valid triggers validation before controller method executes
@PostMapping("/products")
public ResponseEntity<?> createProduct(@Valid @RequestBody CreateProductRequest req) {
    // If validation fails, Spring returns 400 Bad Request automatically
    return ResponseEntity.ok(productService.create(req));
}

POJO vs Record vs Lombok — When to Use Which

• Java Record (Java 16+): Best for immutable DTOs — request/response bodies, query results, value objects. Shortest code, no dependencies. Limitation: cannot extend classes (can implement interfaces).
• Lombok @Data: Best for mutable entities (JPA, Hibernate) where you need setters. No Java version requirement beyond 8. Requires annotation processor setup. Works well with Spring Data JPA.
• Plain POJO: Maximum compatibility, zero dependencies, but verbose. Use when you can't add Lombok or need Java 11 compatibility with mutable state.
• Type fix: The generator uses double for all JSON numbers. Change stock_count and other count/integer fields to int or long after generation.

Frequently Asked Questions

Why does Jackson need @JsonProperty for snake_case fields? Jackson uses Java accessor method names (e.g., getProductId → productId) by default. Snake_case JSON keys don't map to camelCase accessors automatically. Either annotate with @JsonProperty("product_id") or configure Jackson globally: mapper.setPropertyNamingStrategy(PropertyNamingStrategies.SNAKE_CASE).

Can Java records be used with JPA/Hibernate? Generally no — JPA entities require a no-arg constructor and mutable fields. Use records for DTOs (transport layer) and Lombok @Entity classes or plain POJOs for the persistence layer. Map between them in your service layer.

Is my JSON sent to a server? No. TypeMorph runs entirely in your browser — none of your data leaves your machine.