Convert JSON to Java
classes online, free & instant

From JSON to type-safe Java in seconds

No account. No upload. No nonsense.

Related JSON tools

Common questions answered

Converting JSON to Java classes

Java uses Jackson or Gson for JSON serialization, requiring Java classes (POJOs) with matching fields. This tool generates complete class definitions with proper types (String, int, double, boolean), getter/setter methods, and @JsonProperty annotations for Jackson compatibility.

The converter follows Java conventions: PascalCase class names, camelCase fields with private access, JavaBean getter/setter pattern, and List<T> for arrays. The output includes Jackson imports. For modern Java, it can produce Java 16+ record types, which are more concise than traditional POJOs.

{
  "name": "Alice",
  "age": 30,
  "roles": ["admin"],
  "address": {
    "city": "Portland"
  }
}

public class Root {
    private String name;
    private int age;
    private List<String> roles;
    private Address address;

    // getters and setters
    public String getName() {
        return name;
    }
    // ... (generated for all fields)
}

Get the most out of this tool

• Use Java records (Java 16+) for immutable DTOs — more concise than traditional POJOs with getters/setters.
• Jackson @JsonProperty maps JSON keys to Java fields when they differ in casing or naming.
• Nested JSON objects generate separate classes — organize as inner classes or in a separate package.

Java POJO generation from JSON explained

Java's strong typing means you must define explicit classes to deserialize JSON into typed objects. The two most widely used Java JSON libraries are Jackson (by FasterXML, used by Spring Boot by default) and Gson (by Google, common in Android development). Both support deserializing JSON into Plain Old Java Objects (POJOs) — regular Java classes with fields and getter/setter methods. This converter generates Java POJOs with Jackson annotations, which is the standard for Spring Boot applications.

The converter maps JSON types to Java types with specific conventions. JSON strings become String. JSON integers become int (primitive) or Integer (boxed) — the boxed form is preferred when null is possible. JSON floating-point numbers become double or Double. JSON booleans become boolean or Boolean. JSON null maps to null for boxed types. Arrays become List<T> (from java.util.List), and nested objects become separate Java class files — each nested object gets its own public class.

Jackson annotations handle the naming mismatch between JSON conventions and Java conventions. JSON APIs typically use camelCase or snake_case keys. Java classes use camelCase fields by default, which maps well to camelCase JSON. For snake_case JSON keys, the @JsonProperty("field_name") annotation maps the snake_case JSON key to a camelCase Java field name. Alternatively, configuring ObjectMapper with MapperFeature.ACCEPT_CASE_INSENSITIVE_PROPERTIES handles case differences globally.

Spring Boot auto-configures Jackson for JSON serialization and deserialization in REST controllers. @RestController methods that return Java objects are automatically serialized to JSON. @RequestBody parameters are automatically deserialized from the request JSON. The generated Java classes work directly as Spring MVC request and response types. Spring Boot also provides @JsonCreator and @JsonProperty on constructors for immutable deserialization.

Java 14+ records provide a concise alternative to traditional POJOs for immutable data models. A Java record automatically generates a canonical constructor, getters, equals(), hashCode(), and toString(). Jackson 2.12+ supports records natively. For new Spring Boot 3+ projects (Java 17+), records are an excellent choice for JSON DTOs — they are more concise than classes with boilerplate getters and setters, reducing the code that needs to be written and maintained.

Lombok is a popular Java annotation processor that reduces boilerplate in POJOs. @Data generates getters, setters, equals(), hashCode(), and toString(). @Builder generates a builder pattern. @NoArgsConstructor and @AllArgsConstructor generate constructors. Many developers combine Lombok annotations with Jackson annotations for clean, readable POJO code. The converter generates standard POJOs that you can optionally annotate with Lombok for brevity.

When developers use this tool

Additional frequently asked questions