JSON to Java

This tool reads a JSON object or array and generates Java class definitions representing the same data structure, ready to use with Jackson's ObjectMapper for deserialising API responses or serialising data back to JSON in your Java application. The type mapping produces idiomatic Java types for every JSON value type. JSON strings become String fields. JSON integer values become int fields (or Integer for fields that may be null, since Java primitives cannot hold null values). JSON floating-point numbers become double fields (or Double for nullable cases). JSON booleans become boolean fields (or Boolean for nullable cases). JSON null values in your sample, or fields absent from some records in an array input, are typed with boxed types (Integer, Double, Boolean) rather than primitives, and are annotated to allow null during deserialisation. JSON arrays generate List fields with a typed generic parameter. An array of strings becomes List, an array of integers becomes List, and an array of nested objects becomes List where NestedType is a separately generated inner class or top-level class. This typed List approach is what Jackson expects for correct deserialisation of JSON arrays — using raw List or List causes Jackson to deserialise array elements as LinkedHashMap instances rather than typed objects, which is a common source of ClassCastException. Each generated class includes private field declarations, a no-argument constructor (required by Jackson for deserialisation), getter methods following the getFieldName() convention, and setter methods following the setFieldName() convention. Jackson uses the getter methods for serialisation and the setter methods for deserialisation by default, based on the JavaBeans naming convention. When Jackson annotations are enabled, the generator adds @JsonProperty("jsonKeyName") to each field whose Java name differs from the JSON key. For camelCase JSON keys like firstName or isActive where the Java field name matches exactly, no annotation is needed. For JSON keys that conflict with Java reserved words, contain hyphens or underscores, or use a naming convention that does not map directly to the Java field name, @JsonProperty with the exact JSON key string ensures correct mapping. When Lombok mode is enabled, the class is annotated with @Data which instructs Lombok's annotation processor to generate all getter methods, all setter methods, equals(), hashCode(), and toString() at compile time. The source file contains only the field declarations and the @Data annotation — significantly shorter and easier to maintain than the equivalent class with manually written accessors. An optional @Builder annotation adds a fluent builder API for constructing instances without calling setters individually.

Java's type system is one of its greatest strengths for large, long-lived applications. The compiler catches entire categories of bugs at build time that would only surface at runtime in dynamically typed languages. JSON integration in Java requires that you materialise that type system — write out the class structure that mirrors your JSON — before you can benefit from any of it. The raw Map approach — deserialising JSON into Map and casting values manually — is technically possible but represents the worst of both worlds. You lose compile-time type safety (every value is Object), you lose IDE autocompletion (no typed fields to autocomplete), and you still have to write casting code everywhere: (String) user.get("name"), (Integer) user.get("age"). The casts are wrong often enough that experienced Java developers avoid this pattern entirely for anything beyond quick one-off scripts. The verbosity of Java POJO boilerplate is the reason Lombok exists and why it is installed in virtually every modern Java project. A seven-field POJO without Lombok is sixty to seventy lines: seven field declarations, seven getters, seven setters, a constructor, equals, hashCode, and toString. The same class with @Data is twelve lines: the class declaration, seven field declarations, and the annotation. The generated bytecode is identical — Lombok's annotation processor produces exactly the same bytecode as hand-written accessors. The difference is entirely in source code maintenance burden. Spring Boot applications compound this because every request body, every response type, every JPA entity, and every DTO (Data Transfer Object) in a Spring Boot application is a POJO or a Lombok-annotated equivalent. A typical Spring Boot service integrating three external APIs might have thirty to fifty model classes. Writing those by hand from API documentation or JSON response samples is a full day of mechanical work. Generating them from actual API responses takes minutes, and the generated classes are derived from real data rather than documentation that may be out of date. The Jackson @JsonProperty annotation is the specific piece that most developers get wrong when writing POJOs manually. Jackson's default naming strategy maps Java camelCase field names to JSON camelCase keys — firstName maps to firstName, isActive maps to isActive. This works perfectly until you encounter a JSON key that uses snake_case (first_name), a key with a hyphen (X-Request-Id), a key that is a Java reserved word (class, interface, default), or a key whose capitalisation does not match Jackson's inferred getter name. Each of these requires an explicit @JsonProperty annotation, and missing one means that field silently deserialises as null without any error. This tool adds @JsonProperty annotations wherever the mapping is non-trivial, preventing that class of silent data loss.