5. Inhalt
Vorw
Java Architecture for XML Binding 2.0.................................................................................XI
Technologieeinführung ........................................................................................................ XII
Programmiertutorials............................................................................................................ XII
Referenz ............................................................................................................................... XII
Feedback ............................................................................................................................. XIII
1 JAXB im Überblick................................................................................................... 1
1.1 Ziele .........................................................................................................................................1
1.2 Entstehung................................................................................................................................4
1.3 Architektur ...............................................................................................................................5
1.3.1 Annotationen ..............................................................................................................7
1.3.2 Der Schema-Compiler ................................................................................................8
1.3.3 Der Schema-Generator ...............................................................................................9
1.3.4 Das Binding Framework...........................................................................................10
1.4 1.0 + 1.0 = 2.0? ......................................................................................................................14
2 Basistechnologien ................................................................................................. 17
2.1 XML-Schema.........................................................................................................................17
2.1.1 Namespaces verwenden............................................................................................21
2.1.2 Elementdeklarationen in XML-Schema ...................................................................24
2.1.3 Vererbung.................................................................................................................35
2.1.4 Kardinalitäten ...........................................................................................................37
2.1.5 Offene Schemas definieren.......................................................................................38
2.1.6 Namespaces importieren und referenzieren..............................................................40
2.1.7 Eindeutigkeit durch ID und IDREF ..........................................................................43
2.1.8 Dokumentation mit Annotationen ............................................................................45
2.1.9 Das fertige Beispielschema ......................................................................................46
V
6. Inhalt
2.2 XPath......................................................................................................................................48
2.2.1 Die XPath-Sicht auf XML........................................................................................49
2.2.2 XPath-Ausdrücke verwenden ...................................................................................50
2.2.3 Beispiele ...................................................................................................................51
2.2.4 XPath in Java............................................................................................................53
2.3 ANT .......................................................................................................................................55
2.3.1 ANT-Übersicht .........................................................................................................55
2.3.2 Installation und Aufruf .............................................................................................56
2.3.3 Häufig verwendete Elemente....................................................................................57
2.3.4 Benutzerdefinierte Tasks ..........................................................................................58
2.3.5 xjc und schemaGen Tasks ........................................................................................58
2.3.6 Ein Beispiel ..............................................................................................................59
3 Hallo JAXB! ............................................................................................................ 61
3.1 Systemvoraussetzungen .........................................................................................................61
3.2 Die Entwicklungsumgebung einrichten..................................................................................62
3.2.1 JAXB-Referenzimplementierung installieren...........................................................62
3.2.2 Die JAXB-Bibliotheken einbinden...........................................................................62
3.2.3 Die Struktur des Beispielprojekts .............................................................................63
3.3 Am Anfang steht immer: Hallo Welt! ....................................................................................64
3.3.1 Der Weg von Java zu XML ......................................................................................64
3.3.2 Der Weg von XML zu Java ......................................................................................67
3.4 Zusammenfassung..................................................................................................................69
4 JAXB-API ................................................................................................................ 71
4.1 Die ersten Schritte ..................................................................................................................72
4.1.1 Am Anfang war der JAXBContext...........................................................................72
4.1.2 Die Klasse JAXBIntrospector verwenden ................................................................75
4.1.3 Objekte erzeugen mit der ObjectFactory ..................................................................77
4.1.4 Zusammenfassung ....................................................................................................78
4.2 Marshalling ............................................................................................................................79
4.2.1 Das Marshaller-Objekt anlegen ................................................................................79
4.2.2 Den Marshalling-Prozess starten ..............................................................................80
4.2.3 Den Marshalling-Prozess konfigurieren ...................................................................81
4.2.4 Das fertige Beispiel ..................................................................................................83
4.2.5 Marshalling beliebiger Objekte ................................................................................85
4.2.6 Zusammenfassung ....................................................................................................86
4.3 Unmarshalling ........................................................................................................................87
4.3.1 Das Unmarshaller-Objekt anlegen............................................................................87
4.3.2 Den Unmarshalling-Prozess starten..........................................................................88
4.3.3 Den Unmarshalling-Prozess konfigurieren...............................................................89
4.3.4 Das fertige Beispiel ..................................................................................................89
4.3.5 Das xsi:type-Attribut beim Unmarshalling verwenden.............................................90
4.3.6 Elemente ohne @XMLRootElement verarbeiten .....................................................91
4.3.7 Unmarshalling von Teilen eines XML-Dokuments ..................................................93
4.3.8 Flexibles Unmarshalling nutzen ...............................................................................95
VI
7. Inhalt
4.3.9 Zusammenfassung ................................................................................................... 97
4.4 Validierung............................................................................................................................ 97
4.4.1 Beim Unmarshalling validieren ............................................................................... 98
4.4.2 Beim Marshalling validieren.................................................................................... 99
4.4.3 Benutzerdefinierte Validierung.............................................................................. 101
4.4.4 Zusammenfassung ................................................................................................. 107
4.5 Callback-Mechanismen einsetzen ....................................................................................... 107
4.5.1 Die Listener-Klasse verwenden ............................................................................. 108
4.5.2 Callback-Methoden auf Klassenebene definieren.................................................. 110
4.5.3 Zusammenfassung ................................................................................................. 112
4.6 Die Binder-Komponente verwenden ................................................................................... 112
4.6.1 Eine DOM-Sicht erstellen...................................................................................... 113
4.6.2 Die Klasse javax.xml.bind.Binder ......................................................................... 113
4.6.3 Transformation mit unmarshal und marshal .......................................................... 114
4.6.4 Navigation mit getXMLNode und getJAXBNode................................................. 115
4.6.5 Synchronisation mit updateXML und updateJAXB .............................................. 116
4.6.6 Konkrete Anwendungsfälle ................................................................................... 117
4.6.7 Zusammenfassung ................................................................................................. 123
5 XML-Schema zu Java .......................................................................................... 125
5.1 Bindungskonfigurationen .................................................................................................... 125
5.1.1 Eine Bindungskonfiguration definieren ................................................................. 126
5.1.2 Bindungskonfigurationen per xjc-Task einbinden ................................................. 130
5.1.3 Den XJC-Schema-Compiler programmatisch starten ............................................ 130
5.1.4 Externe Bindungskonfigurationen auf der Kommandozeile .................................. 134
5.1.5 Ein Wort zu Versionen .......................................................................................... 134
5.1.6 Der Sichtbarkeitsbereich........................................................................................ 134
5.1.7 Zusammenfassung ................................................................................................. 135
5.2 Die erste Bindungskonfiguration......................................................................................... 136
5.2.1 Zusammenfassung ................................................................................................. 138
5.3 Fünf Bindungsdeklarationen für den Alltag ........................................................................ 138
5.3.1 Aufzählungen anpassen mit jaxb:collectionType................................................... 138
5.3.2 Paketnamen anpassen mit jaxb:package ................................................................ 140
5.3.3 Generierte Klassen anpassen mit jaxb:class........................................................... 142
5.3.4 Änderungen auf Komponentenebene mit jaxb:property ........................................ 145
5.3.5 Dokumentieren mit jaxb:javadoc ........................................................................... 152
5.3.6 Zusammenfassung ................................................................................................. 155
5.4 XML-Bezeichner anpassen.................................................................................................. 155
5.4.1 Einzelne Namenskonflikte auflösen....................................................................... 156
5.4.2 Präfixe und Suffixe mit jaxb:nameXmlTransform................................................. 157
5.4.3 Unterstriche verarbeiten mit jaxb:underScoreBinding........................................... 159
5.4.4 Bezeichner in Enumerationen ................................................................................ 160
5.4.5 Verwenden von Java-Schlüsselwörtern als Bezeichner ......................................... 166
5.4.6 Java-Namenskonventionen .................................................................................... 168
5.4.7 Zusammenfassung ................................................................................................. 168
5.5 Datentypen anpassen ........................................................................................................... 168
VII
8. Inhalt
5.5.1 Datentypen explizit angeben mit jaxb:baseType ....................................................169
5.5.2 Datentypen konvertieren mit jaxb:javaType...........................................................173
5.5.3 Zusammenfassung ..................................................................................................181
5.6 Deklarationen überlagern .....................................................................................................182
5.7 Noch mehr Bindungsdeklarationen ......................................................................................185
5.7.1 Ableiten von einer Oberklasse mit xjc:superClass..................................................186
5.7.2 Ein Wurzelinterface angeben mit xjc:superInterface ..............................................187
5.7.3 Erweiterung von jaxb:javaType mit xjc:javaType ..................................................189
5.7.4 Das Experiment: xjc:simple....................................................................................191
5.7.5 Zusammenfassung ..................................................................................................192
6 Java zu XML-Schema .......................................................................................... 193
6.1 JAXBContext und JAXBElement ganz ohne Schema..........................................................194
6.2 Einfache Elementkonfigurationen ........................................................................................201
6.2.1 Wurzelelemente mit @XmlRootElement definieren ..............................................201
6.2.2 Der „Standardmodus“.............................................................................................205
6.2.3 Abbildung als XML-Element explizit konfigurieren ..............................................210
6.2.4 Java-Eigenschaften an XML-Attribute binden .......................................................216
6.2.5 Java-Eigenschaften an XML-Elementinhalte binden..............................................221
6.2.6 Bindung an XML unterdrücken..............................................................................223
6.2.7 Reihenfolge der XML-Elemente beeinflussen........................................................225
6.2.8 Namen und Verschachtelung des XML-Typs einstellen.........................................230
6.2.9 XML-Elemente referenzieren .................................................................................234
6.2.10 Namespace konfigurieren .......................................................................................237
6.3 Listen und Elementmischungen ...........................................................................................243
6.3.1 Der „Standardmodus“ für Java-Arrays und Java-Listen .........................................244
6.3.2 Listen und Arrays an simpleType/list-Deklarationen binden..................................249
6.3.3 Mehrere Elemente im gleichen Feld speichern.......................................................251
6.3.4 Elementlisten verpacken.........................................................................................263
6.3.5 Mischungen von Elementen und Text ....................................................................266
6.4 Enumerationen .....................................................................................................................270
6.4.1 Enumerationen an XML binden: Standardverhalten...............................................271
6.4.2 Bindung von Enumerationen konfigurieren............................................................272
6.5 Eigene Typbindungen definieren .........................................................................................275
6.5.1 Basisdatentyp als Speicherdatentyp........................................................................277
6.5.2 Komplexe Datentypen als Speicherdatentypen.......................................................280
6.6 Unbekannte Attribut- und Elementwerte binden ..................................................................284
6.6.1 Wildcard-Attribute mit @XmlAnyAttribute definieren..........................................284
6.6.2 Wildcard-Elemente per @XmlAnyElement deklarieren ........................................286
6.6.3 Lax fischen .............................................................................................................288
6.7 Objektgraphen in XML abbilden..........................................................................................290
6.8 Elemente über Factory-Klassen definieren...........................................................................295
7 JAXB-Referenz..................................................................................................... 299
7.1 XJC Kommandozeilenbefehl ...............................................................................................299
7.2 XJC ANT-Task ....................................................................................................................301
VIII
11. Vorwort
Das Buch wendet sich an Entwickler mit guten Java-Kenntnissen, die in ihrem Arbeitsall-
tag oft mit Java und XML arbeiten. In diesem Buch stellen wir mit Suns Java Architecture
for XML Binding, kurz JAXB, eine tolle Lösung vor, wie wir dieser Herausforderung effek-
tiv begegnen können.
Java Architecture for XML Binding 2.0
Wer frühere Versionen der JAXB (1.x) eingesetzt oder evaluiert hat, dem mag die JAXB
damals vielleicht verschroben vorgekommen sein. Tatsächlich war die technologische
Hürde zum Einsatz von JAXB 1.x sehr hoch. Zum einen waren da die Verwirrungen mit
den „endorsed“ XML-Bibliotheken, die Laufzeitfehler verursachten, wenn der Code auf
unterschiedlich konfigurierten JVMs ausgeführt wurde – das gute, alte Java-Motto write
once, run everywhere traf hier nicht mehr ohne Einschränkungen zu. Zudem waren die
JAXB 1.x-Versionen noch nicht inspiriert vom jüngsten Trend zu den POJOs, den Plain
Old Java Objects. Hier wurde stattdessen viel mit Factory-Methoden und Schnittstellen
herumhantiert, die aus einem Schema ein unnatürliches und unhandliches Java-
Datenmodell erzeugten.
Von praktischer Bedeutung war in den Versionen bisher nur der Weg von einem XML-
Schema zu einem Java-Datenmodell. Ergebnis ist, dass bisherige JAXB-Versionen keine
besondere Unterstützung durch Hersteller oder Open-Source-Projekte erfahren haben. Statt
dessen entstanden Projekte, die einen natürlicheren Ansatz zur Umwandlung von XML in
Java jenseits des JAXB-Standards gesucht und gefunden haben und heute zu den Werk-
zeugen der Wahl gehören.
Mit der JAXB 2.0 fließen nun diese Ansätze in die JSE zurück: Die Nachteile der bisheri-
gen JAXB-Versionen sind wie weggeblasen. Übrig bleibt eine sehr komfortable Art und
Weise, aus XML-Schema ein POJO-Datenmodell bzw. aus POJOs ein präzise anpassbares
XML-Format zu generieren. Wir sind überzeugt, dass mit der JAXB 2.0 eine Architektur
entstanden ist, die für Entwickler eine langfristige und befriedigende Lösung des „XML-
und Java“-Themas bringt und durch alle wesentlichen Hersteller und Projekte unterstützt
XI
12. Vorwort
werden wird. Wir möchten mit diesem Buch einen kleinen Beitrag leisten, diese feine
Technologie für alle Entwickler leicht zugänglich machen.
Das Buch teilt sich in drei wesentliche Teile auf: Technologieeinführung, Programmiertu-
torials und Referenz.
Technologieeinführung
Der erste Teile beschreibt die der JAXB-Spezifikation zugrunde liegenden Technologien
XML-Schema, XPath und Ant im Überblick. Den wichtigsten Anteil übernimmt dabei ein
Überblick auf wesentliche Konzepte von XML-Schema. Wir haben im Alltag die Erfah-
rung gemacht, dass viele Entwickler XML-Schema zwar sehr gut als „Format zur Be-
schreibung von XML-Formaten“ einordnen können und einfache Schemata auch ohne wei-
teres verstehen, im konkreten Fall aber gerne nachschlagen, welche Bedeutung einzelne
Schemadeklarationen und -konzepte besitzen. Daher bieten wir in diesem Buch eine kleine
Einführung in XML-Schema mit dem Ziel, Antworten für die wesentlichen Fragen zu bie-
ten, die im Rahmen der Tutorials aufkommen können.
Zu den Technologien, die in den Beispielen dieses Buches verwendet werden, gehört auch
XPath, das SQL der XML-Welt, und Ant. Auch für diese beiden Technologien bieten wir
jeweils eine kleine Darstellung der wesentlichen Möglichkeiten.
Programmiertutorials
Der zweite Teil des Buches besteht aus vier klassischen Programmiertutorials, welche die
verschiedenen Aspekte der JAXB in Beispielen von steigender Komplexität beleuchten.
Nach dem obligatorischen „Hallo Welt“-Beispiel folgt eine Einführung in die Laufzeitbib-
liothek der JAXB. In Kapitel 5 behandeln wir den Weg von einem XML-Schema zu einem
Java-Datenmodell, in Kapitel 6 den Weg von einem Java-Datenmodell zu einem XML-
Dokument.
Referenz
Der dritte Teil ist die Referenz. Wir haben uns zum Ziel gesetzt, dass die Referenz im We-
sentlichen für sich alleine stehen kann – so dass ein Entwickler mit guten JAXB-
Kenntnissen (die er sich in Programmiertutorial aneignen kann) alle im Alltag aufkom-
menden Fragen schnell und insbesondere vollständig anhand der gut strukturierten Refe-
renz klären kann.
Das hat zur Folge, dass einzelne Informationen in diesem Buch eventuell redundant im
Programmiertutorial und in der Referenz vorkommen. Von einem Kommunikationsprofi
habe ich mir aber versichern lassen, dass Redundanz, die wir Entwickler im Programmier-
XII
13. Vorwort
alltag als Code Duplication verteufeln, richtig angewendet im Bereich der Didaktik eine
der gerne zitierten Best Practices ist.
Wir möchten uns an dieser Stelle bei Ihnen als Leser bedanken, dass Sie dieses Buch und
viele weitere durch Ihren beherzten Griff ins Regal Ihres Buchhändlers möglich gemacht
haben, und hoffen an dieser Stelle, dass Ihnen die Lektüre dieses Buchs viel Spaß macht
und Ihnen interessante, neue Ansätze für Ihre alltägliche Arbeit bieten kann.
Feedback
Kein Prozess kann sich ohne Feedback sinnvoll verbessern! Beachten Sie diesen schlauen
Spruch bitte nicht nur in Ihrem Arbeitsalltag, sondern schicken Sie uns gerne Ihr Feedback
zu diesem Buch an jaxbtransparent2@rmiregistry.de. Vielen Dank!
XIII
14.
15. 1 JAXB im Überblick
Im folgenden Kapitel werden wir die Java Architecture for XML Binding 2.0 aus der Vo-
gelperspektive betrachten. Hier gilt es, die wesentlichen Teile der JAXB-Spezifikation an-
schaulich und im Überblick darzustellen. Insbesondere werden wir hier die Begriffe prä-
gen, mit denen wir die Komponenten der JAXB im weiteren Verlauf des Buches und der
Tutorials referenzieren werden. Wir werden darauf eingehen, welche Ziele mit der JAXB-
Spezifikation 2.0 insgesamt angestrebt wurden.
Um die Hintergründe der JAXB zu verstehen, darf ein Blick auf die Entstehung der JAXB-
Spezifikation nicht fehlen. Mit diesem Grundverständnis über den Aufbau und das Zu-
sammenspiel der einzelnen Architekturkomponenten gerüstet, wird es uns leichter fallen,
die später im Programmiertutorial vorgestellten Funktionen zu verstehen. Für Anwender,
die bereits mit der Version 1.0 der JAXB gearbeitet haben, werden wir abschließend die
Unterschiede und Neuerungen in der Version 2.0 vorstellen.
1.1 Ziele
Eine High-Level-XML-API bieten
Die Java Architecture for XML Binding ermöglicht dem Applikationsentwickler, seine Ja-
va-Anwendung optimal mit XML interagieren zu lassen. JAXB hat dabei den Anspruch,
eine API auf weit abstrakterer Ebene zu bieten, als das bisher mit parser-basierten Ansät-
zen wie SAX und DOM möglich war. Auch Entwickler, die nicht mit diesen Parsern ver-
traut sind, sollen die Möglichkeit haben, XML in ihre Anwendungen zu integrieren.
Die JAXB-Spezifikation bemüht sich daher um eine möglichst einfache, für Java-
Entwickler intuitiv nutzbare Schnittstelle für den Zugriff auf XML-Daten. Doch was eignet
sich als intuitive Schnittstelle? Java Beans sind wohl eines der Konzepte, die jedem Java-
Entwickler vertraut sind. Daher liegt es nahe, Bindungsinformation und Daten durch Klas-
sen im Java Beans-Stil zu repräsentieren. Und genau das ist das primäre Ziel der JAXB,
die Bindung von XML an Java über portable Java Beans, im Fachjargon auch Pojos, kurz
1
16. 1 JAXB im Überblick
für plain old Java objects, genannt. Auf diese Weise können wir bequem über die vertrau-
ten Java-Programmiermethoden mit schemabasierten XML-Daten arbeiten.
Die konsequente Einführung des Pojo-Konzepts in die JAXB-Spezifkation und die einfa-
che Konfiguration dieser Objekte mit Annotationen vereinfachen die Erstellung dieses
Typs von Datenbindung ungemein.
Java 5-Spracherweiterungen nutzen
Um diese Bindung bei Bedarf individuell anzupassen, enthält JAXB Konfigurationsme-
chanismen, welche die Struktur der erzeugten Klassen bzw. des erzeugten Schemas beein-
flussen können.
Dafür werden u.a. Java-Annotationen verwendet, die eine der Erweiterungen darstellen,
die mit der Java Standard Edition 5 eingeführt wurden. Die JAXB-Spezifikation macht
aber auch regen Gebrauch von den weiteren Neuerungen der JSE 5 wie den typsicheren
Enumerationen und den sogenannten Generics. Diese Spracherweiterungen machen die
generierten Klassen und XML-Schemas einfacher und vor allem auch deren Verwendung
sicherer (insbesondere typsicherer).
Die Struktur der erzeugten Klassen und XML-Schemas wird durch Standardkonfiguratio-
nen der JAXB und benutzerdefinierte Konfigurationen fest vorgegeben. Oft ist es aber
auch nötig, die generierten Klassen um benutzerdefinierten Code zu erweitern. Auch hier-
für müssen Mechanismen definiert werden, um die generierten Klassen so flexibel wie
möglich zu machen.
XML-Schema vollständig unterstützen
Um die JAXB in realen Anwendungen einsetzbar zu machen, ist außerdem eine vollstän-
dige Unterstützung der W3C XML-Schemasprache ein weiteres primäres Ziel der JAXB
2.0. Denn nur durch eine vollständige Unterstützung von XML-Schema wird sich JAXB
als Standard durchsetzen können.
Bidirektionale Bindung unterstützen
Ein weiteres wichtiges Ziel der Spezifikation ist die Unterstützung einer bidirektionalen
Datenbindung, d.h., sowohl die Generierung von Java Beans aus einem bestehenden
Schema als auch der umgekehrte Weg, die Generierung eines Schemas aus einem beste-
henden Java Beans-Datenmodell, soll durch die JAXB 2.0 unterstützt werden.
Dabei soll auch ein Round Trip möglich sein. Das bedeutet, dass für den Weg Java–XML–
Java, also eine Generierung eines Schemas aus einem Java-Datenmodell und die erneute
Ableitung eines Datenmodells aus diesem Schema, Eingabe und Ausgabe äquivalent sind.
Unterstützung von Webservices
Die Generierung eines Java-Datenmodells aus einem XML-Schema, um eine Anwendung
mit XML-Dokumenten interagieren zu lassen, ist sicherlich vielen ein Begriff. Aber auch
2
17. 1.1 Ziele
der umgekehrte Weg gewinnt im Zeitalter der Webservices mehr an Bedeutung. Wird eine
Anwendung beispielsweise als Webservice veröffentlicht, so wird das existierende Daten-
modell der Anwendung durch ein WSDL-Dokument beschrieben. Dies kann durch JAXB
2.0 automatisiert werden, indem aus dem existierenden Datenmodell ein XML-Schema
generiert wird, das dann bei der Kommunikation über XML und SOAP verwendet wird.
In diesem Zusammenhang sollten wir nicht verschweigen, dass die JAXB 2.0-
Spezifikation die Grundlage für die Bindung von WSDL an Java-Datentypen in der Java
API für XML Web Services (JAX-WS 2.0) bildet. Damit soll JAXB zum Standard für Da-
tenbindungen bei Java-basierten Webservices werden.
Validierung jederzeit ermöglichen
Auch die Validierung von XML-Dokumenten ist eins der Themen, die durch JAXB adres-
siert werden sollen. Sowohl beim Unmarshalling, also der Transformation von XML-
Inhalten in Java-Objekte, als auch beim Marshalling, der Transformation von Java-
Objekten in XML-Dokumentstrukturen, kann eine Validierung anhand eines XML-
Schemas durchgeführt werden. Die Validierung soll dabei so gestaltet sein, dass flexibel
auf ungültige Inhalte reagiert werden kann. Um das Rad nicht neu zu erfinden, wird bei der
Validierung auf bereits bestehende Technologie anderer Java-Spezifikationen zurückge-
griffen.
Schemaevolution unterstützen
Ein großes Problem bei der Entwicklung von Datenbindungen an XML-Schema ist die
Weiterentwicklung des XML-Schemastandards. Ein Ziel der JAXB ist daher die Unter-
stützung des Umgangs mit dieser sog. Schemaevolution.
Portabilität zwischen JAXB-Implementierungen
Um die JAXB als einen De-facto-Standard für XML-Datenbindungen zu etablieren, soll
die Spezifikation in die kommende Java-Version 6.0, Codename „Mustang“, einfließen.
Daher muss die Portabilität der generierten Klassen auf Quellcode- und Binärcode-Ebene
sichergestellt werden. Portabilität bedeutet hier, dass die generierten Klassen einer be-
stimmten JAXB-Implementierung von jeder anderen Implementierung genutzt werden
können.
Portabilität des Quellcodes bedeutet, dass durch JAXB erstellter Quellcode von allen
JAXB-Implementierungen verstanden wird. Der erstellte Quellcode darf außerdem keine
Abhängigkeiten zu einer bestimmten Implementierung besitzen. Die Portabilität des Binär-
codes macht eine erneute Kompilierung dieses Quellcodes bei einem Wechsel der Imple-
mentierung überflüssig.
Dieser Ansatz unterscheidet sich von bisherigen Frameworks, die sich des Mittels des By-
tecode Enhancements bedienen, um eine einfache Javabean nach dem Kompilieren um
Framework-spezifische Funktionalitäten zu erweitern. Solchermaßen erweiterter Bytecode
ist dann nicht mehr portierbar.
3
18. 1 JAXB im Überblick
1.2 Entstehung
Spezifizierung durch JSR 222
JAXB ist aus dem Java Community Process 1 , kurz JCP, hervorgegangen. Im JCP entwi-
ckeln Expertengruppen Spezifikationen im Bereich der Java-Entwicklung. Diese Spezifi-
kationen werden als Java Specification Requests (JSR) betrieben und veröffentlicht. Einige
bekannte JSRs sind etwa die Java 5 Generics aus JSR 14 oder typsichere Enumerationen in
JSR 201.
Auch für die JAXB gibt es eine Expertengruppe, deren Hauptaufgabe natürlich die Weiter-
entwicklung der JAXB-Spezifikation ist. Neben dieser Spezifikation in Papierform besteht
ein JSR in der Regel noch aus einer Codebasis, nämlich einer Referenzimplementierung
(RI) und einem Technology Compatibility Toolkit (TCK).
Die Referenzimplementierung dient dazu, den aktuellen Stand der Spezifikation als Imp-
lementierung widerzuspiegeln und zu validieren. Weitere solcher Implementierungen der
Spezifikation durch andere Anbieter sind natürlich möglich, sogar erwünscht. So wird mit
JAX-Me2 2 eine alternative Implementierung der JAXB von der Apache Group 3 betrieben.
Das TCK stellt die Kompatibilität einer JAXB-Implementierung zum JAXB-Standard si-
cher. Es besteht aus einer Reihe von Tests, die eine JAXB-Implementierung erfolgreich
durchlaufen muss, um sich für den JAXB Standard zu zertifizieren.
Entwicklung durch das JAXB Project
Die Entwicklung und Verwaltung der Referenzimplementierung wird durch das JAXB Pro-
ject betrieben. Das JAXB Project wurde bei Sun als Open-Source-Projekt veröffentlicht.
Diese Entwicklergruppe realisiert neben der oben beschriebenen Referenzimplementierung
und dem TCK noch weitere Tools zur Unterstützung rund um JAXB. Das JAXB Project ist
wiederum Teil des Projekts Glassfish, das eine Referenzimplementierung der neuen Java
Enterprise Edition 5 darstellt.Veröffentlichung
Erstmals veröffentlicht wurde JAXB in der Version 1.0 durch den JSR 31. Seit dieser Ver-
sion ist JAXB auch Bestandteil des Java Web Service Developer Packages (Java WSDP,
aktuell in der Version 2.0). In diesem Buch werden wir uns ausschließlich der neuen JAXB
in der Version 2.0 widmen, die einige bedeutende Neuerungen umfasst und damit einen
großen Schritt in Richtung Projekttauglichkeit macht.
Die JAXB 2.0 wurde im April 2006 als Final Release des JSR 222 verabschiedet. Getragen
wird die Spezifikation dabei hauptsächlich von Sun Microsystems. Die Expertengruppe
1 http://www.jcp.org
2 http://ws.apache.org/jaxme
3 http://www.apache.org
4 https://jaxb.dev.java.net
4
19. 1.3 Architektur
wird jedoch noch von vielen weiteren Industriegrößen wie BEA, Oracle und SAP unter-
stützt. Ziel dabei ist, die JAXB-Spezifikation in Zukunft in die Java Standard Edition zu
integrieren. Damit wäre JAXB die Standardlösung für Java-XML-Datenbindungen.
Doch genug der Geschichte, es ist an der Zeit, einen Blick auf die Architektur von JAXB
zu werfen.
1.3 Architektur
Als erster Überblick sind hier die einzelnen Komponenten der JAXB-Architektur gelistet.
In den folgenden Abschnitten werden wir die genannten Komponenten dann etwas näher
beschreiben.
Architekturkomponenten
Annotationen: Die JAXB ist ein annotationsgetriebenes Framework (annotation
driven). Annotationen werden dazu verwendet, die Abbildung von Java- auf XML-
Repräsentation zu konfigurieren.
Schema-Compiler: Der Schema-Compiler bindet ein existierendes Schema an ein gene-
riertes Java-Datenmodell. Diese Erzeugung einer Java-Repräsentation aus einem
XML-Schemadokument ist ein häufig verwendeter Weg, die Java- und XML-Welten
zu verbinden. Er eignet sich besonders für dokumentgetriebene Anwendungsszenarien.
Schema-Generator: Der Schema-Generator bindet ein existierendes Java-Datenmodell
an ein generiertes XML-Schema. Die Information für die Abbildung der Java-
Elemente auf ein XML-Schema definiert der Entwickler durch Annotationen im exis-
tierenden Datenmodell. Dieser Weg eignet sich am besten für modellgetriebene An-
wendungsszenarien.
Binding Framework: Das Binding Framework stellt die Schnittstelle zur Anwendung
dar. Es bietet eine Reihe von API-Klassen und -Funktionen, die zur Laufzeit aufgeru-
fen werden: Die wichtigsten Funktionen sind das Marshalling und Unmarshalling. Das
Unmarshalling realisiert die Transformation von XML zu Java. Das Marshalling hin-
gegen überführt Java-Objekte in XML-Dokumentinstanzen. Begleitend zu diesen Ope-
rationen kann automatisch eine Validierung der XML-Inhalte anhand eines XML-
Schemas erfolgen. Mit dem Binder schließlich kann eine transparente Bearbeitung ei-
nes XML-Dokuments über ein gebundenes Java-Datenmodell erfolgen – Marshalling
und Unmarshalling finden hier im Hintergrund statt.
5
20. 1 JAXB im Überblick
Compile-Zeit- vs. Laufzeitkomponenten
Grundsätzlich können wir die Architekturkomponenten in zwei Bereiche aufteilen:
Komponenten der Compile-Zeit: Schema-Compiler und Schema-Generator werden zu-
sammen mit den Annotationen zur Compile-Zeit, d.h. vor Ausführung der Anwendung,
benötigt. Sie stellen die Bindung durch Generieren eines Java-Datenmodells bzw. eines
Schemas her.
Komponenten der Laufzeit: Das Binding Framework wird zur Laufzeit von der An-
wendung selbst benutzt, um XML-Inhalte zu verarbeiten.
Das Zusammenspiel dieser Komponenten zeigt die folgende Architekturübersicht.
XML-Schema
Bindungsdeklarationen
Portable Java Beans
JAXB-Annotationen
JAXB Annotationen
Compile-Zeitkomponenten
Laufzeitkomponenten
<f:foo ...
<element ... Unmarshalling Binding-Framework Unmarshalling
</element>
</f:foo>
JAXB API
Marshalling Marshalling
Validierung
XML-Dokument Java Beans-Instanzen
Abbildung 1.1 Komponenten der JAXB-Architektur
6
21. 1.3 Architektur
1.3.1 Annotationen
Annotationen werden, wie bereits erwähnt, durchgängig durch die JAXB verwendet, so-
wohl vom Schema-Compiler als auch vom Entwickler selbst. Sie werden sowohl in den
generierten Java Beans-Klassen verwendet als auch im XML-Schema. Wir unterscheiden
daher zwei Arten von Annotationen:
Mapping-Annotationen: Bei der Generierung eines Java-Datenmodells aus einem exis-
tierenden XML-Schema versieht eine JAXB-Implementierung die generierten Klassen
mit Java-Annotationen, die Informationen über die Java-XML-Bindung enthalten. Ja-
va-Annotationen sind im JSR 175 5 beschrieben und eine der Spracherweiterungen der
Java Standard Edition 5. Diese Mapping-Annotationen beschreiben in JAXB die Ab-
bildung der XML-Elemente des Schemas auf die Elemente des generierten Java-
Datenmodells (z.B. Klassen, Eigenschaften etc.). Dadurch beinhaltet das generierte Da-
tenmodell neben den Java-Klassen gleichzeitig eine Repräsentation des zugrunde lie-
genden Schemas.
Das XML-Schema selbst wird daher zur Laufzeit nicht mehr gebraucht, da alle benö-
tigten Informationen bereits in den Annotationen gespeichert werden. Der eigentliche
Vorteil der Annotationen zeigt sich jedoch erst im umgekehrten Fall, der Bindung von
XML-Daten an ein existierendes Java-Datenmodell. Hier kann der Entwickler jetzt
selbst seine existierenden Java-Klassen mit Mapping-Annotationen versehen. Diese
Mapping-Annotationen definieren die Bindung der Java-Klassen an die XML-Daten.
Sie stellen dann implizit ein XML-Schema dar. Werden keine Mapping-Annotationen
vom Entwickler angegeben, greift JAXB auf Defaultkonfigurationen zurück. Die Refe-
renz enthält in Kapitel 7.5 eine detaillierte Auflistung aller möglichen Mapping-
Annotationen und ihre Auswirkung auf den erzeugten Code.
Bindungskonfigurationen: Auch bei der Erzeugung eines Datenmodells aus einem exis-
tierenden XML-Schema kann die Bindung individuell konfiguriert werden. Dazu kann
der Entwickler Annotationen für das XML-Schema angeben. Diese Annotationen wer-
den Bindungsdeklarationen genannt und sind selbst wieder in XML formuliert. Da-
durch kann z.B. definiert werden, dass alle generierten Java-Klassen für ein XML-
Schema das Interface implementieren. Bindungskonfigurationen kön-
nen definiert werden, indem ein existierendes XML-Schemadokument mit Annotatio-
nen versehen wird. Diese Annotationen werden dann nicht über Java-Annotationen,
sondern direkt in XML durch das -Element formuliert. Sie können entwe-
der im Schema selbst oder über eine externe XML-Datei übergeben werden.
Wir sehen also, dass Annotationen ein grundlegendes Konzept der JAXB sind. Sie tragen
zur Konfigurierbarkeit und Portabilität der Java-XML-Bindung bei.
5 http://www.jcp.org/en/jsr/detail?id=175
7
22. 1 JAXB im Überblick
1.3.2 Der Schema-Compiler
Um eine Bindung von XML-Schema nach Java zu erstellen, generiert der Schema-
Compiler portable Java-Objekte aus einem bestehenden Schema.
<xs:schema ...
<xs:element ...
<xs:attribute ...>
<xs:annotation>
...
</xs:annotation>
</xs:schema>
@XmlRootElement
public class {
XML-Schema
@XmlElement ...
Schema-Compiler String element
...
@XmlAttribute
<jaxb:bindings ...
<jaxb:class... Java Beans mit
<jaxb:property ...> JAXB-Annotationen
</jaxb:bindings>
Bindungs-
konfiguration
Abbildung 1.2 Der Schema-Compiler
Woher weiß der Schema-Compiler nun, wie das generierte Java-Datenmodell aussehen
soll? Die JAXB-Spezifikation definiert dazu für jede Komponente der W3C XML-
Schemasprache eine entsprechende Java-Repräsentation, z.B. eine Java-Klasse, eine Ei-
genschaft oder eine Enumeration.
Jedem dieser Java-Sprachelemente werden zusätzlich Mapping-Annotationen hinzugefügt,
welche die entsprechende Schemakomponente beschreiben. Diese Abbildung zwischen
XML-Schema und Java stellt die Standardbindung des Schema-Compilers dar.
In den meisten Fällen genügt diese Standardbindung den Anforderungen einer Applikatio-
nen. In manchen Fällen sind allerdings Anpassungen der generierten Java-Klassen nötig.
Hier kommen die im vorigen Abschnitt erwähnten Bindungsdeklarationen zum Einsatz.
Sie überschreiben die Standardbindung des Schema-Compilers und erlauben benutzerdefi-
nierte Abbildungen von Schemakomponenten auf Java. Formuliert werden diese Bin-
dungsdeklarationen ebenfalls in XML. Auf die einzelnen Konfigurationsmöglichkeiten ge-
hen wir im Rahmen des Programmiertutorials genau ein.
Die folgende Tabelle gibt uns einen Überblick über die Abbildung der Schemakomponen-
ten auf Java-Programmelemente.
8
23. 1.3 Architektur
Tabelle 1.1 Abbildungsbeziehungen zwischen XML-Schema und Java-Elementen
XML-Schemakomponente Java-Komponente
Namespace Java-Paket
Komplexer Datentyp Benutzerdefinierte Java-Klasse
Einfacher Datentyp Java-Datentypen und Wrapper-Klassen
Einfacher Datentyp mit Enumeration Facet Java-Enumeration
Unterelemente eines komplexen XML-Typ Java-Eigenschaften der gebundenen
Klasse
Das bedeutet, dass wir nach dem Ausführen des Schema-Compilers eine Ansammlung von
Java-Klassen bekommen, die der Schema-Compiler in dem angegebenen Paket ablegt. Der
Schema-Compiler erzeugt zusätzlich dazu noch eine Klasse . Mit dieser
Klasse wird dem Programmierer, der Name verrät es bereits, eine Factory-Klasse an die
Hand gegeben. Mit dieser Klasse können nun bequem Instanzen der generierten JAXB
Klassen erzeugt werden. Wir werden uns die im Zusammenhang mit dem
Marshalling von XML-Dokumenten noch genauer ansehen.
1.3.3 Der Schema-Generator
Der Schema-Generator verwendet die in Tabelle 1.1 definierten Abbildungsregeln im um-
gekehrten Sinne, um ein Schema aus einem bestehenden Java-Datenmodell zu erzeugen.
9
24. 1 JAXB im Überblick
<f:foo ...
<element ...
</element>
</f:foo>
@XmlRootElement
public class ... {
XML-Dokument
@XmlElement ...
String element
...
<xs:schema ...
@XmlAttribute
<xs:element ...
<xs:attribute ...>
Java Beans mit <xs:annotation>
JAXB-Annotationen ...
</xs:annotation>
</xs:schema>
XML-Schema
Abbildung 1.3 Der Schema-Generator
Auch híer gibt es Standardbindungen, die z.B. aus einer benutzerdefinierten Klasse einen
komplexen Typen im XML-Schema erzeugen. Für die Default-Bindungen müssen keine
expliziten Annotationen im Datenmodell angegeben werden, die JAXB-Spezifikation setzt
in diesem Fall die Standardbindung voraus.
Ein Java-Datenmodell kann auf diese Weise mit der Angabe von nur einigen wenigen An-
notationen vollständig auf ein Schema abgebildet werden. Die Standardbindungen können
aber durch die Angabe der oben erwähnten Mapping-Annotationen ergänzt bzw. über-
schrieben werden, um die Bindung entsprechend anzupassen.
Der Vorteil ist, dass diese Annotationen direkt in ein existierendes Datenmodell eingefügt
werden können. Wann und wie wir ein Datenmodell mit Mapping-Annotationen versehen,
wird ausführlich im Programmiertutorial behandelt. Eine detaillierte Auflistung der mögli-
chen Annotationen findet sich in der Referenz.
1.3.4 Das Binding Framework
Wie bereits erwähnt, vereint das Binding Framework die API-Funktionen der JAXB zur
Verarbeitung von XML-Dokumenten zur Laufzeit. Es befindet sich im Paket
der JAXB-Laufzeitbibliothek. Es bietet die folgenden Funktionalitäten, die
wir in diesem Abschnitt im Detail darstellen:
Umarshalling: Laden von XML.
Marshalling: Speichern von XML.
10
25. 1.3 Architektur
Event-Callbacks: Nachrichten im Rahmen des Unmarshallings bzw. Marshallings ver-
arbeiten.
Validierung: Die Gültigkeit von verarbeiteten XML-Dokumenten sicherstellen.
Binder: Modifizieren eines XML-Dokuments ohne explizites Laden oder Speichern.
1.3.4.1 Unmarshalling
Beim Unmarshalling wird eine XML-Schemainstanz, d.h. ein XML-Dokument, das ein
gegebenes Schema als Formatbeschreibung referenziert, in einen Graph aus Java-Objekten
transformiert. Dieser Objektgraph besteht aus Instanzen von Java Beans, die mit Mapping-
Annotationen versehen sind.
Der Inhalt unseres XML-Dokuments ist somit nach erfolgtem Unmarshalling im Speicher
präsent. Unsere Anwendung kann dann ohne den Einsatz einer zusätzlichen XML-API auf
die Java Beans wie auf normale Objekte zugreifen. Klingt einfach, oder? Ist es auch, wie
wir später im Programmiertutorial sehen werden.
Ein häufiges Problem, auf das wir beim Unmarshalling stoßen, sind ungültige XML-
Inhalte. Es ist zwar möglich, bereits vorher über die Validierung Dokumente mit ungülti-
gen Inhalten auszuschließen. Aber nicht immer wollen wir uns den Overhead einer Vali-
dierung leisten. Oft besitzen die XML-Dokumente auch keine besonders hohe Datenquali-
tät, sie sind z.B. unvollständig oder fehlerhaft ausgefüllt. Trotzdem muss die Anwendung
mit diesen Inhalten umgehen können. Daher wurde in JAXB 2.0 die Möglichkeit vorgese-
hen, ein Unmarshalling von ungültigen Inhalten vorzunehmen. Generell existieren nämlich
zwei unterschiedliche Verfahren des Unmarshallings.
Structural Unmarshalling: Dieses Verfahren implementiert das strikte Unmarshalling
eines XML-Dokuments. Die Reihenfolge der Elemente im XML-Dokument muss ex-
akt übereinstimmen mit der im XML-Schema definierten Reihenfolge. Trifft dies nicht
zu, wird das Unmarshalling mit einer Fehlermeldung abgebrochen. Das Unmarshalling
basiert also auf der Struktur des XML-Dokuments. Eventuelle Abweichungen vom
zugrunde liegenden Schemadokument werden sofort aufgedeckt. Dieser Ansatz wurde
in früheren Versionen der JAXB verfolgt. Er eignet sich nicht besonders für die Be-
handlung von ungültigen oder veränderten Inhalten.
Flexible Unmarshalling: Dieses Verfahren ist weniger strikt und lässt uns auch Doku-
mente verarbeiten, deren Elementreihenfolge nicht hundertprozentig mit dem Schema
übereinstimmt. Die Elemente werden dem Namen nach transformiert statt nach ihrer
Position im Dokument. Dadurch können Dokumente verarbeitet werden, die zwar vom
Schema abweichen, deren Inhalte aber dennoch ausreichende Information besitzen.
Dies gilt z.B. für XML-Dokumente mit abweichender Elementreihenfolge, fehlenden
oder unbekannten Elementen. JAXB 2.0 verfolgt standardmäßig ein flexibles Unmars-
halling, um beispielsweise die Evolution, also die Weiterentwicklung von XML-
Schemas und XML-Dokumenten zu unterstützen. Denn immer häufiger unterliegen
XML-Dokumente einer ständigen Weiterentwicklung, so dass der Bedarf für ein fehler-
11
26. 1 JAXB im Überblick
tolerantes, flexibles Unmarshalling ständig größer wird. Ein konkretes Beispiel hierzu
findet sich im Unmarshalling-Abschnitt des Tutorials.
1.3.4.2 Marshalling
Das Marshalling geht nun den umgekehrten Weg. Ein im Speicher vorhandener Objekt-
graph wird serialisiert, d.h., in ein XML-Dokument überführt. Der Objektgraph besteht
dabei wieder aus Instanzen von Java Beans, die mit JAXB-spezifischen Annotationen ver-
sehen sind.
Durch diese Annotationen werden die Objekte auf die zugehörigen XML-Elemente abge-
bildet. Die Zielstruktur, in die Objekte überführt werden, kann dabei verschiedene Formate
besitzen. So kann eine JAXB-Implementierung das XML in Standardausgabeströme der
Java Core API wie oder schreiben, aber auch
höhere Ausgabeschnittstellen und Standards wie SAX, DOM, StAX nutzen und sogar mit
Transformationen per XSL kombinieren.
1.3.4.3 Event Callbacks
Sowohl für das Marshalling als auch das Unmarshalling kann der Entwickler sog. Call-
back-Methoden einfügen. Diese Methoden arbeiten nach dem Hollywood-Prinzip („don’t
call us we’ll call you“), das u.a. durch das Spring Framework 6 populär geworden ist. Da-
durch kann während des Marshallings/Unmarshallings applikationsspezifische Logik aus-
geführt werden. Mit der Implementierung dieser Callback-Mechanismen werden wir uns
später im Programmiertutorial noch näher beschäftigen.
1.3.4.4 Validierung
Eine Validierung von Inhalten kann eine JAXB-Implementierung automatisch sowohl
beim Unmarshalling als auch beim Marshalling durchführen. Diese Validierung ist jedoch
bewusst optional gehalten, um Anwendungsszenarien behandeln zu können, die keine Va-
lidierung benötigen oder wo eine Validierung der Daten nicht regelmäßig möglich ist.
Beim Unmarshalling wird das zu verarbeitende XML-Dokument überprüft. Beim Marshal-
ling dagegen muss der im Speicher existierende Objektgraph auf Gültigkeit überprüft wer-
den.
Wer jetzt denkt, die Validierung beim Unmarshalling sollte doch auch genügen, der sollte
sich das Fail-fast-Prinzip ins Gedächtnis rufen. Nach diesem Entwurfsprinzip für Pro-
grammierschnittstellen sollten Fehler so früh wie möglich aufgedeckt und an die Anwen-
dung kommuniziert werden. Diesem Prinzip folgt auch die JAXB. Das bedeutet, dass un-
gültige Daten bereits beim Marshalling aufgedeckt werden sollten, also noch bevor die Da-
ten eventuell an eine andere Komponente einer Architektur weitergegeben werden.
6 http://www.springframework.org
12
27. 1.3 Architektur
Denkbar wäre z.B. eine Anfrage an einen Webservice, bei der XML-Daten einem WSDL-
Dokument gemäß versendet werden. Eine Validierung der Daten vor der Absendung der
Anfrage, beim Marshalling, hilft, Fehler dort aufzudecken, wo sie entstehen.
Die Validierung führt also die Überprüfung der im XML-Schema definierten Einschrän-
kungen und Formatvorgaben durch. Dabei können die Einschränkungen in zwei Katego-
rien unterteilt werden.
Statische Einschränkungen: Dies sind z.B. Einschränkungen auf Datentypen wie
, oder . Solche Einschränkungen werden später durch die por-
tablen Java Beans aufrechterhalten. Verletzungen dieser Einschränkungen werden be-
reits durch die Java-Typüberprüfung erkannt und können zur Laufzeit bei der Um-
wandlung von und in XML theoretisch nie auftreten.
Dynamische Einschränkungen: Einschränkungen auf Wertebereiche oder die Definition
von komplexen Typen mit bestimmten Kindelementen können erst zur Laufzeit über-
prüft werden. Diese Validierungen können durchaus sehr aufwendig werden, da unter
Umständen der gesamte Objektgraph überprüft werden muss, z.B. um die Eindeutigkeit
einer XML-Element-ID zu überprüfen.
Tritt nun ein Verstoß gegen eine der oben genannten Einschränkungen auf, so wird ein
Fehlerereignis generiert. Das Fehlerereignis besitzt Informationen zu der Art des Fehlers
und dem Ort, an dem der Fehler aufgetreten ist. Solche Fehlerereignisse können entweder
sofort an die aufrufende Anwendung weitergegeben oder zunächst gesammelt und nach
erfolgter Validierung als Liste weitergereicht werden.
Zur Durchführung der Validierung muss im einfachen Fall ein XML-Schema angegeben
werden. Die eigentliche Validierung wird dabei seit JAXB 2.0 durch die in der Java Stan-
dard Edition 5 enthaltene JAXP 1.3 API übernommen. JAXP 1.3 definiert eine Standard-
API zur Validierung von XML-Dokumentinstanzen. Dieses „Outsourcing“ der Validie-
rung hat den zusätzlichen Vorteil einer kompakteren Implementierung.
Die Verwendung der JAXP Validation API bietet weit mehr Flexibilität und Konfigurier-
barkeit als die JAXB-eigene Validierung der Version 1.0. So können beispielsweise neben
den Standardmechanismen zur Behandlung der Validierung auch eigene Implementierun-
gen der sog. Validation-Event-Handler-Interfaces verwendet werden. Dadurch kann indi-
viduell auf ganz bestimmte Fehler reagiert werden, z.B. um eine gewisse Fehlertoleranz
einer Anwendung zu gewährleisten.
Die Validierung ist dabei nicht auf XML-Schema festgelegt – so können über entspre-
chende Schnittstellen auch ganz eigene Implementierungen für eine XML-Validierung
beigesteuert werden.
1.3.4.5 Binder
Die -Komponente der JAXB-API kann zwei verschiedene Sichten auf ein XML-
Dokument gleichzeitig verwalten. Angenommen, es existiert in einer Anwendung bereits
13
28. 1 JAXB im Überblick
eine Sicht auf ein XML-Dokument, z.B. als DOM 7 . Ein DOM-Modell repräsentiert ein
XML-Dokument durch Objekte, die Knoten, Elemente und Attribute darstellen. Mithilfe
des Binders kann zusätzlich dazu für das gesamte Dokument oder auch nur für Teile eine
zweite Sicht erstellt werden. Diese Sicht besteht aus den bereits bekannten JAXB-Klassen.
Wird nun von der Anwendung eine dieser beiden Sichten verändert, kann der Binder die
jeweils andere Sicht mit den Änderungen aktualisieren und so beide Sichten synchron hal-
ten.
Ein häufiger Anwendungsfall ist hier die Darstellung eines Ausschnitts aus dem XML-
Dokument durch JAXB-Klassen. Diese JAXB-Klassen stellen die zu verändernden Teile
des Dokuments dar. Das gesamte Dokument ist weiterhin als DOM-Modell verfügbar,
wird aber vielleicht nur lesend verwendet. Schreibzugriffe erfolgen aufgrund der einfache-
ren Verwendbarkeit durch JAXB.
Der modifizierbare Ausschnitt des Dokuments kann dabei z.B. durch einen XPath-
Ausdruck dargestellt werden. Die folgende Abbildung soll die Funktion der -
Komponente etwas veranschaulichen.
unmarshal Binder update
customer
<response ...
<customer ... load
<address .../>
</customer>
JAXB
</response>
save Mapping
<customer> address
XML-Dokument DOM-Baum
Java Beans-Instanzen
Abbildung 1.4 Die Binder-Komponente
1.4 1.0 + 1.0 = 2.0?
Die Neuerungen der JAXB 2.0
Was hat sich nun seit der Version 1.0 bei der JAXB-Spezifikation getan? Lohnt es sich,
meine Anwendung zu migrieren? Ist JAXB noch komplizierter geworden als in der Vor-
gängerversion? Diese Fragen werden sich diejenigen stellen, die bereits mit JAXB in Be-
rührung gekommen sind.
7 Document Object Model
8 http://www.w3.org/TR/1999/RECxpath-19991116
14
29. 1.4 1.0 + 1.0 = 2.0?
Java nach XML-Schemaabbildung
Die JAXB hat sich mit der Version 2.0 fundamental verändert. Die größte Änderung dürfte
die Einführung der Bindung existierender Java-Datenmodelle an XML sein. Während in
JAXB 1.0 im Wesentlichen ein XML-Schema in ein Java-Datenmodell umgewandelt wur-
de, ist jetzt eine elegante Art der Datenbindung durch die Annotation von existierenden
Klassen entstanden.
In JAXB 2.0 kann eine Java-XML-Bindung konfiguriert werden, ohne dass hierbei aus ei-
nem XML-Schema mithilfe des Schema-Compilers JAXB-spezifische Klassen generiert
werden müssen. Die aus Sicht der Datenbindung bestehende Einbahnstraße in JAXB 1.0
wurde sozusagen zu einer bidirektionalen Autobahn in JAXB 2.0 ausgebaut.
Portabilität
JAXB geht außerdem in der Version 2.0 einen fundamentalen Schritt weiter in Richtung
Portabilität. In JAXB 1.0 werden aus den Komponenten eines Schemas Interfaces und de-
ren Implementierungsklassen generiert. Diese vom Schema abgeleiteten Klassen gingen
eine enge Kopplung mit der jeweiligen Implementierung der JAXB und mit der JAXB-
Laufzeitbibliothek selbst ein.
Für die Abwärtskompatibilität werden diese Interfaces zwar weiterhin unterstützt, jedoch
geht man offiziell einen anderen Weg. In JAXB 2.0 sind es die mit Annotationen versehe-
nen portablen Klassen, die an Schemakomponenten gebunden werden. Da diese Klassen
im Wesentlichen Java Beans darstellen, sind sie an keine spezifische Implementierung der
JAXB gebunden.
Als Entwickler arbeitet man daher mit konkreten Klassen statt der bisherigen Interfaces. Es
ist möglich, ein Java-Datenmodell nachträglich und ohne wesentliche Änderung von einer
JAXB-Implementierung auf eine andere zu portieren, aber auch von einer XML-
Datenbindung beispielsweise an eine Datenbank-Datenbindung.
Volle Unterstützung von XML-Schema
Ein weiteres Manko der JAXB 1.0 ist die unvollständige Unterstützung der XML-
Schemasprache. Mit der Version 2.0 ist in JAXB die volle Unterstützung der W3C XML-
Schemaspezifikation angestrebt. Es können jetzt alle in W3C XML-Schema vorhandenen
Konzepte in einem Java-Datenmodell abgebildet werden. Hinzugefügt wurde unter ande-
rem die fehlende Unterstützung von Wildcards und Typsubstitutionen.
Java 5-Unterstützung
Dem allgemeinen Trend folgend, setzt auch JAXB 2.0 voll auf die Spracherweiterungen
der Java Standard Edition 5. Zum einen sind das die erwähnten Annotationen. Aber auch
Generics werden unterstützt, was eine erhöhte Typsicherheit zur Folge hat, da z.B. alle ge-
nerierten Listen bereits den korrekten Typ besitzen. Auf der anderen Seite bedeutet dies
15
30. 1 JAXB im Überblick
aber auch, dass Anwendungen mit JAXB 2.0 die Verwendung der JSE 5 oder höher vor-
aussetzen.
Redesign der Validierung
Auch was die Validierung angeht bietet JAXB 2.0 einige Neuerungen. Um eine flexiblere
Behandlung der Validierung von XML-Dokumenten zu ermöglichen, wird in der Version
2.0 die Validierungskomponente der JAXP 1.3 API verwendet. Damit wurde die bisherige
On-Demand-Validierung beim Unmarshalling ersetzt.
Die Validierung kann nun optional sowohl beim Unmarshalling als auch beim Marshalling
durchgeführt werden. Die neue Validierungskomponente ist wesentlich flexibler und er-
laubt nun auch das Unmarshalling von teilweise ungültigen XML-Dokumenten.
Dadurch wurden auch Performance-Aspekte in JAXB 2.0 adressiert. So konnte die Anzahl
der generierten Klassen gesenkt und die Größe der Laufzeitbibliotheken verringert werden.
Umstieg von JAXB 1.0 nach 2.0
Doch was passiert nun mit Applikationen, die auf der Version 1.0 der JAXB basieren?
JAXB 2.0 beinhaltet alle nötigen Bibliotheken, die für die Ausführung von existierenden
JAXB 1.0-Applikationen benötigt werden. Der Schema-Compiler der Version 2.0 ist
auch in der Lage, JAXB 1.0-kompatiblen Code zu generieren.
Um eine auf der JAXB 1.0 basierende Applikation auf die JAXB 2.0 zu portieren, muss
allerdings das Schema mit der neuen Version des Schema-Compilers kompiliert und
die Anwendung mit den generierten Klassen aktualisiert werden. Außerdem muss natürlich
beachtet werden, dass JAXB 2.0 nur ab der Java-Version 5 eingesetzt werden kann. Wobei
im Rahmen der Spezifikation darauf geachtet wurde, dass eine JAXB-Implementierung
potenziell über entsprechende „Retro-Translatoren“ zumindest zur Laufzeit Java 1.4-
Kompatibilität bieten können.
16
31. 2 Basistechnologien
In diesem Kapitel gehen wir auf die im Rahmen der JAXB verwendeten Basistechnologien
XML-Schema, XPath und ANT ein.
2.1 XML-Schema
XML ist seit langem eins der Standardformate, wenn es um die plattformunabhängige
Repräsentation von Daten geht. Das Besondere an XML: Es werden nicht nur die reinen
Daten, sondern auch die Metadaten in einem XML-Format gespeichert. Also nicht nur die
Information „Müller“, sondern auch die Information „Müller ist der Nachname eines Kun-
den“. Rein technisch betrachtet ist XML ein sehr redundantes und aufgeblähtes Format, als
Datenaustauschformat hat es den großen Vorteil, dass jeder Entwickler ein XML-
Dokument öffnen und lesen kann, ohne dass die Daten zusätzlich aufbereitet werden müss-
ten.
Besonders vielseitig wird XML durch die Möglichkeit, die erwarteten Daten in Form einer
DTD oder eines XML-Schemas zu spezifizieren. Über solche Formatbeschreibungen las-
sen sich Form und Gültigkeit eines Datensatzes beschreiben: „Jeder Kundendatensatz
muss einen Namen angeben, eine Adressangabe ist optional möglich.“ In diesem Kapitel
möchten wir auf die wesentlichen Möglichkeiten von XML-Schema eingehen, das sich zu
dem umfangreichsten und genauesten Format zur Beschreibung von Formaten gemausert
hat.
Mit XML-Schema können wir Grammatiken definieren, also Einschränkungen und Regeln
zu den Daten in einem XML-Dokument. Ein mit XML-Schema beschriebenes Dokument
kann anhand der Grammatik auf seine Gültigkeit überprüft werden. Eine solche Validie-
rung wird von einem Schema-Validierer durchgeführt.
So lassen sich z.B. Daten beschreiben, die dem Nachrichtenaustausch zwischen verschie-
denen Anwendungen dienen. Durch Verwendung eines XML-Schemas wird den einzelnen
Komponenten ein einheitliches, überprüfbares Format bereitgestellt.
17
32. 2 Basistechnologien
Im Zusammenhang mit XML-Schema werden oft die Begriffe Schemadokument und
Schemainstanz verwendet.
Ein XML-Schemadokument definiert die oben genannte Grammatik zu den XML-
Daten und legt so deren Struktur für alle Beteiligten fest.
Eine XML-Schemainstanz hingegen ist ein XML-Dokument, das ein Schemadokument
verwendet, um XML-Daten konform zu einer Grammatik zu beschreiben.
XML-Schema wird heute von vielen XML-basierten Standards und APIs verwendet wie
z.B. der Web Service Description Language (WSDL).
Ursprünglich vorgeschlagen von Microsoft, wurde die Sprache schließlich 2001 als Emp-
fehlung durch das Webkonsortium W3C 1 offiziell veröffentlicht.
Im Gegensatz zu anderen Grammatikdefinitionen wie DTD , die mittels einer zusätzlichen
Sprache definiert werden, basiert XML-Schema selbst auch auf XML. Weitere Vorzüge
sind die Erweiterbarkeit und eine Vielzahl an vordefinierten Datentypen. Außerdem wer-
den objektorientierte Konzepte wie Namensräume und Vererbung unterstützt. Aus diesen
Gründen hat sich XML-Schema mittlerweile gegen DTD durchgesetzt. Aber auch XML-
Schema hat natürlich Konkurrenz, der wichtigste Standard ist hier wohl RelaxNG, für den
in JAXB bereits experimentelle Unterstützung zu finden ist.
Bei der Arbeit mit JAXB wird uns XML-Schema ein ständiger Begleiter sein. Es gibt eine
ganze Reihe toller Bücher zum Thema XML-Schema. Daher wird dieses Kapitel sich dar-
auf beschränken, einen Überblick über die wichtigsten Konzepte zu geben, die wir für das
unmittelbare Verständnis der Beispiele in diesem Buch für notwendig halten.
Um ein XML-Schema definieren zu können, benötigen wir natürlich ein Grundverständnis
für den Aufbau eines XML-Schemas. Daher wird zunächst der Schemaaufbau unter Ver-
wendung von Namensräumen erläutert. Danach werden wir uns ausführlich der Definition
von Datentypen widmen, da wir diese später mit JAXB an unsere Java-Klassen binden
wollen. Ein weiteres wichtiges Thema in diesem Zusammenhang ist die Formulierung von
Einschränkungen auf diesen Datentypen.
Da wir natürlich mit objektorientierten Datenmodellen arbeiten wollen, darf auch die Ver-
erbung von Datentypen in XML-Schema nicht fehlen. Vererbung ist aber nur ein Mittel
zur Erweiterbarkeit von Schemas. Wir werden uns daher noch mit weiteren Mitteln zur
Definition von erweiterbaren, offenen Schemas befassen. In dieser Hinsicht betrachten wir
abschließend das Zusammensetzen eines Schemas aus mehreren Teilschemas, was uns ei-
ne komponentenbasierte Definition der Daten ermöglicht.
Die genannten Konzepte werden wir anhand eines Objektmodells darstellen, das sukzessi-
ve im Verlauf des Kapitels aufgebaut wird. Auf diesem Domänenobjektmodell, im Engli-
schen das Domain Object Model, werden dann alle weiteren Programmierbeispiele im Ver-
lauf des Buches aufbauen.
1 http://www.w3.org
2 Document Type Definitions
18
33. 2.1 XML-Schema
Da eine erschöpfende Behandlung von XML-Schema weit über den Rahmen dieses Kapi-
tels hinausgeht, sei für weitere Informationen auf das Buch XML Schema von Eric van der
Vlist verwiesen.
Ein XML-Schemadokument bildet also die Grundlage einer Java-XML-Bindung mit
JAXB. Ein solches Schemadokument beschreibt dabei sowohl Struktur als auch Datenty-
pen einer Schemainstanz. Im einfachsten Fall besteht ein Schemadokument aus der Defini-
tion der gültigen Elemente sowie deren Reihenfolge und Anordnung.
Es lassen sich aber auch komplexe Strukturen aufbauen, die sich über mehrere Schemas
erstrecken und ganze Datentyphierarchien aufbauen. Im Verlauf dieses Kapitels werden
wir mehrere Schemas entwickeln und diese zu einer komplexen Struktur zusammenfügen.
Zunächst aber konzentrieren wir uns auf ein einfaches Beispiel:
Stellen wir uns einen Online-Banking-Service vor, der auf eintreffende XML-Requests von
Clients eine entsprechende Response im XML-Format zurückliefert. Im Request wird eine
Kunden-ID mitgeliefert. Als Antwort liefert der Service dann entsprechende Informationen
über die Stammdaten, die Kontodaten sowie über ein evtl. vorhandenes Aktienportfolio
des Kunden. Diese Daten werden z.B. aus einer Datenbank gewonnen. Die Struktur der
vom Service zurückgelieferten Daten wird durch die folgenden XML-Schemas definiert.
response: Enthält die Antwort des Service auf einen eingehenden Request.
customerElement: Enthält die Stammdaten eines Kunden.
accountElement: Enthält alle kontorelevanten Daten eines Kunden.
portfolioElement: Repräsentiert das Aktienportfolio eines Kunden.
Das Schema nutzt dabei die in den Schemas , und
erstellten Datentypen, um eine Datenstruktur für die Ausgabe an den Client zusam-
menzustellen.
Abbildung 2.1 Das response-Schema
Um nicht gleich die Übersicht zu verlieren, sehen wir uns zunächst nur die Stammdaten
eines Kunden an.
19
34. 2 Basistechnologien
Abbildung 2.2 Stammdaten eines Kunden
Für diese Daten sieht ein einfaches Schemadokument nun so aus:
Das Dokument oben legt für den Kunden also ein Element mit den entsprechenden Unter-
elementen für die Stammdaten an.
Das schema-Element
Sehen wir uns zunächst den Kopf dieses Dokuments ein wenig genauer an. Ein Schemado-
kument beginnt immer mit dem einleitenden Wurzelelement . Im obigen Beispiel
sind in diesem -Element zwei weitere Attribute definiert, die beide jeweils eine
URL als Wert enthalten.
20
35. 2.1 XML-Schema
Diese Attribute definieren verschiedene Namensräume in unserem Schemadokument. Die-
se werden gewöhnlich im einleitenden -Element definiert. Ihre Verwendung wird
im nächsten Abschnitt behandelt. Sehen wir uns zunächst noch der Vollständigkeit halber
ein entsprechendes XML-Dokument zu unserem Schemadokument an.
Dieses Dokument nutzt also das vorher definierte -Element, um einen
Kundendatensatz zu beschreiben.
2.1.1 Namespaces verwenden
In der Einleitung wurde erwähnt, dass durch XML-Schema Grammatiken definiert werden.
Eine Grammatik setzt grundsätzlich auf einem bestimmten Vokabular auf. Solche Vokabu-
lare können wir in XML-Schema durch Definition von Elementen frei bestimmen. Was
aber, wenn sich unsere Datentypen mit den Definitionen anderer Vokabulare überschnei-
den? Das Problem solcher Namenskonflikte wird in XML-Schema durch die Verwendung
von Namensräumen, den Namespaces, gelöst. Die XML-Spezifikation definiert einen Na-
mespace wie folgt:
An XML namespace is a collection of names, identified by a URI reference [RFC2396],
which are used in XML documents as element types and attribute names.
Ein Namespace schafft also einen gemeinsamen Kontext für eine Menge von Elementen,
Attributen und Datentypen. Ziel dabei ist es, eine einheitliche und eindeutige Bezeichnung
der Elemente zu ermöglichen. Vergleichbar zu einem XML-Namespace ist ein Java-Paket,
in dem Java-Klassen gruppiert werden, um Namenskonflikte zu verhindern und den Klas-
sen einen gemeinsamen Kontext zu geben.
Das Standardvokabular von XML-Schema besitzt z.B. den Namespace
http://www.w3.org/2001/XMLSchema, der auch schon im einleitenden Beispiel verwendet
wurde. Dieser Namespace enthält die grundlegenden Elemente zur Definition neuer Ele-
mente, Attribute und Typen. Wenn wir nun weitere Elemente definieren, können wir diese
einem anderen, von uns gewählten Namespace zuordnen. Bei der Benennung unserer Ele-
mente bleiben wir dadurch völlig frei.
2.1.1.1 Namespaces definieren
Eine Namespace-Definition wie beispielsweise
setzt sich zusammen aus:
21
36. 2 Basistechnologien
Dem Schlüsselattribut ; dieses Attribut kennzeichnet eine Namespace-Definition.
Einem optionalen Präfix, z.B. ; das Präfix kennzeichnet die Zugehörigkeit eines
lements zu einem bestimmten Namespace, z.B. gehört das Element zum
oben angegebenen XML-Schema-Namespace. Ein Präfix stellt also eine Art Abkür-
zung für den URI eines Namespace dar.
Einem URI 3 , z.B. http://jaxb.transparent/customer, der dem Präfix zugewiesen wird.
Dieser URI stellt einen eindeutigen Bezeichner für den Namespace dar.
2.1.1.2 XML-Schema und Target-Namespace
Es steht uns frei, eigene Namespaces in einem Dokument zu definieren.. Wir können auch
ein Schemadokument erstellen, das keine benutzerdefinierten Namespaces enthält, ein so-
genanntes „stand-alone schema“. Ein Schemadokument muss jedoch zumindest auf den
XML-Schema-Namespace verweisen:
Dieser Namespace definiert nämlich die Standardelemente von XML-Schema, die wir zur
Definition eines Schemadokumentes nutzen können, z.B. , , ,
, , etc. Nach allgemeiner Konvention erhält er zumeist das Präfix
oder .
Da wir später in unserer Anwendung mit mehreren verschiedenen Schemas arbeiten, bietet
es sich jedoch an, für jedes Schema stets einen eigenen Namespace zu definieren. Dies
hilft, später Elemente eindeutig voneinander abzugrenzen. Um die in einem Schemadoku-
ment definierten Elemente, Attribute und Datentypen mit einem bestimmten Namespace
zu verknüpfen, deklarieren wir diesen Namespace als sog. Target-Namespace im Wurzel-
element. Der Target-Namespace lautet für unser Kundenschema beispielsweise
http://jaxb.transparent/customer.
Definitionen von Datentypen in einem Schemadokument beziehen sich immer auf genau
einen Namespace, den Target-Namespace. Ein Schema darf daher genau einen Target-
Namespace definieren. Elemente, die dieses Schema neu definiert, werden automatisch mit
diesem Namespace assoziiert. Geben wir keinen Target-Namespace an, so landen die hier
definierten Schemaelemente im Standard-Namespace und können von anderen Schemas
nicht mehr eingebunden werden.
Auf das obige Beispiel bezogen bedeutet dies, dass das Element auto-
matisch dem Namespace http://jaxb.transparent/customer zugeordnet wird.
2.1.1.3 Namespaces in XML-Dokumenten verwenden
Bisher haben wir im Schemadokument einen eigenen Namespace durch den Target-
Namespace definiert. Wie können wir nun angeben, dass die Elemente in einer Schema-
3 Uniform Resource Identifier
22
