JAXB

"Not so fast, young man! May dalawa pa akong lessons para sa iyo!"

"Dalawa? Wow. Well, okay. What wouldn't do to enhance your own coolness! I'm all ears."

"Ang XML, tulad ng JSON, ay kadalasang ginagamit kapag nagpapasa ng data sa pagitan ng iba't ibang mga program at mga computer. At mayroong ilang mga frameworks na lubos na nagpapasimple sa buhay ng mga Java programmer kapag nagtatrabaho sa XML. Ngayon ay ipapakilala ko sa iyo ang isa sa kanila."

"Ang JAXB ay isang mahusay na multipurpose framework para sa pagtatrabaho sa XML."

"Ang JXB ay bahagi ng JDK, kaya hindi mo kailangang i-download ito nang hiwalay."

"Hayaan mo muna akong magpakita sa iyo ng isang halimbawa kung paano ito gamitin, at pagkatapos ay susuriin namin ito. Halimbawa:"

public static void main(String[] args) throws JAXBException
{
 // Create an object to be serialized into XML
 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();

 // Create a Marshaller object that will perform the serialization
 JAXBContext context = JAXBContext.newInstance(Cat.class);
 Marshaller marshaller = context.createMarshaller();
 marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);
 // And here's the serialization itself:
 marshaller.marshal(cat, writer);

 // Convert everything written to the StringWriter
 String result = writer.toString();
 System.out.println(result);
}

@XmlType(name = "cat")
@XmlRootElement
public class Cat
{
 public String name;
 public int age;
 public int weight;

 public Cat()
 {
 }
}

<cat> 
<name> Missy </name> 
<age> 5 </age> 
<weight> 4 </weight> 
</cat>

"Para sa ilang kadahilanan, linya para sa linya, ang code na ito ay nagpapaalala sa akin ng JSON serialization. Ang parehong mga anotasyon, ngunit JSON ay gumamit ng isang ObjectMapper, at ito ay gumagamit ng Context at Marshaller."

"Yep. They really are very similar. Jackson was modeled after JAXB. Pero JAXB was also copied from somewhere. You can't invent something genius from scratch."

"Mukhang ganyan."

"OK, ganito ang nangyayari:"

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

"Sa linya 10, lumikha kami ng bagay na Writer upang isulat ang resulta."

"Sa linya 13, nilikha namin ang 'konteksto'. Ito ay katulad ng ObjectMapper, ngunit pagkatapos ay dalawang karagdagang child object ang nilikha mula rito. Marshaller ay para sa serialization, at Unmarshaller ay para sa deserialization. May mga maliit na pagkakaiba mula sa Jackson, ngunit ito ay hindi hindi talaga naiiba."

"Sa linya 14, gumawa kami ng isang Marshaller object. Marshalling ay isang kasingkahulugan para sa serialization."

"Sa linya 15, itinakda namin ang FORMATTED_OUTPUT property sa TRUE. Magdaragdag ito ng mga line break at puwang sa resulta, upang ang code ay nababasa ng tao, at hindi lang nasa isang linya ang lahat ng teksto."

"Sa linya 17, sineserye namin ang bagay."

"Sa mga linya 20-21, ipinapakita namin ang resulta ng serialization sa screen."

"Ano ang @XmlType(name = 'cat&') at @XmlRootElement annotation?"

" @XmlRootElement ay nagpapahiwatig na ang bagay na ito ay maaaring maging 'ugat ng isang puno' ng mga elemento ng XML. Sa madaling salita, ito ay maaaring ang pinakamataas na antas ng elemento, at maaaring maglaman ng lahat ng iba pang elemento."

" @XmlType(name = 'cat') ay nagpapahiwatig na ang klase ay kasangkot sa JAXB serialization, at tinutukoy din ang pangalan ng XML tag para sa klase na ito."

"Sige, ngayon ay magpapakita ako sa iyo ng isang halimbawa ng XML deserialization:"

public static void main(String[] args) throws JAXBException
{
 String xmldata = "<cat><name>Missy</name><age>5</age><weight>4</weight></cat>";
 StringReader reader = new StringReader(xmldata);

 JAXBContext context = JAXBContext.newInstance(Cat.class);
 Unmarshaller unmarshaller = context.createUnmarshaller();

 Cat cat = (Cat) unmarshaller.unmarshal(reader);
}

@XmlType(name = "cat")
@XmlRootElement
public class Cat
{
 public String name;
 public int age;
 public int weight;

 public Cat()
 {
 }
}

"Ang lahat ay halos kapareho ng kay Jackson. Pero kung sakali, ipapaliwanag ko ang lahat ng nangyayari dito."

"Sa linya 3, ipinapasa namin ang isang string na nag-iimbak ng XML upang ma-deserialize."

"Sa linya 4, binabalot namin ang XML-string sa isang StringReader ."

"Sa linya 6, lumikha kami ng konteksto ng JAXB , kung saan ipinapasa namin ang listahan ng mga klase."

"Sa linya 7, lumikha kami ng Unmarshaller —ang bagay na magsasagawa ng deserialization."

"Sa linya 9, deserialize namin ang XML mula sa reader object at kumuha ng Cat object."

"Ngayon tila halos halata na ang lahat. Ngunit ilang oras na ang nakalipas, pinag-isipan ko ang aking utak upang malaman kung paano ito gumagana."

"Lagi namang nangyayari 'yan kapag mas matalino ka. Ang mga kumplikadong bagay ay nagiging simple."

"Nagiging matalino na ako? Hindi ko maiwasang hindi maging masaya doon."

"Mahusay. Pagkatapos narito ang isang listahan ng mga anotasyon na maaari mong gamitin upang kontrolin ang resulta ng serialization ng JAXB:"

"Gaano kainteresante! Ngunit maaari mo bang bigyan ako ng isang halimbawa na gumagamit ng mga anotasyong ito? Ang isang paliwanag ay isang bagay, ngunit ang isang gumaganang halimbawa ay iba."

"OK. Magpapakita ako sa iyo ng isang halimbawa. Gusto ko lang idagdag na hinahayaan ka ng JAXB na i-annotate ang mga pamamaraan ng getter/setter sa halip na mga field."

"Narito ang halimbawang ipinangako ko:"

public static void main(String[] args) throws JAXBException
{
 // Create Cat and Zoo objects to be serialized into XML
 Cat cat = new Cat();
 cat.name = "Missy";
 cat.age = 5;
 cat.weight = 4;

 Zoo zoo = new Zoo();
 zoo.animals.add(cat);
 zoo.animals.add(cat);

 // Write the result of the serialization to a StringWriter
 StringWriter writer = new StringWriter();

 // Create a Marshaller object that will perform the serialization
 JAXBContext context = JAXBContext.newInstance(Cat.class, Zoo.class);
 Marshaller marshaller = context.createMarshaller();
 marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);
 // Here's the serialization itself
 marshaller.marshal(zoo, writer);

 // Convert everything written to the StringWriter into a String
 System.out.println(writer.toString());
}

@XmlType(name = "zoo")
@XmlRootElement
public class Zoo
{
 @XmlElementWrapper(name = "wild-animals", nillable = true)
 @XmlElement(name = "tiger")
 public List<Cat> animals = new ArrayList<>();
}

public class Cat
{
 @XmlElement(name = "catname")
 public String name;
 @XmlAttribute(name = "age")
 public int age;
 @XmlAttribute(name = "w")
 public int weight;

 public Cat()
 {
 }
}

<zoo> 
<wild-animals> 
<tiger age = "5" w = "4"> 
<catname>Missy</catname> 
</tiger> 
<tiger age = "5" w = "4"> 
<catname>Missy </catname> 
</tiger> 
</wild-animals> 
</zoo>

"Pansinin na sa pagkakataong ito ay hindi kami nagse-serialize ng isang Cat object, ngunit isang Zoo object na nag-iimbak ng koleksyon ng mga Cat object."

"Ang bagay na pusa ay idinagdag sa koleksyon nang dalawang beses, kaya ito ay nasa XML nang dalawang beses."

"Ang koleksyon ay may sariling tag na ' wild-animals ' na bumabalot sa lahat ng elemento ng koleksyon."

"Ang mga elemento ng edad at timbang ay naging mga katangian ng edad at w."

"Gamit ang isang @XmlElement attribute, binago namin ang cat tag sa isang tigre tag ."

"Bigyang-pansin ang linya 17. Dito ipinapasa namin ang dalawang klase ( Zoo at Cat ) sa konteksto ng JAXB, dahil pareho silang kasangkot sa serialization."

"Today was a very interesting day. So much new information."

"Oo. Masaya ako para sa iyo. Ngayon, magpahinga ka muna at itutuloy natin."