XML, serialization sa XML

"Kumusta na?"

"Mahusay. Hindi makapagreklamo. Ngayon ay sinabi sa akin ni Bilaabo ang tungkol sa JavaScript. Hindi lahat, siyempre, ngunit higit pa sa kaunti. Siyempre, wala pa rin akong naisulat sa JS, ngunit sa palagay ko ay hindi ito magiging mahirap."

"At sinabi sa akin ni Ellie ang tungkol sa serialization ng JSON. At ipinaliwanag mo ang framework ng Jackson at kung paano i-set up ang 'polymorphic deserialization' gamit ang mga anotasyon."

"No way! Matalino ka na, Amigo! A real stud!"

"At pagkatapos ay ilan!"

"OK. Magtrabaho na tayo. Ngayon ay mayroon tayong bago, kawili-wiling paksa: XML. "

"Ang XML ay isang pamantayan para sa kumakatawan sa data na madaling mabasa ng mga tao—at mas madali pa ng mga programa. Narito ang isang halimbawang XML file:"

<data>
<owner first="Adam" last="Shelton">
<address>London</address>
</owner>
<cat name="Missy" age="15"/>
</data>

"Ang pundasyon ng XML ay mga tag. Ang tag ay isang salita sa mga anggulong bracket (mas malaki kaysa sa at mas mababa kaysa sa mga palatandaan). May mga pambungad at pagsasara na tag. Ang bawat pambungad na tag ay may eksaktong isang katumbas na pansarang tag. Ang mga pambungad na tag ay maaaring magkaroon ng mga katangian. "

"Maaaring ilagay ang mga tag sa loob ng isang tag, at sa gayon ay lumilikha ng isang element tree. Ang pinakamataas na antas na tag ay tinatawag na root: mayroon itong mga child tag, na may sariling mga child tag."

"Narito ang ilang mga halimbawa:"

"Mukhang madali lang. Anong klaseng tag ang meron?"

"Anumang uri. Walang mga nakareserbang tag. Ang XML ay isang wika para sa paglalarawan ng anumang data. Ang mga tao ay bumubuo ng mga tag na nakakatugon sa kanilang mga pangangailangan at sumasang-ayon sa kung paano gamitin ang mga ito."

"Mahalaga, ang XML ay isang paraan upang magsulat ng data bilang isang element tree na naiintindihan ng isang computer."

"I think I get it now. Nga pala, may tanong ako."

"Ginagamit ang JSON upang magpadala ng data mula sa isang browser patungo sa isang server, ngunit saan ginagamit ang XML?"

"Sa parehong mga lugar kung saan ginagamit ang JSON: para sa pag-iimbak at pagpapadala ng data."

"Okay, let's continue."

"Isipin na mayroon kang isang nakabahaging XML file na nag-iimbak ng data para sa isang programa na isinulat ng dalawampung tao. Bawat isa sa kanila ay may sariling mga tag, at mabilis silang nakikialam sa isa't isa."

"Upang matiyak na ang mga tag ay natatangi, ang mga prefix ay naimbento. Ganito ang hitsura ng mga ito:"

"Ang mga prefix ay tinatawag ding mga namespace. Kung tinatawag natin silang mga namespace, ang huling paglalarawan sa talahanayan ay magiging 'Isang cat tag na may namespace ng hayop. Isang name attribute na may zoo namespace.'"

"Nga pala, natatandaan mo ba na sa Java ang bawat klase ay may isang maikling pangalan at isang mahabang natatanging pangalan na kasama ang pangalan ng package, na tinukoy din kapag nag-import ng package?"

"Oo."

"Buweno, ang mga prefix ay mayroon ding natatanging mahabang pangalan, at ito ay tinukoy din kapag na-import: "

< data  xmlns:soap="http://cxf.apache.org/bindings/soap" >
 < soap :item> 
< soap :info/> 
</ soap :item> 
</ data >

"' xml ns :soap' ay nangangahulugang ' XML — n ame s pace SOAP'"

"Maaari mo ring itakda ang natatanging pangalan ng mga tag na walang prefix: "

<data xmlns = "http://www.springframework.org/schema/beans" 
xmlns: soap = "http://cxf.apache.org/bindings/soap" 
xmlns:task = "http://www.springframework .org/schema/task" > 
< soap :item> 
< soap :info/> 
< task :info/> 
</ soap :item> 
</data>

Ang "'xmlns=…' ay nagtatakda ng namespace para sa walang laman na prefix. Sa madaling salita, itinatakda nito ang namespace para sa mga tag na walang prefix, gaya ng data sa halimbawa sa itaas."

"Maaari kang magkaroon ng maraming namespace sa isang dokumento hangga't gusto mo, ngunit ang bawat isa ay dapat magkaroon ng isang natatanging pangalan."

"I see. Bakit may kakaibang kakaibang pangalan ang mga namespace na ito?"

"Karaniwan silang nagsasaad ng URL na tumuturo sa isang dokumentong naglalarawan sa namespace at/o sa mga XML tag nito."

"You dumped a lot of information on me today. Ano pa bang meron?"

"May konti pa."

"Una, may header ang XML. Isa itong espesyal na linya na naglalarawan sa bersyon ng XML at pag-encode ng file. "Karaniwang ganito ang hitsura:"

"Karaniwang ganito ang hitsura:"

<?xml  version = "1.0"  encoding = "UTF-8"?>
<data xmlns:soap = "http://cxf.apache.org/bindings/soap">
<soap:item>
<soap:info/>
</soap:item>
</data>

"Maaari ka ring magdagdag ng mga komento sa XML. Upang magsimula ng komento, gamitin ang '<!--'. Upang tapusin ito, gamitin ang '-->'."

<?xml version = "1.0" encoding = "UTF-8"?>
<data xmlns:soap = "http://cxf.apache.org/bindings/soap">
<soap:item>
<!-- <soap:info/> -->
</soap:item>
<!-- This is also a comment  -->
</data>

"I understand so far."

"Ang ilang mga simbolo (< > " &) ay may espesyal na kahulugan sa XML, kaya hindi sila magagamit sa ibang lugar. Malalampasan natin ang paghihigpit na ito sa pamamagitan ng pagkakasunod-sunod ng pagtakas—isang set ng mga character na ginamit upang kumatawan sa iba pang mga character/simbulo. Narito ang ilan sa kanila:"

"At narito ang isang halimbawa ng code na naka-embed sa XML:"

if (a < b)
System.out.println("a is minimum");

<code>
kung (a  <  b)
 System.out.println( " a ay minimum " );
</code>

"Uh... Parang hindi maganda."

"Maaalala mo na sa Java may mga character din na nakatakas? Halimbawa, "\". At na ang sequence na ito ay dapat ding isulat nang dalawang beses kapag nagsusulat sa isang String? Kaya ito ay isang pangkaraniwang pangyayari."

"OK."

"Iyon lang ang mayroon ako para sa araw na ito."

"Hooray. Makakapagpahinga na rin ako sa wakas."