JSON a POJO: classi o record Java da un JSON

Incolla il tuo JSON e ottieni codice Java pronto all’uso: una classe per ogni oggetto, con campi privati, un costruttore senza argomenti, getter e setter, oppure record Java se preferisci. Gli oggetti annidati vengono scritti dentro la classe che li contiene, così tutto il risultato sta in un solo file .java. Aggiungi le annotazioni Jackson o Gson quando ti servono le chiavi JSON originali. La conversione avviene nel browser e il JSON non viene caricato.

JSON to POJO online Java: come si usa

1. Incolla il JSON nella casella JSON (mostra «Incolla qui il JSON...»). Un testo incollato viene convertito subito. Se scrivi, il codice si aggiorna circa 300 millisecondi dopo che ti fermi.
2. Leggi le classi sotto Codice Java. Una riga sotto, come «Generate 2 classi.», indica quante ne sono state scritte.
3. Premi Copia, subito sotto il codice. Il pulsante mostra per un momento «Copiato». Salva il codice in un file con il nome della classe radice, per esempio Root.java.
4. Per cambiare il risultato, apri Impostazioni: scrivi il Nome della classe radice (il valore predefinito è Root), scegli in Annotazioni tra Nessuna, Jackson e Gson, oppure spunta Usa i record invece delle classi. Il codice si aggiorna appena cambi un’impostazione.
5. Premi Cancella per svuotare la casella e ricominciare.

JSON POJO Java: un esempio

Questo è ciò che incolli: { "user_id": 7, "name": "Ana", "price": 4.5, "tags": ["a", "b"], "address": { "city": "Kyoto" } }

Con Annotazioni su «Nessuna», il risultato inizia con import java.util.List; e public class Root. I campi sono Integer userId, String name, Double price, List<String> tags e Address address. Seguono il costruttore senza argomenti e getter e setter come getUserId e setUserId.

L’oggetto annidato address è diventato Address, una public static class dentro Root, ed è per questo che basta un solo file. La chiave user_id è diventata il campo userId. La riga di stato te lo segnala: «1 nome di campo è stato modificato per adattarsi a Java.»

JSON in record Java con annotazioni Jackson

Imposta il Nome della classe radice su Order, scegli Jackson in Annotazioni e spunta Usa i record invece delle classi. Lo stesso JSON diventa public record Order(...).

Ogni componente del record porta @JsonProperty("key") con la chiave JSON originale, quindi user_id continua a corrispondere a userId. Se scegli Gson, gli stessi componenti portano @SerializedName("key"), con l’import di Gson. I record richiedono Java 16 o successivo.

Come i tipi JSON diventano tipi Java

Tutti i tipi sono classi wrapper, quindi ogni campo può mancare o essere null.

• Numero intero come 7: Integer. Troppo grande (12345678901): Long. Ancora più grande (99999999999999999999): BigInteger, con il suo import.
• Numero con punto decimale o esponente, come 4.5, 1.0 o 2e3: Double.
• Testo: String. true o false: Boolean (il getter è getActive, non isActive). null: Object.
• Array di un solo tipo, come ["a", "b"]: List<String>, con java.util.List importato. Array vuoto o di tipi misti: List<Object>. Array dentro un array: List<List<Integer>>.
• Oggetto: una classe o un record annidato che prende il nome della chiave.

I numeri vengono letti esattamente come sono scritti, quindi un ID lungo non viene mai arrotondato. Gli import compaiono solo quando il codice li usa. Se una chiave compare due volte nello stesso oggetto, vince l’ultima.

Come vengono scelti i nomi di classi e campi

• user_id e user-name diventano i campi userId e userName (camelCase).
• Una parola riservata di Java come class diventa _class.
• Un nome che inizia con una cifra, come 2nd, diventa _2nd.
• Una chiave items con un array di oggetti dà la classe Item e il campo List<Item>: la chiave viene messa al singolare.
• Una chiave String con un oggetto dà StringData. I nomi che oscurerebbero String, List o Object ricevono Data in coda.
• Due oggetti con lo stesso nome: la seconda classe riceve un numero, perché i nomi delle classi devono essere unici nel file.

Il nome della classe radice viene ripulito fino a diventare un nome Java valido, e una casella vuota dà Root. Quando il JSON stesso inizia con un array di oggetti, Root descrive un elemento e la pagina ti dice di leggere il JSON come List<Root>.

Quando il JSON non viene accettato

Il lettore è rigoroso, come lo è JSON: commenti, apici singoli e virgole finali sono errori. Il messaggio «Impossibile leggere questo JSON» dà un motivo chiaro e la posizione, come «Riga 3, colonna 5», per esempio «L’analisi si è fermata su «}». Controlla se manca una virgola, i due punti, una parentesi o delle virgolette subito prima.»

• Se il tuo testo è un oggetto JavaScript con chiavi senza virgolette o con apici singoli, passalo prima da «Da oggetto JavaScript a JSON» per ottenere JSON rigoroso.
• Per riformattare il JSON prima di convertirlo, usa «Formattatore JSON».
• Per controllare il JSON rispetto a uno schema, usa «Validatore JSON Schema».
• Per le interfacce TypeScript a partire da JavaScript, guarda «Convertitore da JS a TS».

Un JSON valido che non contiene oggetti, come 42 o un array di numeri, mostra «Questo JSON non contiene oggetti da trasformare in classe.» Un testo di oltre 2.000.000 di caratteri viene rifiutato, così come un annidamento oltre i 200 livelli.

Strumenti correlati

Autoprefixer CSS

Incolla il CSS e ottieni subito i prefissi. Gratis.

Deoffuscatore JS

Rendi leggibile il JavaScript offuscato

Convertitore da JS a TS

Da JavaScript a TypeScript, PropTypes in interfacce

Da oggetto JavaScript a JSON

Converti un oggetto JS in JSON rigoroso con escape

Convertitore da JSX a JS

Compila JSX di React in JavaScript nel browser