JSON to Java

Related

About JSON to Java POJO and Java entity classes

Use Cases

• Android development: convert backend API response JSON into Java POJO entity classes, with optional Gson / Moshi / Fastjson / Jackson annotations ready for deserialization
• Spring Boot backend: turn sample JSON from API docs into DTO / VO / Entity classes, combined with Lombok @Data to reduce boilerplate
• Third-party API integration: convert a partner's response JSON into the corresponding Java model, picking the matching annotation (Jackson / Fastjson / Gson) for seamless integration
• Microservice architecture: unify request / response data models for RPC interfaces so multiple teams share the same Java class definition
• Teaching and training: in data-structure courses or Java classes, convert sample JSON to POJOs to demonstrate object-oriented modeling
• API documentation: embed Java entity class examples in Swagger / OpenAPI / Knife4j documentation
• Unit test preparation: convert JSON fixtures into Java classes and use Jackson to deserialize them as test data drivers
• Data migration scripts: convert JSON config files into Java classes for strongly-typed access from business logic
• Frontend mock alignment: backend turns the JSON model into Java first, while the frontend gets the matching TypeScript interface / Java POJO
• Code review: convert an API response directly into a readable POJO so field naming can be discussed in code review
• Legacy refactoring: refactor code that dynamically accesses JSONObject into strongly-typed POJO access
• Entity / DTO multi-role modeling: from one JSON, generate UserEntity (DB layer) + UserDTO (API layer) + UserVO (view layer), each able to use different annotations
• snake_case backend API integration: backend returns snake_case fields; the Java frontend enables "Convert to camelCase" + Gson/Jackson annotations for seamless consumption
• DTOs that need persistence: tick "Implements Serializable" to make the POJO directly usable in Redis caching or distributed session storage

How to Use

1. Paste a JSON object (recommended) or array into the editor on the left, or click "Sample" to load a built-in example (with nested address / company / tags).
2. Click the "Settings" button on the toolbar (or the class-name-labeled button) and in the dialog: ① set the root class name (e.g. User) and package name (e.g. com.example.entity); ② choose the serialization annotation library (Gson / Jackson / Fastjson / Lombok / None); ③ choose the code style (toString / equals / hashCode / constructor / Serializable); ④ choose the field naming strategy (Keep as-is / camelCase / Lower case / UPPER_SNAKE).
3. The tool auto-converts within 400ms, and the right panel shows all generated Java classes (each in its own card; the title bar shows the active annotation library and a Lombok badge). If the JSON is invalid, a "Repair JSON" button appears.
4. Check that the class names, field names, and annotations look right. If not, edit the source JSON keys or reopen Settings to adjust the options.
5. When satisfied, click the "Copy" button on an individual class to paste into your IDE, or click "Download ZIP" on the toolbar to download every class at once (organized by package path).

Features

• 4 serialization annotation libraries: Gson (@SerializedName) / Jackson (@JsonProperty + @JsonFormat for dates) / Fastjson (@JSONField) / Lombok (@Data) — toggle with a single switch
• Lombok @Data mode: auto-generates the @Data + @Builder + @NoArgsConstructor + @AllArgsConstructor combination, shrinking a Java class from ~50 lines down to ~5 lines
• 4 field naming strategies: Keep as-is / snake_case to camelCase (user_name → userName) / Lower case / UPPER_SNAKE constant style
• Flexible code style: optional toString / equals / hashCode / no-args constructor / all-args constructor / implements Serializable generation
• Smart type inference: automatically recognizes String / Integer / Double / Boolean / List<Object> / nested object types — no need to specify field types manually
• Automatic nested class generation: nested objects are auto-converted into independent Java classes (named by uppercasing the first letter), and objects inside arrays are named by the "strip trailing plural s" rule
• Auto-expanded array generics: JSON arrays are automatically converted into Java List<T> generics, with the element type inferred from the first item
• Complete POJO template: generates a full .java file with package declaration + file header comment (Copyright + auto-generated timestamp) + import + private fields + getter/setter
• ZIP multi-file download: all generated classes are organized by package path (e.g. com/example/entity/User.java) and packaged into a ZIP with directory structure in one click
• Custom package + class name: freely set the package (e.g. com.example.entity) and root class name (e.g. User); all nested class names are derived from the root
• Indentation control: a 2 / 4 space indent toggle on the right panel to match team code conventions
• Copy individual class: each generated Java class has its own "Copy" button for easy paste into an IDE
• Auto-convert + error repair: 400ms debounced auto-convert; on JSON errors, a "Repair JSON" button appears that auto-fixes common formatting mistakes (trailing commas, single quotes, etc.)
• Sample data + file upload: built-in English sample data (with nested address / company / tags / scores) and drag-and-click upload of .json / .txt files
• Local history: persists up to 200 recent inputs in localStorage so you can recover quickly after a refresh or accidental page close
• Runs locally in your browser: all JSON parsing, Java generation, and ZIP packaging are done in JavaScript inside your browser — no data is uploaded to any server

Code Examples

import com.fasterxml.jackson.databind.ObjectMapper;
import com.geekformat.pojo.User;
import com.geekformat.pojo.Address;

public class ApiClient {
    private final ObjectMapper objectMapper = new ObjectMapper();

    public User getUser(int userId) throws Exception {
        // 1) Call the API to get the JSON string
        String json = httpClient.get("https://api.example.com/users/" + userId);

        // 2) Deserialize directly into the tool's generated POJO
        User user = objectMapper.readValue(json, User.class);

        // 3) Strongly-typed field access (compile-time type checking)
        System.out.println("User: " + user.getName());
        if (user.getAddress() != null) {
            System.out.println("City: " + user.getAddress().getCity());
        }
        return user;
    }

    public static void main(String[] args) throws Exception {
        ApiClient client = new ApiClient();
        User user = client.getUser(123);
        System.out.println(user.getName());
    }
}

import com.geekformat.pojo.User;

public class UserService {

    public User createUser() {
        // Lombok @Builder mode: chainable calls, more readable than traditional setters
        User user = User.builder()
            .id(1)
            .userName("Alice")
            .email("alice@example.com")
            .isActive(true)
            .createdAt("2026-07-08T10:00:00.000Z")
            .build();

        System.out.println(user);
        // Lombok @Data auto-generates toString():
        // User(id=1, userName=Alice, email=alice@example.com, ...)

        return user;
    }

    public boolean isValid(User user) {
        // Lombok @Data auto-generates equals() and hashCode()
        return user != null && user.getId() != null;
    }
}

/*
 * Corresponding pom.xml dependency:
 * <dependency>
 *     <groupId>org.projectlombok</groupId>
 *     <artifactId>lombok</artifactId>
 *     <version>1.18.30</version>
 *     <scope>provided</scope>
 * </dependency>
 */

# 1) After downloading the ZIP (filename like User.zip)
unzip User.zip -d src/main/java/

# 2) Inspect the directory layout
tree src/main/java/
# src/main/java/
# └── com/
#     └── example/
#         └── entity/
#             ├── User.java
#             ├── Address.java
#             └── Company.java

# 3) In IntelliJ IDEA: right-click the com directory → "Mark Directory as" → "Sources Root"
#    Or in Eclipse: File → Import → Existing Projects into Workspace

# 4) Use it directly in a Spring Boot project
#    UserController.java
#    @PostMapping("/users")
#    public ResponseEntity<User> createUser(@RequestBody User user) {
#        userService.save(user);
#        return ResponseEntity.ok(user);
#    }

# 5) Verify it compiles
mvn compile
# [INFO] BUILD SUCCESS

# 6) (Optional) When using Lombok, remember to add the lombok dependency in pom.xml
#    <dependency>
#        <groupId>org.projectlombok</groupId>
#        <artifactId>lombok</artifactId>
#    </dependency>

FAQ

Troubleshooting

Glossary

POJO

Plain Old Java Object. Constrained to: private fields + public getter/setter + no framework dependency. The classes generated by this tool are standard POJOs.

JavaBean

An earlier Java-community term for POJO, requiring a public no-args constructor + private fields + public getter/setter. The classes generated by this tool comply with the JavaBean specification.

DTO (Data Transfer Object)

Data transfer object, commonly used as a data carrier across processes (API / RPC). The POJOs generated by this tool can serve directly as DTOs.

VO (Value Object)

Value object, usually used in the view layer (data returned by the Controller to the frontend). The POJOs generated by this tool work for this too.

Entity

Entity object, corresponding to one row in a database table. The POJOs generated by this tool can act as the base class for JPA / Hibernate @Entity (after adding annotations manually).

@SerializedName

The field-mapping annotation in Gson. In Gson mode this tool auto-adds @SerializedName("originalKey") to every field so deserialization maps the original JSON key correctly.

@JsonProperty

The field-mapping annotation in Jackson. In Jackson mode this tool auto-adds @JsonProperty("originalKey") to every field; date fields additionally get @JsonFormat to define the serialization pattern.

@JSONField

The field-mapping annotation in Alibaba's Fastjson. In Fastjson mode this tool auto-adds @JSONField(name = "originalKey") to every field.

Lombok @Data

A composite Lombok annotation equivalent to @Getter + @Setter + @ToString + @EqualsAndHashCode + @RequiredArgsConstructor. In Lombok mode this tool adds it on the class with one click.

Lombok @Builder

The Lombok annotation for the builder pattern. When ticked, this tool auto-adds it and generates a chainable builder() method.

Serializable

A Java marker interface. Once implemented, the object can be serialized (e.g. written to a file / sent over the network / stored in Redis). Ticking "Implements Serializable" in this tool automatically adds implements Serializable and imports java.io.Serializable.

Nested class

An independent Java class auto-generated by the tool for a nested JSON object. Naming rule: upper-case the first letter of the nested object's key (e.g. address → Address).

List generic

An interface in the Java Collections Framework. The tool automatically converts JSON arrays into List<T>, with T inferred from the first item (e.g. ["a"] → List<String>).

getter / setter

Standard accessor methods on a Java Bean. A getter is named getXxx() and returns the field; a setter is named setXxx(value) and assigns the field. In Lombok mode they are auto-generated by @Data; in traditional mode the tool emits them explicitly.

package declaration

The first non-comment line of a Java file, declaring the namespace the class belongs to. This tool generates it from the user-set package name and organizes the ZIP with com/xxx/yy directories.

snake_case → camelCase

A field naming strategy conversion. The tool supports auto-conversion like user_name → userName, is_active → isActive, created_at → createdAt, in line with Java naming conventions.

JSZip

A JavaScript ZIP packaging library that runs in the browser. The tool uses it to generate ZIP files in-browser with no server-side processing.

localStorage history

A browser-local key/value store (capacity roughly 5–10MB). The tool uses localStorage to persist up to 200 recent inputs.

Debounce

A frontend performance technique that coalesces high-frequency events into a single trailing call. The tool uses a 400ms debounce to avoid jank when parsing large files.

tryFixJSON

The JSON repair function built into the tool. It auto-fixes common errors like trailing commas, single-to-double quotes, missing key quotes, and comment removal.

JSON type → Java type mapping cheat sheet

Quick lookup of the JSON data types the tool can auto-infer and their corresponding Java types:

4 serialization annotation libraries comparison

The 4 mainstream Java JSON serialization annotation libraries supported by the tool. Pick the one that matches your project's framework:

4 field naming strategies comparison

The 4 field naming conversion strategies the tool supports, optimized for different JSON sources:

Lombok @Data mode vs traditional POJO mode

Comparing the two code styles across line count, readability, and dependencies:

Privacy & Security

This JSON to Java tool performs all JSON parsing, Java class generation, and ZIP packaging entirely in your browser using JavaScript (JSZip). The JSON you paste and the Java code generated are never uploaded to any server, and are not recorded, cached, or stored in the cloud. It's safe to use sensitive JSON containing internal API fields, unreleased business structures, or unpublished API responses — closing the page clears everything.

Authoritative References

• MDNMDN - JSON.parse / JSON.stringify
• OracleOracle Java Tutorials - Classes and Objects
• OracleOracle Java Tutorials - Encapsulation
• LombokLombok official docs - @Data
• LombokLombok official docs - @Builder
• JacksonJackson official docs - ObjectMapper
• GoogleGson user guide
• AlibabaFastjson on GitHub
• SpringSpring official - @RequestBody