JSON serialization frameworks

"Hi, buddy!"

"Hey, Diego."

"Nakikita ko dito natutunan mo ang mga pangunahing kaalaman ng JSON serialization?"

"Anong ibig mong sabihing 'basics'? Marami akong alam!"

"So naive. You don't know the half of it. Ten percent at best."

"Nagbibiro ka. Ano pa bang meron?"

"Deserialization ng isang object hierarchy (polymorphic deserialization), deserialization ng mga koleksyon, at marami pang iba! Ang balangkas ng Jackson ay malaki at makapangyarihan. Sa totoo lang, nagsimula ka pa lamang na kumamot sa ibabaw."

"Okay, then tell me about it - I'm all ears."

"I'm really enjoying getting smarter with each lesson!"

"Well, ito ay aking kasiyahan na tumulong, aking robot na kaibigan!"

"Handa ka na ba? Tapos makinig ka."

"Tulad ng natutunan mo na, ang mga anotasyon ay ginagamit para sa parehong serialization at deserialization. Sa pagsasagawa, ang serialization ay nangangailangan ng mas kaunting impormasyon kaysa sa deserialization. Halimbawa:"

class Cat
{
 public String name = "missy";
 public Cat[] cats = new Cat[0];
}

{
 "name": "missy",
 "cats": []
}

class Cat
{
 public String name = "missy";
 public List cats = new ArrayList<Cat>();
}

{
 "name": "missy",
 "cats": []
}

class Cat
{
 public String name = "missy";
 public List cats = new LinkedList<Cat>();
}

{
 "name": "missy",
 "cats": []
}

"Ang mga pagkakataon ng Array, ArrayList, LinkedList, at iba pang mga klase ay ginawang JSON array."

"Ngunit kapag na-deserialize mo ang isang JSON array, anong object ang dapat mong gawin: isang ArrayList o isang LinkedList?"

"Tama. Kung ang isang miyembro ng klase ay isang interface (eg public List<Cat> cats ), anong bagay ang dapat iugnay dito?"

"Maaari kaming magdagdag ng mga karagdagang anotasyon sa field o tahasang ipahiwatig ang mga target na klase sa panahon ng deserialization. Tingnan ang halimbawang ito:"

public static void main(String[] args) throws IOException
{
 String jsonString = ""{\"name\":\"Missy\",\"cats\":[{\"name\":\"Timmy\"},{\"name\":\"Killer\"}]}"";
 StringReader reader = new StringReader(jsonString);
 ObjectMapper mapper = new ObjectMapper();
 Cat cat = mapper.readValue(reader, TypeFactory.collectionType(ArrayList.class, Cat.class));
}

@JsonAutoDetect
class Cat {
 public String name;
 public List&ltCat> cats = new ArrayList<>();
 Cat() {
 }
}

"Sa madaling salita, maaari nating gamitin ang pangalawang parameter ng mapper . readValue na paraan upang maipasa ang listahan ng mga klase na gagamitin sa panahon ng deserialization."

"Gusto ko. Maginhawa iyon. Para ma-deserialize mo ang isang JSON array sa anumang kailangan mo, isang ArrayList o isang LinkedList.

"Nabanggit mo rin gamit ang mga anotasyon. Paano mo gagawin iyon?"

"Madali lang. Halimbawa:"

public static void main(String[] args) throws IOException
{
 String jsonString = ""{\"name\":\"Missy\",\"cats\":[{\"name\":\"Timmy\"},{\"name\":\"Killer\"}]}"";
 StringReader reader = new StringReader(jsonString);

 ObjectMapper mapper = new ObjectMapper();

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

@JsonAutoDetect
class Cat
{
 public String name;
 @JsonDeserialize(as = ArrayList.class, contentAs = Cat.class)
 public List&ltCat> cats = new ArrayList<>();
 Cat() {
 }
}

"Idinaragdag lang namin ang annotation @JsonDeserialize(as = ArrayList.class, contentAs = Cat.class) sa line 5 para isaad kung aling pagpapatupad ng List interface ang gagamitin."

"Ah. I see. Iyan talaga ay medyo simple."

"Pero meron pa. Ipagpalagay na ang uri ng data sa isang Listahan ay isa ring interface! Ano ang gagawin mo?"

"Gumagamit din ba tayo ng annotation dito?"

"Oo, pareho. Magagamit mo rin ito para ipahiwatig ang uri ng parameter. Ganito:"

"Cool! Marami talagang anotasyon na kailangan para sa iba't ibang sitwasyon na hindi natin maasahan."

"Hindi lang iyon. At dinadala tayo nito sa pangunahing kurso: sa mga totoong proyekto, ang mga klase ay madalas na nagmamana ng parehong base class o interface, na ginagamit halos saanman. At ngayon isipin na kailangan mong i-deserialize ang isang istraktura ng data na naglalaman ng mga ganoong klase. Halimbawa:"

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

 Dog dog = new Dog();
 dog.name = "Killer";
 dog.age = 8;
 dog.owner = "Bill Jefferson";

 ArrayList<Pet> pets = new ArrayList<Pet>();
 pets.add(cat);
 pets.add(dog);

 StringWriter writer = new StringWriter();
 ObjectMapper mapper = new ObjectMapper();
 mapper.writeValue(writer, pets);
 System.out.println(writer.toString());
}

@JsonAutoDetect
class Pet
{
 public String name;
}

@JsonAutoDetect
class Cat extends Pet
{
 public int age;
}

@JsonAutoDetect
class Dog extends Pet
{
 public int age;
 public String owner;
}

[
 { "name" : "Missy", "age" : 5},
 { "name" : "Killer", "age" : 8 , "owner" : "Bill Jeferson"}
]

"Bigyang-pansin ang resulta ng serialization."

"Hindi namin maaaring i-deserialize ang data na ito sa isang Java object, dahil ito ay mahalagang hindi makilala sa data para sa iba pang mga klase."

"Mayroong ilang natatanging tampok: May field ng may-ari ang aso."

"Oo, ngunit ang field na ito ay maaaring walang bisa o maaari itong ganap na laktawan sa panahon ng serialization."

"Buweno, hindi ba natin matukoy ang uri ng data gamit ang mga anotasyon na alam natin?"

"Hindi. Pagkatapos ng deserialization, ang isang koleksyon ay dapat magkaroon ng iba't ibang mga bagay na Pusa at Aso, pati na rin isang dosenang iba pang mga klase na maaaring magmana mula sa Pet."

"Ano sa mundo ang maaari mong gawin dito?"

"Dalawang bagay ang ginagamit dito."

"Una, ang isang partikular na field ay pinili upang makilala ang isang uri mula sa isa pa. Kung walang isa, kung gayon ito ay nilikha."

"Pangalawa, may mga espesyal na anotasyon na nagbibigay-daan sa iyong kontrolin ang proseso ng «polymorphic deserialization». Narito ang maaari mong gawin:"

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

 Dog dog = new Dog();
 dog.name = "Killer";
 dog.age = 8;
 dog.owner = "Bill Jeferson";

 House house = new House();
 house.pets.add(dog);
 house.pets.add(cat);

 StringWriter writer = new StringWriter();
 ObjectMapper mapper = new ObjectMapper();
 mapper.writeValue(writer, house);
 System.out.println(writer.toString());
}

@JsonTypeInfo(use = JsonTypeInfo.Id.NAME, property = "type")
@JsonSubTypes({
@JsonSubTypes.Type(value = Cat.class, name = "cat"),
@JsonSubTypes.Type(value = Dog.class, name = "dog")
})
class Pet
{
 public String name;
}

class Cat extends Pet
{
 public int age;
}

class Dog extends Pet
{
 public int age;
 public String owner;
}

class House
{
 public List&ltPet> pets = new ArrayList<>();
}

{
 "pets" : [
 {"type" : "dog", "name" : "Killer", "age" : 8, "owner" : "Bill Jeferson"},
 {"type" : "cat", "name" : "Missy", "age" : 5}
]
}

Gamit ang mga anotasyon, ipinapahiwatig namin na ang representasyon ng JSON ay maglalaman ng isang espesyal na field na tinatawag na uri na hahawak sa halagang pusa para sa klase ng Cat , at sa halagang aso para sa klase ng Aso . Ang impormasyong ito ay sapat na upang maayos na ma-deserialize ang isang bagay: sa panahon ng deserialization, ang uri ng bagay na gagawin ay matutukoy sa pamamagitan ng halaga ng field ng uri.

"Minsan ang pangalan ng klase ay ginagamit bilang ang halaga ng field ng uri (hal. «com.example.entity.Cat.class»), ngunit hindi ito magandang kasanayan. Paano malalaman ng isang panlabas na application na tumatanggap ng aming JSON ang mga pangalan ng ang aming mga klase? Ang masama, ang mga klase ay pinapalitan kung minsan ang pangalan. Mas mainam na gumamit ng ilang natatanging pangalan upang makilala ang isang partikular na klase."

"Cool! Sigh. I didn't realize deserialization was so complicated. And that there is so much you can fine-tune."

"Yep. Ito ay mga bagong konsepto para sa iyo, ngunit ito ang uri ng praktikal na kaalaman na gagawin kang isang henyong programmer."

"Si Amigo ay isang cool na programmer. Cool!"

"Sige. Magpahinga ka na."