JSON to Java Converter

Generate Java Classes from JSON

This tool automatically generates Java class definitions from your JSON data. It infers types from values, handles nested objects, and supports popular libraries like Lombok, Jackson, and Gson.

Output Options

Standard POJO with Lombok

Using Lombok's @Data annotation eliminates boilerplate by auto-generating getters, setters, toString, equals, and hashCode:

@Data
public class User {
    @JsonProperty("user_name")
    private String userName;
    
    private Integer age;
    private List<String> roles;
}

Java 16+ Records

Records are immutable data classes with concise syntax. Ideal for DTOs:

public record User(
    @JsonProperty("user_name") String userName,
    Integer age,
    List<String> roles
) {}

Jackson vs Gson

Type Inference

The converter maps JSON types to Java:

Example Conversion

Input JSON:

{
  "id": 1,
  "username": "john_doe",
  "profile": {
    "firstName": "John",
    "age": 30
  }
}

Generated Java (with Lombok + Jackson):

package com.example.model;

import java.util.List;
import lombok.Data;
import com.fasterxml.jackson.annotation.JsonProperty;

@Data
public class Root {
    private Integer id;
    
    private String username;
    
    private Profile profile;
}

@Data
public class Profile {
    @JsonProperty("firstName")
    private String firstName;
    
    private Integer age;
}

Using Generated Classes

With Jackson

ObjectMapper mapper = new ObjectMapper();

// Deserialize
String json = getJsonFromApi();
Root data = mapper.readValue(json, Root.class);

// Serialize
String output = mapper.writeValueAsString(data);

With Gson

Gson gson = new Gson();

// Deserialize
Root data = gson.fromJson(json, Root.class);

// Serialize
String output = gson.toJson(data);

Best Practices

• Use Lombok — Eliminates boilerplate getters/setters
• Use wrapper types — Integer instead of intto handle nulls
• Add validation — Consider adding @NotNull,@Size annotations manually
• Use records for DTOs — Immutable, thread-safe, less code

Related Tools

• JSON Validator — Validate JSON before converting
• JSON to C# — Generate C# classes
• JSON to TypeScript — Generate TS interfaces
• JSON to Python — Generate Python dataclasses
• JSON Schema Validator — Validate structure

Frequently Asked Questions

Should I use Lombok or write getters/setters?

Lombok is recommended for most projects — it reduces boilerplate significantly. However, some teams prefer explicit code for debugging or IDE support reasons.

When should I use Records vs Classes?

Use records for immutable data transfer objects (DTOs). Use classes when you need mutability, inheritance, or complex behavior.

How do I handle null values?

The converter uses wrapper types (Integer, Boolean) which can be null. For primitives that shouldn't be null, change toint, boolean manually.

Common Mistakes & Pro Tips

• Whole numbers default to int and can overflow — A JSON integer is typically mapped to `int`, but Java's `int` is 32-bit (max ~2.1 billion). A 64-bit ID or epoch-millis timestamp will overflow it, so promote those fields to `long` (or `Long`). For arbitrary precision use `BigInteger`, and for exact decimals like currency use `BigDecimal` instead of `double`.
• Use wrapper types so null is possible — Primitive types (`int`, `boolean`, `double`) cannot hold `null`, so a JSON field that may be absent or null must use the boxed wrapper (`Integer`, `Boolean`, `Double`). Jackson/Gson will throw or default a primitive when the JSON value is null, whereas a wrapper simply becomes `null`.
• Map non-camelCase keys with @JsonProperty / @SerializedName — Java fields should be camelCase, but JSON often uses snake_case (`first_name`). Annotate the field with Jackson's `@JsonProperty("first_name")` or Gson's `@SerializedName("first_name")` so the renamed Java field still binds to the original key. Jackson can also do this globally via `PropertyNamingStrategies.SNAKE_CASE`.
• Empty and mixed arrays lose their element type — An empty array `[]` gives no element type and tends to become `List<Object>`; an array mixing objects of different shapes does the same. Replace `Object` with the real generic type once known, and remember Jackson needs `List<Foo>` to be a concrete parameterized type (or a `TypeReference`) to deserialize correctly.
• Reserved keywords and dates need attention — JSON keys like `class`, `default`, or `package` are Java keywords and can't be field names — rename them and add `@JsonProperty` to map back. Date strings stay `String` because JSON has no date type; convert to `LocalDateTime`/`Instant` with `@JsonFormat` and the `jackson-datatype-jsr310` module if you want real date types.