JAXB

„Nicht so schnell, junger Mann! Ich habe noch zwei Lektionen für dich!“

„Zwei? Wow. Na gut. Was würdest du nicht tun, um deine eigene Coolness zu verstärken! Ich bin ganz Ohr.“

„XML wird wie JSON häufig bei der Übermittlung von Daten zwischen verschiedenen Programmen und Computern verwendet. Und es gibt mehrere Frameworks, die Java-Programmierern das Leben bei der Arbeit mit XML erheblich erleichtern. Heute stelle ich Ihnen eines davon vor.“

„JAXB ist ein hervorragendes Mehrzweck-Framework für die Arbeit mit XML.“

„JAXB ist Teil des JDK, Sie müssen es also nicht separat herunterladen.“

„Lassen Sie mich Ihnen zunächst ein Beispiel für die Verwendung zeigen, dann analysieren wir es. Zum Beispiel:“

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>

„Aus irgendeinem Grund erinnert mich dieser Code Zeile für Zeile an die JSON-Serialisierung. Dieselben Anmerkungen, aber JSON verwendete einen ObjectMapper, und dieser verwendet Context und Marshaller.“

„Ja. Sie sind sich wirklich sehr ähnlich. Jackson wurde nach JAXB modelliert. Aber JAXB wurde auch von irgendwoher kopiert. Man kann etwas Geniales nicht von Grund auf neu erfinden.“

„Es scheint so.“

„Okay, hier ist was passiert:“

„In den Zeilen 4–7 erstellen wir ein Cat- Objekt und füllen es mit Daten.“

„In Zeile 10 erstellen wir ein Writer-Objekt, um das Ergebnis zu schreiben.“

„In Zeile 13 erstellen wir den ‚Kontext‘. Dies ähnelt ObjectMapper, aber dann werden daraus zwei zusätzliche untergeordnete Objekte erstellt. Marshaller dient der Serialisierung und Unmarshaller der Deserialisierung. Es gibt kleine Unterschiede zu Jackson, aber das ist nicht der Fall „nicht grundlegend anders.“

„In Zeile 14 erstellen wir ein Marshaller- Objekt. Marshalling ist ein Synonym für Serialisierung.“

„In Zeile 15 setzen wir die Eigenschaft FORMATTED_OUTPUT auf TRUE. Dadurch werden dem Ergebnis Zeilenumbrüche und Leerzeichen hinzugefügt, sodass der Code für Menschen lesbar ist und nicht nur der gesamte Text in einer Zeile steht.“

„In Zeile 17 serialisieren wir das Objekt.“

„In den Zeilen 20-21 zeigen wir das Ergebnis der Serialisierung auf dem Bildschirm an.“

„Was sind die Annotationen @XmlType(name = 'cat&') und @XmlRootElement?“

„ @XmlRootElement gibt an, dass dieses Objekt die ‚Wurzel eines Baums‘ von XML-Elementen sein kann. Mit anderen Worten, es kann das Element der höchsten Ebene sein und alle anderen Elemente enthalten.“

„ @XmlType(name = ‚cat‘) gibt an, dass die Klasse an der JAXB-Serialisierung beteiligt ist, und gibt außerdem den Namen des XML-Tags für diese Klasse an.“

„Okay, jetzt zeige ich Ihnen ein Beispiel für die XML-Deserialisierung:“

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 ist fast wie bei Jackson. Aber für alle Fälle erkläre ich hier alles, was los ist.“

„In Zeile 3 übergeben wir einen String , der das zu deserialisierende XML speichert.“

„In Zeile 4 verpacken wir den XML-String in einen StringReader .“

„In Zeile 6 erstellen wir einen JAXB-Kontext , an den wir die Liste der Klassen übergeben.“

„In Zeile 7 erstellen wir einen Unmarshaller – das Objekt, das die Deserialisierung durchführt.“

„In Zeile 9 deserialisieren wir XML vom Reader-Objekt und erhalten ein Cat-Objekt.“

„Jetzt scheint alles fast offensichtlich. Aber vor ein paar Stunden habe ich mir den Kopf zerbrochen, um herauszufinden, wie es funktioniert.“

„Das passiert immer, wenn man schlauer wird. Komplexe Dinge werden einfach.“

„Ich werde schlauer? Ich kann nicht anders, als darüber glücklich zu sein.“

„Großartig. Dann ist hier eine Liste von Anmerkungen, mit denen Sie das Ergebnis der JAXB-Serialisierung steuern können:“

„Wie interessant! Aber können Sie mir ein Beispiel geben, das diese Anmerkungen verwendet? Eine Erklärung ist eine Sache, aber ein funktionierendes Beispiel ist etwas anderes.“

„OK. Ich zeige Ihnen ein Beispiel. Ich wollte nur hinzufügen, dass Sie mit JAXB Getter/Setter-Methoden anstelle von Feldern mit Anmerkungen versehen können.“

„Hier ist das Beispiel, das ich versprochen habe:“

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>

„Beachten Sie, dass wir dieses Mal kein Cat-Objekt serialisieren, sondern ein Zoo-Objekt, das eine Sammlung von Cat-Objekten speichert.“

„Das Katzenobjekt wurde der Sammlung zweimal hinzugefügt, daher ist es zweimal im XML enthalten.“

„Die Kollektion hat ihr eigenes ‚ Wild-Animals‘ -Tag, das alle Elemente der Kollektion umschließt.“

„Die Elemente Alter und Gewicht sind zu den Attributen Alter und Gewicht geworden.“

„Mithilfe eines @XmlElement- Attributs haben wir das Cat-Tag in ein Tiger-Tag geändert .“

„Achten Sie auf Zeile 17. Hier übergeben wir zwei Klassen ( Zoo und Cat ) an den JAXB-Kontext, da beide an der Serialisierung beteiligt sind.“

„Heute war ein sehr interessanter Tag. So viele neue Informationen.“

„Ja. Ich freue mich für dich. Jetzt mach eine kurze Pause und wir machen weiter.“