Sorozatosítás JSON-ba

– Szia Amigo!

– Szia, Ellie!

"Mivel már megismerkedtél a JSON-val, ma beszéljünk róla bővebben."

"Rendben. Hol használják általában?"

"Általában ez így működik. Valaki (a kliens) adatokat kér egy Java programtól (a szervertől). A program Java objektumokat hoz létre, és kitölti azokat az adatbázisból származó információkkal. Ezután olyan formátumba konvertálja őket, amelyet a kérelmező (a kliens) ) megértheti, például a JSON-t, és visszaküldi őket."

"Hadd mondjam el, hogyan dolgozhat a JSON-nal Java nyelven. Lényegében csak két dolgot kell tennünk: a Java objektumokat JSON formátumba kell szerializálni, és a Java objektumokat JSON formátumból deszerializálnunk."

"Más szóval a JSON egy szabvány az üzenetek/adatok egyik programból a másikba küldésére. Nagyon sok ilyen szabvány létezik. De ha a program JavaScriptben van írva, akkor általában JSON-t próbál használni."

"Rendben, készen állok."

"Remek. Akkor kezdjük."

"Mint már tudja, a Java beépített szabványos szerializációs eszközökkel rendelkezik. De nem támogatják a JSON-t. Tehát, ha egy objektumot JSON-ba kell szerializálni, használhatja az egyik népszerű keretrendszert (könyvtárat), amely tudja, hogyan csináld ezt."

– Mi a különbség a különböző keretrendszerek között?

"Általában különböznek összetettségükben: vannak olyan keretrendszerek, amelyek csak az alapokat tudják elvégezni, de nagyon kicsik és egyszerűek. És vannak nagy, összetett keretrendszerek, amelyek sokkal többre képesek."

"A Jackson az egyik legnépszerűbb keretrendszer. Példaként fogjuk használni, amikor megvizsgáljuk, hogyan kell dolgozni a JSON-nal."

"Először le kell töltenie ezt a keretrendszert, és hozzá kell adnia a projekthez. Ezt közvetlenül az IntelliJ IDEA-ban kell megtennie. A keretrendszert ezen a hivatkozáson keresztül töltheti le ."

"Kész."

– Remek. Akkor folytassuk.

"Egy Java objektumot JSON-ba konvertálni nagyjából olyan egyszerű, mint a szerializálást. Ehhez van egy speciális ObjectMapper osztály (com.fasterxml.jackson.databind.ObjectMapper)."

"Hadd mutassak egy működő példát, aztán elemezzük:"

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}

"Íme, hogyan működik:"

"A 4-7. sorban létrehozunk egy Cat objektumot, és feltöltjük adatokkal."

"A 10. sorban létrehozunk egy Writer objektumot, ahol megírjuk az objektum JSON-karakterlánc reprezentációját."

"A 13. sorban létrehozunk egy ObjectMapper objektumot, amely elvégzi az összes szerializálást."

"A 16. sorban a cat objektum JSON-reprezentációját írjuk az írónak ."

"A 19-20. sorban megjelenítjük az eredményt a képernyőn."

"Minden nagyon egyszerűnek tűnik. Nem nehezebb, mint a Java natív szerializálása."

– Hogyan nézne ki a deszerializáció?

"Majdnem ugyanaz, csak rövidebb:"

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

"Ez még egyszerűbb. Fogjuk az ObjectMappert és átadunk neki egy stringet vagy egy StringReader-t JSON-nal, valamint a deszerializálandó objektum osztályát . Ezután meghívjuk a readValue metódust, és kimenetként kapunk egy kész Java objektumot az összes adatot."

"Nos, ez pontosan olyan, mint a deserializáció a Java-ban."

"Majdnem. A JSON-ba szerializált vagy abból deszerializált objektumokra számos követelmény vonatkozik:"

" 1)  a mezőknek láthatónak kell lenniük: vagy nyilvánosnak kell lenniük, vagy tartalmazniuk kell gettereket és beállítókat"

" 2)  kell lennie egy alapértelmezett konstruktornak (paraméterek nélkül)"

"Értem. Ez nem túl meglepő. De a Java mindent szerializált, még a privát mezőket is."

"Nos, ez volt a Java. Hozzáfér a rejtett adatokhoz. Nem bújhatsz el önmagad elől."

"Van itt egy harmadik szempont. Remélem, észrevetted a @JsonAutoDetect megjegyzést a Cat osztályon?"

– Igen. Épp meg akartam kérdezni, hogy mi az.

"Ez egy megjegyzés: a Jackson-keretrendszer háztartási információi. A megfelelő megjegyzések használatával meglehetősen rugalmasan szabályozhatja a JSON-ba szerializálás eredményeit."

"Csodálatos! Milyen megjegyzések vannak?"

"Íme néhány példa:"

"Milyen érdekes! Vannak még?"

"Sok van. De most nem térünk ki rájuk. Most dolgozzuk át kissé az első példánkat:"

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

"A kód ugyanaz marad, de megváltoztattam a megjegyzéseket: másik nevet adtam meg a névmezőnek: alias. A súlymezőt is Ignore-ként jelöltem meg, ami miatt a JSON objektum megváltozott."

"Jó, hogy mindent így lehet személyre szabni. Azt hiszem, ezt biztosan hasznosnak találom."

"És a deserializáció megérti, hogyan kell ezzel dolgozni? Amikor JSON-ról Java objektumra deserializálunk, az alias mező értéke a Cat objektum név mezőjébe lesz írva?"

"Igen, a deserializálás úgy fog működni, ahogy kell. Okos."

– Akkor minek ne örülj.

– Köszönöm ezt az érdekes leckét, Ellie.