JAXB 2.0 (eBook)

Ein Programmiertutorial für die Java Architecture for XML Binding

Samuel Michaelis, Wolfgang Schmiesing (Autoren)

eBook Download: PDF

2006 | 1. Auflage
399 Seiten
Carl Hanser Fachbuchverlag
978-3-446-40915-6 (ISBN)

Infos

XML hat sich als universelles Format zur Speicherung und Verarbeitung von Daten etabliert. Zusammen mit Java ergibt sich eine Paarung mit einem großen Vorteil für die Datenverarbeitung - beide Technologien sind plattformunabhängig.



Doch jede zu verarbeitende XML-Datei muss erst in ein Java-Datenmodell umgewandelt werden. Das kann man mit der JAXP API jedes Mal aufwändig per Hand programmieren - oder per JAXB (Java API for XML Binding) automatisch generieren.



Einziger Wermutstropfen: Die Einarbeitung in JAXB ist recht aufwändig. Genau hierbei unterstützt das vorliegende Buch den Entwickler. Die Einführung vermittelt alle unmittelbar für das Verständnis von JAXB notwendigen Konzepte von XML Schema und behandelt typische Probleme, die bei der Umwandlung von XML-Datenmodellen in Java-Datenmodelle auftreten, und liefert die passenden Lösungen.



Der Hauptteil ist ein umfassendes JAXB-Programmiertutorial. Von der XML-Variante des "Hallo-Welt"-Beispiels ausgehend werden alle Aspekte der JAXB behandelt. Die letzten Beispiele geben schließlich Denkanstösse, wo überall die JAXB sinnvoll verwendet werden kann - neu-deutsch "JAXB Best Practice". Den Abschluss bildet eine JAXB-Kurzreferenz.



Die Autoren



Samuel Michaelis ist Software-Architekt, Wolfgang Schmiesing Berater und Projektleiter. Beide Autoren sind für die Innovations Softwaretechnologie GmbH in Immenstaad tätig. 

Inhalt

Inhalt 5
Vorwort 11
Java Architecture for XML Binding 2.0 11
Technologieeinführung 12
Programmiertutorials 12
Referenz 12
Feedback 13
1 JAXB im Überblick 15
1.1 Ziele 15
1.2 Entstehung 18
1.3 Architektur 19
1.3.1 Annotationen 21
1.3.2 Der Schema-Compiler 22
1.3.3 Der Schema-Generator 23
1.3.4 Das Binding Framework 24
1.4 1.0 + 1.0 = 2.0? 28
2 Basistechnologien 31
2.1 XML-Schema 31
2.1.1 Namespaces verwenden 35
2.1.2 Elementdeklarationen in XML-Schema 38
2.1.3 Vererbung 49
2.1.4 Kardinalitäten 51
2.1.5 Offene Schemas definieren 52
2.1.6 Namespaces importieren und referenzieren 54
2.1.7 Eindeutigkeit durch ID und IDREF 57
2.1.8 Dokumentation mit Annotationen 59
2.1.9 Das fertige Beispielschema 60
2.2 XPath 62
2.2.1 Die XPath-Sicht auf XML 63
2.2.2 XPath-Ausdrücke verwenden 64
2.2.3 Beispiele 65
2.2.4 XPath in Java 67
2.3 ANT 69
2.3.1 ANT-Übersicht 69
2.3.2 Installation und Aufruf 70
2.3.3 Häufig verwendete Elemente 71
2.3.4 Benutzerdefinierte Tasks 72
2.3.5 xjc und schemaGen Tasks 72
2.3.6 Ein Beispiel 73
3 Hallo JAXB! 75
3.1 Systemvoraussetzungen 75
3.2 Die Entwicklungsumgebung einrichten 76
3.2.1 JAXB-Referenzimplementierung installieren 76
3.2.2 Die JAXB-Bibliotheken einbinden 76
3.2.3 Die Struktur des Beispielprojekts 77
3.3 Am Anfang steht immer: Hallo Welt! 78
3.3.1 Der Weg von Java zu XML 78
3.3.2 Der Weg von XML zu Java 81
3.4 Zusammenfassung 83
4 JAXB-API 85
4.1 Die ersten Schritte 86
4.1.1 Am Anfang war der JAXBContext 86
4.1.2 Die Klasse JAXBIntrospector verwenden 89
4.1.3 Objekte erzeugen mit der ObjectFactory 91
4.1.4 Zusammenfassung 92
4.2 Marshalling 93
4.2.1 Das Marshaller-Objekt anlegen 93
4.2.2 Den Marshalling-Prozess starten 94
4.2.3 Den Marshalling-Prozess konfigurieren 95
4.2.4 Das fertige Beispiel 97
4.2.5 Marshalling beliebiger Objekte 99
4.2.6 Zusammenfassung 100
4.3 Unmarshalling 101
4.3.1 Das Unmarshaller-Objekt anlegen 101
4.3.2 Den Unmarshalling-Prozess starten 102
4.3.3 Den Unmarshalling-Prozess konfigurieren 103
4.3.4 Das fertige Beispiel 103
4.3.5 Das xsi:type- Attribut beim Unmarshalling verwenden 104
4.3.6 Elemente ohne @XMLRootElement verarbeiten 105
4.3.7 Unmarshalling von Teilen eines XML-Dokuments 107
4.3.8 Flexibles Unmarshalling nutzen 109
4.3.9 Zusammenfassung 111
4.4 Validierung 111
4.4.1 Beim Unmarshalling validieren 112
4.4.2 Beim Marshalling validieren 113
4.4.3 Benutzerdefinierte Validierung 115
4.4.4 Zusammenfassung 121
4.5 Callback-Mechanismen einsetzen 121
4.5.1 Die Listener-Klasse verwenden 122
4.5.2 Callback-Methoden auf Klassenebene definieren 124
4.5.3 Zusammenfassung 126
4.6 Die Binder-Komponente verwenden 126
4.6.1 Eine DOM-Sicht erstellen 127
4.6.2 Die Klasse javax.xml.bind.Binder 127
4.6.3 Transformation mit unmarshal und marshal 128
4.6.4 Navigation mit getXMLNode und getJAXBNode 129
4.6.5 Synchronisation mit updateXML und updateJAXB 130
4.6.6 Konkrete Anwendungsfälle 131
4.6.7 Zusammenfassung 137
5 XML-Schema zu Java 139
5.1 Bindungskonfigurationen 139
5.1.1 Eine Bindungskonfiguration definieren 140
5.1.2 Bindungskonfigurationen per xjc-Task einbinden 144
5.1.3 Den XJC-Schema-Compiler programmatisch starten 144
5.1.4 Externe Bindungskonfigurationen auf der Kommandozeile 148
5.1.5 Ein Wort zu Versionen 148
5.1.6 Der Sichtbarkeitsbereich 148
5.1.7 Zusammenfassung 149
5.2 Die erste Bindungskonfiguration 150
5.2.1 Zusammenfassung 152
5.3 Fünf Bindungsdeklarationen für den Alltag 152
5.3.1 Aufzählungen anpassen mit jaxb:collectionType 152
5.3.2 Paketnamen anpassen mit jaxb:package 154
5.3.3 Generierte Klassen anpassen mit jaxb:class 156
5.3.4 Änderungen auf Komponentenebene mit jaxb:property 159
5.3.5 Dokumentieren mit jaxb:javadoc 166
5.3.6 Zusammenfassung 169
5.4 XML-Bezeichner anpassen 169
5.4.1 Einzelne Namenskonflikte auflösen 170
5.4.2 Präfixe und Suffixe mit jaxb:nameXmlTransform 171
5.4.3 Unterstriche verarbeiten mit jaxb:underScoreBinding 173
5.4.4 Bezeichner in Enumerationen 174
5.4.5 Verwenden von Java-Schlüsselwörtern als Bezeichner 180
5.4.6 Java-Namenskonventionen 182
5.4.7 Zusammenfassung 182
5.5 Datentypen anpassen 182
5.5.1 Datentypen explizit angeben mit jaxb:baseType 183
5.5.2 Datentypen konvertieren mit jaxb:javaType 187
5.5.3 Zusammenfassung 195
5.6 Deklarationen überlagern 196
5.7 Noch mehr Bindungsdeklarationen 199
5.7.1 Ableiten von einer Oberklasse mit xjc:superClass 200
5.7.2 Ein Wurzelinterface angeben mit xjc:superInterface 201
5.7.3 Erweiterung von jaxb:javaType mit xjc:javaType 203
5.7.4 Das Experiment: xjc:simple 205
5.7.5 Zusammenfassung 206
6 Java zu XML-Schema 207
6.1 JAXBContext und JAXBElement ganz ohne Schema 208
6.2 Einfache Elementkonfigurationen 215
6.2.1 Wurzelelemente mit @XmlRootElement definieren 215
6.2.2 Der „Standardmodus“ 219
6.2.3 Abbildung als XML-Element explizit konfigurieren 224
6.2.4 Java-Eigenschaften an XML- Attribute binden 230
6.2.5 Java-Eigenschaften an XML-Elementinhalte binden 235
6.2.6 Bindung an XML unterdrücken 237
6.2.7 Reihenfolge der XML-Elemente beeinflussen 239
6.2.8 Namen und Verschachtelung des XML-Typs einstellen 244
6.2.9 XML-Elemente referenzieren 248
6.2.10 Namespace konfigurieren 251
6.3 Listen und Elementmischungen 257
6.3.1 Der „Standardmodus“ für Java- Arrays und Java-Listen 258
6.3.2 Listen und Arrays an simpleType/list-Deklarationen binden 263
6.3.3 Mehrere Elemente im gleichen Feld speichern 265
6.3.4 Elementlisten verpacken 277
6.3.5 Mischungen von Elementen und Text 280
6.4 Enumerationen 284
6.4.1 Enumerationen an XML binden: Standardverhalten 285
6.4.2 Bindung von Enumerationen konfigurieren 286
6.5 Eigene Typbindungen definieren 289
6.5.1 Basisdatentyp als Speicherdatentyp 291
6.5.2 Komplexe Datentypen als Speicherdatentypen 294
6.6 Unbekannte Attribut- und Elementwerte binden 298
6.6.1 Wildcard- Attribute mit @XmlAnyAttribute definieren 298
6.6.2 Wildcard-Elemente per @XmlAnyElement deklarieren 300
6.6.3 Lax fischen 302
6.7 Objektgraphen in XML abbilden 304
6.8 Elemente über Factory-Klassen definieren 309
7 JAXB-Referenz 313
7.1 XJC Kommandozeilenbefehl 313
7.2 XJC ANT-Task 315
7.3 schemaGen-Kommandozeilenbefehl 317
7.4 schemaGen- ANT- Task 318
7.5 JAXB- Annotationen 320
7.5.1 XmlAccessorOrder 320
7.5.2 XmlAccessorType 321
7.5.3 XmlAnyAttribute 325
7.5.4 XmlAnyElement 326
7.5.5 XmlAttachmentRef 328
7.5.6 XmlAttribute 328
7.5.7 XmlElement 330
7.5.8 XmlElementDecl 332
7.5.9 XmlElementRef 334
7.5.10 XmlElementRefs 335
7.5.11 XmlElements 337
7.5.12 XmlElementWrapper 338
7.5.13 XmlEnum 339
7.5.14 XmlEnumValue 340
7.5.15 XmlID 341
7.5.16 XmlIDREF 342
7.5.17 XmlInlineBinaryData 344
7.5.18 XmlList 344
7.5.19 XmlJavaTypeAdapter 345
7.5.20 XmlJavaTypeAdapters 346
7.5.21 XmlMimeType 347
7.5.22 XmlMixed 347
7.5.23 XmlNs 348
7.5.24 XmlRegistry 348
7.5.25 XmlRootElement 349
7.5.26 XmlSchema 350
7.5.27 XmlSchemaType 352
7.5.28 XmlSchemaTypes 353
7.5.29 XmlTransient 354
7.5.30 XmlType 355
7.5.31 XmlValue 356
7.6 Typkonversionen Java zu XML-Schema 357
7.7 Typkonversionen XML-Schema zu Java 359
7.8 XML-Elemente der Bindungskonfiguration 360
7.8.1 Globale Einstellungen 360
7.8.2 Schemaspezifische Einstellungen 373
7.8.3 Komponentenspezifische Einstellungen 377
Register 395

Textauszug

6 Java zu XML-Schema (S. 193)

Eine der großen Neuerungen der Version 5 von Java sind die Annotationen. Informationen zu Java-Elementen, die bisher nur in Kommentaren oder getrennten Dateien gespeichert wurden, können nun direkt im Java-Quelltext aufgenommen werden und sind mit den Mitteln der Reflection-API programmatisch verfügbar.

Nicht alle Entwickler haben diese Neuerung mit Begeisterung begrüßt – es ist abzusehen, dass tausendundeine API sich der Annotationen mehr oder weniger geschickt annehmen werden – und statt der ach so einfach verständlichen POJOs wird es vielleicht bald von MAJOs wimmeln, „Massively Annotated Java Objects". Die Version 2.0 der Java Architecture for XML Binding bedient sich ausgiebig der Annotationen und in diesem Fall, wie wir finden, auf verführerisch praktische Art und Weise. In den vorherigen Kapiteln war stets ein XML-Schema Gegenstand des Beispiels und wie man ein Java-Datenmodell daraus zaubern kann. In diesem Kapitel beschäftigen wir uns mit dem Rückweg, den Annotationen sei Dank, und zwar wie wir von einem Java- Datenmodell passendes XML erzeugen können, indem wir für die einzelnen Java- Elemente durch die entsprechenden JAXB-Annotationen definieren, wie das Element in XML abgebildet werden soll.

Dieser Weg zurück ist das Besondere der JAXB 2.0. Während in früheren Versionen das aus einem XML-Schema erzeugte Java-Datenmodell nicht mit sinnvollem Aufwand für ein anderes XML-Schema angepasst werden konnte, bemüht sich die Version 2.0 um eine bidirektionale Abbildung von XML-Schema auf Java. Diese Abbildung mag vielleicht noch nicht in jedem Fall astrein sein – funktioniert in der Regel aber erstaunlich gut, wie wir in den kommenden Abschnitten darstellen werden.

Nun unterscheiden sich Java und XML-Datenstrukturen erheblich voneinander. Wo in Java eine Java Bean-Eigenschaft definiert ist, kann im XML ein Attribut, ein Element oder ein verschachtelter Datentyp stehen. Während in Java die Reihenfolge der definierten Java Bean-Eigenschaften irrelevant ist, muss für XML die Reihenfolge von Unterelementen explizit festgelegt (oder freigelassen) werden. Daher ist es für viele Fälle notwendig, die gewünschte Abbildung zu konfigurieren.

Im vorigen Teil des Buches haben wir uns mit den Bindungskonfigurationen befasst, die unmittelbar an einem XML-Schema hängen und dort diese Konfigurationen vorhalten. Das folgende Kapitel wird sich nun mit den Konfigurationen beschäftigen, die wir per Annotationen an Klassen, Variablen und Methoden anfügen können, um so eine bestimmte Form der Abbildung von Java in ein XML-Format zu erzielen. Die Annotationen der JAXB stellen im Moment einen Großteil der in der Java 5 Core API definierten Annotationen dar. Die Annotationen sind im Paket javax. xml.bind.annotations zusammengefasst.

Aufbau des Kapitels

Nutzung der API ohne ein vorgegebenes Schema
Einfache Elementkonfigurationen
Elementlisten, Referenzen und Elementmischung
Enumerationen
Eigene Typbindungen definieren
Mit unbekannten XML-Elementen und Attributen arbeiten
Objektgraphen in XML abbilden
Elemente über Factory-Klassen definieren

Produkt-Details

• Erscheint lt. Verlag: 1.1.2006
• Sprache: deutsch
• Themenwelt: Informatik ► Programmiersprachen / -werkzeuge ► Java
• Themenwelt: Informatik ► Programmiersprachen / -werkzeuge ► XML
• Themenwelt: Mathematik / Informatik ► Informatik ► Web / Internet
• ISBN-10: 3-446-40915-7 / 3446409157
• ISBN-13: 978-3-446-40915-6 / 9783446409156