Serialisatie naar JSON

"Hallo Amigo!"

"Hallo, Ellie!"

"Omdat je al kennis hebt gemaakt met JSON, laten we er vandaag meer over praten."

"OK. Waar wordt het meestal gebruikt?"

"Zo werkt het gewoonlijk. Iemand (de klant) vraagt ​​gegevens op bij een Java-programma (de server). Het programma maakt Java-objecten en vult deze met informatie uit de database. Vervolgens converteert het ze naar een formaat dat de aanvrager (de klant) ) kan begrijpen, zoals JSON, en stuurt ze terug."

"Laat me je vertellen hoe je met JSON in Java kunt werken. In wezen hoeven we maar twee dingen te doen: Java-objecten serialiseren naar het JSON-formaat en Java-objecten deserialiseren vanuit het JSON-formaat."

"Met andere woorden, JSON is een standaard voor het verzenden van berichten/gegevens van het ene programma naar het andere. Er zijn veel van dat soort standaarden. Maar als het programma in JavaScript is geschreven, probeert het meestal JSON te gebruiken."

"OK ik ben klaar."

"Geweldig. Laten we dan beginnen."

"Zoals u al weet, heeft Java ingebouwde standaard serialisatietools. Maar ze ondersteunen geen JSON. Dus als u een object moet serialiseren naar JSON, kunt u een van de populaire frameworks (bibliotheken) gebruiken die weten hoe doe dit."

"Wat is het verschil tussen deze verschillende kaders?"

"Ze verschillen meestal in hun complexiteitsniveau: er zijn frameworks die alleen de basis kunnen, maar ze zijn erg klein en eenvoudig. En er zijn grote complexe frameworks die veel meer kunnen."

"Jackson is een van de meest populaire frameworks. We zullen het als voorbeeld gebruiken als we kijken hoe we met JSON kunnen werken."

"Eerst moet je dit framework downloaden en aan je project toevoegen. Je moet dit rechtstreeks in IntelliJ IDEA doen. Je kunt het framework downloaden via deze link ."

"Klaar."

'Geweldig. Laten we dan verder gaan.'

"Het converteren van een Java-object naar JSON is ongeveer net zo eenvoudig als het serialiseren ervan. Om dit te doen, is er een speciale ObjectMapper-klasse (com.fasterxml.jackson.databind.ObjectMapper)."

"Laat me je een werkend voorbeeld laten zien, en dan zullen we het analyseren:"

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}

"Dit is hoe het werkt:"

"In regels 4-7 maken we een Cat- object en vullen het met gegevens."

"In regel 10 maken we een Writer-object waar we een JSON-stringrepresentatie van het object zullen schrijven."

"In regel 13 maken we een ObjectMapper- object dat alle serialisatie zal uitvoeren."

"In regel 16 schrijven we de JSON-representatie van het cat- object naar writer ."

"In de regels 19-20 tonen we het resultaat op het scherm."

"Alles ziet er vrij eenvoudig uit. Niet moeilijker dan native serialisatie in Java."

"Hoe zou deserialisatie eruit zien?"

"Het is bijna hetzelfde, alleen korter:"

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() { }
}

"Het is zelfs nog eenvoudiger. We nemen ObjectMapper en geven het een string of een StringReader met JSON door, evenals de klasse van het object dat moet worden gedeserialiseerd . Vervolgens roepen we de readValue- methode aan en als uitvoer krijgen we een kant-en-klaar Java-object met alle gegevens."

"Nou, dat is precies zoals deserialisatie in Java."

"Bijna. Er worden verschillende vereisten gesteld aan objecten die zijn geserialiseerd naar of gedeserialiseerd vanuit JSON:"

" 1)  de velden moeten zichtbaar zijn: ze moeten openbaar zijn of getters en setters hebben"

" 2)  er moet een standaardconstructor zijn (een zonder parameters)"

'Ik begrijp het. Dat is niet zo verwonderlijk. Maar Java heeft alles geserialiseerd, zelfs privévelden.'

'Nou, dat was Java. Het heeft toegang tot verborgen gegevens. Je kunt je niet voor jezelf verbergen.'

"Er is hier nog een derde aspect. Ik hoop dat je de @JsonAutoDetect-annotatie in de Cat-klasse hebt opgemerkt?"

'Ja. Ik wilde net vragen wat het was.'

"Het is een annotatie: huishoudinformatie voor het Jackson-framework. Door de juiste annotaties te gebruiken, heb je vrij veel flexibele controle over de resultaten van serialisatie naar JSON."

"Cool! Wat voor annotaties zijn er?"

"Hier zijn een paar voorbeelden:"

"Wat interessant! Zijn er nog meer?"

"Er zijn er veel. Maar we zullen ze nu niet behandelen. Laten we nu ons eerste voorbeeld een beetje herwerken:"

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"}

"De code blijft hetzelfde, maar ik heb de annotaties gewijzigd: ik heb een andere naam opgegeven voor het naamveld: alias. Ik heb ook het gewichtsveld gemarkeerd als Negeren, waardoor het JSON-object veranderde."

"Het is goed dat je alles zo kunt aanpassen. Ik denk dat ik dit zeker handig ga vinden."

"En deserialisatie zal begrijpen hoe hiermee te werken? Bij deserialisatie van JSON naar een Java-object, wordt de waarde van het aliasveld naar het naamveld van het Cat-object geschreven?"

"Ja, deserialisatie zal werken zoals het hoort. Het is slim."

"Wat is er dan niet om blij mee te zijn."

"Bedankt voor deze interessante les, Ellie."