Serialisering till JSON

"Hej, Amigo!"

"Hej Ellie!"

"Eftersom du redan har blivit introducerad till JSON, låt oss prata mer om det idag."

"OK. Var brukar det användas?"

"Så här fungerar det vanligtvis. Någon (klienten) begär data från ett Java-program (servern). Programmet skapar Java-objekt och fyller dem med information från databasen. Det konverterar dem sedan till ett format som begäranden (klienten) ) kan förstå, som JSON, och skickar tillbaka dem."

"Låt mig berätta hur man arbetar med JSON i Java. I huvudsak behöver vi bara göra två saker: serialisera Java-objekt till JSON-formatet och deserialisera Java-objekt från JSON-formatet."

"JSON är med andra ord en standard för att skicka meddelanden/data från ett program till ett annat. Det finns många sådana standarder. Men om programmet är skrivet i JavaScript försöker det oftast använda JSON."

"OK jag är redo."

"Jättebra. Då sätter vi igång."

"Som du redan vet har Java inbyggda standardverktyg för serialisering. Men de stöder inte JSON. Så om du behöver serialisera ett objekt till JSON kan du använda ett av de populära ramverken (biblioteken) som vet hur man gör det här."

"Vad är skillnaden mellan dessa olika ramverk?"

"De brukar skilja sig åt i sin komplexitetsnivå: det finns ramverk som bara kan göra det allra grundläggande, men de är väldigt små och enkla. Och det finns stora komplexa ramverk som kan göra mycket mer."

"Jackson är ett av de mest populära ramverken. Vi kommer att använda det som ett exempel när vi tittar på hur man arbetar med JSON."

"Först måste du ladda ner det här ramverket och lägga till det i ditt projekt. Du måste göra detta direkt i IntelliJ IDEA. Du kan ladda ner ramverket med den här länken ."

"Gjort."

"Bra. Låt oss fortsätta då."

"Att konvertera ett Java-objekt till JSON är ungefär lika enkelt som att serialisera det. För att göra detta finns det en speciell ObjectMapper-klass (com.fasterxml.jackson.databind.ObjectMapper)."

"Låt mig visa dig ett fungerande exempel, och sedan analyserar vi det:"

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}

"Så här fungerar det:"

"På rad 4-7 skapar vi ett Cat- objekt och fyller det med data."

"På rad 10 skapar vi ett Writer-objekt där vi skriver en JSON-strängrepresentation av objektet."

"På rad 13 skapar vi ett ObjectMapper- objekt som kommer att utföra all serialisering."

"På rad 16 skriver vi JSON-representationen av kattobjektet till författaren ."

"På raderna 19-20 visar vi resultatet på skärmen."

"Allt ser ganska enkelt ut. Inte svårare än native serialisering i Java."

"Hur skulle deserialisering se ut?"

"Det är nästan likadant, bara kortare:"

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

"Det är ännu enklare. Vi tar ObjectMapper och skickar den en sträng eller en StringReader med JSON, samt klassen för objektet som ska deserialiseras . Sedan anropar vi readValue- metoden, och som utdata får vi ett färdigt Java-objekt med all data."

"Tja, det är precis som deserialisering i Java."

"Nästan. Det finns flera krav på objekt som serialiserats till, eller deserialiserats från, JSON:"

" 1)  fälten måste vara synliga: de måste antingen vara offentliga eller ha getters och setters"

" 2)  det måste finnas en standardkonstruktor (en utan parametrar)"

"Jag förstår. Det är inte alltför förvånande. Men Java serialiserade allt, även privata områden."

"Tja, det var Java. Den har tillgång till dolda data. Du kan inte gömma dig för dig själv."

"Det finns en tredje aspekt här. Jag hoppas att du märkte @JsonAutoDetect-kommentaren på Cat-klassen?"

"Japp. Jag tänkte precis fråga vad det var."

"Det är en anteckning: hushållsinformation för Jackson-ramverket. Genom att använda rätt annoteringar har du ganska mycket flexibel kontroll över resultaten av serialisering till JSON."

"Coolt! Vilken typ av kommentarer finns det?"

"Här är några exempel:"

"Vad intressant! Finns det fler?"

"Det finns många. Men vi kommer inte att täcka dem just nu. Låt oss nu omarbeta vårt första exempel lite:"

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

"Koden förblir densamma, men jag ändrade kommentarerna: Jag angav ett annat namn för namnfältet: alias. Jag markerade också viktfältet som Ignorera, vilket fick JSON-objektet att ändras."

"Det är bra att man kan anpassa allt så. Jag tror att jag definitivt kommer att ha nytta av det här."

"Och deserialisering kommer att förstå hur man arbetar med detta? När man deserialiserar från JSON till ett Java-objekt kommer värdet av aliasfältet att skrivas till Cat-objektets namnfält?"

"Ja, deserialiseringen kommer att fungera som den ska. Det är smart."

"Vad är man inte glad för då."

"Tack för denna intressanta lektion, Ellie."