JAXB

'Niet zo snel, jongeman! Ik heb nog twee lessen voor je!'

"Twee? Wauw. Nou, oké. Wat zou je niet doen om je eigen kalmte te vergroten! Ik ben een en al oor."

"XML wordt, net als JSON, vaak gebruikt bij het doorgeven van gegevens tussen verschillende programma's en computers. En er zijn verschillende frameworks die het leven van Java-programmeurs enorm vereenvoudigen bij het werken met XML. Vandaag zal ik je kennis laten maken met een van hen."

"JAXB is een uitstekend multifunctioneel framework voor het werken met XML."

"JAXB maakt deel uit van de JDK, dus je hoeft het niet apart te downloaden."

"Laat me je eerst een voorbeeld laten zien van hoe je het moet gebruiken, en dan zullen we het analyseren. Bijvoorbeeld:"

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>

"Om de een of andere reden, regel voor regel, doet deze code me denken aan JSON-serialisatie. Dezelfde annotaties, maar JSON gebruikte een ObjectMapper, en deze gebruikt Context en Marshaller."

"Ja. Ze lijken echt erg op elkaar. Jackson is gemodelleerd naar JAXB. Maar JAXB is ook ergens vandaan gekopieerd. Je kunt niet vanuit het niets iets geniaals verzinnen."

"Zo lijkt het."

"OK, dit is wat er gebeurt:"

"In regels 4-7 maken we een Cat- object en vullen het met gegevens."

"In regel 10 maken we een Writer-object om het resultaat te schrijven."

"In regel 13 creëren we de 'context'. Dit is vergelijkbaar met ObjectMapper, maar dan worden er twee extra onderliggende objecten van gemaakt. Marshaller is voor serialisatie en Unmarshaller is voor deserialisatie. Er zijn kleine verschillen met Jackson, maar het is 't fundamenteel anders."

"In regel 14 maken we een Marshaller- object. Marshalling is een synoniem voor serialisatie."

"In regel 15 hebben we de eigenschap FORMATTED_OUTPUT ingesteld op TRUE. Dit voegt regeleinden en spaties toe aan het resultaat, zodat de code leesbaar is voor mensen en niet alleen alle tekst op één regel heeft."

"In regel 17 rangschikken we het object."

"In de regels 20-21 tonen we het resultaat van de serialisatie op het scherm."

"Wat zijn de @XmlType(name = 'cat&') en @XmlRootElement annotaties?"

" @XmlRootElement geeft aan dat dit object de 'root of a tree' van XML-elementen kan zijn. Met andere woorden, het kan het element van het hoogste niveau zijn en kan alle andere elementen bevatten."

" @XmlType(name = 'cat') geeft aan dat de klasse betrokken is bij JAXB-serialisatie en specificeert ook de naam van de XML-tag voor deze klasse."

"Oké, nu zal ik je een voorbeeld van XML-deserialisatie laten zien:"

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

'Alles is bijna hetzelfde als bij Jackson. Maar voor het geval dat, zal ik alles uitleggen wat hier aan de hand is.'

"In regel 3 geven we een string door waarin de XML wordt opgeslagen die moet worden gedeserialiseerd."

"In regel 4 verpakken we de XML-string in een StringReader ."

"In regel 6 maken we een JAXB-context , waaraan we de lijst met klassen doorgeven."

"In regel 7 maken we een Unmarshaller - het object dat de deserialisatie zal uitvoeren."

"In regel 9 deserialiseren we XML van het lezerobject en krijgen we een Cat-object."

"Nu lijkt het allemaal bijna vanzelfsprekend. Maar een paar uur geleden pijnigde ik mijn hersens om erachter te komen hoe het werkt."

"Dat gebeurt altijd als je slimmer wordt. Complexe dingen worden simpel."

"Word ik slimmer? Daar kan ik niet anders dan blij mee zijn."

"Geweldig. Dan is hier een lijst met annotaties die u kunt gebruiken om het resultaat van JAXB-serialisatie te controleren:"

"Wat interessant! Maar kun je me een voorbeeld geven waarin deze annotaties worden gebruikt? Een uitleg is één ding, maar een werkend voorbeeld is iets anders."

"OK. Ik zal je een voorbeeld laten zien. Ik wilde alleen toevoegen dat je met JAXB getter/setter-methoden kunt annoteren in plaats van velden."

"Hier is dat voorbeeld dat ik beloofde:"

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 leeftijd = "5" w = "4"> 
<catname>Missy</catname> 
</tiger> 
<tiger leeftijd = "5" w = "4"> 
<catname>Missy </catname> 
</tiger> 
</wild-animals> 
</zoo>

"Merk op dat we deze keer geen Cat-object serialiseren, maar een Zoo-object dat een verzameling Cat-objecten opslaat."

"Het cat-object is twee keer aan de collectie toegevoegd, dus het staat twee keer in de XML."

"De collectie heeft zijn eigen ' wilde dieren' -tag die alle elementen van de collectie omhult."

"De leeftijds- en gewichtselementen zijn de leeftijds- en w w-attributen geworden ."

"Met behulp van een @XmlElement- attribuut hebben we de cat-tag gewijzigd in een tiger-tag ."

"Let op regel 17. Hier geven we twee klassen ( Zoo en Cat ) door aan de JAXB-context, aangezien ze beide betrokken zijn bij de serialisatie."

"Vandaag was een zeer interessante dag. Zoveel nieuwe informatie."

"Ja. Ik ben blij voor je. Neem nu een korte pauze en we gaan verder."