JAXB Tutorial
Mit Hilfe der Java Architecture for XML Binding (JAXB) API können Java Objekte bequem in XML-Dokumente gewandelt werden und umgekehrt. Über Annotations teilen hierbei die Entwickler dem Compiler mit, welcher Klasse oder welches Attribut welche Eigenschaft in dem XML-Dokument übernehmen wird.
Bereits in dem Tutorial Java und XML Tutorial wurde die Bearbeitung von XML-Dokumenten auf Basis eines Literatur Beispiels gezeigt. Dieses Beispiel werde ich nun mit Hilfe von JAXB erneut aufgreifen.
Mehr Informationen über das Thema XML gibt es in dem Blogbeitrag XML – Extensible Markup Language. Zusatztechnologien wie zum Beispiel XPath, XPointer, oder XLink behandelt der Beitrag XML Zusatztechnologien.
Annotations
Eine kleine Übersicht der verwendeten Annoations mit ihren Funktionen.
| Annotation | Funktion |
| @XmlRootElement(namespace = “http://www.itblogging.de/myNameSpace”) | Kennzeichnet das Root Element. Die Angabe des Namensraums ist optional. |
| @XmlElement(name = “myName”) | Gibt dem XML Element einen alternativen Namen, falls gewünscht. |
| @XmlType(propOrder = {“title”, “isbn”}) | Bestimmt die Reihenfolge der Ausgabe. |
| @XmlElementWrapper(name = “authorlist”) | Erzeugt einen Wrapper um eine Liste von Objekten. |
| @XmlSchemaType(name = “dateTime”) | Anhagabe des Typen. |
Author.java
Die Author Klasse ist eine ganz normale Bean Klasse. Es werden keine Annotations zur Kennzeichnung besonderer Attribute benötigt.
public class Author
{
private String firstName;
private String lastName;
public String getFirstName()
{
return firstName;
}
public void setFirstName(String firstName)
{
this.firstName = firstName;
}
public String getLastName()
{
return lastName;
}
public void setLastName(String lastName)
{
this.lastName = lastName;
}
}
Edition.java
Hier ein Beispiel der @XmlElement Annotation. Normalerweise würde das XML-Tag nach der Generierung den Namen “editionNo” erhalten. Statt “editionNo” wird das Tag dank der Annotation den Namen “numberOfEdition” erhalten.
import javax.xml.bind.annotation.XmlElement;
public class Edition
{
private String publisher;
private int editionNo;
private int publicationYear;
public String getPublisher()
{
return publisher;
}
public void setPublisher(String publisher)
{
this.publisher = publisher;
}
public int getEditionNo()
{
return editionNo;
}
@XmlElement(name = "numberOfEdition")
public void setEditionNo(int editionNo)
{
this.editionNo = editionNo;
}
public int getPublicationYear()
{
return publicationYear;
}
public void setPublicationYear(int publicationYear)
{
this.publicationYear = publicationYear;
}
}
Book.java
Über das Attribut propOrder der @XmlType Annotation kann die Reihenfolge der Ausgabe bestimmt werden. Einige Tagnamen werden mit Hilfe der @XmlElement neu vergeben.
Die Annotation @XmlElementWrapper ummantelt alle Autoren mit einem weiteren Tag, dem authorlist Tag.
import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlElementWrapper;
import javax.xml.bind.annotation.XmlType;
// Property Reihenfolge mit "propOrder" bestimmen
@XmlType(propOrder = {"title", "isbn", "edition", "authors"})
public class Book
{
private String title;
private List<Author> authors;
private Edition edition;
private String isbn;
public Book()
{
this.authors = new ArrayList<Author>();
}
public String getTitle()
{
return title;
}
public void setTitle(String title)
{
this.title = title;
}
public void addAuthor(Author a)
{
authors.add(a);
}
@XmlElementWrapper(name = "authorlist")
@XmlElement(name = "author")
public List<Author> getAuthors()
{
return authors;
}
public void setEdition(Edition edition)
{
this.edition = edition;
}
@XmlElement(name = "editionInfo")
public Edition getEdition()
{
return edition;
}
public String getIsbn()
{
return isbn;
}
public void setIsbn(String isbn)
{
this.isbn = isbn;
}
}
Literature.java
Die Annotation @XmlRootElement kennzeichnet das Wurzelelement des XML-Dokumentes. Optional kann der Namensraum angegeben werden.
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlElementWrapper;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlSchemaType;
import javax.xml.bind.annotation.XmlType;
// Angabe des Root Elements. Optional kann der namespace -sofern er vorhanden
// ist- angegeben werden.
@XmlRootElement(namespace = "http://www.itblogging.de/myNameSpace")
@XmlType(propOrder = {"currentTime", "bookList"})
public class Literature
{
private List<Book> bookList;
private Date currentTime;
private String version;
public Literature()
{
this.bookList = new ArrayList<Book>();
}
// Der Wrapper soll "booklist" heißen
@XmlElementWrapper(name = "booklist")
// und die einzelnen Elemente jeweils "book"
@XmlElement(name = "book")
public List<Book> getBookList()
{
return bookList;
}
// explizite Typenangabe
@XmlSchemaType(name = "dateTime")
public Date getCurrentTime()
{
return currentTime;
}
public void setCurrentTime(Date currentTime)
{
this.currentTime = currentTime;
}
// Die Version soll ein Attribut des RootElements sein
@XmlAttribute
public String getVersion()
{
return version;
}
public void setVersion(String version)
{
this.version = version;
}
}
XMLCreator.java
Diese Klasse hilft uns ein neues XML-Dokument zu erzeugen, auszugeben, zu speichern und anschließend erneut wieder einzulesen.
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
import java.util.Date;
import javax.xml.bind.JAXB;
public class XmlCreator
{
public static void main(String[] args) throws IOException
{
Literature literature = createLiterature();
// Konsolenausgabe
JAXB.marshal(literature, System.out);
// Dateiname (wird in dem Projektverzeichnis hinterlegt)
String fileName = "literatur.xml";
// Speicherung in Datei
Writer fileWriter = new FileWriter(fileName);
JAXB.marshal(literature, fileWriter);
fileWriter.close();
// Aus Datei lesen
Literature backToObject = JAXB.unmarshal(new File(fileName), Literature.class);
System.out.println("\nVersion: " + backToObject.getVersion());
System.out.println("Datum: " + backToObject.getCurrentTime());
System.out.println("---");
for(Book book : backToObject.getBookList())
{
System.out.println("Titel: " + book.getTitle());
System.out.println("ISBN: " + book.getIsbn());
// ....
}
}
// Erzeugt das Literaturverzeichnis
private static Literature createLiterature()
{
Literature literature = new Literature();
literature.setCurrentTime(new Date());
literature.setVersion("0.1");
// Book
Book book = new Book();
book.setIsbn("3-89842-488-X");
book.setTitle("Einstieg in XML");
// Edition
Edition edition = new Edition();
edition.setEditionNo(2);
edition.setPublicationYear(2004);
edition.setPublisher("Galileo Computing");
book.setEdition(edition);
// Author
Author author = new Author();
author.setFirstName("Helmut");
author.setLastName("Vonhoegen");
book.getAuthors().add(author);
// Buch hinzufügen
literature.getBookList().add(book);
return literature;
}
}
Ergebnis
Nachdem die Datei XMLCreator.java ausgeführt wurde, wird zum einen das Ergebnis in der Konsole ausgegeben und zum anderen in der neu angelegten Datei literature.xml gespeichert.
Man beachte, dass die Tagnamen wie vorgeschrieben benannt wurden.
<?xml version="1.0" encoding="UTF-8" standalone="yes"?> <ns2:literature xmlns:ns2="http://www.itblogging.de/myNameSpace" version="0.1"> <currentTime>2012-04-09T20:39:52.364+02:00</currentTime> <booklist> <book> <title>Einstieg in XML</title> <isbn>3-89842-488-X</isbn> <editionInfo> <numberOfEdition>2</numberOfEdition> <publicationYear>2004</publicationYear> <publisher>Galileo Computing</publisher> </editionInfo> <authorlist> <author> <firstName>Helmut</firstName> <lastName>Vonhoegen</lastName> </author> </authorlist> </book> </booklist> </ns2:literature>
Das JAXB Tutorial steht auch als zip-Datei zum Download zur Verfügung.
