JSON zu Java

Ähnliche Tools

Über JSON zu Java POJO und Java-Entitätsklassen

Anwendungsfälle

• Android-Entwicklung: JSON-Antworten des Backends in Java-Entitätsklassen (POJO) umwandeln – mit optionalen Gson- / Moshi- / Fastjson- / Jackson-Annotationen direkt für die Deserialisierung verwendbar
• Spring-Boot-Backend: Beispiel-JSON aus API-Dokumentationen schnell in DTO- / VO- / Entity-Klassen umwandeln und mit Lombok @Data den Codeumfang drastisch reduzieren
• Anbindung an Drittanbieter-Schnittstellen: Antwort-JSONs der Gegenstelle in das passende Java-Modell umwandeln und mit der jeweiligen Serialisierungs-Annotation (Jackson / Fastjson / Gson) nahtlos anbinden
• Microservice-Architektur: Request- / Response-Datenmodelle von RPC-Schnittstellen vereinheitlichen – mehrere Teams teilen sich dieselbe Java-Klassendefinition
• Lehre und Schulung: in Datenstrukturkursen oder Java-Schulungen Beispiel-JSONs in POJOs umwandeln, um objektorientierte Modellierung zu demonstrieren
• API-Dokumentation: Java-Entitätsklassen-Beispiele in Swagger / OpenAPI / Knife4j-Dokumenten einbetten
• Vorbereitung von Unit-Tests: JSON-Fixtures in Java-Klassen umwandeln und anschließend mit Jackson deserialisieren, um datengetriebene Tests zu erstellen
• Datenmigrations-Skripte: JSON-Konfigurationsdateien in Java-Klassen umwandeln und stark typisiert in der Geschäftslogik verwenden
• Frontend-Mock-Abstimmung: Das Backend wandelt das JSON-Modell in Java um, das Frontend erhält parallel die passende TypeScript-Interface- bzw. Java-POJO-Definition
• Code-Review: API-Antwort-JSONs direkt in lesbare POJOs umwandeln, um Feldbenennungen im Code-Review zu diskutieren
• Refactoring von Altprojekten: Code, der bisher dynamisch per JSONObject auf JSON zugreift, auf stark typisierten POJO-Zugriff umstellen
• Entity / DTO Multi-Rollen-Modellierung: Aus demselben JSON UserEntity (DB-Schicht) + UserDTO (API-Schicht) + UserVO (View-Schicht) erzeugen – mit jeweils unterschiedlichen Annotationen
• Anbindung an snake_case-Backend-APIs: Das Backend liefert Felder in snake_case, das Java-Frontend aktiviert „In camelCase umwandeln" plus Gson/Jackson-Annotationen für eine nahtlose Anbindung
• Persistierbare DTOs: Mit aktivierter Option „Serializable implementieren" direkt in Redis-Caches oder verteilte Session-Speicher einsetzbar

Anleitung

1. Füge im linken Editor ein JSON-Objekt (empfohlen) oder -Array ein oder klicke auf „Sample", um das chinesische Beispiel (mit verschachteltem address / company / tags) zu laden
2. Klicke in der Werkzeugleiste auf „Settings" (bzw. die Schaltfläche mit dem Klassennamen) und wähle im Dialog: ① Root-Klassenname (z. B. User) und Paketname (z. B. com.example.entity); ② Serialisierungs-Annotation-Bibliothek (Gson / Jackson / Fastjson / Lombok / Keine); ③ Code-Stil (toString / equals / hashCode / Konstruktoren / Serializable); ④ Feldnamen-Strategie (Wie vorhanden beibehalten / camelCase / Alles in Kleinbuchstaben / UPPER_SNAKE)
3. Das Tool konvertiert automatisch innerhalb von 400ms und zeigt rechts alle generierten Java-Klassen (jede Klasse auf einer eigenen Karte, in der Titelleiste werden die aktuelle Annotation-Bibliothek und das Lombok-Badge live angezeigt). Bei JSON-Fehlern erscheint die Schaltfläche „JSON reparieren"
4. Prüfe, ob die generierten Klassen-, Feldnamen und Annotationen den Erwartungen entsprechen; passe sie bei Bedarf durch Änderung der Quell-JSON-Keys oder erneutes Öffnen der Settings an
5. Wenn alles passt, kopiere einzelne Klassen über die Schaltfläche „Kopieren" in deine IDE oder lade alle Klassen über „Download ZIP" als Paket (mit Paketpfad-Verzeichnisstruktur) herunter

Funktionen

• 4 Serialisierungs-Annotation-Bibliotheken: Gson (@SerializedName) / Jackson (@JsonProperty + @JsonFormat für Datumsfelder) / Fastjson (@JSONField) / Lombok (@Data) – per Schalter umschaltbar
• Lombok @Data Modus: generiert automatisch @Data + @Builder + @NoArgsConstructor + @AllArgsConstructor und reduziert die Java-Klasse von ~50 Zeilen auf ~5 Zeilen
• 4 Feldnamen-Strategien: Wie vorhanden beibehalten / snake_case zu camelCase (user_name → userName) / Alles in Kleinbuchstaben / UPPER_SNAKE Konstanten-Stil
• Frei kombinierbarer Code-Stil: optional generierbar sind toString / equals / hashCode / parameterloser Konstruktor / Vollargument-Konstruktor / implementierung der Serializable-Schnittstelle
• Intelligente Typableitung: erkennt automatisch String / Integer / Double / Boolean / List<Object> / verschachtelte Objekttypen – keine manuelle Typzuweisung nötig
• Automatische Generierung verschachtelter Klassen: verschachtelte Objekte werden in eigenständige Java-Klassen umgewandelt (Klassennamen mit großem Anfangsbuchstaben), Objekte in Arrays werden nach der Regel „Entfernen des Plural-s" benannt
• Automatisches Auflösen von Array-Generics: JSON-Arrays werden automatisch in Java List<T> konvertiert, der Elementtyp wird anhand des ersten Elements abgeleitet
• Vollständige POJO-Vorlage: generiert komplette .java-Dateien mit package-Deklaration + Datei-Header-Kommentar (Copyright + automatischer Zeitstempel) + import + private Felder + getter/setter
• ZIP-Download mit mehreren Dateien: alle generierten Klassen werden nach Paketpfad organisiert (z. B. com/example/entity/User.java) und mit einem Klick als ZIP-Archiv heruntergeladen – inklusive Verzeichnisstruktur
• Eigener Paket- und Klassenname: frei wählbarer package (z. B. com.example.entity) und Root-Klassenname (z. B. User) – alle Klassennamen werden basierend auf dem Root-Klassennamen synchron erzeugt
• Einrückungssteuerung: rechtsseitig umschaltbar zwischen 2 und 4 Leerzeichen Einrückung, passend zu den Team-Code-Konventionen
• Einzelne Klassen kopieren: jede generierte Java-Klasse verfügt über eine eigene Schaltfläche „Kopieren" zum bequemen Einfügen in die IDE
• Automatische Konvertierung und Fehlerbehebung: Eingabe wird nach 400ms Debounce automatisch konvertiert; bei JSON-Fehlern erscheint die Schaltfläche „JSON reparieren", die häufige Formatfehler (überflüssige Kommata, einfache Anführungszeichen usw.) automatisch behebt
• Beispieldaten und Datei-Upload: integrierte chinesische Beispieldaten (mit verschachteltem address / company / tags / scores), Drag-and-Drop oder Klick zum Hochladen von .json- und .txt-Dateien
• Lokaler Verlauf: bis zu 200 letzte Eingaben werden persistent in localStorage gespeichert und können nach einem Neuladen oder versehentlichen Schließen der Seite wiederhergestellt werden
• Lokale Ausführung im Browser: gesamtes JSON-Parsing, Java-Generierung und ZIP-Packung erfolgen über JavaScript direkt in deinem Browser – es werden keine Daten an einen Server übertragen

Codebeispiele

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) API aufrufen und JSON-String abrufen
        String json = httpClient.get("https://api.example.com/users/" + userId);

        // 2) Direkt in das vom Tool generierte POJO deserialisieren
        User user = objectMapper.readValue(json, User.class);

        // 3) Starker Typzugriff auf Felder (Typprüfung zur Compile-Zeit)
        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-Modus: verkettete Aufrufe, intuitiver als klassische Setter
        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 erzeugt automatisch toString():
        // User(id=1, userName=Alice, email=alice@example.com, ...)

        return user;
    }

    public boolean isValid(User user) {
        // Lombok @Data erzeugt automatisch equals() und hashCode()
        return user != null && user.getId() != null;
    }
}

/*
 * Zugehörige Abhängigkeit in pom.xml:
 * <dependency>
 *     <groupId>org.projectlombok</groupId>
 *     <artifactId>lombok</artifactId>
 *     <version>1.18.30</version>
 *     <scope>provided</scope>
 * </dependency>
 */

# 1) Nach dem Download des ZIP (Dateiname z. B. User.zip)
unzip User.zip -d src/main/java/

# 2) Verzeichnisstruktur prüfen
tree src/main/java/
# src/main/java/
# └── com/
#     └── example/
#         └── entity/
#             ├── User.java
#             ├── Address.java
#             └── Company.java

# 3) In IntelliJ IDEA: Rechtsklick auf das Verzeichnis com → "Mark Directory as" → "Sources Root"
#    In Eclipse: File → Import → Existing Projects into Workspace

# 4) Direkt im Spring-Boot-Projekt verwenden
#    UserController.java
#    @PostMapping("/users")
#    public ResponseEntity<User> createUser(@RequestBody User user) {
#        userService.save(user);
#        return ResponseEntity.ok(user);
#    }

# 5) Kompilieren und prüfen
mvn compile
# [INFO] BUILD SUCCESS

# 6) (Optional) Bei Verwendung von Lombok lombok-Abhängigkeit in pom.xml ergänzen
#    <dependency>
#        <groupId>org.projectlombok</groupId>
#        <artifactId>lombok</artifactId>
#    </dependency>

Häufig gestellte Fragen

Fehlerbehebung

Glossar

POJO

Plain Old Java Object – ein gewöhnliches Java-Objekt. Eigenschaften: private Felder + öffentliche getter/setter + keine Framework-Abhängigkeit. Dieses Tool erzeugt Standard-POJOs.

JavaBean

Frühere Java-Community-Bezeichnung für POJO. Voraussetzungen: öffentlicher parameterloser Konstruktor + private Felder + öffentliche getter/setter. Die von diesem Tool erzeugten Klassen entsprechen der JavaBean-Spezifikation.

DTO (Data Transfer Object)

Datentransferobjekt, häufig verwendet für die Datenübertragung zwischen Prozessen (API / RPC). Die von diesem Tool erzeugten POJOs können direkt als DTO verwendet werden.

VO (Value Object)

Wertobjekt, in der Regel auf der View-Schicht verwendet (Daten, die der Controller an das Frontend zurückgibt). Die von diesem Tool erzeugten POJOs sind ebenfalls dafür geeignet.

Entity

Entitätsobjekt, entspricht einer Zeile in einer Datenbanktabelle. Die erzeugten POJOs können als Basisklasse für JPA- / Hibernate-@Entity-Definitionen dienen (nach manueller Hinzufügung der Annotationen).

@SerializedName

Annotation der Gson-Bibliothek zur Feldzuordnung. Im Gson-Modus fügt das Tool jedem Feld automatisch @SerializedName("Original-Key") hinzu, damit die Deserialisierung anhand des ursprünglichen JSON-Feldnamens erfolgt.

@JsonProperty

Annotation der Jackson-Bibliothek zur Feldzuordnung. Im Jackson-Modus fügt das Tool jedem Feld @JsonProperty("Original-Key") hinzu; Datumsfelder erhalten zusätzlich @JsonFormat zur Definition des Serialisierungsformats.

@JSONField

Annotation der Alibaba-Fastjson-Bibliothek zur Feldzuordnung. Im Fastjson-Modus fügt das Tool jedem Feld automatisch @JSONField(name = "Original-Key") hinzu.

Lombok @Data

Zusammengesetzte Annotation der Lombok-Bibliothek, äquivalent zu @Getter + @Setter + @ToString + @EqualsAndHashCode + @RequiredArgsConstructor. Im Lombok-Modus fügt das Tool diese Annotation mit einem Klick auf Klassenebene hinzu.

Lombok @Builder

Annotation für das Builder-Muster in Lombok. Nach Aktivierung fügt das Tool sie automatisch hinzu und erzeugt eine verkettet aufrufbare builder()-Methode.

Serializable

Java-Marker-Interface. Nach Implementierung kann das Objekt serialisiert werden (z. B. in Dateien schreiben, Netzwerkübertragung, Redis-Cache). Mit aktivierter Option „Serializable implementieren" fügt das Tool implements Serializable hinzu und importiert java.io.Serializable.

Verschachtelte Klasse (Nested Class)

Eigenständige Java-Klasse, die das Tool für verschachtelte JSON-Objekte automatisch erzeugt. Benennungsregel: Schlüssel des verschachtelten Objekts mit großem Anfangsbuchstaben (z. B. address → Address).

List-Generics

Interface des Java-Collections-Frameworks. Das Tool wandelt JSON-Arrays automatisch in List<T> um, wobei T anhand des ersten Elements abgeleitet wird (z. B. ["a"] → List<String>).

getter / setter

Standard-Accessor-Methoden eines Java-Beans. getter heißt getXxx() und gibt das Feld zurück, setter heißt setXxx(value) und setzt es. Im Lombok-Modus werden sie automatisch von @Data erzeugt, im klassischen Modus explizit vom Tool generiert.

package-Deklaration

Erste Nicht-Kommentar-Zeile einer Java-Datei, die den Namespace der Klasse deklariert. Das Tool erzeugt sie anhand des vom Benutzer festgelegten Paketnamens automatisch und organisiert die Verzeichnisstruktur im ZIP nach com/xxx/yy.

snake_case → camelCase

Umwandlung der Feldnamenstrategie. Das Tool unterstützt die automatische Umwandlung: user_name → userName, is_active → isActive, created_at → createdAt – konform mit den Java-Namenskonventionen.

JSZip

JavaScript-Bibliothek zur ZIP-Erstellung im Browser. Das Tool verwendet sie, um ZIP-Dateien direkt im Browser zu erzeugen, ohne serverseitige Verarbeitung.

localStorage-Verlauf

Lokaler Schlüssel-Wert-Speicher des Browsers (Kapazität ca. 5–10 MB). Das Tool nutzt localStorage, um bis zu 200 letzte Eingaben dauerhaft zu speichern.

Debounce

Frontend-Leistungsoptimierung: Häufig auftretende Ereignisse werden auf den letzten Aufruf reduziert. Das Tool verwendet ein Debounce von 400ms, um Ruckler beim Parsen großer Dateien zu vermeiden.

tryFixJSON

Im Tool integrierte JSON-Reparaturfunktion: behebt automatisch häufige Fehler wie überflüssige Kommata am Ende, Ersetzen einfacher Anführungszeichen durch doppelte, Ergänzen fehlender Anführungszeichen bei Keys und Entfernen von Kommentaren.

Schnellübersicht: JSON-Typ zu Java-Typ

Vom Tool automatisch abgeleitete JSON-Datentypen und die zugehörigen Java-Typen:

Vergleich der 4 Serialisierungs-Annotation-Bibliotheken

Die 4 unterstützten Java-JSON-Serialisierungs-Annotation-Bibliotheken – wähle je nach verwendetem Framework:

Vergleich der 4 Feldnamen-Strategien

Die 4 unterstützten Feldnamen-Umwandlungsstrategien – optimiert für unterschiedliche JSON-Quellen:

Lombok @Data Modus vs. klassischer POJO-Modus

Vergleich der beiden Code-Stile hinsichtlich Zeilenanzahl, Lesbarkeit und Abhängigkeiten:

Privacy & Security

Bei diesem JSON-zu-Java-Tool erfolgen sämtliche JSON-Analysen, Java-Klassengenerierungen und ZIP-Packungen vollständig lokal in deinem Browser über JavaScript (JSZip). Weder die eingegebenen JSON-Daten noch der generierte Java-Code werden an irgendeinen Server übertragen, aufgezeichnet, zwischengespeichert oder in der Cloud gespeichert. Auch sensible JSONs mit internen Schnittstellenfeldern, unveröffentlichten Geschäftsstrukturen oder nicht-öffentlichen API-Antworten können bedenkenlos verwendet werden – beim Schließen der Seite werden alle Daten vollständig gelöscht.

Authoritative References

• MDNMDN - JSON.parse / JSON.stringify
• OracleOracle Java-Tutorial - Klassen und Objekte
• OracleOracle Java-Tutorial - Zugriffskontrolle
• LombokLombok Offizielle Dokumentation - @Data
• LombokLombok Offizielle Dokumentation - @Builder
• JacksonJackson Offizielle Dokumentation - ObjectMapper
• GoogleGson Benutzerhandbuch
• AlibabaFastjson GitHub
• SpringSpring Offizielle Dokumentation - @RequestBody