JSON in Java

Raccomandazioni correlate

Informazioni su JSON in Java POJO e classi entità Java

Casi d'uso

• Sviluppo Android: convertire il JSON restituito dalle API backend in classi entità Java (POJO), con annotazioni opzionali Gson / Moshi / Fastjson / Jackson utilizzabili direttamente per la deserializzazione
• Backend Spring Boot: convertire rapidamente il JSON di esempio presente nella documentazione delle API in classi DTO / VO / Entity, sfruttando Lombok @Data per ridurre il codice
• Integrazione con API di terze parti: convertire il JSON di risposta delle API esterne nei modelli Java corrispondenti, scegliendo l'annotazione di serializzazione appropriata (Jackson / Fastjson / Gson) per un'integrazione senza soluzione di continuità
• Architettura a microservizi: unificare i modelli di dati di richiesta/risposta delle interfacce RPC, condividendo la stessa definizione delle classi Java tra più team
• Didattica e formazione: in corsi di strutture dati o lezioni Java, convertire JSON di esempio in POJO per dimostrare la modellazione orientata agli oggetti
• Redazione di documentazione API: incorporare esempi di classi entità Java nella documentazione Swagger / OpenAPI / Knife4j
• Preparazione di unit test: convertire i fixture JSON in classi Java, quindi deserializzare con Jackson per alimentare i dati di test
• Script di migrazione dati: convertire i file di configurazione JSON in classi Java per un accesso fortemente tipizzato nella logica di business
• Mock lato frontend: il backend converte prima il modello JSON in Java, mentre il frontend riceve in parallelo l'interfaccia TypeScript / il POJO Java corrispondente
• Code review: convertire direttamente il JSON restituito dalle API in POJO leggibili, per facilitare la discussione sui nomi dei campi durante la review
• Refactoring di progetti legacy: ristrutturare il codice basato sull'accesso dinamico a JSONObject in un accesso fortemente tipizzato basato su POJO
• Modellazione multi-ruolo Entity / DTO: dallo stesso JSON generare UserEntity (livello DB) + UserDTO (livello API) + UserVO (livello vista), scegliendo annotazioni diverse per ciascuno
• Integrazione con backend snake_case: API backend che restituiscono campi snake_case; lato Java frontend attivare "Converti in camelCase" + annotazioni Gson/Jackson per un'integrazione immediata
• DTO che richiedono persistenza: selezionare "Implementa Serializable" per utilizzarli direttamente nella cache Redis o nella memorizzazione di sessioni distribuite

Come utilizzare

1. Incolla un oggetto JSON (consigliato) o un array nell'editor di sinistra, oppure fai clic su "Esempio" per caricare il sample cinese (con address / company / tags annidati)
2. Fai clic sul pulsante "Impostazioni" nella barra degli strumenti (o sul pulsante con il nome della classe) e nella finestra popup seleziona: ① imposta il nome della classe radice (es. User) e il package (es. com.example.entity); ② scegli la libreria di annotazioni di serializzazione (Gson / Jackson / Fastjson / Lombok / Nessuna); ③ scegli lo stile del codice (toString / equals / hashCode / costruttore / Serializable); ④ scegli la strategia di denominazione dei campi (Mantieni invariato / camelCase / Tutto minuscolo / UPPER_SNAKE)
3. Lo strumento esegue la conversione automatica entro 400 ms; a destra vengono mostrate tutte le classi Java generate (una scheda per classe, con badge in tempo reale per la libreria di annotazioni e Lombok); in caso di JSON non valido appare il pulsante "Correggi JSON"
4. Verifica che i nomi delle classi, i nomi dei campi e le annotazioni siano quelli attesi; se necessario, modifica le chiavi del JSON sorgente o riapri le Impostazioni per regolare le opzioni
5. Quando sei soddisfatto, fai clic sul pulsante "Copia" di una singola classe per incollarla nell'IDE, oppure fai clic su "Download ZIP" nella barra degli strumenti per scaricare tutte le classi con un solo clic (con struttura di directory organizzata per package)

Funzionalità

• 4 librerie di annotazioni di serializzazione: Gson (@SerializedName) / Jackson (@JsonProperty + @JsonFormat per date) / Fastjson (@JSONField) / Lombok (@Data), selezionabili con un interruttore
• Modalità Lombok @Data: genera automaticamente la combinazione @Data + @Builder + @NoArgsConstructor + @AllArgsConstructor, riducendo la classe Java da ~50 righe a ~5 righe
• 4 strategie di denominazione dei campi: Mantieni invariato / snake_case a camelCase (user_name → userName) / Tutto minuscolo / stile costante UPPER_SNAKE
• Stile del codice liberamente combinabile: generazione opzionale di toString / equals / hashCode / costruttore senza argomenti / costruttore con tutti gli argomenti / implementazione dell'interfaccia Serializable
• Deduzione intelligente dei tipi: riconosce automaticamente String / Integer / Double / Boolean / List<Object> / tipi di oggetti annidati, senza dover specificare manualmente i tipi di campo
• Generazione automatica di classi annidate: gli oggetti annidati vengono convertiti in classi Java indipendenti (nominate con la prima lettera maiuscola), gli oggetti negli array vengono nominati seguendo la regola "rimuovi la 's' finale"
• Espansione automatica dei generics per gli array: gli array JSON vengono convertiti automaticamente in generics Java List<T>, con il tipo degli elementi dedotto dal primo elemento
• Modello POJO completo: genera un file .java completo con dichiarazione package + commento di intestazione (Copyright + timestamp di generazione automatica) + import + campi privati + getter/setter
• Download ZIP multi-file: tutte le classi generate sono organizzate per percorso package (es. com/example/entity/User.java), impacchettate in un ZIP scaricabile con un clic, inclusa la struttura delle directory
• Nome package + nome classe personalizzati: è possibile impostare liberamente il package (es. com.example.entity) e il nome della classe radice (es. User); tutti i nomi delle classi vengono generati in modo sincrono in base al nome della classe radice
• Controllo dell'indentazione: supporta il passaggio tra 2 / 4 spazi di indentazione sul lato destro, per adattarsi alle convenzioni di codice del team
• Copia di una singola classe: ogni classe Java generata ha un pulsante "Copia" indipendente, utile per incollare direttamente nell'IDE
• Conversione automatica + correzione errori: conversione automatica con debounce di 400 ms; in caso di errore JSON appare il pulsante "Correggi JSON" che ripara automaticamente gli errori di formato più comuni (virgole extra, apici singoli, ecc.)
• Dati di esempio + caricamento file: dati di esempio integrati in cinese (con address / company / tags / scores annidati), supporto per il trascinamento o il caricamento di file .json / .txt
• Cronologia locale: persistenza basata su localStorage delle ultime 200 voci inserite, con ripristino rapido dopo un aggiornamento o una chiusura accidentale della pagina
• Esecuzione nel browser locale: tutte le operazioni di parsing JSON, generazione Java e creazione ZIP vengono eseguite nel browser tramite JavaScript; i dati non vengono mai inviati a un server

Esempi di codice

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 POJO generated by this tool
        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: chained calls, more intuitive 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) Check the directory structure
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 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) Compile to verify
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>

Domande frequenti

Risoluzione dei problemi

Glossario

POJO

Plain Old Java Object, normale oggetto Java. Vincoli: campi private + getter/setter pubblici + nessuna dipendenza da framework. Lo strumento genera POJO standard.

JavaBean

Termine storico della comunità Java per indicare i POJO, che richiede: costruttore pubblico senza argomenti + campi private + getter/setter pubblici. Le classi generate da questo strumento sono conformi alle specifiche JavaBean.

DTO (Data Transfer Object)

Oggetto per il trasferimento di dati, spesso usato come veicolo per dati tra processi (API / RPC). I POJO generati da questo strumento possono essere utilizzati come DTO.

VO (Value Object)

Value Object, generalmente usato per il livello di vista (dati restituiti dal Controller al frontend). I POJO generati da questo strumento sono ugualmente adatti.

Entity

Oggetto entità, corrispondente a una riga di una tabella del database. I POJO generati da questo strumento possono essere usati come classe base @Entity per JPA / Hibernate (dopo l'aggiunta manuale delle annotazioni).

@SerializedName

Annotazione di mappatura dei campi della libreria Gson. In modalità Gson, lo strumento aggiunge automaticamente @SerializedName("chiave originale") a ogni campo, garantendo la mappatura con il nome del campo JSON originale in fase di deserializzazione.

@JsonProperty

Annotazione di mappatura dei campi della libreria Jackson. In modalità Jackson, lo strumento aggiunge automaticamente @JsonProperty("chiave originale") a ogni campo; per i campi data aggiunge inoltre @JsonFormat per definire il formato di serializzazione.

@JSONField

Annotazione di mappatura dei campi della libreria Fastjson di Alibaba. In modalità Fastjson, lo strumento aggiunge automaticamente @JSONField(name = "chiave originale") a ogni campo.

Lombok @Data

Annotazione composita della libreria Lombok, equivalente a @Getter + @Setter + @ToString + @EqualsAndHashCode + @RequiredArgsConstructor. In modalità Lombok, lo strumento aggiunge questa annotazione alla classe con un solo clic.

Lombok @Builder

Annotazione di Lombok per il pattern Builder. Una volta selezionata, lo strumento la aggiunge automaticamente, generando un metodo builder() richiamabile in modo concatenato.

Serializable

Interfaccia marker di Java; una volta implementata, l'oggetto può essere serializzato (ad esempio scritto su file / trasmesso in rete / memorizzato nella cache Redis). Selezionando "Implementa Serializable" nello strumento, vengono aggiunti automaticamente implements Serializable e l'import di java.io.Serializable.

Classe annidata (Nested Class)

Classe Java indipendente generata automaticamente dallo strumento per oggetti JSON annidati. Regola di denominazione: la chiave dell'oggetto annidato viene convertita con la prima lettera maiuscola (es. address → Address).

List generico

Interfaccia del Java Collection Framework. Lo strumento converte automaticamente gli array JSON in List<T>, dove T viene dedotto dal primo elemento dell'array (es. ["a"] → List<String>).

getter / setter

Metodi di accesso standard dei Java Bean. Il getter è nominato getXxx() e restituisce il campo, il setter è nominato setXxx(value) e imposta il campo. In modalità Lombok vengono generati automaticamente da @Data; in modalità tradizionale li genera esplicitamente lo strumento.

Dichiarazione package

Prima riga di codice non commento in un file Java, usata per dichiarare il namespace a cui appartiene la classe. Lo strumento la genera automaticamente in base al package impostato dall'utente e organizza lo ZIP con directory com/xxx/yy.

snake_case → camelCase

Conversione della strategia di denominazione dei campi. Lo strumento supporta la conversione automatica: user_name → userName, is_active → isActive, created_at → createdAt, in conformità con le convenzioni di denominazione Java.

JSZip

Libreria JavaScript per la creazione di archivi ZIP lato browser. Lo strumento la utilizza per generare file ZIP direttamente nel browser, senza necessità di elaborazione lato server.

Cronologia localStorage

Archivio chiave-valore locale del browser (capacità circa 5-10 MB). Lo strumento utilizza localStorage per memorizzare in modo persistente le ultime 200 voci inserite.

Debounce

Tecnica di ottimizzazione delle prestazioni frontend: unisce eventi ad alta frequenza in un'unica esecuzione finale. Lo strumento imposta un debounce di 400 ms per evitare rallentamenti nel parsing di file di grandi dimensioni.

tryFixJSON

Funzione di correzione JSON integrata nello strumento: corregge automaticamente errori comuni come virgole extra alla fine, sostituzione di apici singoli con doppi apici, aggiunta di apici mancanti alle chiavi e rimozione di commenti.

Tabella di mappatura rapida da tipo JSON a tipo Java

Tabella di confronto tra i tipi di dati JSON dedotti automaticamente dallo strumento e i tipi Java corrispondenti:

Tabella di confronto tra 4 librerie di annotazioni di serializzazione

Le 4 principali librerie di annotazioni di serializzazione JSON per Java supportate dallo strumento; scegliere in base al framework utilizzato nel progetto:

Tabella di confronto tra 4 strategie di denominazione dei campi

Le 4 strategie di conversione dei nomi dei campi supportate dallo strumento, ottimizzate per diverse origini JSON:

Confronto tra modalità Lombok @Data e modalità POJO tradizionale

Confronto tra i due stili di codice in termini di righe, leggibilità e dipendenze:

Privacy & Security

Tutte le operazioni di parsing JSON, generazione delle classi Java e creazione dell'archivio ZIP di questo strumento JSON in Java vengono eseguite interamente nel tuo browser locale tramite JavaScript (JSZip); i dati JSON inseriti e il codice Java generato non vengono mai caricati su alcun server, né registrati, memorizzati nella cache o archiviati nel cloud. È possibile usarlo in tranquillità anche con JSON sensibili contenenti campi di interfacce interne, strutture aziendali non ancora rilasciate o risposte API riservate; chiudendo la pagina tutti i dati vengono eliminati.

Authoritative References

• MDNMDN - JSON.parse / JSON.stringify
• OracleOracle Java Tutorial - Classi e oggetti
• OracleOracle Java Tutorial - Incapsulamento
• LombokDocumentazione ufficiale Lombok - @Data
• LombokDocumentazione ufficiale Lombok - @Builder
• JacksonDocumentazione ufficiale Jackson - ObjectMapper
• GoogleGuida utente Gson
• AlibabaFastjson su GitHub
• SpringSpring Boot ufficiale - @RequestBody