Serialization sa JSON

"Hi, Amigo!"

"Hi, Ellie!"

"Dahil naipakilala ka na kay JSON, pag-usapan pa natin ito ngayon."

"OK. Saan ito kadalasang ginagamit?"

"Narito kung paano ito karaniwang gumagana. Ang isang tao (ang kliyente) ay humiling ng data mula sa isang Java program (ang server). Ang programa ay lumilikha ng mga bagay sa Java at pinupuno ang mga ito ng impormasyon mula sa database. ) ay maaaring maunawaan, tulad ng JSON, at ibabalik ang mga ito."

"Hayaan akong sabihin sa iyo kung paano magtrabaho kasama ang JSON sa Java. Sa pangkalahatan, kailangan lang nating gawin ang dalawang bagay: i-serialize ang mga Java object sa JSON na format, at i-deserialize ang mga Java object mula sa JSON na format."

"Sa madaling salita, ang JSON ay isang pamantayan para sa pagpapadala ng mga mensahe/data mula sa isang programa patungo sa isa pa. Mayroong maraming mga pamantayan na ganoon. Ngunit kung ang programa ay nakasulat sa JavaScript, kadalasang sinusubukan nitong gamitin ang JSON."

"Ok handa na ako."

"Great. Saka na tayo magsimula."

"Tulad ng alam mo na, may built-in na standard na serialization tool ang Java. Ngunit hindi nila sinusuportahan ang JSON. Kaya, kung kailangan mong i-serialize ang isang object sa JSON, maaari mong gamitin ang isa sa mga sikat na frameworks (library) na alam kung paano gawin ito."

"Ano ang pagkakaiba ng iba't ibang balangkas na ito?"

"Karaniwan silang naiiba sa kanilang antas ng pagiging kumplikado: may mga balangkas na maaari lamang gawin ang mga pinakapangunahing bagay, ngunit ang mga ito ay napakaliit at simple. At may mga malalaking kumplikadong mga balangkas na maaaring gumawa ng higit pa."

"Ang Jackson ay isa sa mga pinakasikat na frameworks. Gagamitin namin ito bilang isang halimbawa habang tinitingnan namin kung paano magtrabaho kasama ang JSON."

"Una, kailangan mong i-download ang framework na ito at idagdag ito sa iyong proyekto. Kailangan mong gawin ito nang direkta sa IntelliJ IDEA. Maaari mong i-download ang framework gamit ang link na ito ."

"Tapos na."

"Great. Ituloy na natin."

"Ang pag-convert ng Java object sa JSON ay halos kasingdali ng pagse-serialize nito. Para magawa ito, mayroong espesyal na klase ng ObjectMapper (com.fasterxml.jackson.databind.ObjectMapper)."

"Hayaan akong magpakita sa iyo ng isang gumaganang halimbawa, at pagkatapos ay susuriin namin ito:"

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}

"Narito kung paano ito gumagana:"

"Sa mga linya 4-7, gumagawa kami ng Cat object at nilagyan namin ito ng data."

"Sa linya 10, lumikha kami ng object ng Writer kung saan magsusulat kami ng JSON-string representation ng object."

"Sa linya 13, lumikha kami ng object ng ObjectMapper na gagawa ng lahat ng serialization."

"Sa linya 16, isinusulat namin ang representasyon ng JSON ng object ng pusa sa manunulat ."

"Sa mga linya 19-20, ipinapakita namin ang resulta sa screen."

"Mukhang medyo simple ang lahat. Walang mas mahirap kaysa sa katutubong serialization sa Java."

"Ano ang magiging hitsura ng deserialization?"

"Halos pareho lang, mas maikli lang:"

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

"Ito ay mas madali. Kinukuha namin ang ObjectMapper at ipinapasa ito ng isang string o isang StringReader na may JSON, pati na rin ang klase ng object na i-deserialized . Pagkatapos ay tinatawag namin ang readValue method, at bilang output ay nakakakuha kami ng isang handa na Java object na may lahat ng data."

"Well, iyon ay eksakto tulad ng deserialization sa Java."

"Halos. Mayroong ilang mga kinakailangan na inilagay sa mga bagay na naka-serialize sa, o deserialized mula sa, JSON:"

" 1)  ang mga field ay dapat na nakikita: ang mga ito ay dapat na pampubliko o may mga getter at setter"

" 2)  dapat mayroong isang default na tagabuo (isa na walang mga parameter)"

"I see. That's not too surprising. But Java serialized everything, even private fields."

"Well, that was Java. Ito ay may access sa hidden data. You can't hide from yourself."

"May pangatlong aspeto dito. Sana napansin mo ang @JsonAutoDetect annotation sa klase ng Cat?"

"Yep. Itatanong ko lang sana kung ano yun."

"Ito ay isang anotasyon: impormasyon sa housekeeping para sa balangkas ng Jackson. Sa pamamagitan ng paggamit ng mga tamang anotasyon, mayroon kang napakaraming flexible na kontrol sa mga resulta ng serialization sa JSON."

"Astig! Anong klaseng anotasyon ang meron?"

"Narito ang ilang mga halimbawa:"

"How interesting! Meron pa ba?"

"Marami. Ngunit hindi natin sila sasaklawin sa ngayon. Ngayon ay i-rework natin nang bahagya ang ating unang halimbawa:"

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

"Nananatiling pareho ang code, ngunit binago ko ang mga anotasyon: Tinukoy ko ang isa pang pangalan para sa field ng pangalan: alias. Minarkahan ko rin ang weight field bilang Ignore, na naging sanhi ng pagbabago ng object ng JSON."

"Buti na lang kaya mong i-customize lahat ng ganyan. I think I'll definitely find this useful."

"At mauunawaan ng deserialization kung paano ito gagawin? Kapag nagde-deserialize mula sa JSON patungo sa isang Java object, ang halaga ng field ng alias ay isusulat sa field ng pangalan ng object ng Cat?"

"Oo, gagana ang deserialization ayon sa nararapat. Matalino ito."

"Ano ang hindi dapat ikatuwa kung gayon."

"Salamat sa kawili-wiling aral na ito, Ellie."