Java und XML - s3-eu-west-1.amazonaws.com · 8.2 JAX-WS besorgen und installieren ..... 511 8.3 Code-First – Webservices aus Java-Klassen generieren ... 512 8.3.1 Das Beispiel

Michael Scholz, Stephan Niedermeier

Java und XMLGrundlagen, Einsatz, Referenz

1308.book Seite 1 Montag, 7. September 2009 5:02 17

3

Auf einen Blick

1 XML ......................................................................... 17

2 XML mit Java – Grundbegriffe ................................. 73

3 DOM ........................................................................ 109

4 SAX .......................................................................... 173

5 JAXP ......................................................................... 215

6 StAX ......................................................................... 305

7 JAXB ......................................................................... 391

8 XML-Webservices mit JAX-WS ............................... 495

9 Publishing mit Java und XML .................................. 585

A Eclipse-Grundlagen .................................................. 627

B Apache Ant .............................................................. 645

C Properties und Features von SAX ............................ 665

D JAXB-Binding Compiler ........................................... 669

E Wichtige Quellen ..................................................... 683

F Buch-CD ................................................................... 689


5

Inhalt

Vorwort ........................................................................................ 15

1 XML ............................................................................ 17

1.1 Was ist XML? ................................................................ 171.2 Das XML-Dokument ..................................................... 18

1.2.1 XML-Namen .................................................. 191.2.2 Elemente ....................................................... 191.2.3 Attribute ........................................................ 201.2.4 Text ............................................................... 211.2.5 Kommentare .................................................. 221.2.6 XML-Deklaration ........................................... 231.2.7 Processing Instructions ................................... 241.2.8 Knoten und ihre Beziehungen zueinander ...... 251.2.9 Wohlgeformtheit ........................................... 261.2.10 XML-Parser .................................................... 27

1.3 Die Namensräume ........................................................ 271.4 XML beschränken mit DTD ........................................... 30

1.4.1 Ein einfaches Beispiel ..................................... 311.4.2 Elemente ....................................................... 321.4.3 Attribute ........................................................ 331.4.4 Entities .......................................................... 341.4.5 DTD einbinden .............................................. 35

1.5 XML beschränken mit XML Schema .............................. 371.5.1 Ein XML Schema referenzieren ....................... 381.5.2 Die XML-Schema-Datei ................................. 381.5.3 Definition von einfachen Typen ...................... 391.5.4 Definition von komplexen Typen .................... 411.5.5 Definition von Attributen ............................... 461.5.6 Definition von Elementen .............................. 471.5.7 Globale Definitionen und Referenzen ............. 471.5.8 XML Schema und Namensräume .................... 49

1.6 Navigieren mit XPath .................................................... 511.6.1 Knotentypen .................................................. 521.6.2 Lokalisierungspfad ......................................... 531.6.3 Prädikate ....................................................... 541.6.4 XPath-Funktionen .......................................... 561.6.5 Einsatzgebiete von XPath ............................... 57


6

Inhalt

1.7 XML transformieren mit XSLT ...................................... 571.7.1 Das XSLT-Stylesheet ...................................... 581.7.2 Wichtige XSLT-Instruktionen ......................... 61

1.8 XSL-FO ........................................................................ 631.8.1 Der Aufbau eines XSL-FO Dokuments ........... 631.8.2 XSL-FO und XSLT-Stylesheet ......................... 681.8.3 Der FO-Prozessor .......................................... 691.8.4 Ein kleines Beispiel ........................................ 70

1.9 Zusammenfassung ........................................................ 71

2 XML mit Java – Grundbegriffe ................................... 73

2.1 Parsen und Serialisieren ................................................ 742.1.1 Begriffsklärung ............................................... 742.1.2 Aufgaben von XML-Bibliotheken ................... 76

2.2 Validieren .................................................................... 762.3 Streambasierte Verarbeitung ........................................ 77

2.3.1 SAX ............................................................... 782.3.2 StAX .............................................................. 81

2.4 Modellbasierte Verarbeitung ........................................ 842.4.1 DOM ............................................................. 872.4.2 Binding .......................................................... 92

2.5 Navigieren mit XPath und Transformieren mit XSLT ..... 1002.6 APIs und Factories ....................................................... 101

2.6.1 APIs in der Java-Welt .................................... 1022.6.2 Probleme abstrakter APIs .............................. 1032.6.3 Die Lösung: Factories .................................... 1042.6.4 Einziges Problem: die Factory finden ............. 1052.6.5 Zusammenfassung ......................................... 106

2.7 Die Rolle von JAXP ...................................................... 1062.8 Zusammenfassung ........................................................ 108

3 DOM .......................................................................... 109

3.1 Einführungsbeispiel ...................................................... 1093.1.1 Öffnen des Beispiels ...................................... 1103.1.2 Beispiel 1: Parsen und Navigieren .................. 1123.1.3 Beispiel 2: Dokumente erzeugen, ändern und

serialisieren ................................................... 1223.1.4 Zusammenfassung ......................................... 129


7

Inhalt

3.2 Der Ausgangspunkt: die DOMImplementation ............. 1303.2.1 Features abfragen ........................................... 1313.2.2 Features abrufen ............................................ 1323.2.3 Dokument erzeugen ....................................... 1333.2.4 Erzeugen einer DOM-Implementierung .......... 1333.2.5 Zusammenfassung .......................................... 135

3.3 Das Objektmodell ......................................................... 1353.3.1 Knoten- und Hilfsinterfaces ............................ 1353.3.2 DOM-eigene Datenstrukturen für Listen und

Maps ............................................................. 1383.3.3 Node – die Basis aller Knoten-Interfaces ........ 1393.3.4 Document ...................................................... 1433.3.5 Element ......................................................... 1443.3.6 Attr ................................................................ 1463.3.7 Text, CDATASection und Comment ................ 1473.3.8 ProcessingInstruction ..................................... 1493.3.9 Sonstige Knoten-Interfaces ............................ 1493.3.10 Zusammenfassung .......................................... 150

3.4 Navigieren .................................................................... 1513.4.1 Allgemeine Navigationsfunktionen ................. 1523.4.2 Spezifische Navigationsfunktionen ................. 1533.4.3 Zusammenfassung .......................................... 155

3.5 Neue Knoten generieren ............................................... 1553.6 Modifizieren ................................................................. 1573.7 Dokumente parsen und serialisieren ............................. 159

3.7.1 Überblick ....................................................... 1593.7.2 Parsen ............................................................ 1603.7.3 Serialisieren ................................................... 1643.7.4 Zusammenfassung .......................................... 166

3.8 Namensräume .............................................................. 1663.8.1 Namensraum-URI, Präfix, lokaler Name und

qualifizierter Name ......................................... 1663.8.2 Zugriff auf Knoten über ihren Namen ............. 1683.8.3 Knoten in Namensräumen erzeugen ............... 1693.8.4 Manuelles Erzeugen von Präfix- und

Default-Namespace-Bindungen ...................... 1703.8.5 Zusammenfassung .......................................... 172

3.9 Alternative DOM-Implementierungen .......................... 172


8

Inhalt

4 SAX ............................................................................. 173

4.1 Einführungsbeispiel ...................................................... 1744.1.1 Öffnen des Beispiels ...................................... 1744.1.2 Das Beispiel starten ....................................... 1754.1.3 Das Hauptprogramm ..................................... 1754.1.4 Die Handler-Klasse – PersonHandler .............. 1774.1.5 Zusammenfassung ......................................... 183

4.2 Parsen .......................................................................... 1844.2.1 Parser-Instanz erzeugen ................................. 1854.2.2 Konfigurieren des XMLReaders ...................... 1864.2.3 Eingabedokument vorbereiten ....................... 1884.2.4 Starten des Parse-Vorgangs ........................... 1894.2.5 Zusammenfassung ......................................... 190

4.3 Handler ........................................................................ 1904.3.1 Den Dokumentinhalt abgreifen mit dem

ContentHandler ............................................. 1904.3.2 Erweiterte Inhaltsinformation abgreifen mit

dem LexicalHandler ....................................... 1984.3.3 Zugriff auf DTD-Inhalte mit dem DTDHandler

und dem DeclHandler ................................... 1994.3.4 Fehlerbehandlung mit dem ErrorHandler ....... 2014.3.5 Verweise auflösen mit dem EntityResolver ..... 2024.3.6 Hilfsklassen zur Erstellung von Handler-

Klassen .......................................................... 2044.3.7 Zusammenfassung ......................................... 206

4.4 Filter und Pipelines ...................................................... 2064.5 Ein Wort zu SAX 1 ....................................................... 2134.6 Zusammenfassung ........................................................ 214

5 JAXP ........................................................................... 215

5.1 Aufbau und Installation von JAXP ................................ 2165.1.1 Die Package-Struktur von JAXP ..................... 2165.1.2 JAXP-Versionen und die JAXP-

Referenzimplementierung .............................. 2165.2 Grundlegende Klassen und Mechanismen .................... 218

5.2.1 Die Klasse QName ......................................... 2185.2.2 Der Factory-Mechanismus von JAXP .............. 219

5.3 Einstieg in die SAX-API ................................................ 2215.3.1 Einführungsbeispiel ....................................... 222


9

Inhalt

5.3.2 Der Ausgangspunkt: die SAXParserFactory ..... 2255.3.3 Die Parser-Implementierung: der SAXParser ... 2295.3.4 Zusammenfassung .......................................... 231

5.4 Einstieg in die DOM-API .............................................. 2315.4.1 Einführungsbeispiel ........................................ 2325.4.2 Der Ausgangspunkt: die

DocumentBuilderFactory ............................... 2355.4.3 Dokumente parsen und generieren mit dem

DocumentBuilder ........................................... 2405.4.4 Zusammenfassung .......................................... 243

5.5 Dokumente transformieren ........................................... 2435.5.1 Einführungsbeispiel ........................................ 2445.5.2 Der Ausgangspunkt: die TransformerFactory ... 2485.5.3 Transformationen durchführen mit dem

Transformer ................................................... 2525.5.4 Transformationsquellen .................................. 2575.5.5 Transformationsergebnisse ............................. 2625.5.6 SAX-Erweiterungen ........................................ 2655.5.7 Zusammenfassung .......................................... 271

5.6 Dokumente validieren .................................................. 2715.6.1 Validierung mit klassischen Mitteln ................ 2725.6.2 Schnelleinstig in die neue Validation-API ....... 2745.6.3 Der Ausgangpunkt: die SchemaFactory .......... 2775.6.4 Schemainformationen wiederverwenden

mit dem Schema-Objekt ................................ 2815.6.5 Validierungen durchführen mit dem Validator 2825.6.6 Validierung von Dokumenten, die als

SAX-Events vorliegen ..................................... 2845.6.7 Zusammenfassung .......................................... 286

5.7 Navigieren in Dokumenten ........................................... 2865.7.1 Einführungsbeispiel ........................................ 2875.7.2 Der Ausgangspunkt: die XPathFactory ............ 2905.7.3 XPath-Ausdrücke auswerten mit dem

XPath-Objekt ................................................. 2955.7.4 Alternative XPath-Implementierungen ........... 3015.7.5 Zusammenfassung .......................................... 301

5.8 Dokumente serialisieren ............................................... 3025.9 Zusammenfassung ......................................................... 303


10

Inhalt

6 StAX ........................................................................... 305

6.1 StAX besorgen und installieren ..................................... 3056.1.1 StAX und Java 6 ............................................ 3066.1.2 StAX und ältere Java-Versionen ..................... 3066.1.3 Die StAX-Referenzimplementierung .............. 307

6.2 Der Factory-Mechanismus von StAX ............................ 3076.3 Die API-Varianten von StAX ......................................... 307

6.3.1 Die Cursor-API .............................................. 3086.3.2 Die Event-Iterator-API ................................... 3096.3.3 Zusammenfassung ......................................... 311

6.4 Einführungsbeispiel ...................................................... 3116.4.1 Öffnen des Beispiels ...................................... 3126.4.2 Parsen ........................................................... 3146.4.3 Serialisieren ................................................... 3266.4.4 Wie geht es weiter? ....................................... 335

6.5 Der Ausgangspunkt: Die Factory-Klassen ...................... 3366.5.1 Erzeugen von Parsern mit der

XMLInputFactory .......................................... 3376.5.2 Erzeugen von Serializern mit der

XMLOutputFactory ........................................ 3436.5.3 Bausteininstanzen erzeugen mit der

XMLEventFactory .......................................... 3446.6 Die Cursor-API im Detail .............................................. 346

6.6.1 Parsen mit der Cursor-API über den XMLStreamReader ......................................... 346

6.6.2 Serialisieren mit der Cursor-API über den XMLStreamWriter ......................................... 362

6.7 Die Event-Iterator-API im Detail .................................. 3716.7.1 Die Baustein-Interfaces .................................. 3726.7.2 Parsen mit der Event-Iterator-API über den

XMLEventReader ........................................... 3856.7.3 Serialisieren mit der Event-Iterator-API über

den XMLEventReader .................................... 3876.8 Zusammenfassung ........................................................ 389

7 JAXB ........................................................................... 391

7.1 XML-Binding mit JAXB ................................................. 3917.1.1 XML-Binding – ein Rückblick ......................... 3917.1.2 Vorstellung von JAXB .................................... 392


11

Inhalt

7.2 Einführungsbeispiel ....................................................... 3957.2.1 Öffnen des Beispiels ....................................... 3967.2.2 Generierung von Modellklassen mit dem XJC-

Binding Compiler ........................................... 3977.2.3 Die Compiler-Ausgabe und die Abbildungs-

regeln ............................................................ 3997.2.4 Die Anwendung und die JAXB-API ................. 4027.2.5 Generierung eines Schemas mit dem Schema-

Gen Binding Compiler .................................... 4107.3 Abbildung von XML nach Java ...................................... 413

7.3.1 Standardregeln, Binding Declarations und Mapping Annotations .................................... 414

7.3.2 Das Standardverhalten anhand eines Beispiels 4167.3.3 Konvertierung von Namen ............................. 4177.3.4 Komplexe Typen – ComplexTypes .................. 4187.3.5 Einfache Typen – SimpleTypes ........................ 4287.3.6 Typ-Binding auf einen Blick ............................ 4357.3.7 ObjectFactory ................................................ 4357.3.8 Binding Declarations ...................................... 436

7.4 Abbildung von Java nach XML ...................................... 4417.4.1 Konvertierung von Namen ............................. 4427.4.2 Das Standardverhalten anhand eines Beispiels 4437.4.3 Klassen .......................................................... 4457.4.4 Primitive Typen und Standard-Java-Typen ...... 4477.4.5 Enum-Typen .................................................. 4487.4.6 Collection-Typen und eindimensionale Arrays 4497.4.7 Maps ............................................................. 4507.4.8 Mehrdimensionale Arrays ............................... 4527.4.9 Mapping Annotations .................................... 4557.4.10 Sonstige Aufgaben ......................................... 459

7.5 Die JAXB-API ................................................................ 4627.5.1 Package-Überblick ......................................... 4637.5.2 Der Ausgangspunkt: JAXBContext .................. 4647.5.3 Unmarshalling ................................................ 4677.5.4 Marshalling .................................................... 4737.5.5 Binden an ein XML-Objektmodell mit dem

Binder ............................................................ 4777.5.6 Validierung .................................................... 4867.5.7 Exception-Klassen .......................................... 4907.5.8 Nützliche Hilfsklassen ..................................... 491

7.6 Zusammenfassung ......................................................... 493


12

Inhalt

8 XML-Webservices mit JAX-WS ................................. 495

8.1 Webservices – eine Einführung ..................................... 4968.1.1 Was sind eigentlich Webservices? .................. 4968.1.2 Webservices vs. andere Technologien ............ 4988.1.3 SOAP und die Rolle von XML ........................ 4988.1.4 Webservices und XML-Binding ...................... 5008.1.5 Webservices beschreiben mit WSDL .............. 5008.1.6 Aufbau eines WSDL-Dokuments .................... 5018.1.7 Contract-First oder Code-First? ...................... 5088.1.8 Kompatibilität von Webservices .................... 5108.1.9 Zusammenfassung ......................................... 511

8.2 JAX-WS besorgen und installieren ................................ 5118.3 Code-First – Webservices aus Java-Klassen generieren ... 512

8.3.1 Das Beispiel ................................................... 5138.3.2 Die Vorgehensweise ...................................... 5148.3.3 Die Service-Klasse schreiben .......................... 5158.3.4 Hilfsklassen generieren .................................. 5278.3.5 Testbetrieb .................................................... 5318.3.6 Deployment in einem Application Server ....... 5368.3.7 Die Ansätze kombinieren: Contract-First mit

Code-First-Mitteln ......................................... 5398.3.8 Zusammenfassung ......................................... 541

8.4 Contract-First – Das WSDL-Dokument als Ausgangspunkt ............................................................. 5428.4.1 Das Beispiel ................................................... 5438.4.2 Die Vorgehensweise ...................................... 5438.4.3 Das WSDL-Dokument erstellen ..................... 5458.4.4 Service-Interface und Binding-Klassen

generieren ..................................................... 5568.4.5 Service-Interface implementieren .................. 5628.4.6 Testbetrieb .................................................... 5648.4.7 Deployment in einem Application Server ....... 5668.4.8 Zusammenfassung ......................................... 567

8.5 Webservice-Clients erstellen ........................................ 5688.5.1 Verwandtschaft zwischen Server- und

Client-Betrieb ................................................ 5688.5.2 Die Vorgehensweise ...................................... 5698.5.3 Service-Interface, Binding-Klassen und

Client generieren ........................................... 569


13

Inhalt

8.5.4 Die Aufruf- und Verarbeitungslogik implementieren .............................................. 572

8.5.5 Zusammenfassung .......................................... 5788.6 Ausblick ........................................................................ 578

8.6.1 JAX-WS-Dokumentation ................................ 5798.6.2 JAX-WS-Beispiele .......................................... 5818.6.3 Alternative Implementierungen: Apache Axis2

und Apache CXF ............................................ 5828.6.4 Zusammenfassung .......................................... 583

9 Publishing mit Java und XML .................................... 585

9.1 Grundbegriffe ............................................................... 5859.2 XML-Publishing-Frameworks ........................................ 5879.3 Apache Cocoon ............................................................ 588

9.3.1 Grundsätzliches zu Cocoon ............................ 5909.3.2 Maven 2 ........................................................ 5929.3.3 Cocoon-Block erstellen .................................. 5939.3.4 Cocoon-Block starten ..................................... 5969.3.5 Cocoon-Block in Eclipse importieren .............. 5969.3.6 Cocoon-Block deployen ................................. 5979.3.7 Die Sitemap ................................................... 5989.3.8 Die Pipeline ................................................... 6009.3.9 Registrieren einer Sitemap-Komponente ........ 6029.3.10 Verwenden einer Sitemap-Komponente ......... 6049.3.11 Sitemap-Komponente: Matcher ..................... 6059.3.12 Sitemap-Komponente: Generator ................... 6109.3.13 Sitemap-Komponente: Transformer ................ 6129.3.14 Sitemap-Komponente: Serializer .................... 6149.3.15 Sitemap-Komponente: Reader ....................... 6159.3.16 Ein kleines Beispiel ......................................... 6179.3.17 Zusammenfassung .......................................... 623

Anhang ............................................................................ 625

A Eclipse-Grundlagen ................................................................. 627A.1 Eclipse installieren ........................................................ 627A.2 Erste Gehversuche ........................................................ 628

A.2.1 Eclipse starten ................................................ 628A.2.2 Einen Workspace anlegen .............................. 629


14

Inhalt

A.2.3 Die Oberfläche: Menüs, Symbolleisten, Views und Perspectives ................................. 629

A.3 Java-Installationen einbinden ....................................... 632A.3.1 Öffnen des Konfigurationsdialogs .................. 632A.3.2 Neue Installation hinzufügen ......................... 633

A.4 Projekte ....................................................................... 634A.4.1 Importieren von Projekten ............................. 634A.4.2 Aufbau von Java-Projekten ............................ 635A.4.3 Dateien editieren ........................................... 637A.4.4 Projekte öffnen und schließen ....................... 639

A.5 Programme starten ....................................................... 639A.5.1 Starten über den Package Explorer ................ 639A.5.2 Start über den Editor oder die Outline-View ... 640A.5.3 Run Configurations ........................................ 640A.5.4 Ant-Scripts starten ......................................... 643

B Apache Ant ............................................................................ 645B.1 Ant besorgen und installieren ....................................... 646

B.1.1 Ant in der IDE ............................................... 646B.1.2 Ant separat installieren .................................. 646

B.2 Erstellen und Ausführen von Ant-Scripts ...................... 647B.2.1 Ein erstes Beispiel .......................................... 647B.2.2 Weitere Ant-Tasks ......................................... 649B.2.3 Target-Abhängigkeiten .................................. 651B.2.4 Dateimengen ................................................. 653B.2.5 Properties ...................................................... 655

B.3 Externe Tasks einbinden ............................................... 660B.3.1 Ein kleines Beispiel ........................................ 662

B.4 Zusammenfassung ........................................................ 663C Properties und Features von SAX ............................................ 665

C.1 Wichtige Standard-Properties ....................................... 665C.2 Wichtige Standard-Features ......................................... 666

D JAXB-Binding Compiler ........................................................... 669D.1 Der XJC Binding Compiler ............................................ 669D.2 Der SchemaGen Binding Compiler ................................ 677

E Wichtige Quellen .................................................................... 683F Buch-CD ................................................................................. 689

Index ........................................................................................... 691


391

In diesem Kapitel lernen Sie eine fortgeschrittene API kennen, die XML-Dokumente auf einer höheren Abstraktionsebene ver-arbeitet. Es handelt sich dabei um das Konzept des XML-Bin-dings, das eine einfache Möglichkeit bietet, aus XML-Dokumen-ten Java-Objekte zu erzeugen, und für das die JAXB-Spezifikation eine standardisierte Architektur beschreibt.

7 JAXB

In Kapitel 2, »XML mit Java – Grundbegriffe«, haben Sie ja bereits sehrausführlich erfahren, was sich hinter dem Begriff XML-Binding verbirgt,nämlich die Verarbeitung von XML-Dokumenten mit speziell auf dieGrammatik abgestimmten Objektmodellen. In diesem Kapitel stellen wirIhnen nun die Technologie JAXB 2.0 vor, die im Java-Umfeld inzwi-schen als Standard für XML-Binding gilt und auch in fortgeschrittenerenTechnologien wie JAX-WS (siehe Kapitel 8, »XML-Webservices mit JAX-WS«) Verwendung findet.

7.1 XML-Binding mit JAXB

Als Erstes wollen wir Ihnen noch einmal kurz ins Gedächtnis rufen, wasXML-Binding ist und wofür man es einsetzt, und Ihnen danach JAXBgrundlegend vorstellen.

7.1.1 XML-Binding – ein Rückblick

Zunächst noch einmal ein kleiner Rückblick auf Abschnitt 2.4.2 XML-Binding erspart Ihnen in zwei Fällen eine Menge Arbeit:

� Sie haben eine bestehende XML-Grammatik und wollen auf einfacheWeise Dokumente zu dieser Grammatik in Ihrer Anwendung verar-beiten.

� Sie haben ein bestehendes Objektmodell und möchten daraus auf ein-fache Weise XML-Daten erzeugen, um sie beispielsweise an eineandere Anwendung weiterzugeben.


392

JAXB7

Um eines dieser beiden Ziele zu erreichen, müssen Sie bei XML-Bindingimmer in zwei Schritten vorgehen. Erst müssen Sie mit dem sogenanntenBinding Compiler

� Klassen aus der bestehenden Grammatik oder

� eine Grammatik aus den bestehenden Klassen

generieren. Dies ist jedoch nur einmal zur Entwicklungszeit notwendig.Danach können Sie nun im zweiten Schritt mit ein paar wenigen Hand-griffen zur Programmlaufzeit Daten von der einen Welt in die anderekonvertieren. XML-Binding erspart Ihnen also

� das manuelle Erstellen von Modellklassen oder Grammatik und

� das Schreiben der Parse- und Serialisierungslogik.

Wann sollten Sie XML-Binding verwenden?

XML-Binding eignet sich damit für datengetriebene Anwendungen, alsosolche, bei denen hauptsächlich Daten über XML persistiert oder ausge-tauscht werden sollen. Da es sich aber auch hier – wie bei DOM – umeinen Objektmodell-Ansatz handelt, wird immer das ganze Dokument inden Speicher gelesen, was Speicher und Performance verbraucht. Fürressourcenschonende Verarbeitung ist immer noch SAX und StAX derVerzug zu geben.

7.1.2 Vorstellung von JAXB

JAXB steht für Java Architecture for XML Binding, ist also schon vomNamen her eine XML-Binding-Architektur für Java. Wie wir aber schonangedeutet haben, ist sie nicht die einzige ihrer Art im Java-Umfeld, dochwie schon JAXP zeichnet sie sich dadurch aus, fester Bestandteil des JDK(ab Version 6.0) und damit gängiger Standard zu sein.

Spezifikationund API

Wie auch JAXP oder StAX ist JAXB innerhalb einer Spezifikation defi-niert, die aus einer Sammlung von Klassen und Interfaces (der API) unddem Spezifikationsdokument besteht. Dieses Dokument ist mit seinenüber 300 Seiten (in der Version 2.0) bei JAXB sehr ausführlich gehalten.

XML Schemaund beidseitige

BindingCompilation

Die Spezifikation schreibt einer Implementierung vor, mindestens mitGrammatiken vom Typ XML Schema umgehen zu können und BindingCompilation in beiden Richtungen zu unterstützen, also sowohl dasGenerieren von Java-Klassen aus einem Schema als auch den umgekehr-ten Weg. Das Unterstützen anderer Grammatiken wird durch die Spezi-fikation nicht grundlegend untersagt, weshalb es durchaus Implementie-


393

XML-Binding mit JAXB 7.1

rungen geben darf, die beispielsweise RelaxNG oder DTD als Grammatikunterstützen.

JAXB 2.0Wir werden in diesem Kapitel auf die aktuelle Version 2.0 der JAXB-Spe-zifikation eingehen, die allerdings nur mit der Java-Version 5.0 oderhöher kompatibel ist, da sie intensiv auf dort neu hinzugekommenenStandards, wie Generics, Annotations und JAXP 1.3, aufsetzt. Eine engeZusammenarbeit mit StAX ist übrigens auch gegeben. Ab Java-Version6.0 ist JAXB 2.0 ebenfalls fester Bestandteil des JDK und ab Version 5auch Teil der Java EE.

Eine API, mehrere Implementierungen

Wie eben beschrieben, verfolgt JAXB prinzipiell denselben Ansatz wiedie bisher vorgestellten APIs, nämlich, dass einerseits durch eine Samm-lung von Interfaces und Klassen ein allgemeiner Programmierrahmenvorgegeben wird, mit dem der Entwickler arbeitet, und dass andererseitsdafür theoretisch mehrere Implementierungen existieren können, diebeliebig austauschbar sind. Aufgaben wie das Konfigurieren und Erzeu-gen von Marshallern und Unmarshallern, das Durchführen der entspre-chenden Umwandlungsvorgänge oder das Validieren sind dabei durchdie API genau geregelt, nicht jedoch die Art und Weise der Realisierungder Binding-Compiler-Komponente. Deshalb wird diese im Regelfall alsspezifisches Tool zusammen mit der jeweiligen Implementierung ausge-liefert.

Referenz-implementierung

In diesem Buch arbeiten wir mit der JAXB-Referenzimplementierungvon der Firma Sun. Sie wurde entwickelt im Rahmen des Open-Source-Application-Server-Projekts »Glassfish« und lässt funktionstechnischkeine Wünsche offen, weshalb Sie sie guten Gewissens in produktivenUmgebungen einsetzen können. Sie erhalten sie in den folgenden Vari-anten, die Sie auch alle auf der Buch-CD finden:

JAXB 2.1

Inzwischen gibt es bereits eine JAXB-Spezifikation in der Version 2.1, diejedoch als kleines »Maintenance Release« beschrieben wird und gegenüberden in diesem Buch erwähnten Features keine Änderungen bringt. Wir wer-den deswegen weiterhin von JAXB 2.0 sprechen, ohne uns über die Unter-version Gedanken zu machen.

Wenn Sie noch mit älteren Java-Versionen arbeiten, können Sie nur die alteJAXB-Version 1.0 einsetzen, die sich allerdings in einigen Punkten von deraktuellen unterscheidet. In jedem Fall würden wir Ihnen – falls möglich – denGebrauch von JAXB 2.0 empfehlen, da sich hier einige wesentliche Vereinfa-chungen ergeben haben.


394

JAXB7

� Standalone-Version

� Teil des Java SDK ab Version 6.0

Wir werden nun kurz auf beide Varianten etwas näher eingehen.

Die Standalone-Version von JAXB

Die Standalone-Version von JAXB sollten Sie nutzen, wenn Sie nichtüber das Java SDK 6.0 verfügen und nicht mit einem Java-EE-5-kompa-tiblen Application Server arbeiten. Sie erhalten sie als JAR-Datei auf derBuch-CD oder unter der URL https://jaxb.dev.java.net. Ähnlich wie beiStAX müssen Sie diese JAR-Datei mit Java ausführen (über java -jar<Dateiname>) und im sich öffnenden Fenster die Lizenzbedingungenakzeptieren, bevor sich das Archiv selbst im aktuellen Ordner entpackt.Wenn Sie dies erledigt haben, finden Sie im erzeugten Verzeichnis die inTabelle 7.1 aufgeführten Unterordner:

JAXB im Java SDK

Wenn Sie das Java SDK ab der Version 6.0 nutzen, ist JAXB bereits dortintegriert, es gibt also kein eigenes JAXB-Verzeichnis. Stattdessen befin-den sich im bin-Ordner zwei zusätzliche Startdateien für den BindingCompiler; die zugehörigen Klassen sind direkt in der Laufzeitbibliothekrt.jar bzw. in der Erweiterungsbibliothek tools.jar untergebracht.

Ordner Inhalt

bin Start-Dateien für den Binding Compiler

docs Dokumentation

lib Bibliotheken

samples Beispiele

Tabelle 7.1 Ordner der JAXB-Referenzimplementierung

Hinweis

Bevor Sie nun mit dem Rest des Kapitels fortfahren, sollten Sie sich auf jedenFall einige grundlegende Kenntnisse über XML Schema angeeignet haben.Dazu empfehlen wir eine XML-Referenz oder ein Online-Tutorial. Außerdemfinden Sie in Abschnitt 1.5, »XML beschränken mit XML Schema«, einenkleinen Crash-Kurs.


395

Einführungsbeispiel 7.2

7.2 Einführungsbeispiel

JAXB 2.0 ist eine sehr umfangreiche Technologie, bei der Sie an vielenStellen Feineinstellungen und benutzerdefinierte Anpassungen vorneh-men können. Und wie Sie schon in Abschnitt 2.4.2 nachlesen konnten,besteht eine XML-Binding-Umgebung klassischerweise aus mehrerenKomponenten, wie den Entwicklungs- und Laufzeitkomponenten, wasbei JAXB nicht anders ist. Trotz der Komplexität der Materie fällt jedochder Einstieg im Regelfall nicht schwer, da viele Dinge intuitiv verständ-lich sind und Sie mit nur wenig Konfigurationsaufwand bereits produk-tive Ergebnisse erzielen.

Aus diesem Grund möchten wir Ihnen nun anhand einer kleinen Bei-spielanwendung einen Crash-Kurs in JAXB 2.0 geben mit einem kurzenÜberblick über die wichtigsten Komponenten und Aspekte dieser Tech-nologie. Vielleicht erinnern Sie sich noch an Abschnitt 2.4.2. Dort habenwir Ihnen die Kern-Features von XML-Binding-Frameworks vorgestellt:

� Erstellung von Modellklassen zu einer gegebenen XML-Grammatikmit dem Binding Compiler

� Erstellung einer XML-Grammatik zu gegebenen Modellklassen mitdem Binding Compiler

� Unmarshalling (Parsen von XML-Dokumenten in das Objektmodell)über die API

� Marshalling (Serialisierung des Objektmodells in XML-Dokumente)über die API

Außerdem verfügt jedes XML-Binding-Framework über Abbildungs-regeln zwischen den XML-Inhalten und dem Objektmodell.

Dieser Abschnitt soll Ihnen nun mit einem einfachen Beispiel den Bin-ding Compiler, die Abbildungsregeln und die API von JAXB vorstellen.Konkret werden wir dabei in den folgenden Schritten vorgehen:

� Erzeugen von Java-Klassen aus einem XML Schema mit dem XJC Bin-ding Compiler (siehe Abschnitt 7.2.2)

� Kurze Einführung in die Abbildungsregeln zwischen XML Schemaund Java anhand der oben generierten Klassen (siehe Abschnitt 7.2.3)

� Vorstellung der wichtigsten API-Komponenten zum Arbeiten mitkonkreten XML-Dokumenten (siehe Abschnitt 7.2.4)

� Rückumwandlung der generierten Java-Klassen in ein XML Schemamit dem SchemaGen Binding Compiler (siehe Abschnitt 7.2.5)


396

JAXB7

Nach diesem groben Überblick werden wir dann in den folgendenAbschnitten jeweils detaillierter auf die einzelnen Punkte eingehen. Siewerden aber sehen, wie schnell und einfach sich der Einstieg in JAXB 2.0gestaltet und dass Sie sich nicht unbedingt mit allen Details vertrautmachen müssen, um bereits ordentliche Ergebnisse zu erzielen.

7.2.1 Öffnen des Beispiels

Auf der Buch CD finden Sie bei den Beispielen das Eclipse-Projekt 07 –JAXB, das alle Beispiele für JAXB enthält. Dieses müssen Sie nur in IhrenEclipse-Workspace importieren, und schon können Sie loslegen. WennSie das Projekt öffnen, sehen Sie zunächst, dass es (im Gegensatz zu denbisherigen Beispielen) über mehrere Quellordner verfügt. Genau gesagt,gibt es pro JAXB-Beispiel einen Ordner ex#/src und eventuell noch einenOrdner ex#/src-gen (# ist dabei die Beispielnummer). Für das erste Bei-spiel dreht sich also alles um die Ordner ex1/src und ex1/src-gen.

src Im Ordner ex1/src finden Sie im Package de.javaundxml.jaxb.personenein Ihnen vielleicht bekanntes XML Schema personen.xsd zu unseremschon mehrfach verwendeten Personendaten-Beispiel sowie die KlassePersonenApp, die auch die main()-Methode für unser Einführungsbei-spiel enthält.

src-gen Der Ordner ex1/src-gen enthält die Modellklassen. Sie wurden nicht vonuns geschrieben, sondern automatisch mit dem Binding Compiler ausdem Schema generiert. Diesen Schritt werden wir nachher einmal durch-spielen.

build.xml, launchund data

Außerdem enthält der Ordner ex1 ein Ant-Script build.xml und einen lee-ren Ordner data, in dem später die Arbeitsdateien abgelegt werden. Aufoberster Projektordner-Ebene, also parallel zu den ex#-Ordnern, gibt esaußerdem einen Ordner launch mit fertigen Eclipse Run Configurationsfür das Projekt.

Falls Sie noch nicht mit dem Java-basierten Build-Tool Ant Kontakt hat-ten oder einen kleinen Auffrischungskurs dafür benötigen, sollten Siezuerst einen Blick in Anhang B werfen. Wir setzen Ant in diesem Beispielspeziell dafür ein, die Binding Compiler auszuführen. Deshalb sollten Siehier über grundlegende Vorkenntnisse verfügen, die Ihnen der Anhangjedoch vermittelt.


397


7.2.2 Generierung von Modellklassen mit dem XJC-Binding Compiler

In diesem Abschnitt zeigen wir Ihnen nun, wie Sie in JAXB Modellklas-sen aus einem XML Schema erzeugen. Dies ermöglicht Ihnen einesemantische Sicht auf Ihre Daten frei von jeglichen XML-Bausteinen, wieElementen oder Attributen. Ohne diese Klassen kann die Anwendungnicht laufen, da PersonenApp mit ihnen arbeitet und damit davonabhängt.

Der Binding Compiler zur Klassengenerierung heißt bei der JAXB-Refe-renzimplementierung XJC. Gestartet wird er üblicherweise per Ant-Script. In der Datei build.xml im Ordner ex1 sehen Sie, wie der entspre-chende Aufruf aussehen sollte. Speziell das Target –xjc ist dafür interes-sant, das wir in Listing 5.1 auch nochmals abgebildet haben.

<target name="-xjc"><taskdef name="xjc"

classname="com.sun.tools.xjc.XJCTask"classpathref="path.lib.jaxb"/>

<xjc destdir="${dir.srcgen}">

<schema dir="${dir.src}" includes="**/*.xsd"/><produces dir="${dir.srcgen}"/>

</xjc></target>

Listing 7.1 Aufruf des XJC-Binding Compilers mit Ant

Task-DefinitionSie sehen zunächst die Definition des Ant-Tasks: Der XJC wird gestartetüber die Klasse com.sun.tools.xjc.XJCTask, als Klassenpfad verweisenwir auf eine weiter oben definierte Pfad-Referenz path.lib.jaxb, diewiederum alle JAR-Dateien aus dem lib-Ordner des Projekts enthält. Indiesem lib-Ordner liegen alle JAR-Dateien der Standalone-JAXB-Refe-renzimplementierung (siehe Abschnitt 7.1). Mehr müssen Sie später inIhrer Anwendung nicht tun: Sie müssen lediglich dafür sorgen, dass dieeben beschriebenen JAR-Dateien im Klassenpfad des XJC-Tasks enthal-ten sind und Ant mit der Java-Version 5 oder höher gestartet wird, schonist der Task lauffähig. Details zur weiteren Konfiguration des XJC findenSie im Anhang in Abschnitt D.1.


398

JAXB7

Aufruf des Tasks In den Zeilen unter der Task-Definition sehen Sie, wie der XJC schließ-lich aufgerufen wird. Dabei wird mit dem destdir-Attribut festgelegt, inwelchen Ordner die generierten Java-Klassen ausgegeben werden. Dasinnere <schema>-Element ist zu nutzen wie ein Ant-übliches <fileset>-Element und bestimmt die zu verarbeitende(n) Schemadatei(en). Das<produces>-Element ist ebenfalls wie ein <fileset>-Element zu verwen-den und bestimmt, welche Dateien der XJC generiert. Dies dient ihmdazu, über einen Vergleich der Änderungszeitpunkte der Schema- undausgegebenen Java-Dateien festzustellen, ob letztere noch aktuell sindund das Schema neu kompiliert werden muss (mehr zu diesem Featurefinden Sie ebenfalls im Anhang in Abschnitt D.1).

Ausführungstarten

Nachdem Sie nun gesehen haben, wie Sie den XJC als Ant-Task definie-ren und ausführen, können Sie den Binding Compiler nun einmal testen.Starten Sie hierzu die mitgelieferte Eclipse Run Configuration Beispiel 1 –Build (genau gesagt ist dies eine External Tools Configuration, da ja Antgestartet wird; achten Sie also darauf, das richtige Menü zu verwenden).Dies startet den Binding Compiler zur Generierung der Java-Klassen unddanach den Java-Compiler, um die vorhandenen und soeben generiertenKlassen zu kompilieren.

GenerierteDateien löschen

Möglicherweise wird bei diesem Schritt aber nicht sehr viel passieren,denn dank des gerade eben erwähnten <produces>-Elements im <xjc>-Task stellt der Binding Compiler fest, dass er gar nichts tun muss. WennSie jedoch die Quelldateien im Quellordner ex1/src-gen löschen, wirdder Binding Compiler aktiv und erzeugt die soeben gelöschten Dateienvon neuem aus dem XML Schema. Sie sollten aber einen Refresh des Pro-jekts bzw. des src-gen-Ordners durchführen, damit Eclipse die generier-ten Klassen findet und neu einliest.

Hinweis

Sollten Sie Java 6 benutzen, wo die JAXB-Referenzimplementierung bereitsenthalten ist, muss zur Ausführung des XJC über Ant dennoch die Dateijaxb-xjc.jar im Klassenpfad vorhanden sein, da im JDK die Binding Compilernicht standardmäßig als Ant-Tasks ausgeliefert werden, nur als Kommandosim bin-Ordner des JDK. Die JAXB-Referenzimplementierung liefert in ihrembin-Ordner übrigens auch Kommadozeilen-Varianten der Binding Compilermit, die analog zu denen des JDK 6 benutzt werden können. EntsprechendeDokumentation finden Sie in den Dateien doc/xjc.html und doc/schema-gen.html der JAXB-Referenzimplementierung.


399


Das war es auch schon. Nachdem Sie den XJC erfolgreich ausgeführthaben, können Sie in der Praxis nun damit beginnen, Ihre Applikation zuentwerfen (was bei uns mit der Klasse PersonenApp schon passiert ist).Eine erneute Codegenerierung würde erst dann notwendig werden,wenn sich Änderungen am XML Schema ergeben.

7.2.3 Die Compiler-Ausgabe und die Abbildungsregeln

Nun ist es aber Zeit, einen Blick auf die Ausgabe des Binding Compilersim Ordner src-gen zu werfen. Öffnen Sie dazu diesen Ordner in Eclipse.Sie finden dort das Package de.javaundxml.jaxb.personen.model unddarin die folgenden fünf generierten Dateien:

� die Klasse PersonenType

� die Klasse PersonType

� die Klasse HobbysType

� die Klasse ObjectFactory

� die Datei package-info.java mit Metainformationen zum Java-Package

Klassen für komplexe Typen

Werfen Sie nun (falls noch nicht geschehen) einen Blick auf die zugehö-rige Schemadatei im src-Ordner. Sie werden feststellen, dass zu den dreidort definierten komplexen Typen personenType, personType undhobbysType jeweils genau eine Modellklasse erstellt wurde (mit ange-passten Namen), in der alle Informationen des komplexen Typs unterge-bracht werden können – Sie werden gleich sehen, in welcher Form dasgeschieht.

ObjectFactoryZusätzlich wurde die Klasse ObjectFactory erstellt – dies wird spezifika-tionsgemäß von jedem JAXB Binding Compiler für jedes generierte Java-Package gemacht. Anhand des Klassennamens dürften Sie allerdingsschon erraten, was deren Aufgabe ist, denn es handelt sich hierbei umeine ganz normale Factory-Klasse, die dazu dient, Instanzen der verschie-denen anderen Modellklassen anzulegen.

package-info.javaDie package-info.java-Datei ist ein Element, das es ab Java 5.0 gibt unddas die alte package-info.html-Datei ablöst. Darin können Metainforma-tionen zu dem jeweiligen Java-Package angegeben werden, wie z. B.Package-Annotations oder Javadoc-Kommentare. Im Folgenden werdenwir nun auf jedes der fünf Elemente kurz etwas detaillierter eingehen.

PersonenTypeZuerst werfen Sie nun bitte einen Blick in die Klasse PersonenType. Dortsehen Sie zunächst, dass es nur eine einzige Methode gibt, nämlich


400

JAXB7

getPerson() mit dem Rückgabewert java.util.List<PersonType>. DerBinding Compiler hat also bemerkt, dass im analysierten Schema imkomplexen Typ personenType ein Kindelement <person> vorkommendarf, und zwar mehrfach (wegen des Attributs maxOccurs="unbounded"im entsprechenden <xs:element>-Element der XSD-Datei). Deshalb hater den Namen der Methode auf getPerson() und deren Rückgabetyp aufList<PersonType> gesetzt.

Für diese Liste wurde auch gleich eine Instanzvariable person angelegt,der in der getPerson()-Methode über das Lazy Initialization Pattern1

beim ersten Zugriff eine ArrayList<PersonType> zugewiesen wird.

Javadoc-Kommentare

Außerdem sind die Klasse selbst und ihre getPerson()-Methode mitsehr ausführlichen Javadoc-Kommentaren ausgestattet worden, in denenSie beispielsweise eine normierte <xs:complexType>-Definition zu demzugrundeliegenden Schematyp finden. Diese kann von der Originaldefi-nition in Ihrer Schemadatei abweichen, sollte aber semantisch identischsein.

MappingAnnotations

Als letzter und wichtigster Punkt fallen schließlich die Java Annotationsauf, mit denen die Klasse und die person-Instanzvariable ausgestattetsind. Hierbei handelt es sich um sogenannte Mapping Annotations, dieTeil der JAXB-API sind (siehe auch Abschnitt 7.4.9). Da ein XML Schemamehr bzw. detaillierte Informationen über die Grammatik (wie z. B. dieReihenfolge der Elemente oder deren genaue Namen) bereitstellen kannals einfache bean-artige Java-Klassen, müssen letztere mit zusätzlichenMetainformation angereichert werden, damit später ein 1:1-Mappingvon Java auf XML möglich ist. So verwendet der Binding Compiler dieseAnnotations, um aus existierenden Klassen ein XML Schema zu generie-ren (falls der umgekehrte Weg wie in unserem Beispiel gegangen wird).Sie bilden aber auch die zentralen Informationselemente, die JAXB zurLaufzeit auswertet, um die Abbildung zwischen XML-Dokumenten undJava-Objekten vorzunehmen. Glücklicherweise sind die Annotations ein-fach und intuitiv zu lesen, so sehen Sie beispielsweise, wie in der Anno-tation @XmlType der XML-Name des komplexen Typs und die Reihen-folge der Kindelemente festgelegt werden.

HobbysType Kommen wir nun zur nächsten Modellklasse HobbysType. Sie ist analogaufgebaut zu PersonenType – es gibt dort eine Methode getHobby(), dieals Rückgabewert allerdings List<String> hat, denn laut der Schemavor-

1 Lazy Initialization: Ein Objekt wird erst dann angelegt, wenn es das erste Mal benö-tigt wird; dies spart Speicher, falls nie darauf zugegriffen wird.


401


lage sind die <hobby>-Kindelemente vom Typ xs:string. Ansonsten sindauch hier wieder eine Instanzvariable, ausführliche Javadoc-Kommen-tare und Annotations ähnlich denen aus PersonenType zu finden.

PersonTypeSchauen Sie sich nun bitte die Klasse PersonType näher an. Sie sehen,dass der XJC zu den drei Elementen, die ein Element vom TyppersonType enthalten darf – <nachname>, <vorname> und <hobbys> –,jeweils eine Getter- und Setter-Methode und eine Instanzvariable erstellthat. Die Properties nachname und vorname haben dabei logischerweiseden Typ String erhalten, hobbys den Typ HobbysType.

ZwischenstandDamit haben Sie nun die drei Modellklassen untersucht, die der BindingCompiler von JAXB aus den komplexen Typen erstellt, die in der Sche-madatei definiert sind. Sie sollten anhand dieses praktischen Beispielsein erstes Gefühl dafür bekommen, welche Komponenten der XJC zuwelchen Elementen im XML Schema generiert. So werden beispielsweisekomplexe Typen auf Java-Klassen, Kindelemente immer über eineInstanzvariable mit Getter- und Setter-Methode abgebildet und mehrfacherlaubte Elemente durch eine java.util.List vom entsprechendengenerischen Typ. Die Namen orientieren sich an denen im XML Schema,werden jedoch auf Java-Namenskonventionen angepasst. Probieren Siegerne auch einmal selbst, zum Beispiel, was passiert, wenn Sie einem derkomplexen Typen noch Attribute zuordnen. In Abschnitt 7.3, »Abbil-dung von XML nach Java«, erfahren Sie dann etwas mehr darüber, wieXML-Schema-Typen standardmäßig auf Java-Typen abgebildet werden.

Zuvor jedoch beschäftigen wir uns nun noch mit den beiden verbleiben-den Elementen, die vom XJC erzeugt wurden, nämlich der KlasseObjectFactory und der Datei package-info.java.

ObjectFactoryWir beginnen zunächst mit der letzten Klasse des Packages, derObjectFactory. Wie schon erwähnt, dient sie teilweise dazu, Instanzender drei eben vorgestellten Modellklassen anzulegen. Sie verfügt selbstüber einen Default-Konstruktor, weshalb Sie jederzeit eine Instanz davonanlegen und mit ihr arbeiten können. Zur Erzeugung der Modellklassen-Instanzen existieren die folgenden drei createXXX()-Methoden mit ent-sprechenden Rückgabetypen:

� createPersonenType()

� createPersonType()

� createHobbysType()

Interessant ist nur noch die vierte Methode createPersonen(). Sieerwartet als Argument ein Objekt vom Typ PersonenType und liefert als


402

JAXB7

Ergebnis ein Objekt vom Typ JAXBElement<PersonenType>. Der Hinter-grund ist dabei, dass die drei Modellklassen nur die komplexen Typenaus dem XML Schema repräsentieren, es gibt aber noch kein Pendantzum Wurzelelement <personen>. Dem wird mit dieser letzten Methodeabgeholfen. Der Typ JAXBElement ist ein fester Teil der JAXB-API unddient der Repräsentation von Elementdeklarationen. Er kapselt nebendem Typ des Elements weitere Information, wie z. B. dessen qualifizier-ten Namen. Diese zusätzlichen Informationen über unser <personen>-Element müssen wir allerdings nicht selbst beschaffen, das erledigt dieObjectFactory für uns. Alles, was sie benötigt, ist der eigentliche Inhaltdes Elements, also eine Instanz von PersonenType.

Mehr wollen wir an dieser Stelle noch nicht zur ObjectFactory sagen, inAbschnitt 7.3.7 finden Sie allerdings detaillierte Informationen. Außer-dem sehen Sie natürlich im nächsten Abschnitt, wie Sie dieObjectFactory konkret einsetzen.

package-info.java Zuletzt sollten Sie nun einen Blick auf die Datei package-info.java wer-fen. Das Erste, was Sie darüber wissen müssen, ist, dass es sich dabei umkeine Klasse handelt, auch wenn sie die Endung .java besitzt. Stattdessenist sie eine Container-Datei für package-bezogene Informationen undmuss im Übrigen immer genau diesen Namen tragen. Vor Java 5.0konnte man zu diesem Zweck noch package-info.html-Dateien proPackage ablegen, worin dann Javadoc-Kommentare für dieses Packagehinterlegt werden konnten. Allerdings gibt es ja ab Java 5.0 nun dasoben schon erwähnte neue Sprach-Feature der Annotations, die unteranderem auch auf Package-Ebene definiert werden können. Für dieseZwecke ist jedoch eine einfache HTML-Datei nicht mehr ausreichend,deshalb hat man diese neue Pseudo-Java-Datei eingeführt. Sie enthältnichts weiter als die Package-Deklaration, die aber nun »annotiert« seinkann, was bei normalen Klassen innerhalb des Packages nicht erlaubt ist.Wie JAXB 2.0 diesen Mechanismus konkret nutzt, können Sie inAbschnitt 7.4.9 nachlesen.

7.2.4 Die Anwendung und die JAXB-API

Die Generierung des Quellcodes ist natürlich nur der erste Schritt zurErstellung einer Anwendung, dafür wird er im Regelfall nicht sehr oftwiederholt werden müssen – es sei denn natürlich, Ihr XML Schema hatsich geändert.


403


Der nächste Schritt ist nun normalerweise das Schreiben der eigentlichenAnwendung um die Modellklassen herum. In unserem Einführungsbei-spiel ist dies allerdings schon geschehen.

Im Ordner src des ersten Beispiels finden Sie im Packagede.javaundxml.jaxb.personen die Klasse PersonenApp, die unsereeigentliche Anwendung bildet. Werfen Sie zunächst einen Blick auf diemain()-Methode in Listing 7.2.

Schema schema = createSchema();

JAXBContext context =JAXBContext.newInstance(

PersonenType.class.getPackage().getName());

File dataFile = new File("ex1/data/personen.xml");

marshal(schema, dataFile, context);unmarshal(schema, dataFile, context);

Listing 7.2 Die main()-Methode der PersonenApp-Anwendung

createSchema()Wie Sie im Listing sehen, dient die Methode quasi nur als Koordinatorder Anwendung, die eigentliche Logik versteckt sich in den drei Hilfsme-thoden createSchema(), marshal() und unmarshal(). Auf erstere wer-den wir allerdings nicht weiter eingehen, denn dort wird einfach überJAXP ein Schema-Objekt generiert und zurückgegeben (mehr dazu findenSie in Abschnitt 5.6, »Dokumente validieren«).

JAXBContextDie zweite Anweisung der Methode ist schon wesentlich interessanter.Hier wird ein Objekt vom Typ JAXBContext angelegt. Diese Klasse istauch gleich die wichtigste von JAXB – sie bildet den zentralen Einstiegs-punkt in die gesamte JAXB-API. Ein JAXBContext bezieht sich immer aufeine oder mehrere Grammatiken, genauer gesagt auf eine konkreteMenge an Modellklassen, und bietet dann Funktionalitäten wie dasGenerieren von Marshallern und Unmarshallern für diese. Wie Siesehen, funktioniert das Anlegen des JAXBContexts – ähnlich wie beiJAXP und StAX – über eine von mehreren vorhandenen newInstance()-Factory-Methoden. In diesem Beispiel haben wir die Methodenvariantegewählt, der der Name eines Java-Packages in Form eines Strings über-geben wird. Dieses Package wird dann auf Modellklassen und diepackage-info.java-Datei untersucht (unter Beachtung der dort definiertenMapping Annotations), und die gefundenen Informationen werden imJAXBContext hinterlegt.


404

JAXB7

Dateiobjektanlegen

Der nächste sehr kurze Schritt in der Anwendung ist das Anlegen einesFile-Objekts für das folgende Marshalling und Unmarshalling. Hierzudürfte kein weiterer Erklärungsbedarf bestehen.

marshal() Der nächste große Schritt in der Anwendung, das Generieren eines Bei-spiel-Objektmodells und das Marshalling in eine Datei, ist ausgelagert indie Methode marshal() – zu sehen in Listing 7.3 Sie erhält das Schema-Objekt, die Arbeitsdatei und den JAXBContext als Argumente und führtdamit die in Listing 7.3 gezeigten Aktionen aus.

ObjectFactory factory = new ObjectFactory();

PersonenType personen;PersonType person;HobbysType hobbys;

personen = factory.createPersonenType();

// Person 1person = factory.createPersonType();person.setNachname("Scholz");person.setVorname("Michael");

hobbys = factory.createHobbysType();hobbys.getHobby().add("Java");hobbys.getHobby().add("XML");hobbys.getHobby().add("Groovy");person.setHobbys(hobbys);

personen.getPerson().add(person);

Hinweis

Vielleicht ist Ihnen die Art und Weise nicht vertraut, wie wir in diesem Bei-spiel an den Package-Namen für den JAXBContext gelangen. Wir besorgenuns einfach über PersonenType.class das Class-Objekt zum TypPersonenType. Hierin sind nun Metainformationen über die Klasse gespei-chert wie beispielsweise auch das Java-Package, zu dem wir mitgetPackage() ein Package-Objekt erhalten. Davon erhalten wir schließlichmit getName() den Namen als String. Natürlich hätten wir auch einfach denNamen des Packages direkt als String angeben können. Die vorgestellteVorgehensweise hat allerdings den Vorteil, dass der Code auch dann nochfunktioniert, wenn Sie mit einem Refactoring-Tool die Java-Packages umbe-nennen, denn solche Tools erkennen nicht zwangsweise auch Umbenennun-gen, die in String-Literalen notwendig sind.


405


// Person 2person = factory.createPersonType();person.setNachname("Niedermeier");person.setVorname("Stephan");

hobbys = factory.createHobbysType();hobbys.getHobby().add("Java");hobbys.getHobby().add("XML");hobbys.getHobby().add("Cocoon");person.setHobbys(hobbys);


// Person 3person = factory.createPersonType();person.setNachname("Skulschus");person.setVorname("Marco");


// Personen-Element anlegenJAXBElement<PersonenType> personenElement =

factory.createPersonen(personen);

// Marshaller aus dem JAXBContext generieren und Schema// für Validierung setzenMarshaller marshaller = context.createMarshaller();marshaller.setSchema(schema);

// Pretty-Print für die Ausgabe einschaltenmarshaller.setProperty(

Marshaller.JAXB_FORMATTED_OUTPUT, true);

// Marshalling durchführenmarshaller.marshal(

personenElement, new FileOutputStream(dataFile));

Listing 7.3 Die marshal()-Methode der PersonenApp-Anwendung

Die Methode marshal() führt im letzten Schritt das Marshalling (also dieSerialisierung) durch, baut jedoch zuvor ein beispielhaftes Personen-Objektmodell mit den vom XJC generierten Modellklassen zusammen.

Wie Sie sehen, starten wir mit der Erzeugung einer ObjectFactory, diewir dann stetig zur Generierung unserer Modellobjekte benutzen. AlsErstes legen wir ein Objekt personen vom Typ PersonenType an, das


406

JAXB7

quasi das Wurzelelement des Dokuments repräsentiert. Danach generie-ren wir hintereinander drei PersonType-Objekte und gehen dabei immernach folgendem Muster vor:

1. Generieren einer PersonType-Instanz über die ObjectFactory

2. Setzen von Nach- und Vorname über die zugehörigen Setter-Metho-den

3. Optional, falls die Person Hobbys hat:

� Generierung einer HobbysType-Instanz über die ObjectFactory

� Hinzufügen der einzelnen Hobbys als String zur Hobby-Liste

� Zuweisen der HobbysType-Instanz an die PersonType-Instanz überdie entsprechende Setter-Methode

4. Hinzufügen der fertigen PersonType-Instanz in der Person-Liste despersonen-Objekts

Das Resultat ist ein fertig »befülltes« PersonenType-Objekt. Wie aber inAbschnitt 7.2.3 schon beschrieben, muss dieses Objekt vor dem eigentli-chen Marshalling noch in ein JAXBElement<PersonenType>-Objekt ver-packt werden. Dies geschieht wiederum über die ObjectFactory. Mitdiesem neuen Objekt können wir nun das Marshalling durchführen.

Marshaller Im Listing erkennen Sie, welche Schritte dazu notwendig sind: Zuerst las-sen wir uns vom JAXBContext ein Marshaller-Objekt über die MethodecreateMarshaller() erzeugen. Sie sehen dabei erneut, dass derJAXBContext der Ursprung allen Handelns in JAXB ist und ihm eine ähn-liche Bedeutung zukommt wie beispielsweise der DocumentBuilder-Factory in JAXP. So ist auch Marshaller, wie beispielsweise schonDocumentBuilder bei JAXP, keine konkrete Klasse, sondern in diesemFall ein Interface. Der JAXBContext dient uns dabei als Factory. Auf demerhaltenen Marshaller-Objekt wird nun zunächst das von dercreateSchema() generierte Schema-Objekt über die Methode set-

Schema() registriert. Dieses Objekt nutzt der Marshaller dann zur Vali-dierung des Objektmodells gegen die Grammatik während der Serialisie-rung. Außerdem können nun noch über die Methode setProperty()diverse Einstellungen vorgenommen werden (auch das kennen Siebereits bestens von JAXP). Wir nutzen diesen Mechanismus hier bei-spielsweise, um festzulegen, dass das erzeugte XML-Dokument mit Ein-rückungen und Zeilenumbrüchen schön formatiert wird. Der Name derentsprechenden Property ist dabei als statische Konstante JAXB_

FORMATTED_OUTPUT im Marshaller-Interface fest hinterlegt.


407


Marshalling durchführen

Der letzte Schritt ist nun noch das eigentliche Marshalling. Hierzu bietetuns der Marshaller mehrere Methoden marshal() an. All diese Metho-den erwarten als erstes Argument das Modellobjekt, das serialisiert wer-den soll – in unserem Fall also das oben erzeugte JAXBElement<Per-sonenType>-Objekt. Das zweite Argument bestimmt immer das Ziel derSerialisierung – wir nutzen hier einen FileOutputStream, um die Aus-gabe in die in der main()-Methode definierte Arbeitsdatei umzulenken.

Sobald Sie die Anwendung dann laufen lassen, wird im data-Ordner eineDatei personen.xml angelegt und das generierte Objektmodell in XML-Form dort abgelegt. Die Ausgabe sollte aussehen wie in Listing 7.4.

<?xml version="1.0" encoding="UTF-8" standalone="yes"?><personen

xmlns="http://javaundxml.de/jaxb/personen/model"><person>

<nachname>Scholz</nachname><vorname>Michael</vorname><hobbys>

<hobby>Java</hobby><hobby>XML</hobby><hobby>Groovy</hobby>

</hobbys></person><person>

<nachname>Niedermeier</nachname><vorname>Stephan</vorname><hobbys>

<hobby>Java</hobby><hobby>XML</hobby><hobby>Cocoon</hobby>

</hobbys></person><person><nachname>Skulschus</nachname><vorname>Marco</vorname>

</person></personen>

Listing 7.4 Das Ergebnis des Marshalling

unmarshal()Der letzte Schritt, den unsere Beispielanwendung jetzt noch ausführt, istschließlich das Unmarshalling der soeben generierten Datei zurück in einPersonen-Objektmodell, das dann in einfach lesbarer Form in der Kon-sole ausgegeben wird. Diese Aufgaben übernimmt die Methodeunmarshal(), deren Inhalt Sie in Listing 7.5 nachlesen können.


408

JAXB7

// Unmarshaller aus dem JAXBContext generieren und// Schema für Validierung setzenUnmarshaller unmarshaller =

context.createUnmarshaller();unmarshaller.setSchema(schema);

// Unmarshalling durchführenJAXBElement<PersonenType> personenElement =

(JAXBElement<PersonenType>)unmarshaller.unmarshal(dataFile);

// Informationen ausgebenfor(PersonType person :

personenElement.getValue().getPerson()){

System.out.println("Nachname: " + person.getNachname());

System.out.println("Vorname : " + person.getVorname());

HobbysType hobbys = person.getHobbys();if(hobbys != null){

System.out.println("Hobbys : " + hobbys.getHobby());

}

System.out.println("=======================");}

Listing 7.5 Die unmarshal()-Methode der PersonenApp-Anwendung

Unmarshaller Die erste Aktion in dieser Methode ist natürlich das Generieren desUnmarshallers, in JAXB über ein Interface Unmarshaller definiert. Anlogzur Generierung des Marshaller-Objekts in der vorherigen Methodeerhalten wir eine Unmarshaller-Instanz vom JAXBContext, und zwarüber die Methode createUnmarshaller(). Die erste Aktion mit dererhaltenen Instanz ist wieder das Setzen des Schema-Objekts. DerUnmarshaller nutzt es aber diesmal natürlich, um während des Unmar-shalling-Prozesses das Eingabe-XML-Dokument gegen die Grammatik zuvalidieren.

Unmarshalling Als nächster Schritt kommt nun schon das Unmarshalling. Es erfolgt übereine der diversen unmarshal()-Methoden des Unmarshaller-Objekts,die es für verschiedene Eingabeformate gibt, darunter auch für File-


409


Objekte. Hier übergeben wir nun dasselbe Objekt wie schon für das Mar-shalling, so dass die eben erzeugte Datei gleich wieder geparst wird. DerRückgabetyp der unmarshal()-Methoden ist immer Object, da der Com-piler ja nicht wissen kann, mit welchem Objektmodell Sie arbeiten. Ausdiesem Grunde ist in unserem Beispiel noch ein Typecast des zurückge-gebenen Objekts nach JAXBElement<PersonenType> notwendig.

Iterieren über PersonType-Objekte

Nächstes Ziel ist es nun, das frisch geparste Objektmodell noch auf derKonsole auszugeben. Wir beginnen dazu mit einer Schleife über allePersonType-Objekte aus der List<PersonType> des Wurzelelements.Dazu besorgen wir uns zunächst über getValue() das PersonenType-Objekt von dem JAXBElement<PersonenType>-Objekt – dies ist dieMethode, mit der Sie von jedem JAXBElement das innere Typobjekterhalten können. Vom PersonenType-Objekt besorgen wir uns dann dieList<PersonType> mit allen inneren PersonType-Objekten übergetPerson(). Auf diese Weise erhalten wir im Schleifenrumpf einObjekt nach dem anderen.

Wir schreiben dort dann zunächst eine Ausgabe für den Nach- und denVornamen in die Konsole. Danach holen wir uns das HobbysType-Objektfür die jeweilige Person. Da auf Schemaebene das zugehörige <hobbys>-Element im komplexen Typ personType nicht zwangsweise vorkommenmuss (wegen des Attributs minOccurs="0"), ist auf Java-Ebene dasHobbysType-Objekt möglicherweise null. Dies prüfen wir und geben nurdann, wenn wir wirklich ein Objekt erhalten haben, dieses noch auf dieKommandozeile aus. Da es sich dabei um eine List<String> handelt, be-kommen wir auch gleich eine schöne String-Darstellung in der Konsole.

Zuletzt geben wir noch eine Trennzeile aus, um das Ergebnis besser les-bar zu machen. Die Ausgabe des Programms sehen Sie auch in Listing 7.6.

Nachname: ScholzVorname : MichaelHobbys : [Java, XML, Groovy]=======================Nachname: NiedermeierVorname : StephanHobbys : [Java, XML, Cocoon]=======================Nachname: SkulschusVorname : Marco=======================

Listing 7.6 Die Ausgabe der PersonenApp-Anwendung


410

JAXB7

Zusammenfassung Sie haben jetzt bereits alles erfahren, was Sie benötigen, um eine Verar-beitungsanwendung für ein gegebenes XML Schema zu schreiben. Siewissen, wie Sie über Ant mit dem XJC aus dem Schema Ihre Modellklas-sen erzeugen, haben den JAXBContext kennengelernt und erfahren, wieSie mit ihm Marshaller und Unmarshaller generieren. Letztere benutzenSie schließlich, um ihre XML-Dokumente zu serialisieren und zu parsen.

Was nun noch für den nächsten Abschnitt verbleibt, ist die Generierungeines XML Schemas aus einem schon bestehenden Objektmodell.

7.2.5 Generierung eines Schemas mit dem SchemaGen Binding Compiler

SchemaGen Wie auch beim O/R-Mapping – der mit dem XML-Binding verwandtenTechnologie, die die Abbildung von Datenbankmodellen auf Klassen rea-lisiert – kommt auch bei der XML-Verarbeitung der Anwendungsfall vor,dass es zuerst ein Objektmodell in Ihrer Anwendung gibt und erst nach-träglich dazu ein XML Schema benötigt wird. Denken Sie zum Beispiel aneine zunächst eigenständige Java-Anwendung, die nun plötzlich miteiner .NET-Anwendung Daten austauschen soll. Hierfür ist die Daten-übertragung über XML eine denkbare Vorgehensweise. Falls die Java-Anwendung das führende System ist und für die auszutauschendenDaten ohnehin ein Objektmodell existiert (oder mit wenig Aufwandimplementiert werden kann), bietet es sich an, einfach über JAXB einXML Schema dazu zu generieren und dieses dann den Entwicklern der.NET-Anwendung als Schnittstellenbeschreibung zur Verfügung zu stel-len. Alles, was Sie dann tun müssen, ist, die Modellklassen mit den ent-sprechenden Mapping Annotations anzureichern und den Binding Com-piler für die Java-nach-XML-Richtung darauf loszulassen. Bei der JAXB-Referenzimplementierung trägt dieser übrigens den Namen SchemaGen.

In unserem Beispiel haben wir ein leichtes Spiel, denn der XJC hat füruns schon ein fertiges Objektmodell inklusive der Mapping Annotationsgeneriert, das wir nun einfach wiederverwenden. Wenn JAXB ordentlicharbeitet, sollte das so generierte XML Schema semantisch exakt demursprünglich von uns vorgegebenen entsprechen.

Hinweis

Für die Laufzeitbibliothek von JAXB, also den JAXBContext und die von ihmgenerierten Hilfsobjekte wie Marshaller und Unmarshaller, wird das XMLSchema übrigens nicht benötigt. Die Modellklassen und die darin enthalte-nen Mapping Annotations sind alles, was diese Objekte brauchen.


411


Wie schon der XJC, so lässt sich auch der SchemaGen auf einfache Weiseüber Ant starten. Werfen Sie dazu einen Blick auf das Ant-Targetschemagen in der build.xml oder in Listing 7.7.

<target name="schemagen">

<taskdef

name="schemagen"classname="com.sun.tools.jxc.SchemaGenTask"classpathref="path.lib.jaxb"/>

<schemagen srcdir="${dir.srcgen}" destdir="data"

classpathref="path.lib.jaxb"><schema namespace=

"http://javaundxml.de/jaxb/personen/model"file="personen.xsd"/>

</schemagen></target>

Listing 7.7 Aufruf des SchemaGen Binding Compilers mit Ant

Task-DefinitionAuch hier sehen Sie zunächst, wie der Task definiert wird. Diesmalbenutzen wir die Klasse com.sun.tools.jxc.SchemaGenTask, verweisenaber wieder auf denselben Klassenpfad wie schon beim XJC.

Aufruf des TasksDanach folgt dann der Aufruf des soeben definierten Tasks. Wie Siesehen, muss zunächst über das srcdir-Attribut der Quellordner angege-ben werden, in dem sich die Modellklassen befinden, hier also unser src-gen-Ordner. Über das Attribut destdir wird dann das Verzeichnis festge-legt, in dem die XML-Schema-Datei(en) ausgegeben werden soll(en) – inunserem Fall data. Zusätzlich muss der Klassenpfad zur den JAXB-Biblio-theken über das classpathref-Attribut spezifiziert sein.

Innerhalb des <schemagen>-Elements befindet sich ein Kindelement<schema>. Dieses dient dazu, den jeweiligen SchemanamensräumenDateinamen zuzuordnen. Wie Sie vielleicht wissen, bezieht sich ein XML

Sie könnten deshalb also mit JAXB XML-Binding komplett ohne ein XMLSchema betreiben. Einen Haken hat die Sache jedoch: Sie können in diesemFall keine Validierung mehr durchführen. Wie schon gezeigt, brauchen Siedafür ein JAXP-Schema-Objekt, das Sie nur aus einem XML-Schema-Doku-ment und nicht aus den Modellklassen generieren können.


412

JAXB7

Schema ja immer auf genau einen Zielnamensraum (gegebenenfalls denleeren Namensraum), dementsprechend sind auch JAXB-Modellklassenimmer einem solchen zugeordnet. Die zugehörige Information ist übri-gens in der package-info.java des jeweiligen Java-Packages und dort inder Mapping Annotation @XmlSchema enthalten. In unserem Beispielmüssen wir deshalb dem Namensraum http://javaundxml.de/jaxb/perso-nen/model, auf den sich unser Package de.javaundxml.jaxb.personen.model bezieht, noch einen Schemadateinamen zuordnen, hier perso-nen.xsd. Zusammen mit dem oben spezifizierten Ausgabeverzeichnisdata wird also der <schemagen>-Task das resultierende XML Schema indata/personen.xsd innerhalb des ex1-Ordners des Projekts ablegen.

Ausführungstarten

Nachdem Sie jetzt wissen, wie Sie den SchemaGen als Ant-Task definie-ren und ausführen, wird es nun Zeit, den Generierungsprozess anzusto-ßen. Starten Sie hierzu die mitgelieferte Eclipse External Tools Configu-ration Beispiel 1 – Schema-Generierung. Diese führt das vorgestellte Ant-Target und damit den <schemagen>-Task aus.

Das Ergebnis Als nächsten Schritt sollten Sie nun einen Refresh des Projekts bzw. desdata-Ordners durchführen, damit Eclipse das generierte XML Schema fin-den kann. Wenn Sie die Datei öffnen, werden Sie erfreulicherweise fest-stellen, dass sie bis auf wenige kleine Ausnahmen dem ursprünglichenSchema entspricht. Unterschiede finden Sie beispielsweise beim benutz-ten Namensraum-Präfix tns, das in der Original-Datei nicht vorhandenwar, oder beim nillable="true"-Attribut in der Definition des Wurzele-lements <personen>. Dies sind jedoch Unterschiede, die die Grammatikan sich nicht verändern, nur die Beschreibung weicht etwas ab.

Zusammenfassung Auf jeden Fall hat dieser kleine Versuch unsere vorherige Behauptungbestätigt, dass die Rückgenerierung des XML Schemas aus den ihrerseitsgenerierten Java-Klassen wieder zum ursprünglichen Ergebnis führt. Siehaben damit außerdem den umgekehrten Weg der Generierung kennen-

Zwei Hinweise

Befinden sich im angegebenen Quellordner mehrere JAXB-Modell-Packages,so können Sie über mehrere <schema>-Kindelemente allen Namensräumenentsprechende Dateinamen zuordnen.

Sie können die Namensraum-Zuordnung auch weglassen. In diesem Fall wirdfür jeden unbekannten Namensraum eine Datei schemaX.xsd generiert,wobei X eine fortlaufende Nummer ist, die bei 1 beginnt.


413

Abbildung von XML nach Java 7.3

gelernt, den Sie ja bekannterweise einschlagen sollten oder müssen,wenn Sie zuerst über fertige Java-Klassen verfügen und dafür dann einXML Schema benötigen.

Damit sind Sie nun am Ende unserer Einführung in JAXB angelangt. Jenachdem, was Sie nun noch an speziellen Anpassungen für Ihre Anwen-dung benötigen, können Sie in den folgenden Abschnitten detailliertereInformationen zu den Abbildungsregeln zwischen Java- und XML-Ele-menten und der JAXB-API nachlesen. In Anhang D finden Sie außerdemnähere Erläuterungen zur Konfiguration der Binding Compiler.

7.3 Abbildung von XML nach Java

Nachdem Sie einen ersten Überblick über die JAXB-Technologie erhaltenhaben, werden wir Ihnen nun die Regeln und Mechanismen für dieAbbildung etwas näher vorstellen. Den Begriff Abbildung, den wir in die-sem Buch verwenden, verstehen Sie dabei bitte als Zusammenfassungder Umwandlungsaktionen der Binding Compiler und der JAXB-Lauf-zeitumgebung. Wenn wir also von »Abbildung von XML nach Java«,sprechen, sind damit der XJC Binding Compiler und die Unmarshaller-Laufzeitkomponente gemeint bzw. die Umwandlungen zwischen derXML- und Java-Welt, die diese beiden vornehmen.

Wir unterscheiden dabei grundsätzlich zwischen den beiden Richtungender Abbildung, also XML nach Java und Java nach XML. Erstere behan-deln wir in diesem Abschnitt, letztere in Abschnitt 7.4, »Abbildung vonJava nach XML«. Dabei werden wir allerdings nicht auf die Konfigurationder beiden Binding Compiler eingehen. Werfen Sie stattdessen einenBlick in Anhang D wo wir diese Themen noch einmal etwas detaillierterbeleuchten. Außerdem sollte Ihnen das Einführungsbeispiel bereits dasNotwendigste vermittelt haben.

Hinweis

Sollten Sie noch mit Java 1.4 arbeiten und deshalb gezwungenermaßen nurJAXB 1.0 nutzen können, ist es leider nicht möglich, den Generierungspro-zess in dieser Richtung durchzuführen, da es diesen erst ab JAXB 2.0 mitHilfe der Mapping Annotations gibt.


691

Index

A

Anastasia 588Annotation 455

in JAXB 458Ant 645

<ant> 651<antcall> 651<bunzip2> 651<bzip2> 651<checksum> 651<classpath> 661<copy> 651<delete> 650<echo> 649<exec> 651<fileset> 653<gunzip> 651<gzip> 651<import> 651<jar> 650<java> 651<javac> 650<javadoc> 651<mkdir> 650<move> 651<project> 648<property> 657<tar> 651<target> 648<task> 649<taskdef> 660<unjar> 651<untar> 651<unzip> 651<zip> 651installieren 646Property 655Script 645starten 647Target 648Target-Abhängigkeiten 651Task 649

Apache Ant � Ant

Apache Cocoon 588Asterisk 608Beispiel 617COB-INF 595Cocoon-Block 590Cocoon-Block deployen 597Cocoon-Block erstellen 593Cocoon-Block importieren (Eclipse)

596Cocoon-Block starten 596Cocoon-Block-Struktur 594default 603Default-Komponente 603, 620deployen 597DirectoryGenerator 611eingebettete Anweisung 613Flowscript 600Generator 592, 610Generator registrieren 611Generator verwenden 611Gruppierung 600Jetty 596Komponente 591Komponente registrieren 602Komponente verwenden 604Komponenten-Element 603M2_REPO 597map:action-set 600map:components 599map:flow 600map:generate 611map:generator 611map:generators 611map:match 600, 605, 606, 607map:matcher 607map:matchers 607map:pipeline 600map:pipelines 600map:read 616map:reader 616map:readers 616map:resources 600map:serialize 615map:serializer 614map:serializers 614


692

Index

Apache Cocoon (Forts.)map:transform 613map:transformer 612map:transformers 612map:views 600Matcher 605Matcher registrieren 607Matcher verwenden 607Maven 2 592META-INF 595name (Komponente) 603Packen 597pattern 606Pipeline 590, 600Pipeline-Element 604Pipeline-Key 609Pipeline-Komponente 591Pipeline-Pfad 605Pipeline-Prozess 601pom.xml 596Publishing 585rcl.properties 596Reader 615Reader registrieren 616Reader verwenden 616Request-Response 605SAX-Event 591Serializer 592, 614Serializer registrieren 614Serializer verwenden 615Sitemap 591, 598sitemap.xmap 595Sitemap-Variable 609src (Komponente) 603Standard-Generator 612Standard-Reader 616Standard-Serializer 615Standard-Transformer 613Transformer 592, 612Transformer registrieren 612Transformer verwenden 613Typelement 603virtuelle Pfadangabe 606Wildcard 608Wildcard URI Matcher 605, 606XML-Pipeline 590, 600XSLT-Transformer 592

API 101

Application Programming Interface 102

archetype 594artifactId 594AttachmentMarshaller 477AttachmentUnmarshaller 473Attribut 20

in DOM 145, 146in JAXB 421in SAX 180, 193in StAX 358, 367, 375, 379in XML Schema 46

Attribute (Interface) 375, 379

B

Binder 477generieren 479

Binding Compiler 98Binding � XML-Binding

C

Callback-Klasse 80, 190CDATA 22

in DOM 147in SAX 198in StAX 354, 369, 376

Characters 376Child � KindknotenCocoon � Apache CocoonCocoon-Block 590Comment 377Content Repository 585Content Syndication 586ContentHandler 190Cross-Publishing 586

D

Dateimengen 653DeclHandler 200, 201DefaultHandler 205DefaultHandler2 205, 206Default-Namensraum 29DocBook 18Document Object Model � DOMDocumentBuilder 234, 240

generieren 240


693

Index

DocumentBuilderFactory 234, 235generieren 240

DOM 87, 109Attr 146, 156Attribut 120, 146CDATASection 147, 148, 156CharacterData 147Comment 147, 157Document 89, 113, 143, 155DocumentType 123, 128, 150Dokument erzeugen 123, 234, 243DOMConfiguration 127, 163, 165DOMImplementation 113, 130DOMImplementationLS 116, 160DOMImplementationRegistry 114,

134DOMStringList 163Element 89, 113, 144, 156Entity 150EntityReference 150, 156Feature 131Knoten-Interfaces 87, 135Level 90, 131Load and Save 159LSInput 116, 161LSOutput 127, 164LSParser 117, 162LSResourceResolver 278, 282LSSerializer 127, 165mit JAXP 231mit TrAX nutzen 259, 263Modul 131Module 90NamedNodeMap 138Namensraum 166navigieren 151Node 139NodeList 118, 138Notation 150Objektmodell 135parsen 160ProcessingInstruction 149, 157serialisieren 164Text 147, 148, 156

DOMImplementation 130erzeugen 133, 235generieren 242

DTD<!ATTLIST> 33, 201

DTD (Forts.)<!DOCTYPE> 35<!ELEMENT> 32, 201<!ENTITY> 34, 201Attribut 33einbetten 36einbinden 35Element 32Entity 34, 200, 201Import 35in DOM 150in SAX 199in StAX 370, 384mit JAXP 226, 236, 272Notation 200referenzieren 35

DTDHandler 200registrieren 186, 200

E

Element 19in DOM 144in JAXB 422in SAX 180, 192in StAX 357, 365, 378in XML Schema 47

Element Content Whitespace � Ignorable Whitespace

Elternknoten 25in DOM 152

EndDocument 378EndElement 379Entity 34

in DOM 150in SAX 200, 201in StAX 382

EntityDeclaration 382EntityReference 383Entity-Referenz 21

in DOM 150in JAXP 238in SAX 196, 199in StAX 370, 383

EntityResolver 202registrieren 186

ErrorHandler 201registrieren 186

ErrorListener 249, 256


694

Index

EventFilter 341Extensible Markup Language � XMLExtensible Stylesheet Language � XSLT

F

Factory 104Abstract Factory 104Factory-Method 104in JAXB 406, 435, 464in JAXP 219in StAX 307, 336

FOP 69Optionen 70starten 70

FO-Prozessor 69Formatting Objects 63

G

Generieren mit DOM 155, 169Geschwisterknoten 25

in DOM 153groupId 594

H

HandlerBase 213Handler-Klasse 80, 190Holder 561

I

Ignorable Whitespacein DOM 148in JAXP 237in SAX 194in StAX 376

InputSource 188Inversion of Control 81, 177

J

Java API for XML Web Services � JAX-WS

Java Architecture for XML Binding � JAXB

Java Community 102

JAXB 391@XmlAccessorType 418@XmlAttribute 421@XmlElement 423@XmlElementDecl 462@XmlElementRef 427@XmlElementRefs 426@XmlEnum 433@XmlJavaTypeAdapter 473@XmlList 434@XmlRegistry 462@XmlType 418API 462Array abbilden 449AttachmentMarshaller 477AttachmentUnmarshaller 473Attribut 421Aufzählungstypen 432Binder 477Binding Compiler 397, 410Binding Declaration 415, 436Binding-Compiler 669Collection-Typ abbilden 449einfache Typen 428Element 422Enumeration Types 432Enum-Typen abbilden 448Event-Callback 472, 476in JAX-WS 523, 556jaxb.index 460JAXBContext 403, 464JAXBElement 402JAXBException 490JAXBResult 492JAXBSource 491Klasse abbilden 445komplexe Typen 418Listener 472, 477Listentypen 433Map abbilden 450Mapping Annotation 414, 455Marshaller 406MarshallException 490Marshalling 407, 473mehrdimensionales Array abbilden

452ObjectFactory 401, 435, 461Package 463package-info.java 402


695

Index

JAXB (Forts.)primitive Typen abbilden 447PropertyException 490Propertys 465, 470, 475, 486Referenzimplementierung 393Sammeltypen 434SAX-Integration 471SchemaGen 410, 677Standard-Java-Typen abbilden 447Unions 434UnmarshalException 490Unmarshaller 408, 467UnmarshallerHandler 471Unmarshalling 408, 467ValidationEvent 489ValidationEventCollector 492ValidationEventHandler 487ValidationEventLocator 489ValidationException 490validieren 486XJC 397, 669XmlAdapter 473, 477

JAXBContext 403, 464generieren 464

JAXBElement 402JAXBException 490JAXP 106, 215

Aufgabengebiete 107DocumentBuilder 134, 234, 240DocumentBuilderFactory 234, 235DOM-Einstieg 231DOMResult 263DOMSource 259einbinden 218Entity-Referenz 238ErrorListener 249, 256Factory-Mechanismus 219Kommentar 239NamespaceContext 295navigieren 286, 297Package 216QName 218Result 247, 262SAX-Einstieg 221SAXParser 185, 224, 229SAXParserFactory 223, 225SAXResult 264SAXSource 259SAXTransformerFactory 266

JAXP (Forts.)Schema 276, 281SchemaFactory 276, 277serialisieren 302Source 247, 257StAXResult 265StAXSource 261StreamResult 264StreamSource 260Template 252TemplatesHandler 266Transformer 247, 252TransformerFactory 246, 248TransformerHandler 268transformieren 243, 257URIResolver 248, 256Validator 276, 282ValidatorHandler 284validieren 271Versionen 217XInclude 227, 236XMLFilter 269XPath 289, 295XPathExpression 299XPathFactory 289, 290XPathFunction 292XPathFunctionResolver 292XPathVariableResolver 293

JAX-WS 495@RequestWrapper 560@ResponseWrapper 560@WebEndpoint 575@WebFault 521@WebMethod 520@WebParam 520@WebResult 521@WebService 516, 525, 562@WebServiceClient 574@XmlSeeAlso 559Apt 530Binding-Klasse 544, 556Client 568Code-First 512Contract-First 542Deployment 515, 536, 566Endpoint 533Hilfsklasse 514, 527, 544Holder 561, 577installieren 511


696

Index

JAX-WS (Forts.)Service-Interface 519, 526, 540, 544,

556, 559, 560, 572Service-Klasse 514, 515, 544, 562Service-Proxy 572Servlet 536sun-jaxws.xml 538Testbetrieb 514, 531, 545, 564WebServiceException 576WSDL-Dokument abrufen 534WSDL-Dokument einbinden 563, 565WsGen 528WsImport 557, 571Ziel-Namensraum 526

JCP 102Jetty 596

K

Kindknoten 25hinzufügen 158in DOM 152

Kommentar 22in DOM 147in SAX 198in StAX 370, 377mit JAXP 239

L

LexicalHandler 198registrieren 199, 224

Location 345, 348, 374Locator 196Lokaler Name 28LSResourceResolver 282

in JAXP 278

M

MarshalException 490Marshaller 406Marshalling 98MathML 18Maven 2 590, 592Mazzocchi, Stefano 588Modellbasierte Verarbeitung 84

DOM 87, 109JAXB 391

Modellbasierte Verarbeitung (Forts.)XML-Binding 92

Modellklasse 85Modifizieren

mit DOM 157Multichannel Publishing 586

N

Namensraum 27Default-Namensraum 29, 168in DOM 166in Java 218in StAX 357, 363, 368, 376lokaler Name 28, 167Präfix 28, 167, 168Präfixbindung 29, 168, 170, 195,

296, 353, 360, 368, 376qualifizierter Name 29, 167URI 28, 167

Namespace (Interface) 376Namespace � NamensraumNamespaceContext 295

in StAX 354, 364in XPath registrieren 296

Navigierenmit DOM 151mit JAXP 286, 297mit XPath 51, 100

Notationin DOM 150in SAX 200in StAX 380

NotationDeclaration 380

O

ObjectFactory 401, 435, 461Objektmodell 85

DOM 135in JAX-WS 523

Objekt-Modelle 87, 92OSGi 590

P

package-info.java 402Parent � Elternknoten


697

Index

Parsen 74mit DOM 160mit JAXP 230, 242mit SAX 184mit StAX 346, 385Pull-Parsing 82Push-Parsing 81

Parser 76in DOM 162in SAX 176in StAX 346, 385

PI � Processing InstructionPipeline 590Präfix 28Präsentierendes Format 63Presenting XML 588Processing Instruction 24

Daten 24in DOM 149in SAX 195in StAX 361, 370, 380Ziel 24

ProcessingInstruction (Interface) 380PropertyException 490Proxy 572Public-ID 161, 260Publishing 585Publishing-Framework 587Pull-Parsing 82Push-Parsing 81Push-Serializing 83

Q

QName 218in StAX 357, 378

Qualifizierter Name 29

R

Resin 588Result 262

DOMResult 263JAXBResult 492SAXResult 264StAXResult 265StreamResult 264

Root � Wurzelelement

S

SAX 78, 173Attribut 180, 193AttributeList 213Attributes 180Callback-Klasse 80, 173, 190Callback-Methode 177, 190CDATA 198ContentHandler 176, 190DeclHandler 200DefaultHandler 205DefaultHandler2 205DocumentHandler 213Dokument 179, 192DTD 199DTDHandler 186, 200Element 180, 192Entity 200, 201Entity-Referenz 196, 199EntityResolver 186, 202ErrorHandler 186, 201Event 79, 173, 190Event validieren 284Feature 187, 666Features 227Fehlerbehandlung 197, 201Filter 206Handler-Klasse 80, 173, 190ignorable Whitespace 194InputSource 176, 188JAXB-Integration 471Kommentar 198LexicalHandler 198Locator 196mit JAXP 221mit TrAX nutzen 259, 264, 265Notation 200parsen 184Parser 213ParserAdapter 214ParserFactory 213Pipeline 206Processing Instruction 195Property 665Propertys 187, 230SAXException 197Text 182, 193XMLFilter 208


698

Index

SAX (Forts.)XMLFilterImpl 208XMLReader 176XMLReaderAdapter 214XMLReaderFactory 176, 185

SAX-Event 591SAXException

SAXNotRecognizedException 188SAXNotSupportedException 188SAXParseException 201

Saxon 245SAXParser 224, 229

generieren 228SAXParserFactory 223, 225

generieren 229SAXTransformerFactory 266Schema 276, 281

generieren 279SchemaFactory 276, 277

generieren 279Serialisieren 74

mit DOM 164mit JAXP 302mit StAX 387Push-Serializing 83

Serializer 76in DOM 165in StAX 362, 387

Service-oriented Architecture 497Service-Proxy 572Services-API 221Sibling � GeschwisterknotenSimple API for XML � SAXSitemap 591SJSXP 306Snaml 588SOA 497SOAP 498

Binding-Style 550Source 257

DOMSource 259JAXBSource 491SAXSource 259StAXSource 261StreamSource 260

Stack 178StartDocument 377StartElement 378

StAX 81, 305API-Varianten 307Attribut 358, 367, 375, 379Attribute (Interface) 375, 379CDATA 354, 369, 376Characters 376Comment 377Cursor-API 308, 346Dokument 352, 364, 377DTD 370, 384Element 357, 365, 378EndDocument 378EndElement 379EntityDeclaration 382EntityReference 383Entity-Referenz 370, 383EventFilter 341Event-Iterator-API 309, 371Factory-Mechanismus 307filtern 340installieren 305Knotentypen 347, 349, 372Kommentar 370, 377Location 345, 348, 374mit TrAX nutzen 261, 265Namensraum 363, 368Namespace 376NamespaceContext 354, 364NotationDeclaration 380parsen 346, 385Processing Instruction 361, 370, 380ProcessingInstruction (Interface) 380Propertys 337, 344, 353, 386serialisieren 362, 387StartDocument 377StartElement 378StreamFilter 341Text 354, 369, 376XMLEvent 310, 373XMLEventAllocator 343XMLEventFactory 344XMLEventReader 385XMLEventWriter 387XMLInputFactory 337XMLOutputFactory 343XMLReporter 338XMLResolver 339XMLStreamConstants 347XMLStreamReader 346


699

Index

StAX (Forts.)XMLStreamWriter 362

Streambasierte Verarbeitung 77SAX 78, 173StAX 81, 305

StreamFilter 341Streaming API for XML � StAXStylesheet 58, 244Sun Java Streaming XML Parser �

SJSXPSystem-ID 161

T

Templates 252generieren 266

TemplatesHandler 266Text 21

in DOM 147in SAX 182, 193in StAX 354, 369, 376in XML Schema 39

Transformation API for XML � TrAXTransformer 247, 252

generieren 250, 252TransformerFactory 246, 248

generieren 252SAXTransformerFactory 266

TransformerHandler 268erzeugen 268

Transformieren 57, 100mit JAXP 243, 257

TrAX 243

U

Union 40UnmarshalException 490Unmarshaller 408, 467UnmarshallerHandler 471Unmarshalling 98URI 161URIResolver 248, 256

V

ValidationEvent 489ValidationEventCollector 492ValidationEventHandler 487

ValidationEventLocator 489ValidationException 490Validator 276, 282

generieren 281ValidatorHandler 284

generieren 281Validieren 76

mit JAXB 486mit JAXP 226, 236, 271, 272, 274von SAX-Events 284

Verarbeitungsanweisung � Processing Instruction

W

W3C 17Web Service Description Language �

WSDLWebservice 496

Code-First 509, 512Consumer 508Contract-First 508, 542Fault-Message 503, 521Input-Message 503, 520Kompatibilität 510, 554Nachricht 502Operation 503, 520Output-Message 503, 521Protokoll 498, 499Provider 508SOAP 498WSDL 500WS-I 510XML-Binding 500Ziel-Namensraum 501, 526

Wellformedness 26Wohlgeformtheit 26WSDL 500

<binding> 505, 550<fault> 504<import> 502<input> 504<message> 502, 549<operation> 504<output> 504<part> 502, 549<port> 506, 552<portType> 504, 549<service> 507, 552


700

Index

WSDL (Forts.)<soap:body> 552<soap:operation> 552<types> 502, 549Datentypen 502importieren 502in JAX-WS 534Nachricht 502Nachrichtentypen 503Operation 503Operationstypen 503Port 506Port-Typen 504Protokoll 506Protokollbindung 505Service 507Struktur 501

WS-I 510Basic Profile 1.1 554

Wurzelelement 25in DOM 153in JAXB 459

X

X4Dialog 588XInclude mit JAXP 227, 236XML 17

Attribut 20, 145, 146, 180, 193, 358, 367, 375, 379, 421

Attributname 20Attributwert 20beschränken 30CDATA 22, 147, 198, 354, 369, 376Deklaration 23, 143Dokument 18, 143, 179, 192, 352,

364, 377Element 19, 144, 180, 192, 357,

365, 378, 422Element – Kurzform 20Elementname 20, 145Encoding 23End-Tag 19Entity-Referenz 21, 150, 196, 199,

238, 370, 383generieren 155Grammatik 30, 76Gültigkeit 27Knoten 25

XML (Forts.)Knotentypen 135Kommentar 22, 147, 198, 239, 370,

377modifizieren 157navigieren 51, 100, 151, 286, 297parsen 74, 160, 184, 230, 242, 346,

385Parser 76Processing Instruction 24, 149, 195,

361, 370, 380serialisieren 74, 164, 302, 362, 387Serializer 76Standalone 23Start-Tag 19Text 21, 147, 182, 193, 354, 369,

376transformieren 57, 100, 243, 257validieren 76, 226, 236, 271, 272,

274, 486verarbeiten 77, 84Version 23

XML Inclusions � XIncludeXML Schema 37

<all> 43<attribute> 44, 46<choice> 43<complexContent> 45<complexType> 42<element> 43, 47<extension> 45<import> 50, 278<include> 278<list> 40<restriction> 40, 45<schema> 38<sequence> 42<simpleContent> 45<simpleType> 39<union> 40Attribut definieren 46einfache Typen 39Elemente definieren 47globale Definition 47in JAXP 226, 236, 272, 274komplexe Typen 41Referenz 48, 49referenzieren 38Schemadatei 38


701

Index

XML Schema (Forts.)Ziel-Namensraum 49

XmlAdapter 473, 477XML-Binding 92

bei Webservices 500Binding Compiler 98, 397, 410, 669Features 96Marshalling 98, 407, 473mit JAXB 391Überblick 98Unmarshalling 98, 408, 467

XML-Deklaration 23, 143XML-Dokument 18

in DOM 143in SAX 179, 192in StAX 352, 364, 377

XMLEvent 310, 373erzeugen 344

XMLEventAllocator 343XMLEventFactory 344

erzeugen 336XMLEventReader 385

erzeugen 340XMLEventWriter 387

erzeugen 344XMLFilter 208

generieren 270mit TrAX nutzen 269XMLFilterImpl 208

XMLInputFactory 337erzeugen 336

XML-Name 19XMLOutputFactory 343

erzeugen 336XML-Parser 27XML-Pipeline 590XML-Publishing 585XML-Publishing-Framework 587XMLReporter 338XMLResolver 339XMLStreamConstants 347XMLStreamReader 346

erzeugen 340XMLStreamWriter 362

erzeugen 344XPath 51, 100

* 54@ 53@* 54

XPath (Forts.)Attributknoten 53comment() 54compare() 56concat() 56contains() 57count() 56document() 256Elementknoten 53Funktionen 56in Java 100Knotentypen 52Kommentarknoten 54Lokalisierungspfad 53lower-case() 57mit Java 57name() 57node() 54not() 57position() 56Prädikat 54Processing Instruction 54processing-instruction() 54round() 56starts-with() 57string-length() 57text() 54Textknoten 54upper-case() 57Wildcard 54

XPath (Interface) 289, 295generieren 294

XPathExpression 299XPathFactory 289, 290

generieren 294XPathFunction 292XPathFunctionResolver 292

registrieren 293, 297XPathVariableResolver 293

registrieren 294, 297XSL-FO 63

DIN-A4-Vorlage 70fo 64fo:block 68fo:flow 67fo:layout-master-set 65fo:list-block 68fo:page-sequence 66fo:region-after 66


702

Index

XSL-FO (Forts.)fo:region-before 66fo:region-body 66fo:region-end 66fo:region-start 66fo:root 64fo:simple-page-master 65fo:table 68fo:table-and-caption 68FOP 69FO-Prozessor 69master-name 65Namensraum 64page-reference 67PDF erzeugen 70Präfix 64präsentierendes Format 63Regionen 66Seitenrand 65XSL-FO-Dokument 64XSLT-Stylesheet 68

XSLT 57, 58, 100Kontextknoten 61Namensraum 60Präfix 60Prozessor 58, 244Quelldokument 58, 244, 257Stylesheet 58, 244, 257Version 60Wurzelelement 60xsl:apply-templates 62xsl:copy-of 62xsl:for-each 63xsl:if 63xsl:import 249xsl:include 249xsl:output 255xsl:param 253xsl:sort 62xsl:template 61xsl:value-of 62Zieldokument 58, 244, 262

Documents

Java und XML - s3-eu-west-1.amazonaws.com · 8.2 JAX-WS besorgen und installieren ..... 511 8.3 Code-First – Webservices aus Java-Klassen generieren ... 512 8.3.1 Das Beispiel