Michaelis/Schmiesing

                        JAXB 2.0
   Ein Programmiertutorial für die
Java Architecture for XML Bindin...
Samuel Michaelis
Wolfgang Schmiesing

JAXB 2.0
Ein Programmiertutorial
für die Java Architecture
for XML Binding
Die Autoren:
Samuel Michaelis, Software-Architekt
Wolfgang Schmiesing, Berater und Projektleiter
Beide Autoren sind für di...
Inhalt


Vorw...
Inhalt

         2.2   XPath.................................................................................................
Inhalt

      4.3.9 Zusammenfassung .........................................................................................
Inhalt

               5.5.1 Datentypen explizit angeben mit jaxb:baseType ..................................................
Inhalt

7.3       schemaGen-Kommandozeilenbefehl ............................................................................
Vorwort
Das Buch wendet sich an Entwickler mit guten Java-Kenntnissen, die in ihrem Arbeitsall-
tag oft mit Java und XML a...
Vorwort

          werden wird. Wir möchten mit diesem Buch einen kleinen Beitrag leisten, diese feine
          Technolog...
Vorwort

alltag als Code Duplication verteufeln, richtig angewendet im Bereich der Didaktik eine
der gerne zitierten Best ...
1 JAXB im Überblick
      Im folgenden Kapitel werden wir die Java Architecture for XML Binding 2.0 aus der Vo-
      gelp...
1 JAXB im Überblick

        für plain old Java objects, genannt. Auf diese Weise können wir bequem über die vertrau-
    ...
1.1 Ziele

der umgekehrte Weg gewinnt im Zeitalter der Webservices mehr an Bedeutung. Wird eine
Anwendung beispielsweise a...
1 JAXB im Überblick

1.2     Entstehung

        Spezifizierung durch JSR 222
        JAXB ist aus dem Java Community Proc...
1.3 Architektur

      wird jedoch noch von vielen weiteren Industriegrößen wie BEA, Oracle und SAP unter-
      stützt. Z...
1 JAXB im Überblick

        Compile-Zeit- vs. Laufzeitkomponenten
        Grundsätzlich können wir die Architekturkompone...
1.3 Architektur

1.3.1     Annotationen
Annotationen werden, wie bereits erwähnt, durchgängig durch die JAXB verwendet, so...
1 JAXB im Überblick

        1.3.2       Der Schema-Compiler
        Um eine Bindung von XML-Schema nach Java zu erstellen...
1.3 Architektur

Tabelle 1.1 Abbildungsbeziehungen zwischen XML-Schema und Java-Elementen

XML-Schemakomponente           ...
1 JAXB im Überblick




                                                                            <f:foo ...
           ...
1.3 Architektur

   Event-Callbacks: Nachrichten im Rahmen des Unmarshallings bzw. Marshallings ver-
   arbeiten.
   Valid...
1 JAXB im Überblick

           tolerantes, flexibles Unmarshalling ständig größer wird. Ein konkretes Beispiel hierzu
   ...
1.3 Architektur

Denkbar wäre z.B. eine Anfrage an einen Webservice, bei der XML-Daten einem WSDL-
Dokument gemäß versende...
1 JAXB im Überblick

        eine Sicht auf ein XML-Dokument, z.B. als DOM 7 . Ein DOM-Modell repräsentiert ein
        XM...
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ößt...
1 JAXB im Überblick

        aber auch, dass Anwendungen mit JAXB 2.0 die Verwendung der JSE 5 oder höher vor-
        aus...
2 Basistechnologien
      In diesem Kapitel gehen wir auf die im Rahmen der JAXB verwendeten Basistechnologien
      XML-S...
2 Basistechnologien

        Im Zusammenhang mit XML-Schema werden oft die Begriffe Schemadokument und
        Schemainsta...
2.1 XML-Schema

Da eine erschöpfende Behandlung von XML-Schema weit über den Rahmen dieses Kapi-
tels hinausgeht, sei für ...
2 Basistechnologien




        Abbildung 2.2 Stammdaten eines Kunden


        Für diese Daten sieht ein einfaches Schema...
2.1 XML-Schema

Diese Attribute definieren verschiedene Namensräume in unserem Schemadokument. Die-
se werden gewöhnlich i...
2 Basistechnologien

            Dem Schlüsselattribut ; dieses Attribut kennzeichnet eine Namespace-Definition.

   ...
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
JAX B
Upcoming SlideShare
Loading in...5
×

JAX B

4,861

Published on

Published in: Technology
0 Comments
1 Like
Statistics
Notes
  • Be the first to comment

No Downloads
Views
Total Views
4,861
On Slideshare
0
From Embeds
0
Number of Embeds
1
Actions
Shares
0
Downloads
100
Comments
0
Likes
1
Embeds 0
No embeds

No notes for slide

JAX B

  1. 1. Michaelis/Schmiesing JAXB 2.0 Ein Programmiertutorial für die Java Architecture for XML Binding              
  2. 2. Samuel Michaelis Wolfgang Schmiesing JAXB 2.0 Ein Programmiertutorial für die Java Architecture for XML Binding
  3. 3. Die Autoren: Samuel Michaelis, Software-Architekt Wolfgang Schmiesing, Berater und Projektleiter Beide Autoren sind für die Innovations Softwaretechnologie GmbH in Immenstaad tätig. Alle in diesem Buch enthaltenen Informationen, Verfahren und Darstellungen wurden nach bestem Wissen zusammengestellt und mit Sorgfalt getestet. Dennoch sind Fehler nicht ganz auszuschließen. Aus diesem Grund sind die im vorliegenden Buch enthaltenen Informationen mit keiner Verpflich- tung oder Garantie irgendeiner Art verbunden. Autoren und Verlag übernehmen infolgedessen keine juristische Verantwortung und werden keine daraus folgende oder sonstige Haftung übernehmen, die auf irgendeine Art aus der Benutzung dieser Informationen – oder Teilen davon – entsteht. Ebenso übernehmen Autoren und Verlag keine Gewähr dafür, dass beschriebene Verfahren usw. frei von Schutzrechten Dritter sind. Die Wiedergabe von Gebrauchsnamen, Handelsnamen, Warenbe- zeichnungen usw. in diesem Buch berechtigt deshalb auch ohne besondere Kennzeichnung nicht zu der Annahme, dass solche Namen im Sinne der Warenzeichen- und Markenschutz-Gesetzgebung als frei zu betrachten wären und daher von jedermann benutzt werden dürften. Bibliografische Information Der Deutschen Nationalbibliothek Die Deutsche Nationalbibliothek verzeichnet diese Publikation in der Deutschen Nationalbibliografie; detaillierte bibliografische Daten sind im Internet über http://dnb.d-nb.de abrufbar. Dieses Werk ist urheberrechtlich geschützt. Alle Rechte, auch die der Übersetzung, des Nachdruckes und der Vervielfältigung des Buches, oder Teilen daraus, vorbehalten. Kein Teil des Werkes darf ohne schriftliche Genehmigung des Verlages in irgendeiner Form (Fotokopie, Mikrofilm oder ein anderes Verfahren) – auch nicht für Zwecke der Unterrichtsgestaltung – reproduziert oder unter Verwendung elektronischer Systeme verarbeitet, ver- vielfältigt oder verbreitet werden. © 2007 Carl Hanser Verlag München Wien Lektorat: Fernando Schneider Sprachlektorat: Sandra Gottmann, Münster-Nienberge Herstellung: Monika Kraus Umschlagdesign: Marc Müller-Bremer, Rebranding, München Umschlaggestaltung: MCP · Susanne Kraus GbR, Holzkirchen Datenbelichtung, Druck und Bindung: Kösel, Krugzell Ausstattung patentrechtlich geschützt. Kösel FD 351, Patent-Nr. 0748702 Printed in Germany ISBN-10: 3-446-40753-7 ISBN-13: 978-3-446-40753-4 www.hanser.de/computer
  4. 4. 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
  5. 5. 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
  6. 6. 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
  7. 7. 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
  8. 8. Inhalt 7.3 schemaGen-Kommandozeilenbefehl ................................................................................... 303 7.4 schemaGen-ANT-Task........................................................................................................ 304 7.5 JAXB-Annotationen............................................................................................................ 306 7.5.1 XmlAccessorOrder ................................................................................................ 306 7.5.2 XmlAccessorType ................................................................................................. 307 7.5.3 XmlAnyAttribute................................................................................................... 311 7.5.4 XmlAnyElement .................................................................................................... 312 7.5.5 XmlAttachmentRef................................................................................................ 314 7.5.6 XmlAttribute.......................................................................................................... 314 7.5.7 XmlElement........................................................................................................... 316 7.5.8 XmlElementDecl ................................................................................................... 318 7.5.9 XmlElementRef ..................................................................................................... 320 7.5.10 XmlElementRefs.................................................................................................... 321 7.5.11 XmlElements ......................................................................................................... 323 7.5.12 XmlElementWrapper ............................................................................................. 324 7.5.13 XmlEnum .............................................................................................................. 325 7.5.14 XmlEnumValue ..................................................................................................... 326 7.5.15 XmlID.................................................................................................................... 327 7.5.16 XmlIDREF............................................................................................................. 328 7.5.17 XmlInlineBinaryData............................................................................................. 330 7.5.18 XmlList.................................................................................................................. 330 7.5.19 XmlJavaTypeAdapter ............................................................................................ 331 7.5.20 XmlJavaTypeAdapters........................................................................................... 332 7.5.21 XmlMimeType ...................................................................................................... 333 7.5.22 XmlMixed.............................................................................................................. 333 7.5.23 XmlNs.................................................................................................................... 334 7.5.24 XmlRegistry........................................................................................................... 334 7.5.25 XmlRootElement ................................................................................................... 335 7.5.26 XmlSchema ........................................................................................................... 336 7.5.27 XmlSchemaType ................................................................................................... 338 7.5.28 XmlSchemaTypes.................................................................................................. 339 7.5.29 XmlTransient ......................................................................................................... 340 7.5.30 XmlType................................................................................................................ 341 7.5.31 XmlValue............................................................................................................... 342 7.6 Typkonversionen Java zu XML-Schema............................................................................. 343 7.7 Typkonversionen XML-Schema zu Java............................................................................. 345 7.8 XML-Elemente der Bindungskonfiguration ........................................................................ 346 7.8.1 Globale Einstellungen............................................................................................ 346 7.8.2 Schemaspezifische Einstellungen .......................................................................... 359 7.8.3 Komponentenspezifische Einstellungen ................................................................ 363 Register............................................................................................................................ 381 IX
  9. 9. 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
  10. 10. 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
  11. 11. 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
  12. 12. 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
  13. 13. 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
  14. 14. 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
  15. 15. 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
  16. 16. 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
  17. 17. 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
  18. 18. 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
  19. 19. 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
  20. 20. 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
  21. 21. 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
  22. 22. 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
  23. 23. 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
  24. 24. 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
  25. 25. 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
  26. 26. 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
  27. 27. 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
  28. 28. 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
  29. 29. 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
  30. 30. 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
  31. 31. 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
  32. 32. 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
  33. 33. 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

×