Serializzazione in JSON

"Ciao, Amico!"

"Ciao, Eli!"

"Dal momento che ti è già stato presentato JSON, parliamone di più oggi."

"OK. Dove si usa di solito?"

"Ecco come funziona di solito. Qualcuno (il client) richiede dati da un programma Java (il server). Il programma crea oggetti Java e li riempie con informazioni dal database. Quindi li converte in un formato che il richiedente (il client ) può capire, come JSON, e li rimanda indietro."

"Lascia che ti dica come lavorare con JSON in Java. In sostanza, dobbiamo solo fare due cose: serializzare gli oggetti Java nel formato JSON e deserializzare gli oggetti Java dal formato JSON."

"In altre parole, JSON è uno standard per l'invio di messaggi/dati da un programma a un altro. Esistono molti standard del genere. Ma se il programma è scritto in JavaScript, di solito tenta di utilizzare JSON."

"Ok sono pronto."

"Fantastico. Allora cominciamo."

"Come già sai, Java ha strumenti di serializzazione standard incorporati. Ma non supportano JSON. Quindi, se hai bisogno di serializzare un oggetto in JSON, puoi usare uno dei popolari framework (librerie) che sanno come Fai questo."

"Qual è la differenza tra questi diversi framework?"

"Di solito differiscono nel loro livello di complessità: ci sono framework che possono fare solo le basi, ma sono molto piccoli e semplici. E ci sono framework grandi e complessi che possono fare molto di più".

"Jackson è uno dei framework più popolari. Lo useremo come esempio mentre esaminiamo come lavorare con JSON."

"Per prima cosa, devi scaricare questo framework e aggiungerlo al tuo progetto. Devi farlo direttamente in IntelliJ IDEA. Puoi scaricare il framework usando questo link ."

"Fatto."

"Fantastico. Andiamo avanti, allora."

"Convertire un oggetto Java in JSON è facile quanto serializzarlo. Per fare ciò, esiste una classe ObjectMapper speciale (com.fasterxml.jackson.databind.ObjectMapper)."

"Lascia che ti mostri un esempio funzionante e poi lo analizzeremo:"

public static void main(String[] args) throws IOException
{
 // Create an object to be serialized into JSON
 Cat cat = new Cat();
 cat.name = "Missy";
 cat.age = 5;
 cat.weight = 4;

 // Write the result of the serialization to a StringWriter
 StringWriter writer = new StringWriter();

 // This is the Jackson object that performs the serialization
 ObjectMapper mapper = new ObjectMapper();

 // And here's the serialization itself: the first argument is where, and the second is what
 mapper.writeValue(writer, cat);

 // Convert everything written to the StringWriter into a String
 String result = writer.toString();
 System.out.println(result);
}

@JsonAutoDetect
class Cat
{
 public String name;
 public int age;
 public int weight;
Cat(){}
}

{"name":"Missy", "age":5, "weight":4}

"Ecco come funziona:"

"Nelle righe 4-7, creiamo un oggetto Cat e lo popoliamo con i dati."

"Nella riga 10, creiamo un oggetto Writer in cui scriveremo una rappresentazione in stringa JSON dell'oggetto."

"Nella riga 13, creiamo un oggetto ObjectMapper che eseguirà tutta la serializzazione."

"Nella riga 16, scriviamo la rappresentazione JSON dell'oggetto cat in writer ."

"Nelle righe 19-20, visualizziamo il risultato sullo schermo."

"Tutto sembra abbastanza semplice. Non più difficile della serializzazione nativa in Java."

"Come sarebbe la deserializzazione?"

"È quasi lo stesso, solo più breve:"

public static void main(String[] args) throws IOException
{
 String jsonString = "{ \"name\":\"Missy\", \"age\":5, \"weight\":4}";
 StringReader reader = new StringReader(jsonString);

 ObjectMapper mapper = new ObjectMapper();

 Cat cat = mapper.readValue(reader, Cat.class);
}

@JsonAutoDetect
class Cat
{
 public String name;
 public int age;
 public int weight;

 Cat() { }
}

"È ancora più semplice. Prendiamo ObjectMapper e gli passiamo una stringa o uno StringReader con JSON, così come la classe dell'oggetto da deserializzare . Quindi chiamiamo il metodo readValue e come output otteniamo un oggetto Java già pronto con tutti i dati".

"Beh, è ​​esattamente come la deserializzazione in Java."

"Quasi. Esistono diversi requisiti per gli oggetti serializzati o deserializzati da JSON:"

" 1)  i campi devono essere visibili: devono essere pubblici o avere getter e setter"

" 2)  ci deve essere un costruttore predefinito (uno senza parametri)"

"Capisco. Non è troppo sorprendente. Ma Java ha serializzato tutto, anche i campi privati."

"Beh, quello era Java. Ha accesso a dati nascosti. Non puoi nasconderti da te stesso."

"C'è un terzo aspetto qui. Spero che tu abbia notato l'annotazione @JsonAutoDetect sulla classe Cat?"

"Sì. Stavo proprio per chiedere cosa fosse."

"È un'annotazione: informazioni di pulizia per il framework Jackson. Usando le giuste annotazioni, hai un controllo abbastanza flessibile sui risultati della serializzazione in JSON."

"Fantastico! Che tipo di annotazioni ci sono?"

"Ecco alcuni esempi:"

"Che interessante! Ce ne sono altri?"

"Ce ne sono molti. Ma non li copriremo adesso. Ora rielaboriamo leggermente il nostro primo esempio:"

public static void main(String[] args) throws IOException
{
 Cat cat = new Cat();
 cat.name = "Missy";
 cat.age = 5;
 cat.weight = 4;

 StringWriter writer = new StringWriter();

 ObjectMapper mapper = new ObjectMapper();

 mapper.writeValue(writer, cat);

 String result = writer.toString();
 System.out.println(result);
}

@JsonAutoDetect
class Cat
{
 @JsonProperty("alias")
 public String name;
 public int age;
 @JsonIgnore
 public int weight;

 Cat() {
 }
}

{"age":5, "alias":"Missy"}

"Il codice rimane lo stesso, ma ho cambiato le annotazioni: ho specificato un altro nome per il campo del nome: alias. Ho anche contrassegnato il campo del peso come Ignora, il che ha causato la modifica dell'oggetto JSON."

"È un bene che tu possa personalizzare tutto in questo modo. Penso che lo troverò sicuramente utile."

"E la deserializzazione capirà come lavorare con questo? Durante la deserializzazione da JSON a un oggetto Java, il valore del campo alias verrà scritto nel campo del nome dell'oggetto Cat?"

"Sì, la deserializzazione funzionerà come dovrebbe. È intelligente."

"Cosa c'è di cui non essere felice allora."

"Grazie per questa lezione interessante, Ellie."