XML. extensible Markup Language. Dr. Beatrice Amrhein.

Transkript

1 XML extensible Markup Language Dr. Beatrice Amrhein

2 2

3 Inhaltsverzeichnis 1 XML Grundlagen Die wichtigsten Punkte XML Sprachen und Anwendungen Der Aufbau eines XML Dokuments Elemente Attribute Zeichen- und Entity-Referenzen Kommentare und Verarbeitungsanweisungen Die XML Deklaration XML Knotentypen und Nachfolger Wohlgeformtheit: Zusammenfassung Namespaces Wozu dienen Namespaces? Definition eines Namespaces Qualifizierte Element-Namen XSD: XML Schema Definition Deklarationen <--> Definitionen Deklaration von einfachen Typen Vordefinierte primitive Schema Typen Attribut Deklarationen Komplexe Schema Typen Spezielle Schema Elemente Schlüssel SAX: Simple Application Interface for XML Was ist SAX? Wofür ist SAX geeignet? Wie funktioniert SAX? Übersicht über das SAX API Implementation des Default Handlers Fehlerbehandlung: ErrorHandler...42 Ein SAX Beispiel DOM: Das Document Object Model...45 Was ist DOM?...45 Die DOM Node Typen Die org.w3c.dom Java Interfaces Benutzen des DOM Parsers StAX: Streaming API for XML Was ist StAX? JAXB: Java Architecture for XML Binding Die JAXB Architektur Das Binding Übersetzung verschiedener Basis-Datentypen Erzeugen der Java Klassen Einlesen der XML Daten Schreiben der Daten in ein XML File Anpassen der generierten Java Klassen und Member Variablen Externe Binding-Deklaration Erzeugen von Schematas Schreiben von XML Daten ohne ObjectFactory Die Transformations-Sprache XSLT

4 8.1 Wie funktioniert XSLT? Der Aufbau eines Stylesheets: Templates Die wichtigsten XSLT Befehle Grundlegendes zu XSLT Default Template Regeln Template Driven vs. Data Driven Stylesheets XPath: Die XSL Adressierungssprache Die XPath Syntax Adressierungs-Achsen Die wichtigsten XPath Funktionen XSL-FO Einführung Die wichtigsten FO Elemente Die wichtigsten Attribute

5 1 XML Grundlagen 1.1 Die wichtigsten Punkte XML ist dazu gemacht, Informationen auszutauschen, zu speichern und zu übertragen, aber nicht um Daten darzustellen. In HTML sind Daten und deren Darstellung vermischt. In XML sind die Daten von deren Präsentation getrennt. XML wird benutzt, um Daten zwischen verschiedenen Applikationen, Datenbanken, Computer Systemen und auch über das Internet auszutauschen. XML ist keine Programmiersprache, sondern ein Standard, um Informationen zu strukturieren, zu verschicken oder zu speichern. XML trennt Information von deren Darstellung -- im Gegensatz zu HTML XML vereinfacht den Daten Austausch zwischen inkompatiblen Systemen. XML vereinfacht den Austausch von Informationen über das Internet (B2B). XML Dokumente sind Unicode Text Files, einfach lesbar und somit einfach benutzbar. Aus XML entstehen neue Sprachen: SVG, WAP (Wireless Application Protocol ), WML (Wireless Markup Language), CML (Chemical Markup Language ), MathML,... Immer mehr Applikationen haben XML Schnittstellen, (Datenbanken, MSExcel, MSWord, SAP...), was den einfachen Austausch von Informationen erlaubt. XML wurde 1998 von einer Arbeitsgruppe des World Wide Web Consortium (W3C) definiert, um Informationen im World Wide Web bereitzustellen. extensible: Die Tag-Menge ist erweiterbar (Metasprache) markup: Die Tags enthalten Metadaten Ein HTML Beispiel <html> <h1>people</h1> <table border="1"> <tr> <th>name</th> <th>profession</th> </tr> <tr> <td>alan Turing</td> <td>computer scientist</td> </tr> <tr> <td>richard M. Feynman</td> <td>physicist</td> </tr> </table> </html> 5

6 Ein XML Beispiel XML Dokumente sind reine Datenfiles und enthalten im Gegensatz zu HTML normalerweise keine Präsentations-Hinweise. <?xml version="1.0"?>  <people> <person> <name>alan Turing</name> <profession>computer scientist</profession> </person> <person> <name>richard M. Feynman</name> <profession>physicist</profession> </person> </people> Der Unterschied von XML zu HTML HTML ist endliche Menge von Formatierungselementen wie Überschriften, Absätze, Listen, Tabellen usw. und dient zur Darstellung von Informationen XML ist eine erweiterbare Menge struktureller und inhaltlicher Elemente und enthält die Beschreibung und die Struktur der Informationen 6

7 1.2 XML Sprachen und Anwendungen Durch Vereinbaren gewisser Tags, wird eine gemeinsame (Austausch-) Sprache für mathematische oder chemische Formeln, Bilder, Ressourcen,... definiert. Extensible HyperText Markup Language (XHTML) Scalable Vector Graphics (SVG) Mathematical Markup Language (MathML) XML Schema Definition (XSD) Wireless Markup Language (WML) Chemical Markup Language (CML) Financial Products Markup Language (FpML) User Interface Markup Language (UIML) Geography Markup Language (GML) Bean Markup Language (BML)... Obwohl XML zunächst vor allem für Internet Applikationen definiert wurde, wird XML heute für verschiedenste Anwendungen eingesetzt. Die Standards werden darum laufend den neuen Bedürfnissen angepasst. Elektronischer Datenaustausch zwischen Firmen (B2B) Konfigurationsfiles von Software Erstellen und Verarbeiten von Textdokumenten (vgl. DocBook) Definition von Netzwerk- oder Internet Protokollen (SOAP, WSDL,...) Schnittstelle zu Datenbanken Deklarative Programmierung Der Aufbau eines XML Dokuments XML-Dokumente müssen wohlgeformt sein. Das heisst, sie müssen nach gewissen Regeln aufgebaut sein.ein XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das Dokument ohne Fehler einlesen kann. XML-Dokument XML-Parser Applikation Einige der Regeln sind: Es gibt im XML-Dokument genau ein äusserstes Element (Root Element). Jedes Element hat ein Start- und ein passendes End-Tag. Die Elemente sind korrekt geschachtelt.... Dieses Kapitel behandelt im Folgenden die vollständigen Regeln für die Wohlgeformtheit. 7

8 Ein Beispiel <?xml version="1.0"?>  <people> <person> <name>alan Turing</name> <profession> computer scientist </profession> </person> Prolog optionaler Kommentar Root / Document -element <person> <name>richard M. Feynman</name> <profession> physicist </profession> </person> </people> <people> ist das Root-Element oder Document-Element des XML Dokuments. Die zwei <person> Elemente sind Kind-Elemente von <people> Das <name> Element hat als Kind einen Text-Knoten. 1.4 Elemente Die Struktur eines Elements Start-Tag <person> <name>alan Turing</name> <profession> computer scientist </profession> </person> Inhalt End-Tag Jedes Element beginnt mit einem Start-Tag (hier <person>) und endet mit einem End-Tag </person>. StartTag und End-Tag müssen identisch sein (case-sensitiv) bis auf den Slash im End-Tag. Gültige Element Namen Elementnamen dürfen Buchstaben, Ziffern, Unterstriche (_), Bindestriche (-) und Punkte (.) enthalten Elementnamen müssen mit einem Buchstaben oder einem Unterstrich beginnen Doppelpunkte sind für Namespaces reserviert Gültige Namen <Drivers_License_Number> <year-month-day> <firstname> Ungültige Namen <Driver's_License_Number> <year/month/day> <first Name> 8

9 Der Element-Inhalt Der Inhalt eines Elementes kann aus Zeichendaten oder aus weiteren Elementen bestehen: <person> <name> <firstname>alan</firstname> <lastname>turing</lastname> </name> <profession>computer scientist</profession> <profession>mathematician</profession> <profession>cryptographer</profession> </person> <firstname> und <lastname> sind Elemente, welche als Kinder nur Zeichendaten (Text-Knoten) enthalten. <name> und <person> enthalten weitere Kind-Elemente. Der folgende Baum entspricht (hier) gerade dem DOM (Document Object Model). Die Blätter eines XML-Baums sind entweder Text-Knoten (Zeichendaten, Strings) oder leere Knoten. Man unterscheidet im Baum zwischen Kindern (d.h. direkten Nachfolgern) und allgemeinen Nachfolgern auf beliebigen Stufen (Kinder, Enkel, Urenkel,...) Elemente mit gemischten Inhalt Textorientierte XML-Dokumente enthalten oft Elemente mit gemischtem Inhalt. Beispiele davon sind Briefe, Reports, Bücher, Artikel,... <biography> <name>alan Turing</name> was one of the first people to truly deserve the name <profession>computer scientist</profession> </biography> Das <biography> Element ist ein sog. "mixed element". Es enthält sowohl Zeichendaten (Text-Knoten) als auch Element-Knoten. 9

10 Im zugehörigen XML Baum hat das biography Kinder darum Elemente und Text-Knoten als Kinder. biography name was one of the... profession Alan Turing computer scientist Leere Elemente Leere Elemente sind solche ohne Inhalt. <image></image> Bei leeren Elementen darf der End-Tag fehlen, die Darstellung verkürzt sich auf den Start-Tag. <image/> 1.5 Attribute Das Start-Tag eines Elements kann ein oder mehrere Attribute enthalten <person born="1912/06/23" died="1954/06/07"> <name>alan Turing</name> <image src="turing.jpg"/> </person> Nur das Start Tag darf Attribute enthalten. Attribut Werte müssen in Anführungszeichen (") oder in Apostrophe (') eingeschlossen werden Attribut Werte dürfen das Zeichen, in das sie eingeschlossen sind, nicht enthalten Attribut Werte dürfen das Zeichen < nicht enthalten Attribut Werte dürfen das Zeichen & nur am Anfang einer Zeichen- oder Entity-Referenz enthalten Ein Element darf nicht zwei Attribute mit dem gleichen Namen haben Attribute können nicht verschachtelt werden Die Reihenfolge der Attribute ist unwesentlich Attribute sind darum eher für Metadaten, Elemente für die eigentlichen Daten zu verwenden. Die Unterscheidung zwischen Daten und Metadaten ist allerdings nicht immer einfach. 10

11 1.6 Zeichen- und Entity-Referenzen Sonderzeichen können als Zeichen Referenzen (Entity) mit dem entsprechenden Unicode eingefügt werden: <copyright> Copyright 2001</copyright> Beispiele von Zeichen Referenzen: (Copyright) (Euro) Für die Zeichen &, <, >, ', " gibt es spezielle Entity Referenzen Zeichen Entity-Referenz & & < < > > ' ' " " <publisher> O'Reilly & Associates </publisher> Durch Angabe des entsprechenden Zeichensatzes wie zum Beispiel <?xml version="1.0" encoding="iso "?> werden die Umlaute ä, ö, ü als Zeichen erkannt und müssen nicht als Referenzen angegeben werden. 1.7 Kommentare und Verarbeitungsanweisungen Kommentare dienen der Dokumentation des XML Codes und können überall ausser innerhalb eines Tags stehen  Kommentare dürfen ausser am Anfang () keine "--" Sequenz enthalten. Verarbeitungsanweisungen (Processing Instructions) liefern Informationen für bestimmte Anwendungen und stehen normalerweise im Prolog des XMLDokuments <?robots index="yes" follow="no"?> Eine spezielle Verarbeitungsanweisung ist die XML Deklaration zu Beginn des Dokumentes <?xml version="1.0" encoding="iso "?> Eine andere Verarbeitungsanweisung wird zum Verknüpfen eines XSL-Stylesheets verwendet <?xml-stylesheet href="stl.xsl" type="text/xsl"?> 1.8 Die XML Deklaration Die XML-Deklaration ist optional, muss aber - falls vorhanden - ganz am Anfang des XML-Dokuments stehen <?xml version="1.0" encoding="utf-8"?> <?xml version="1.0" encoding="iso "?> Das Encoding gibt die für das XML Dokument verwendete Codierung an. 11

12 1.9 XML Knotentypen und Nachfolger Wenn man in XML von Knoten redet, meint man die Bestandteile der Dokument-Baumstruktur. Die verschiedenen XML Knotentypen sind Elemente --> <firstname>... </firstname> Attribute --> date="1912" Textknoten --> Alan Kommentarknoten -->  Verarbeitungsanweisungen --> <? processing introduction?> Wir betrachten das folgende Beispiel: <people>  <person> <name> <firstname>alan</firstname> <lastname>turing</lastname> </name> <born date= 1912/06/23 > <profession>computer scientist</profession> <profession>cryptographer</profession> </person> <people> Jedes XML-Dokument beginnt mit einem Wurzelknoten. Dieser hat jedoch keine konkrete Ausprägung, sondern ist nur der abstrakte "Ursprung" der Daten und wird oft mit einem Slash (/) bezeichnet. Erst sein unmittelbarer Abkömmling in der Baumstruktur hat eine konkrete Ausprägung: nämlich das RootElement oder Dokument-Element, also das äusserste, den gesamten Inhalt umfassende Element (hier <people>). Das Root-Element hat in unserem Beispiel zwei Kind-Knoten (bzw. direkte Nachfolger): einen KommentarKnoten und ein person Element. Aus Sicht des person Elements ist der Knoten people der Elternknoten, oder das Elternelement. Der person Knoten hat vier Kind-Knoten, nämlich ein name Element, ein born Elemen und zwei profession Elemente. Das born Element hat einen assoziierten Knoten, nämlich ein Attribut namens date. Der Kind-Knoten von firstname ist der Text-Knoten Alan. Die (direkten und indirekten) Nachfolger des person-elementes sind dessen Kinder (name, born, profession) sowie die indirekten Nachfolger firstname und lastname Wohlgeformtheit: Zusammenfassung XML-Dokumente müssen wohlgeformt sein. Das heisst, sie müssen nach folgenden Regeln aufgebaut sein: Es gibt im XML-Dokument genau ein äusserstes Element (Document- oder Root-Element) Jedes Element hat ein Start- und ein passendes End-Tag (case-sensitive!) Die Elementnamen bestehen aus Buchstaben, Ziffern und den Zeichen Punkt, Unterstrich, Bindestrich und Doppelpunkt (für Namespaces) Elementnamen beginnen mit einem Buchstaben oder einem Unterstrich Die Elemente sind korrekt geschachtelt Alle Attribut-Werte stehen im Start-Tag eines Elements und in Anführungszeichen (Single oder Double Quotes) Ein Element hat nicht mehrere Attribute mit demselben Namen Kommentare und Verarbeitungsanweisungen stehen nicht innerhalb von Tags Attribut-Werte dürfen die Zeichen < nicht enthalten und & nur für Entities 12

13 2 Namespaces 2.1 Wozu dienen Namespaces? Namespaces werden benötigt um: Namenskonflikte bei Elementen und Attributen zu vermeiden. Elemente und Attribute einer bestimmten XML-Anwendung zuzuordnen (XSL, SVG, MathML, FO,...). Browser können diese automatisch erkennen und umsetzen. die gewohnten Namen (title, name, type,...) für verschiedene Anwendungen benutzen zu können. Ein SVG Beispiel <svg:svg xmlns:svg=" > <svg:g font-family="helvetica" font-size="6"> <svg:rect x="10" y="33" width="10" height="10" fill="#ffcccc"/> <svg:text x="7" y="50">0 sec.</svg:text> <svg:rect x="60" y="20" width="10" height="10" fill="#ffcccc"/> <svg:text x="52" y="40">3 sec.</svg:text> <svg:path d="m-5,0 L0,-10 L5,0 z" fill="blue" stroke="red"> <svg:animatemotion from="15,43" to="65,30" begin="0s" dur="3s"/> </svg:path> </svg:g> </svg:svg> Ein MathML Beispiel MathML wird in diesem Beispiel innerhalb von einer HTML Seite benutzt. <html xmlns=" <body> <h4>can your browser display Presentation MathML?</h4> <p> <m:math xmlns:m=" <m:mrow> <m:msup> <m:mfenced open="[" close="]"> <m:mrow> <m:mi>a</m:mi> <m:mo>+</m:mo> <m:mi>b</m:mi> </m:mrow> </m:mfenced> <m:mn>260</m:mn>... </p>... 13

14 Beispiel eines Namenskonflikts Namen wie date, title, name, description will man oft in verschiedenstem Kontext benutzen können: <?xml version="1.0"?> <catalog> <description> <title>impressionist Paintings</title> <creator>elliotte Rusty Harold</creator> <date> </date> </description> <painting> <title>memory of the Garden at Etten</title> <artist>vincent van Gogh</artist> <date> <month>november</month> <year>1888</year> </date> </painting> </catalog> 2.2 Definition eines Namespaces Durch Definieren eines Namespaces werden die Namen eindeutig description creator painting title date artist day month year description dc:creator dc:title dc:date painting pt:artist pt:title pt:day pt:date pt:month pt:year Ein Namespace wird durch einen URI definiert: xmlns:dc= xmlns:m=" Der URI zeigt nicht unbedingt auf eine existierende HTML-Seite.Wichtig ist bloss, dass der Namespace eindeutig ist. Parser vergleichen Namespace-URIs zeichenweise. Der Präfix dient als dessen Abkürzung. Für Namespaces werden URL's benutzt, weil diese weltweit eindeutig festgelegt sind. So benutzt zum Beispiel Microsoft für ihre Anwendungen Namespaces der Form oder OpenOffice die Namespaces 14

15 2.3 Qualifizierte Element-Namen Um Elemente in einen Namespace einzufügen, werden sie mit dem entsprechenden Präfix qualifiziert: <dc:title>impressionist Paintings</dc:title> Mit einem xmlns-attribut kann einem Namespace-URI ein Präfix zugeordnet werden: <description xmlns:dc=" > Der Präfix ist nur innerhalb des Elements gültig, in dem er definiert wird. Damit ein Präfix im ganzen Dokument gültig ist, muss er also im Root-Element definiert werden. Die definierten Namespaces werden dann im XML Dokument verwendet, um die Namenskonflikte aufzulösen. <?xml version="1.0"?> <catalog xmlns:dc=" xmlns:pt=" <dc:description > <dc:title>impressionist Paintings</dc:title> <dc:creator>elliotte Rusty Harold</dc:creator> <dc:date> </dc:date> </dc:description> <pt:painting> <pt:title>memory of the Garden at Etten</pt:title> <pt:artist>vincent van Gogh</pt:artist> <pt:date> <pt:month>november</pt:month> <pt:year>1888</pt:year> </pt:date> </pt:painting> </catalog> Default Namespaces Wird ein Namespace ohne Präfix definiert, so gehören alle Elemente ohne qualifizierten Namen innerhalb dieses Bereichs zu diesem Namespace. <html xmlns=" <head><title>presentation Examples</title></head> <body> <h4>this is a Presentation of MathML</h4> <math xmlns=" <mrow> <msubsup><mi>x</mi><mn>1</mn><mi>a</mi></msubsup> <mo>+</mo> <msubsup><mi>x</mi><mn>2</mn><mi>b</mi></msubsup> </mrow> </math> </body> </html> 15

16 16

17 XSD XML Schema Definition 17

18 3 XSD: XML Schema Definition Was ist ein Schema? XML Schema ist eine XML basierte Alternative für ein DTD. Ein XML Schema beschreibt die Struktur eines XML Dokuments. XML Schema ist eine W3C Recommendation Statt XML Schema wird oft die Abkürzung XSD (XML Schema Definition) benutzt. Ein Schema definiert die Elemente, welche im Dokument vorkommen dürfen die Attribute, welche vorkommen dürfen welche Elemente Kind-Elemente sind die Reihenfolge der Elemente die Anzahl der Kind-Elemente ob ein Element leer ist oder Text enthalten kann Datentypen für Elemente und Attribute Default Werte und feste Werte für Elemente und Attribute Die Vorteile von XML Schema XML Schema unterstützt Datentypen Einfache und exakte Beschreibung der erlaubten Werte Einfache Verifizierbarkeit der Korrektheit der Daten Einfaches Definieren von Einschränkungen (facets) an die Daten Einfaches Definieren von Datenformaten (pattern) Einfaches Konvertieren der Daten in andere Datentypen Einfaches Arbeiten mit Daten aus Datenbanken XML Schema benutzt XML Syntax Keine neue Sprache muss erlernt werden. Editieren, transformieren und parsen der Schema Files kann durch die selben Editoren oder Tools erfolgen wie für normale XML Dateien. XML Schemas sind erweiterbar Eigene Datentypen können von den vordefinierten Datentypen hergeleitet werden Schemas (die darin definierte Typen) können in anderen Schemas wieder verwendet werden Ein beliebiges XML Dokument kann mehrere Schemas referenzieren. 18

19 Ein Beispiel Schema <?xml version="1.0"?> <xs:schema xmlns:xs=" targetnamespace=" elementformdefault="qualified"> <xs:element name="note"> <xs:complextype> <xs:sequence> <xs:element name="to" type="xs:string"/> <xs:element name="from" type="xs:string"/> <xs:element name="heading" type="xs:string"/> <xs:element name="body" type="xs:string"/> </xs:sequence> </xs:complextype> </xs:element> </xs:schema> Das Schema definiert ein neues Vokabular. Alle im Schema definierten Elemente (und ev. Attribute) gehören dann zum Target- Namespace ( Ein dazu passendes Instanz Dokument <?xml version="1.0"?> <note xmlns=" xmlns:xsdi=" xsdi:schemalocation=" note.xsd"> <to> Bill </to> <from> Jani </from> <heading> Reminder </heading> <body> Don't forget the book! </body> </note> Das XML-Dokument benutzt das im Schema definierte Vokabular. Verknüpfen des Schemas mit dem Instanz Dokument xmlns=" ist der vom Schema definierte Namespace (hier als Default Namespace gesetzt). xmlns:xsdi=" /XMLSchema-instance" definiert den xsdi Namespace (für alle xsdi- Befehle). xsdi:schemalocation= " note.xsd" gibt das Schema File an: im File note.xsd wird die im Instanz-Dokument benutzte Sprache (zum Namespace definiert. 19

20 Die Teile eines Schemas Eine Element-Deklaration bestimmt den Namen und den Typ eines Elementes. Eine Typ-Definition bestimmt den Namen eines Typs und die Beschreibung (Zusammensetzung) dieses Typs. 3.1 Deklarationen <--> Definitionen Elementdeklarationen sind entweder lokal oder global: Globale Elementdeklarationen sind Kind-Elemente von <schema> und können als Dokumentelement eines Instanz-Dokuments vorkommen. <xs:schema...> <xs:element name="note"> <xs:complextype>... </xs:complextype> </xs:element>... </xs:schema> Lokale Elementdeklarationen sind Kind-Elemente einer Typ-Definition und somit nicht global bekannt. <xs:complextype name="addresstype"> <xs:sequence> <xs:element name="to" type="xs:string"/>... </xs:sequence>... Eine Deklaration beschreibt ein Element oder Attribut, welches im Instanz-Dokument vorkommen darf. So wird ein <age>, bzw. ein <product> Element deklariert. <xs:element name="age" type="xs:short"/> <xs:element name="product">... </xs:element> 20

21 Eine Definition definiert einen Typ (hier producttype), welcher dann in einer Element- oder AttributDeklaration verwendet werden kann. <xs:complextype name="producttype">... </xs:complextype> Lokale Typen (die in eine Typ-Definition eingebettet sind und also keinen Namen haben) nennt man auch anonyme Typen. Eine Typ-Definition hat immer ein name-attribut (sonst kann der Typ nirgendwo verwendet werden). Ein solcher Typ nennt man darum benannter Typ. In der Deklaration kann ein Element entweder einen vordefinierten (benannten) Typ verwenden (shoetype) <xs:element name="shoesize" type="shoesizetype"/>... oder einen anonymen Typ definieren <xs:element name="shoesize"> <xs:complextype> <xs:simplecontent>... </xs:simplecontent> </xs:complextype> </xs:element> aber nicht beides gleichzeitig! Das Schema Typ-System Einfache Typen sind Strings, Zahlen, Zeittypen oder Listen, bzw. Vereinigungen davon. Elemente mit komplexen Typen können selber wieder Elemente und/oder Attribute enthalten. 21

22 3.2 Deklaration von einfachen Typen Beispiele von einfachen Elementen mit atomaren Typen <lastname>schmid</lastname> <age>34</age> <born> </born> Die entsprechenden Deklarationen: <xs:element name="lastname" type="xs:string"/> <xs:element name="age" type="xs:short"/> <xs:element name="born" type="xs:date"/> Elemente mit atomaren (einfachen) Typen können einen Default Wert oder einen festen Wert haben: <xs:element name="color" type="xs:string" default="red"/> <xs:element name="color" type="xs:string" fixed="red"/> Wiederholungen minoccurs/maxoccurs Die Anzahl möglicher Wiederholungen eines Elementes wird mit den Attributen minoccurs und maxoccurs angegeben: <xs:complextype name="familytype"> <xs:sequence> <xs:element name="lastname" type="xs:string"/> <xs:element name="childname" type="xs:string" maxoccurs="10" minoccurs="0"/> </xs:sequence> </xs:complextype> Fehlt das minoccurs oder maxoccurs Attribut, dann gilt automatisch der Defaultwert 1. Die allgemeine Syntax für einfache Elemente: <xs:element name="elementname" type="elementtyp" minoccurs="min" maxoccurs="max" default/fixed="vorgabe" /> 22

23 3.3 Vordefinierte primitive Schema Typen Es gibt in der Schema Sprache bereits vordefinierte primitive Typen: Mögliche boolean Werte sind: true, false, 1, 0 date ist von der Form (Jahr-Monat-Tag) time ist von der Form 21:36:54 (Stunde:Minute:Sekunde) gyearmonth besteht bloss aus Jahr und Monat gmonthday besteht bloss aus Monat und Tag datetime ist date und time getrennt durch ein Trenn-Zeichen T ( T21:36:54) Abgeleitete String Typen string: Ein beliebiger String normalizedstring: Ein String ohne Tabs oder Newlines token: Ein normalizedstring ohne Anfangs-, End- oder aufeinander folgende Spaces anyuri: Ein URI, z.b. Name: Ein Elementname mit Namespace NCName: Ein Name ohne Namespace language: Ein gültiger xml:lang Wert z.b. DE, EN, FR,... ID, IDREF, ENTITY,... sind aus Kompatibilitätsgründen aus der Sprache DTD übernommen. 23

24 Numerische Datentypen integer: Eine (beliebig grosse) ganze Zahl nonpositiveinteger: Eine negative Zahl (inklusive 0) negativeinteger: Eine negative Zahl (ohne 0) long: Der Bereich von bis int: Der Bereich von bis short: Der Bereich von bis byte: Der Bereich von -128 bis 127 nonnegativeinteger: Von 0 bis unendlich unsignedlong: Von 0 bis unsignedint: Von 0 bis unsignedshort: Von 0 bis unsignedbyte: Von 0 bis 255 positiveinteger: Von 1 bis unendlich decimal: Eine beliebig lange Zahl der Form , -98, +24.5,... float: 32 bit Zahlen der Form 12.56E3, 1.356, INF, -INF, NAN,... double: 64 bit Zahlen der Form 12.56E3, 12560, 0, INF, -INF, NAN,... 24

25 3.4 Attribut Deklarationen Attribute können nicht verschachtelt werden, sie haben also immer einen einfachen Typ. Elemente, welche Attribute enthalten, haben hingegen immer einen komplexen Typ. Ein Beispiel <person gender="male">peter Muster</person> die Attribut-Deklaration: <xs:attribute name="gender" type="xs:string"/> Wie ein Attribut einem Element zugefügt wird, sehen wir im Kapitel über die Komplexen Typen. Beispiele von Attribut Deklarationen Ein Attribut mit Default Wert: <xs:attribute name="lang" type="xs:string" default="en"/> Ein Attribut mit fixem Wert: <xs:attribute name="lang" type="xs:string" fixed="en"/> Ein optionales Attribut: <xs:attribute name="lang" type="xs:string" use="optional"/> Das Attribut muss vorhanden sein: <xs:attribute name="lang" type="xs:string" use="required"/> Vorsicht: Attribute sind optional, ausser sie sind mit use="required" deklariert! List und Union Typen Ein List-Typ definiert eine Liste von einfachen Typen: Beispiel: Liste von ganzen Zahlen <xs:simpletype name="regnumbertype"> <xs:list itemtype="xs:int"/> </xs:simpletype> Liste von ganzen Zahlen der Länge 4: <xs:simpletype name="shortregnumbertype"> <xs:restriction base="regnumbertype"> <xs:length value="4"/> </xs:restriction> </xs:simpletype> Eine Liste von ganzen Zahlen: <regnumber> </regnumber> Eine Liste der Länge 4: <shortregnumber> </shortregnumber> Ein Union-Typ ist eine Vereinigung von einfachen Typen: <xs:simpletype name="unotype"> <xs:union membertypes="xs:int </xs:simpletype> xs:boolean"/> Elemente vom Typ UnoType wären also zum Beispiel <unoelem>41</unoelem> oder <unoelem>true</unoelem> 25

26 3.5 Komplexe Schema Typen Ein komplexes Element ist ein XML Element mit einem komplexen Typ. Es gibt vier Arten von komplexen Elementen leere Elemente (die nur Attribute enthalten), Elemente, welche nur andere Elemente enthalten, gemischte Elemente enthalten sowohl andere Elemente als auch Text. Elemente mit beliebigem Inhalt Elemente mit komplexen Typen können also andere Elemente, Text-Knoten und/oder Attribute enthalten. Leere Elemente Ein leeres Element <product productid="1345" /> Ein mögliches XML Schema: <xs:complextype name="producttype"> <xs:attribute name="productid" type="xs:positiveinteger"/> </xs:complextype> <xs:element name="product" type="producttype"/> Eine analoge Elementdeklarationen (mit anonymem Typ): <xs:element name="product"> <xs:complextype> <xs:attribute name="prodid" type="xs:positiveinteger"/> </xs:complextype> </xs:element> Ein einfaches Element mit Attribut Zum Beispiel <shoesize country="france">35</shoesize> Ein mögliches XML Schema: <xs:complextype name="shoesizetype" > <xs:simplecontent> <xs:extension base="xs:positiveinteger"> <xs:attribute name="country" type="xs:string"/> </xs:extension> </xs:simplecontent> </xs:complextype> 26

27 Elemente mit einer Sequenz von Kind-Elementen <person> <firstname>john</firstname> <lastname>smith</lastname> </person> Ein XML Schema <xs:complextype name="persontype"> <xs:sequence> <xs:element name="firstname" type="xs:string"/> <xs:element name="lastname" type="xs:string"/> </xs:sequence> </xs:complextype> Durch Definieren eines benannten Typs kann dieser für Elementdeklarationen wiederverwendet werden <xs:element name="person" type="persontype"/> <xs:element name="employee" type="persontype"/> Sequenz von Kind-Elementen erweitert um ein Attribut <person gender="male"> <firstname>john</firstname> <lastname>smith</lastname> </person> Das XML Schema <xs:complextype name="persontype"> <xs:sequence> <xs:element name="firstname" type="xs:string"/> <xs:element name="lastname" type="xs:string"/> </xs:sequence> <xs:attribute name="gender" type="xs:string"/> </xs:complextype> Attribute werden immer nach den Kind-Elementen (sequence, choice oder all) aufgeführt. Elemente mit einer unsortierten Folge von Kind-Elementen Der all Indikator gibt an, dass die Kind-Elemente in beliebiger Reihenfolge, aber jedes Kind nur (höchstens) einmal vorkommen darf: <xs:complextype name="persontype"> <xs:all> <xs:element name="firstname" type="xs:string"/> <xs:element name="lastname" type="xs:string"/> </xs:all> </xs:complextype> Innerhalb des all Indikators kann minoccurs nur die Werte 0 oder 1 annehmen. maxoccurs kann nur den Wert 1 haben. 27

28 Elemente mit einer Auswahl von Kind-Elementen Der Choice Indikator bestimmt, dass entweder das eine oder das andere Kind vorkommen soll: <xs:complextype name="persontype" > <xs:choice> <xs:element name="employee" type="employeetype"/> <xs:element name="member" type="membertype"/> </xs:choice> </xs:complextype> Eine Person ist also entweder ein employee oder ein member (nicht beides). Elemente mit gemischtem Inhalt Das letter Element ist ein Element mit gemischtem Inhalt. <letter> Dear Mr.<name>J. Smith</name>. Your order <orderid>1032</orderid> will be shipped on <shipdate> </shipdate>.</letter> Dies wird durch mixed= true deklariert: <xs:element name="letter"> <xs:complextype mixed="true"> <xs:sequence> <xs:element name="name" type="xs:string"/> <xs:element name="orderid" type="xs:positiveinteger"/> <xs:element name="shipdate" type="xs:date"/> </xs:sequence> </xs:complextype> </xs:element> Die Reihenfolge und Anzahl der Kind-Elemente ist dadurch fest vorgegeben. Mixed Elemente werden vor allem für Text-Dokumente und weniger für Daten-Dokumente verwendet. 28

29 3.6 Spezielle Schema Elemente Wir behandeln in diesem Kurs nur die wichtigsten Schema Elemente. Für eine vollständige Behandlung sämtlicher Schema Elemente (Element- oder Attribut-Gruppen, Substitutionen, Typ-Referenzen,...) siehe z.b. Facetten Einfache Typ-Elemente lassen sich weiter einschränken durch sogenannte Facetten (facets). Mögliche Restriktionen können maximale oder minimale Länge, ein Pattern (reg. Ausdruck), eine Aufzählung der gültigen Werte (enumeration) oder ein minimaler/maximaler Wert sein. Facetten für Strings: length, maxlength, minlength Facetten für numerische Werte: totaldigits, fractiondigits, maxexclusive, minexclusive, maxinclusive, mininclusive Facetten für Zeit-Typen: maxexclusive (<), minexclusive (>), maxinclusive (<=), mininclusive (>=) Für alle Typen: enumeration, pattern, whitespace Einige Beispiele Erlaubte Wochentage sind Montag, Mittwoch und Samstag. <xs:simpletype name="weekdaytype"> <xs:restriction base="xs:string"> <xs:enumeration value="montag"/> <xs:enumeration value="mittwoch"/> <xs:enumeration value="samstag"/> </xs:restriction> </xs:simpletype> Eine Publisher ID ist entweder von der Form P-ABC oder von der Form P-321: <xs:simpletype name="publisheridtype"> <xs:restriction base="xs:string"> <xs:pattern value="p-[a-z]+"/> <xs:pattern value="p-[0-9]+"/> <xs:maxlength value="5"/> </xs:restriction> </xs:simpletype> Falls mehrere Pattern angegeben sind, werden diese einfach der Reihe nach probiert. Zuletzt wird hier noch zusätzlich die Länge geprüft. 29

30 Die Bedeutung der verschiedenen Facetten enumeration Definiert eine Liste von möglichen Werten fractiondigits Spezifiziert die maximal erlaubte Anzahl Dezimalstellen (grösser oder gleich null) length Spezifiziert die (exakte!) Anzahl Buchstaben oder Listenelemente (grösser oder gleich null) maxexclusive Spezifiziert eine obere Schranke für numerische Werte (Werte sind kleiner!) maxinclusive minexclusive Spezifiziert eine obere Schranke für numerische Werte (kleiner oder gleich) Spezifiziert die maximal erlaubte Anzahl Buchstaben oder Listenelemente (grösser oder gleich null) Spezifiziert eine untere Schranke für numerische Werte (Werte sind grösser!) mininclusive Spezifiziert eine untere Schranke für numerische Werte (grösser oder gleich) minlength Spezifiziert die minimale Anzahl Buchstaben oder Listenelemente (grösser oder gleich null) pattern Definiert ein Muster für die erlaubten Werte totaldigits Spezifiziert die maximale Anzahl Ziffern (grösser oder gleich null) whitespace Spezifiziert, wie Whitespaces (newlines, tabs,...) behandelt werden sollen maxlength Beispiele von Facetten Ein letter Wert besteht aus genau einem kleinen Buchstaben (von a bis z) <xs:simpletype name="lettertype"> <xs:restriction base="xs:string"> <xs:pattern value="[a-z]"/> </xs:restriction> </xs:simpletype> Ein threeinitials Wert besteht aus genau drei Buchstaben (von A bis Z) <xs:simpletype name="threeinitialstype > <xs:restriction base="xs:string">  <xs:pattern value="[a-za-z][a-za-z][a-za-z]"/> </xs:restriction> </xs:simpletype> Oder vier Buchstaben aus a,t und x <xs:restriction base="xs:string"> <xs:pattern value="[atx] {4} "/> </xs:restriction> Eine product Id besteht aus 4 Ziffern <xs:simpletype name="productidtype"> <xs:restriction base="xs:int"> <xs:pattern value="[0-9][0-9][0-9][0-9]"/> </xs:restriction> </xs:simpletype>  30

31 mystring besteht aus 5 bis acht kleinen Buchstaben und Zahlen <xs:simpletype name="mystringtype"> <xs:restriction base="xs:string"> <xs:pattern value="([a-z0-9])*"/> <xs:minlength value="5"/> <xs:maxlength value="8"/> </xs:restriction> </xs:simpletype> Oder einem Grossbuchstaben gefolgt von mindestens einem kleinen Buchstaben <xs:restriction base="xs:string"> <xs:pattern value="[a-z]([a-z])+"/> </xs:restriction> Der XML-Parser soll die Leer-Zeichen mitzählen <xs:simpletype name="addresstype"> <xs:restriction base="xs:string"> <xs:minlength value="5"/> <xs:whitespace value="preserve"/> </xs:restriction> </xs:simpletype> Nur Werte von 0 bis 100 <xs:simpletype name="agetype"> <xs:restriction base="xs:int"> <xs:mininclusive value="0"/> <xs:maxinclusive value="100"/> </xs:restriction> </xs:simpletype> oder ohne "Rand" (1 bis 99 ) <xs:restriction base="xs:int"> <xs:minexclusive value="0"/> <xs:maxexclusive value="100"/> </xs:restriction> Die wichtigsten regulären Ausdrücke Bedeutung \. x ^x [x] () {x} {x,} {x,y}? * + \d \D \s \S Escape, um Instanzen von Zeichen zu finden, welche als Metazeichen benutzt werden (wie Punkt, Klammer,... ) Ein beliebiges Zeichen (ausser newline) Eine Instanz von x Jedes Zeichen ausser x Alle Zeichen in diesem Bereich ( z.bsp. [abuv] die Buchstaben a, b, u oder v, [a-z] alle Kleinbuchstaben) Runde Klammern dienen für die Gruppierung Der OR Operator (Auswahl) (a A) Der Ausdruck muss genau x Mal vorkommen Der Ausdruck muss mindestens x Mal vorkommen Der Ausdruck kommt mindestens x Mal und höchstens y Mal vor. Abkürzung für {0,1} Abkürzung für {0, } Abkürzung für {1, } \d : Abkürzung für [0-9] (digits) \D : alles ausser Ziffern \s : Whitespace (spaces, tabs, newlines,...) \S : kein Whitespace 31

32 3.7 Schlüssel Mit Hilfe von keys können Elemente oder Attribute als Schlüssel definiert und damit die Eindeutigkeit innerhalb eines Instanzdokuments garantiert werden <xs:key name="departmentid"> <xs:selector xpath="department"/> <xs:field </xs:key> Die Schlüsseldefinition befindet sich normalerweise in der Deklaration des Root-Elements des XMLDokuments. Der xs:selector enthält die Adresse, wo sich das Schlüsselfeld befindet (hier im department Element direkt unter dem Root Element). Ein oder mehrere xs:field Elemente definieren die Schlüsselfelder (hier ein Attribut namens id). Ein analoges Konstrukt ist die unique Definition. Auch damit kann die Eindeutigkeit von Elementen festgelegt werden. <xs:unique name="nameunique"> <xs:selector xpath="name"/> <xs:field </xs:unique> Referenzen auf Schlüssel Mittels keyref können Referenzen auf Schlüssel (key) definiert werden <xs:keyref name="departmentref" refer="departmentid"> <xs:selector xpath="employee/department"/> <xs:field </xs:keyref> Die Schlüssel-Referenz-Definition befindet sich normalerweise direkt bei der Schlüsseldefinition. Der xs:selector enthält die Adresse, wo sich die Schlüsselreferenz befindet (hier im employee/department Element unter dem Root Element). Das xs:field definiert die Felder der Schlüsselreferenzen (hier ein Attribut namens ref). Ein Beispiel Schema mit Schlüsseldefinition In den Elementen person/born und person/died gibt es je eine Referenz auf eine Adresse. <?xml version="1.0" encoding="utf-8"?> <xs:schema elementformdefault="qualified" xmlns:xs=" <xs:element name="people"> <xs:complextype> <xs:sequence> <xs:element maxoccurs="unbounded" name="person" type="persontype"/> <xs:element maxoccurs="unbounded" name="address" type="addresstype"/> </xs:sequence> </xs:complextype> <xs:key name="addressid"> <xs:selector xpath="address"/> <xs:field </xs:key> <-- alle Adress-Ids sind verschieden --> 32

33 <xs:keyref name="bornref" refer="addressid"> <xs:selector xpath="person/born"/> <xs:field </xs:keyref> <-- addressref bezieht sich auf eine Adress-Id --> <xs:keyref name="diedref" refer="addressid"> <xs:selector xpath="person/died"/> <xs:field </xs:keyref> </xs:element> <xs:complextype name="persontype">... </xs:complextype> <xs:complextype name="addresstype"> <xs:sequence> <xs:element name="country" type="xs:string"/> <xs:element name="city" type="xs:string"/> </xs:sequence> <xs:attribute name="id" type="xs:string"/> </xs:complextype> <xs:complextype name="bdtype"> <xs:attribute name="addressref" type="xs:string"/> <xs:attribute name="date" type="xs:positiveinteger"/> </xs:complextype> </xs:schema> Ein mögliches Instanzdokument <?xml version="1.0" encoding="utf-8"?> <people xmlns:xsi=" xsi:nonamespaceschemalocation="people.xsd"> <person> <name> <firstname>alan</firstname> <lastname>turing</lastname> </name> <born date="1912" addressref="gbl"/>  <died date="1954" addressref="gbc"/>  <profession>computer scientist</profession> <profession>mathematician</profession> <profession>cryptographer</profession> <hobby>philosophy</hobby> <hobby>biology</hobby> </person> <address id="gbl">  <country>great Britain</country> <city>london</city> </address> <address id="gbc">  <country>great Britain</country> <city>cambridge</city> </address> </people> 33

34 Any-Elemente und Attribute Ein <any> Element erlaubt uns, das XML Dokument zu einem späteren Zeitpunkt um beliebige Elemente zu erweitern. Das selbe bewirkt ein <anyattribute> für Attribute. <xs:element name="person"> <xs:complextype> <xs:sequence> <xs:element name="firstname" type="xs:string"/> <xs:element name="lastname" type="xs:string"/> <xs:any minoccurs="0"/> </xs:sequence> <xs:anyattribute/> </xs:complextype> </xs:element> Eine mögliche Erweiterung, zum Beispiel um ein Children Element und ein gender Attribut: <xs:element name="children"> <xs:complextype> <xs:sequence> <xs:element name="childname" maxoccurs="unbounded"/> </xs:sequence> </xs:complextype> </xs:element> <xs:attribute name="gender"> <xs:simpletype> <xs:restriction base="xs:string"> <xs:pattern value="male female"/> </xs:restriction> </xs:simpletype> </xs:attribute> Ein gültiges (erweitertes) Instanz-Dokument Das person Element kann so um ein gender Attribut und ein children Element erweitert werden. <person gender="female"> <firstname>maria</firstname> <lastname>stuard</lastname> <children> <childname>jakob</childname> <childname>cecilia</childname> </children> </person> 34

35 Schema Dokumentation Anmerkungen (xs:annotation) enthalten Informationen für den Benutzer (xs:documentation) oder für eine Applikation (xs:appinfo) <xs:annotation> <xs:documentation xml:lang="en"> This is a schema for address books </xs:documentation> </xs:annotation> Einfügen von Schemas Mittels include kann ein anderes Schema eingefügt werden, welches denselben Target-Namespace hat: <xs:include schemalocation="address.xsd"/> Mittels import kann ein Schema eingefügt werden, welches einen andern Target-Namespace hat: <xs:import namespace=" schemalocation="address.xsd"/> Include erweitert also das Schema um weitere Typen desselben Namespaces. Import hingegen erlaubt das Benutzen von Typen aus anderen Namespaces. 35

36 36

37 Verarbeiten von XML Dokumenten SAX: Simple Application Interface for XML org.xml.sax DOM: Document Object Model StAX: Streaming API for XML javax.xml.stream 37

38 4 SAX: Simple Application Interface for XML 4.1 Was ist SAX? SAX definiert ein einfaches API für einen Event basierten Parser. Event basiert heisst, der Parser liest ein XML Dokument von Anfang bis Ende und benachrichtigt bei jeder erkannten syntaktischen Struktur (Element, Prozess Instruktion, Kommentar, Namespace-Definition,...) die Applikation. Die Benachrichtigung erfolgt durch Aufruf der entsprechenden Funktionen startdocument startelement endelement enddocument... SAX funktioniert wie ein serieller I/O Stream In SAX ist kein Random Access möglich. Der Parser läuft linear durch das Dokument, zurückgehen auf eine frühere Position ist nicht möglich. SAX ist darum vor allem dann nützlich, wenn wir die Daten des XML Dokuments lesen oder gewisse Elemente heraus filtern (aber das Dokument nicht verändern oder bearbeiten) wollen. 4.2 Wofür ist SAX geeignet? Sax ist geeignet für das schnelle, effiziente Lesen oder Validieren von XML Dokumenten. für grosse Dokumente wenn wenig Speicher zur Verfügung steht. SAX benötigt wenig Speicher, da die gelesenen Daten nicht intern abgespeichert, sondern direkt an die Applikation weitergeleitet werden. falls keine Änderungen in der XML Struktur nötig sind. Wenn die XML Struktur oder die XML Daten verändert werden sollen oder die Daten nicht linear durchlaufen werden sollen, ist SAX nicht geeignet. Für solche Anwendungen sind XSLT, StAX oder DOM geeigneter. 4.3 Wie funktioniert SAX? Ganz zu Beginn beim Lesen wird ein startdocument Event erzeugt. Danach werden abhängig von der Struktur des XML Dokuments die folgenden Events erzeugt. <name> <first_name> Alan </first_name> <last_name> Turing </last_name> </name> --> --> --> --> --> --> --> --> startelement() startelement() characters() endelement() startelement() characters() endelement() endelement() Eine Start-Tag (<...>) triggert ein startelement Event, ein End-Tag (</...> ) triggert ein endelement Event. Text Knoten triggern ein characters Event. Als letztes wird ein enddocument Event erzeugt. 38

39 4.4 Übersicht über das SAX API XMLReaderFactory Erzeugen eines XML Readers XMLReader Setzen der Parser Eigenschaften (validating, namespace-aware,...) Bietet verschiedene parse() Methoden an (aus File, InputStream, URI,...). Interface für die verschiedenen Event Handler Methoden start / enddocument, start / endelement(), characters,... ContentHandler ErrorHandler Interface für die Fehlerbehandlung: error(), fatalerror(), warning() EntityResolver Interface für das Einlesen von Entities: resolveentity() DefaultHandler Implementation der (Event-)Handler Interfaces. Implementiert (leere) Methoden für start-/enddocument start-/endelement, characters,... 39

40 Funktionsweise des XML Readers XMLReader Main ContentHandler ErrorHandler parse() XML Document start/enddocument() start/endelement() characters() Application EventHandler 4.5 Implementation des Default Handlers Um einen Sax-Parser zu schreiben, überschreibt man üblicherweise einfach die Klasse Default Handler. Da dort bereits alle vom Interface geforderten Methoden leer implementiert sind, müssen wir nur noch die von uns benötigten Methoden überschreiben. startdocument / enddocument Beim Parsen des XML Dokuments wird als erstes die Methode startdocument() aufgerufen. In dieser können alle Initialisierungs-Schritte ausgeführt werden. Ganz am Ende wird dann die Methode enddocument() aufgerufen, die zum Freigeben und Aufräumen aller benutzten Ressourcen verwendet werden kann. startelement public void startelement( String uri, // String lname, // String qname, // Attributes attrs) // throws SAXException Namespace URI lokaler Name qualifizierter Name Attribut-Liste Die Methode startelement() wird immer dann aufgerufen, wenn der Parser ein Start-Tag liest. Den Tag-Namen finden wir im Parameter qname (Tag-Name mit Namespace-Prefix, falls vorhanden), oder als lname (lokaler Name) und uri (Namespace). uri und lname können leere Strings sein, falls der Parser den Namespace ignoriert (durch Setzen der entsprechenden namespace-property). Im attrs-argument befindet sich die Liste aller Attribute. Falls keine Attribute vorhanden sind, ist attrs eine leere Attribut-Liste. In startelement können wir also die Attribute (name und value) des Elements lesen: if (attrs!= null) { for(int i = 0; i < attrs.getlength(); i++) { // Attribute name (local or qualified) String aname = attrs.getlocalname(i); if ("".equals(aname)) aname = attrs.getqname(i); // Attribute value String val = attrs.getvalue(i); } } 40

41 Die Attribute haben entweder einen lokalen Namen String getlocalname(int i) oder einen qualifizierten Namen (mit Namespace) String getqname(int i) Den Wert des Attributes erhalten wir entweder über den Listen-Index String getvalue(int i) oder über den Namen String getvalue(string aname). characters Der Parser ruft für jeden Textknoten (einmal oder mehrmals) die Methode characters auf. StringBuffer textbuffer = new StringBuffer(); public void characters( char chars[], // die Zeichen aus dem XML Dokument int start, // die Start-Position im Array int length ) // die Anzahl Zeichen, welche gelesen werden können throws SAXException { // Auslesen der Zeichen aus dem Puffer chars und // abspeichern in den Text-Puffer textbuffer.append(chars, start, length); } Ein SAX Parser kann alle Zeichen des Dokuments auf einmal zurückgeben, oder sie in verschiedene Blöcke zerteilen. Das Argument start gibt an, wo im Puffer chars die für diesen Textknoten relevante Information anfängt. length gibt an, wie viele Zeichen des Puffers (ab Position start) zu diesem Aufruf gehören. endelement public void endelement( String uri, // Namespace URI String lname, // lokaler Name String qname ) // qualifizierter Name throws SAXException { } // verarbeite den Inhalt des Elements // ev. aufräumen. Die endelement Methode wird bei jedem XML End-Tag (oder am Ende eines leeren Elements) aufgerufen. Da der Text Inhalt eines Elements oft in mehreren Blöcken eingelesen wird, ist es sinnvoll, den Text-Puffer aus der characters Methode erst in der endelement Methode zu verarbeiten. IgnorableWhitespace Die Methode ignorablewhitespace dient zur Behandlung der Whitespace Zeichen zwischen den Elementen. Leerzeichen wie Tabs oder Zeilenumbrüche zwischen den Elementen werden normalerweise ignoriert. Die Methode ignorablewhitespace kann zum Lesen/Behandeln dieser Zeichen verwendet werden. 41

42 ProcessingInstruction Die Methode processinginstruction dient zur Behandlung von Verarbeitungs-Anweisungen. Verarbeitungs-Anweisungen werden normalerweise vom Parser ignoriert. Die Methode processinginstruction kann zum Lesen der Verarbeitungsanweisungen benutzt werden. startprefixmapping / endprefixmapping Diese Methoden dienen zum Behandeln von Namespaces am Anfang, bzw. am Ende des Setzen eines Namespace Prefix. start/endprefixmapping wird immer am Anfang, bzw. am Ende des Gültigkeitsbereiches einer Namespace Deklaration aufgerufen. 4.6 Fehlerbehandlung: ErrorHandler Warnungen werden während der Verarbeitung des DTD oder des Schemas erzeugt: Unnötige (doppelte) Deklarationen für Entities, Attribute oder Notations oder Fehler im Schema können zum Aufruf der Methode warning() führen. Ein Fehler (Aufruf von error()) entsteht, falls das XML-Dokument nicht dem Schema oder DTD entspricht, also das XML-Dokument nicht gültig ist. Die Methode fatalerror() wird aufgerufen, falls das XML-Dokument nicht wohlgeformt ist. Bei einem fatalerror bricht der Parser normalerweise ab. Um diese Fehler erkennen und bearbeiten zu können, ist es wichtig den ErrorHandler sinnvoll zu implementieren und Fehlermeldungen auszugeben. Die SAXParseException kennt die Zeile/Spalte, wo der Fehler im Dokument aufgetreten ist: e.getlinenumber() --> Ausgabe der Zeilen Nummer e.getcolumnnumber() --> Ausgabe der Spalten Nummer e.getlocalizedmessage() --> Ausgabe der Fehlermeldung 42

43 Ein SAX Beispiel Der DefaultHandler import org.xml.sax.*; import org.xml.sax.helpers.*; public class SAXExample extends DefaultHandler { public void startdocument() { System.out.println("StartDocument"); } public void enddocument() { System.out.println("EndDocument"); } public void startelement(string uri, String lname, String qname, Attributes attrs) { System.out.println("StartElement: " + qname); } for (int i = 0; i < attrs.getlength(); i++) System.out.println(" " + attrs.getlocalname(i) + " = " + attrs.getvalue(i)); public void endelement(string uri, String lname, String qname) { System.out.println("EndElement: " + qname); } public void characters(char[] chars, int start, int length) { String s = new String(chars, start, length); if ((s.trim()).length() > 0) System.out.println("Characters: " + s); } public void warning(saxparseexception e) { System.out.print("Warning: at line " + e.getlinenumber() + " in column " + e.getcolumnnumber() + ": "); System.out.println(e.getLocalizedMessage()); } public void error(saxparseexception e) { System.out.print("Error at line " + e.getlinenumber() + " in column " + e.getcolumnnumber() + ": "); System.out.println(e.getLocalizedMessage()); } public void fatalerror(saxparseexception e) throws SAXException { System.out.print("Fatal error at line " + e.getlinenumber() + " in column " + e.getcolumnnumber() + ": "); throw new SAXException(e.getLocalizedMessage()); } } 43

44 Die Main Klasse import org.xml.sax.*; import org.xml.sax.helpers.xmlreaderfactory; public class Main { public static final String filename = "XML/catalog.xml"; private static final String schemafile = "catalog.xsd"; private static final String schemasource = " private static final String schemalanguage = " private static final String w3schema = " private static final String validation = " private static final String schemavalidation = " private static final String namespaces = " static public void main(string[] argv) { try { XMLReader xr = XMLReaderFactory.createXMLReader(); // XMLReader xr.setfeature(namespaces, false); xr.setfeature(validation, true); xr.setfeature(schemavalidation, true); xr.setproperty(schemalanguage, w3schema); xr.setproperty(schemasource, schemafile); SAXExample handler = new SAXExample(); // ContentHandler xr.setcontenthandler(handler); xr.seterrorhandler(handler); xr.parse(filename); } } catch (SAXParseException e) { System.out.println(e.getMessage()); } catch (SAXException e) { System.out.println(e.getMessage()); } catch (IOException e) { System.out.println(e.getMessage()); } } Ein vollständiges SAX Beispiel finden Sie auf der Übungsseite. 44

45 5 DOM: Das Document Object Model Was ist DOM? DOM definiert einen Standard zum Lesen und Bearbeiten von XML-Dokumenten. DOM stellt XML-Dokumente als Baumstruktur dar. DOM definiert eine Menge von Interfaces (Node, NodeList, Element, Attr,...) und eine Menge von Methoden darauf. DOM ist Plattform- und Sprach-unabhängig definiert. DOM ist ein W3C Standard. Die DOM Node Typen Der W3C Standard definiert die folgenden Knoten-Typen: Node nodename() nodevalue() attributes NodeType() Attr name of attribute value of attribute null 2 CDATASection #cdata-section content of the CDATA Section null 4 Comment #comment content of the comment null 8 Document #document null null 9 DocumentFragment #document-fragment null null 11 DocumentType document type name null null 10 Element tag name null NamedNode Map 1 Entity entity name null null 6 EntityReference name of entity referenced null null 5 Notation notation name null null 12 ProcessingInstruction target entire content excluding null the target 7 Text content of the text node null 3 #text 45

46 5.1 Die org.w3c.dom Java Interfaces Für jeden Knoten-Typ definiert Java ein entsprechendes Interface im org.w3c.dom Package. Element für Elementknoten Attr für Attribute Text für Text Knoten Document für das Document Element Node für beliebige Knoten NodeList für Listen von Knoten ProcessingInstruction für Verarbeitungs-Anweisungen... Das Node Interface Das Node Interface definiert die Methoden zum Lesen und Bearbeiten von DOM Knoten: Node appendchild(node newchild) fügt einen neuen Knoten am Ende der Liste der Kind-Knoten ein. Node clonenode(boolean deep) Kopiert diesen Knoten (deep=true --> mit allen Kind-Knoten) NamedNodeMap getattributes() gibt eine NamedNodeMap zurück, welche die Attribute dieses Elements enthält oder null, falls der Knoten kein Elementknoten ist. NodeList getchildnodes() gibt eine NodeList mit allen Kindknoten zurück. Node getfirstchild() / getlastchild() gibt den ersten/letzten Kind-Knoten dieses Knotens zurück. String getlocalname() gibt den lokalen Namen (ohne Namespace Prefix) zurück. short getnodetype() / String getnodevalue() der Node Type / Node Value (gemäss Tabelle in Abschnitt 8.2) Node getparentnode() gibt den Elternknoten dieses Knotens zurück (falls er existiert). Node removechild(node oldchild) entfernt oldchild aus der Liste der Kinder dieses Knotens.... Das NodeList Interface Das NodeList Interface definiert Methoden zum Bearbeiten von (geordneten) Knotenmengen. Eine NodeList erhalten wir zum Beispiel als Rückgabewert von getchildnodes. Das NodeList Interface definiert die beiden Methoden int getlength() gibt die die Länge der Liste zurück. Node item(int n ) gibt das n-te Element der Liste (beginnend bei 0) zurück. 46

47 Das Document Interface Die wichtigsten Methoden des Document Interfaces sind NodeList getelementsbytagname(string tagname) NodeList getelementsbytagnamens(string namespace, String localname) gibt eine NodeList mit allen Elementen mit dem Namen tagname zurück. Die Reihenfolge der Liste ist die gleiche wie im XML-Dokument. Diese Methode ist im allgemeinen einfacher zu benutzen als die Methode getchildnodes, da hier alle zurückgegebenen Knoten Elementknoten sind. void normalizedocument() hat den gleichen Effekt, wie wenn das Dokument gespeichert und neu geladen würde. Das bedeutet, dass (beim validierenden DOM) erneut die Gültigkeit des Dokuments geprüft wird. So kann geprüft werden, ob ein Dom-Baum im Memory immer noch der im Schema vorgegebenen Struktur entspricht. Element getelementbyid(string id) gibt das eindeutige Element mit der ID id zurück (falls das Element existiert und die id als Id deklariert ist). Mit Hilfe dieser Methoden können Referenzen aufgelöst werden. Das Element Interface Die wichtigsten Methoden des Element Interfaces sind String getattribute(string name) String getattributens(string namespace, String localname) gibt den Inhalt des entsprechenden Attributs zurück (ohne / mit Namespace). void removeattribute(string name) removeattributens(string namespace, String localname) Löscht im Element das Attribute name (ohne / mit Namespace) void setattribute(string name, String value) / void setattributens(string ns, String name, String value) Fügt in das Element ein neues Attribut ein. NodeList getelementsbytagname(string tagname) NodeList getelementsbytagnamens(string namespace, String localname) gibt alle Nachfolger dieses Elements mit Namen tagname zurück (ohne/mit Namespace). void setidattribute(string name, boolean isid) void setidattributens(string ns, String localname, boolean idid) Falls isid gleich true ist, wird das entsprechende name Attribute zu einem ID-Attribut (es gibt keine Methode setidelement). Diese Methode wird vorallem im Zusammenhang mit getelementbyid() gebraucht. 47

48 5.2 Benutzen des DOM Parsers public static final String filename = "XML/catalog.xml"; private static final String schemafile = "XML/catalog.xsd"; private static final String namespaces = " static public void main(string[] argv) { try { // create validating document builder factory DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); factory.setfeature(namespaces, true); // ignore element content whitespace factory.setignoringelementcontentwhitespace(true); // use validating parser SchemaFactory schemafactory = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI); Schema schema = schemafactory.newschema(new StreamSource(new File(schemaFile))); factory.setschema(schema); // parse XML tree into DOM document tree DocumentBuilder builder = factory.newdocumentbuilder(); builder.seterrorhandler(new MyErrorHandler()); Document document = builder.parse(filename);... } catch (Exceptions e) {... } } Navigieren durch den DOM Baum Das Document Interface bietet Methoden zum Sammeln aller Elemente mit gleichem Tag Name. DieseElemente können dann durch Iteration durch die NodeList gelesen werden: NodeList nodelist = document.getelementsbytagname("tagname"); for (int i = 0; i < nodelist.getlength(); i++) { Node node = nodelist.item(i); String value = node.getnodevalue(); // Wert des i-ten Elements NamedNodeMap attrs = node.getattributes(); // Wert des id Attributs String idval = attrs.getnameditem("id").getnodevalue();... } Ausserdem können wir das Element mit einer bestimmten ID suchen: Element anode = document.getelementbyid(idref); getelementbyid() funktioniert aber nur, falls isid(id) zu true evaluiert. Dazu muss id entweder im Schema oder programmatisch als ID definiert sein. Das kann zum Beispiel erreicht durch das explizite Setzen dieser Eigenschaft: z. B. das Attribute mit Namen id eines nodes wird durch node.setidattribute( id, true); zu einer ID. Falls ein Knoten kopiert werden soll, muss er zuerst durch clone() verdoppelt werden. Das boolesche 48

49 Argument (true/false) gibt an, ob der ganze Unterbaum neu angelegt werden soll. Node clone = anode.clonenode(true); Node parent = node.getparentnode(); parent.appendchild(clone); // kopiere den Knoten anode // einfügen in parent von node Löschen von Nodes Da beim Löschen von Elementen aus einer NodeList gleichzeitig die Liste verändert wird, sollten die ListenElemente rückwärts (vom Ende zum Anfang der Liste) oder in einer while-schleife gelöscht werden: NodeList nodelist = document.getelementsbytagname("tagname"); for (int i = nodelist.getlength()-1; i >= 0; i--) { // Rückwärts! Node node= nodelist.item(i); Node parent = node.getparentnode(); parent.removechild(node);... Ausgeben eines DOM Baums: LSSerializer Seit dem DOM Level 3 gibt es mit Hilfe des LSSerializers eine komfortable Möglichkeit zum Schreiben von DOM Dokumenten. Ein Beispiel dazu: import com.sun.org.apache.xml.internal.serialize.*; OutputFormat format = new OutputFormat(DOM_Document); format.setlinewidth(linewidth); // define line width format.setindenting(true/false); // define indentation format.setindent(indent); // number of spaces format.setomitdocumenttype(true/false); // omit Document Type definition FileOutputStream fos = new FileOutputStream(resultFile); XMLSerializer serializer = new XMLSerializer(fos, format); serializer.serialize(dom_document); // print out document Ein vollständiges DOM Beispiel finden Sie auf der Übungsseite. 49

50 6 StAX: Streaming API for XML 6.1 Was ist StAX? StAX ist ein JAVA API, um XML Dateien zu verarbeiten. Die beiden vorherigen XML-APIs sind entweder baumbasiert das gesamte Dokument wird als Baumstruktur in den Speicher gelesen und kann dann dort bearbeitet werden (DOM), oder ereignisbasiert die Anwendung bekommt ein Ereignis, wenn neue Knoten im Dokument entdeckt werden (SAX). Beide Varianten haben Vor- und Nachteile: die erste erlaubt wahlfreien Zugriff auf das Dokument, die zweite benötigt weniger Speicher und ist daher üblicherweise viel schneller. Eine baumbasierte API erlaubt einen lesenden und schreibenden Zugriff auf das Dokument, eine ereignisbasierte API ist ein einmaliger lesender Durchlauf durch das Dokument. StAX wurde als komfortablere Alternative für SAX entworfen. In StAX ist der programmatische Einstieg ein Cursor, der eine Stelle im Dokument repräsentiert. Die StAX Anwendung bewegt den Cursor selber vorwärts. Die StAX API Dokumentation finden Sie unter javax.xml.stream. Wir beschränken uns hier auf die beiden Interfaces XMLStreamReader und XMLStreamWriter. XML-Dokumente lesen Um mit Hilfe von StAX eine XML-Datei verarbeiten zu können, muss zuerst ein XMLStreamReader erzeugt werden. Der XMLStreamReader dient dann als Parser zum Lesen des Dokuments. InputStream inputstream = new FileInputStream(inFile); XMLInputFactory factory = XMLInputFactory.newInstance(); XMLStreamReader reader = factory.createxmlstreamreader(inputstream); Der Reader liefert beim Lesen des XML-Dokuments eine Reihe von Events. Die verschiedenen Event-Typen sind als Konstanten in der Klasse XMLStreamConstants festgelegt: START_DOCUMENT: END_DOCUMENT --> Beginn / Ende des XML-Dokuments. START_ELEMENT: Start Tag des Elements --> Die Attribute können hier gelesen werden. END_ELEMENT --> End Tag des Elements. CHARACTERS --> gesamter Textknoten innerhalb eines Elements.... Ein Beispiel: Lesen eines XML-Dokuments mit StAX while (reader.hasnext()) { switch (reader.next()) { case XMLStreamConstants.START_ELEMENT: System.out.print(reader.getName()); if (reader.getattributecount() > 0) System.out.print(" : " + reader.getattributevalue(0)); break; case XMLStreamConstants.END_ELEMENT: System.out.print(reader.getName()); break; case XMLStreamConstants.CHARACTERS: System.out.print(reader.getText()); break; } 50

51 Die Benutzung von StAX ist viel intuitiver als diejenige von SAX, so liest die Methode gettext() den ganzen Text-Knoten und nicht nur den nächsten Block. XML-Dokumente schreiben Im Gegensatz zu DOM-orientierten APIs, bei denen das gesamte Dokument im Speicher vorliegt und verändert werden kann, ist es bei StAX nicht möglich, die vorhandene XML-Datei zu verändern. Mit Hilfe von SAX ist es sehr mühsam, ein XML-Dokument zu schreiben. Hier bietet STaX hingegen gute Möglichkeiten. Mit Hilfe der XMLOutputFactory wird ein XMLStreamWriter erzeugt: FileOutputStream fos = new FileOutputStream(outFile); XMLOutputFactory factory = XMLOutputFactory.newInstance(); XMLStreamWriter outwriter =factory.createxmlstreamwriter(fos); Der XMLStreamWriter bietet dann Methoden zum Schreiben der XML-Elemente und Attribute: outwriter.writestartdocument("1.0"); outwriter.writestartelement(name); outwriter.writeattribute(attr, value) outwriter.writecharacters(string) outwriter.writecomment(comment) outwriter.writeendelement(); --> --> --> --> --> --> <?xml version="1.0"?> <name> <... attr= value > string  </name> (aus dem Kontext) Es muss nicht angegeben werden, welches Element geschlossen werden muss. Dies erkennt StAX mit Hilfe der Wohlgeformtheit jeweils von selber. Ein vollständiges StAX Beispiel finden Sie auf der Übungsseite. 51

52 52

53 JAXB Java Architecture for XML Binding jaxb.java.net 53

54 7 JAXB: Java Architecture for XML Binding JAXB ist eine schnelle und einfache Methode, um ein XML Schema mit einer Java Repräsentation zu verbinden. Damit ist es sehr einfach, XML Daten nach Java einzulesen, dort zu verarbeiten und wieder nach XML abzuspeichern. JAXB erzeugt aus dem Schema automatisch eine entsprechende Java Daten Hierarchie, liest die Daten aus dem Dokument und stellt Zugriffs-Methoden für alle Elemente zur Verfügung. JAXB kann als Ersatz für DOM oder SAX benutzt werden. Die Programmier-Details für das Lesen und Schreiben der XML Daten bleiben verborgen. Wir müssen keine neuen Befehle kennen lernen. Der Zugriff auf die Daten erfolgt nach den Namen, wie sie im XML Schema definiert sind. 7.1 Die JAXB Architektur Eine JAXB Implementation besteht aus den folgenden Teilen: Der Schema Compiler Erzeugt aus einem Schema eine Menge von dazu passenden Java Klassen. Das Mapping erfolgt gemäss der Namen im Schema, kann aber durch Schema-Annotations oder ein BindingsDeklarationsfile angepasst werden. Der Schema Generator Erzeugt aus existierenden Java Klassen ein passendes Schema. Das Mapping erfolgt gemäss den Annotations in den Java Klassen. Das Binding Runtime Framework Bietet die Operationen unmarshalling (reading) und marshalling (writing) um von Java aus auf XML Daten zuzugreifen, sie zu ändern oder zu validieren. 54

55 7.2 Das Binding Der Binding Prozess besteht aus den folgenden Schritten: 1. Generate classes Der xjc (xml to java compiler) Befehl generiert aus dem XML Schema die zugehörigen Java Klassen. Der Befehl dazu lautet: xjc.exe -p packagename schema.xsd -d outputdirectory 2. Compile classes Die generierten Klassen müssen kompiliert werden: javac outputdirectory/packagename/*.java 3. Unmarshal Durch den unmarshal Befehl werden die Daten der XML Dokumente gelesen, die entprechenden Java Objekte erzeugt und die gelesenen Daten darin abgespeichert. Das Unmarshalling funktioniert nicht nur für Files sondern auch für DOM Knoten, SAX-Sourcen, String-Buffer,... Der XML Baum wird dabei gemäss der Definitionen im Schema in eine Java Objekt-Struktur abgefüllt. 4. Validate (optional) Falls erwünscht kann während des unmashallings die eingelesene XML Source gegen das Schema validiert werden. 5. Process content Die Inhalte der Java Struktur können nun beliebig verändert werden. 6. Marshal Die (geänderten) Java Objekte können dann wieder in ein XML Dokument (File, String, DOMKnoten,...) zurückgeschrieben werden. Während des Schreibens der Daten (marshal) können diese wiederum durch das Schema validiert werden. 55

56 7.3 Übersetzung verschiedener Basis-Datentypen Die benutzten XML Schema Typen werden in (ziemlich) offensichtlicher Art in Java Typen übersetzt: XML Schema Type Java Data Type xsd:string xsd:integer xsd:int xsd.long xsd:short xsd:decimal xsd:float xsd:double xsd:boolean java.lang.string java.math.biginteger int long short java.math.bigdecimal float double boolean xsd:byte byte xsd:qname javax.xml.namespace.qname xsd:datetime javax.xml.datatype.xmlgregoriancalendar xsd:base64binary byte[] xsd:hexbinary byte[] xsd:unsignedint long xsd:unsignedshort int xsd:unsignedbyte short xsd:time javax.xml.datatype.xmlgregoriancalendar xsd:date javax.xml.datatype.xmlgregoriancalendar xsd:anysimpletype java.lang.string xsd:duration javax.xml.datatype.duration xsd:notation javax.xml.namespace.qname 56

57 7.4 Erzeugen der Java Klassen Die Java-Klassen und Member Variablen werden gemäss dem Schema erzeugt: <xs:schema xmlns:xs=" targetnamespace=" elementformdefault="qualified" xmlns=" <xs:element name="people"> <xs:complextype> <xs:sequence> <xs:element name="person" type="persontype" maxoccurs="unbounded"/> <xs:element name="address" type="addresstype" maxoccurs="unbounded"/> </xs:sequence> </xs:complextype> </xs:element> Das obige (Teil-) Schema erzeugt eine Klasse People der Form People List<PersonType> person; List<AddresType> address; List<PersonType> getperson(); List<AddressType> getaddress(); Die folgende Typendefinition <xs:complextype name="persontype"> <xs:sequence> <xs:element name="name" type="nametype"/> <xs:element name="born" type="borntype"/> <xs:element name="died" type="diedtype"/>... </xs:sequence> </xs:complextype> erzeugt eine Java Klasse der Form: PersonType NameType name; BornType born;... NameType getname(); void setname(nametype name);... 57

58 7.5 Einlesen der XML Daten Die vom Framework gelieferte JAXBContext Klasse erstellt einen Zugriff zum JAXB API. Damit wird ein Unmashaller erzeugt. try{ JAXBContext jc = JAXBContext.newInstance(People.class); Unmarshaller unmarshaller = jc.createunmarshaller(); SchemaFactory schemafactory = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI); Schema schema = schemafactory.newschema(new File("schema.xsd")); unmarshaller.setschema(schema); Object obj = unmarshaller.unmarshal( InputStream File DocNode... )... } catch(jaxbexception e) {... } Für unser People-Beispiel könnte das etwa so aussehen: PeopleType people = (People) unmarshaller.unmarshal( new File("People.xml") ); Durch die erzeugte Java Struktur kann dann mit den beim Binding erzeugten Zugriffsmethoden navigiert werden: for(persontype b : people.getperson()) { String firstname = b.getname().getfirstname(); String lastname = b.getname().getlastname(); } 7.6 Schreiben der Daten in ein XML File Zum (formatierten) Schreiben der Daten erzeugen wir mittels des JAXBContext ein Marshaller Objekt. JAXBContext jc = JAXBContext.newInstance(People.class); Marshaller ms = jc.createmarshaller(); ms.setproperty( Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE ); SchemaFactory sf = SchemaFactory.newInstance( XMLConstants.W3C_XML_SCHEMA_NS_URI); Schema schema = sf.newschema( new File("Schema.xsd")); marshaller.setschema(schema); // Schreiben der Daten nach people.xml ms.marshal( people, new FileOutputStream("people.xml")); Dies generiert ein neues File people.xml und scheibt die gesamte (oder Teile der) Java Objekt Struktur in dieses File. Beim Schreiben der XML Daten wird hier die Struktur gegen das Schema validiert. Die Java Objekte können nach Belieben in einen OutputStream, einen Document Node, einen SaxContentHandler,... geschrieben werden (vgl. JAXB Dokumentation). 58

59 7.7 Anpassen der generierten Java Klassen und Member Variablen Durch Angabe einer appinfo-annotation im Schema können die Namen für die generierten Klassen und deren Member-Variablen verändert werden. Die wichtigsten Annotations sind jxb:class und jxb:property. So kann zum Beispiel bestimmt werden, wie die generierte Address-Klasse aussehen soll (vgl. Beispiel auf der Übungsseite) <xs:schema xmlns:xs=" targetnamespace=" xmlns:jxb=" jxb:version="2.0" elementformdefault="qualified" xmlns=" <xs:complextype name="addresstype"> <xs:annotation> <xs:appinfo> <jxb:class name="address"/> </xs:appinfo> </xs:annotation> <xs:sequence> <xs:element name="country" type="xs:string"/> <xs:element name="city" type="xs:string"/> </xs:sequence> <xs:attribute name="id" use="required" type="xs:string"> <xs:annotation> <xs:appinfo> <jxb:property name="addressid"/> </xs:appinfo> </xs:annotation> </xs:attribute> </xs:complextype>... erzeugt neu eine Klasse Address (statt AddressType) mit einer Member Variablen addressid (statt id). 59

60 7.8 Externe Binding-Deklaration Statt die gewünschten Java-Typen als Annotations ins Schema File zu schreiben, kann man deren Deklarationen auch in einem separaten File ablegen. Dieses Bindings-File muss dann als Parameter beim Erzeugen der Java Klassen mit angegeben werden (vgl. xjc -b peoplebindings.xjb -d. -p people people.xsd Ein solches Bindings-File könnte etwa so aussehen: <jxb:bindings version="1.0" xmlns:jxb=" xmlns:xs=" schemalocation="people.xsd">  <jxb:bindings <jxb:bindings <jxb:property name="hobbylist"/> </jxb:bindings> </jxb:bindings>  <jxb:bindings <jxb:bindings <jxb:property name="addrref"/> </jxb:bindings> </jxb:bindings>  <jxb:bindings <jxb:property name="givenname"/> </jxb:bindings>  </jxb:bindings> Dies bewirkt, dass die Klasse PersonType neu wie folgt aussieht: PersonType Name name; BornType born; List<String> hobbylist;... NameType getname(); void setname(nametype name);... 60

61 7.9 Erzeugen von Schematas Aus einer Java Klassen-Hierarchie lässt sich umgekehrt mit Hilfe von Annotationen das dazu passende @XmlAttribute... --> erzeugen eines Schema Types (mit angegebener Reihenfolge) --> erzeugen eines Schema Elements --> erzeugen eines Schema Attributs Der Aufruf zum Erzeugen eines Schemas lautet schemagen.exe package\*.java Ein Beispiel: Die People Klasse import java.util.*; = { "person", "address" = "people") public class People = true) protected List<Person> = true) protected List<Address> address; public List<Person> getperson() { if (person == null) { person = new ArrayList<Person>(); } return this.person; } public List<Address> getaddress() { if (address == null) { address = new ArrayList<Address>(); } return this.address; } } 61

62 Die Address Klasse = "addresstype", proporder = { "country", "city" }) public class Address = true) protected String = true) protected String = "id", required = true) protected String addressid; public String getcountry() { return country; } public void setcountry(string value) { this.country = value; }... Das daraus generierte Schema <?xml version="1.0" encoding="utf-8" standalone="yes"?> <xs:schema elementformdefault="qualified" version="1.0" targetnamespace=" xmlns:tns=" xmlns:xs=" <xs:element name="people"> <xs:complextype> <xs:sequence> <xs:element name="person" type="persontype" maxoccurs="unbounded"/> <xs:element name="address" type="addresstype" maxoccurs="unbounded"/> </xs:sequence> </xs:complextype> </xs:element> <xs:complextype name="addresstype"> <xs:sequence> <xs:element name="country" type="xs:string"/> <xs:element name="city" type="xs:string"/> </xs:sequence> <xs:attribute name="id" type="xs:string" use="required"/> </xs:complextype>... </xs:schema> 62

63 7.10 Schreiben von XML Daten ohne ObjectFactory Zum Schreiben von Java Daten in ein XML Dokument braucht es entweder die (beim Binding automatisch generierte) ObjectFactory Klasse oder ein jaxb.index File, in welchem die Namen der annotierten Java Klassen stehen. Das jaxb.index File muss die Klassen Namen (lokale Namen ohne.java oder.class Endung) enthalten und liegt im gleichen Package wie die annotierten Java-Klassen. Mit einem solchen jaxb.index File können wir Java Daten nach XML schreiben, ohne vorher ein Java Binding ausführen zu müssen. Unser Beispiel 63

64 64

65 XSLT / XPath / XSL-FO Die Transformations- und Adressierungs-Sprachen für XML

66 Die XSL Sprachen Einleitung, Motivation XSL ist ein vom World Wide Web Consortium empfohlener Standard W3C Recommendation von XSLT2.0 und XPath2.0, sowie Xquery 1.0 vom 23 Januar 2007 XSLT: XPath: W3C Recommendation des XSL- Formatting Objects Teil vom Dezember 2006 XSL-FO: Vergleich: CSS und XSL Die W3C hat mit dem XSL Standard angefangen, bevor derjenige von CSS (Cascading Stylesheet Language) festgelegt war. Warum gibt es überhaupt zwei Stylesheet Sprachen? CSS XSL Verwendung mit HTML ja nein Verwendung mit XML ja ja Transformations-Sprache nein ja Syntax CSS XML CSS ist für das Layouting von HTML-Dokumenten geeignet. XSL ist angepasst an die Bedürfnisse von XML. XSL ist viel mächtiger, differenzierter und ausgefeilter als CSS. XSL kann XML- Dokumente beliebig transformieren (also auch in andere Sprachen wie TeX, Java, HTML/CSS,... umformen) Beide Sprachen können als Stylesheet für XML- Dokumente verwendet werden. CSS und XSL benutzen das gleiche Formatierungs-Modell und beide Sprachen bieten die gleichen Formatierungs-Möglichkeiten. CSS Stylesheet für HTML Files HTML benutzt vordefinierte (und darum allgemein bekannte) Tags: <h1> Titel-Element <p> neuer Abschnitt,... In CSS wird definiert, wie die verschiedenen HTML Elemente darzustellen sind (Fonts, Farben,...) h1 { font-family: sans-serif; font-size: 48pt } Die h1 Header sollen mit einer sans-serif Schrift der Grösse 48 ausgegeben werden. p { font-size: 8pt; color: blue } Alle <p> - Elemente sollen in einer 8pt Schrift in blauer Farbe ausgegeben werden. Die Browser kennen diese HTML Tags und verwenden ein CSS (Default-) Stylesheet für deren Darstellung. 66

67 XSL - Stylesheet für XML XML benutzt keine vordefinierten Tags: <table> kann eine HTML Tabelle oder auch ein Möbelstück sein. Im XML-Dokument steht nicht, wie die Daten dargestellt werden sollen. Es braucht einen Mechanismus, welcher beschreibt, wie die Daten eines XML-Dokumentes dargestellt werden sollen. XSL bietet diesen Mechanismus Das XML Dokument soll nur die reinen Daten enthalten und (im Gegensatz zu HTML) nichts über deren Darstellung (ob als Liste, Tabelle, oder als Fliesstext in Abschnitte unterteilt,...) aussagen. Mit Hilfe eines XSL Stylesheet wird festgelegt, wie diese Daten dargestellt werden sollen. CSS bietet keine Möglichkeit, Daten zu transformieren oder in Tabellen, Listen, usw. zu verpacken. XSL ist eine Sprache, welche XML nach (X)HTML (oder einer beliebigen Sprache) übersetzen kann, XML Daten sortieren oder filtern kann, Spezielle Teile von XML Dokumenten adressieren kann, XML Daten zum Beispiel abhängig vom Wert verschieden formatieren kann (negative Zahlen rot, positive Zahlen schwarz,...) XML Daten für verschiedene Devices formatieren kann (Bildschirm, Drucker,...) XSL kann aus den XML Daten nicht nur (neue) XML- Files oder XHTML- Files, sondern beliebige Formate erzeugen. XSL wird oft auch verwendet, um die Daten des XML- Dokuments anders zu strukturieren (zum Beispiel passend zu einem anderen Schema oder DTD). Obwohl XSL eigentlich aus drei Teilen mit drei verschiedenen Namen zusammengesetzt ist, wird oft einfach für alles der Name XSL benutzt. Eine Transformationssprache --> XSLT (XSL Transformation) Eine Adressierungssprache --> XPath (Adressieren und Selektieren) Eine Formatierungssprache --> XSL-FO (XSL Formatting Objects) 67

68 8 Die Transformations-Sprache XSLT XSLT ist der wichtigste Teil des XSL Standards. XSLT wird benutzt, um XML Dokumente in andere XML-, HTML-,... Dokumente umzuformen. XSLT kann auch neue, nicht im XML-Dokument enthaltene Daten-Elemente in das AusgabeDokument einfügen (zum Beispiel Formatier-Befehle), Elemente umsortieren oder weglassen XSLT kann die XML-Knoten (zum Beispiel auch abhängig com Wert des Elementes) unterschiedlich behandeln. 8.1 Wie funktioniert XSLT? Ein XSL File besteht aus Regeln (Templates), welche bestimmen, wie die einzelnen Knoten eines XML- Dokuments umgeformt werden sollen. XSLT benutzt im Transformations-Prozess die Sprache XPath, um die zu einer Regel (Template) passenden Knoten des XML Dokuments heraus zu filtern. Wenn im XML- Dokument ein passender Knoten (match) gefunden wird, formt XSLT diesen Knoten mit Hilfe der angegebenen Regel um, und schreibt das Resultat ins Ausgabe-Dokument. Alle Text-Knoten des XML- Dokumentes, welche nicht zu einer Regel passen, werden unmodifiziert in das Ausgabe-Dokument kopiert (vgl. Default Template Rules). 68

69 Das Beispiel Dokument: People.xml <?xml version="1.0"?> <people> <person> <name> <firstname>alan</firstname> <lastname>turing</lastname> </name> <born date="1912" addressref="gbl"/> <died date="1954" addressref="gbc"/> <profession>computer scientist</profession> <profession>mathematician</profession> <profession>cryptographer</profession> <hobby>philosophy</hobby> <hobby>biology</hobby> </person>... Das vollständige XML- Dokument finden Sie auf dem Zusatzblatt. Verbinden mit einem Stylesheet Im XML Dokument kann mit Hilfe der Prozess-Instruktion <?xml-stylesheet...?> das zu verwendende XSL-Stylesheet angegeben werden. <?xml version="1.0"?> <?xml-stylesheet type="text/xsl" href=" <people> <person> <name> <firstname >Alan</firstName> <lastname>turing</lastname> </name>... Falls das XML-Dokument nicht statisch zu einem Stylesheet verbunden werden soll, kann zum Beispiel auch ein kleines Javaskript geschrieben werden, welche die beiden Teile verbindet. Die URL des Stylesheets kann relativ sein, also z.bsp. href="mystyle.xsl" (wie im obigen Beispiel) als absolute Adresse. 69

70 8.2 Der Aufbau eines Stylesheets: Templates XSL benutzt Templates (Regeln), um zu bestimmen, wie die XML-Knoten umgeformt werden sollen. Ein "match"-attribut wird benutzt, um ein Knoten einem Template zuzuordnen. <xsl:template match= Knoten > Action </xsl:template> Der Befehl xsl:template legt zuerst die Liste (sequence) aller Knoten des XML-Dokuments an, welche durch match adressiert werden. Die Elemente der Liste werden dann der Reihe nach gemäss den Regeln in Action transformiert. Die Sprache XPath dient hier zur exakten Adressierung der Knoten (welche Knoten sollen umgeformt werden). Das Resultat von Action (der Transformation) wird in das Ausgabe-Dokument geschrieben. Ein erstes XSL Beispiel: hello world Da das Stylesheet selber auch ein XML Dokument ist, fängt es mit einer xml-deklaration an: <?xml version="1.0" encoding="utf-8"?> <xsl:stylesheet version="2.0" xmlns:xsl=" <xsl:output method="text" encoding="utf-8"/> <xsl:template match="people"> hello world </xsl:template> </xsl:stylesheet> Der xsl:stylesheet Befehl in der zweiten Zeile ist der eigentliche Start des Stylesheets. Der Namespace URI für xsl muss genau so angegeben werden. Das <xsl:template> Element definiert den Start eines Templates. Das Template Attribute match="people" adressiert das (alle) people-element(e) des XMLDokumentes. Zwischen dem Start- und dem End-Tag von xsl:template stehen die Anweisungen, welche für das adressierte Element auszuführen sind. Das Tag <xsl:output> definiert, wie das Output File aussehen soll. Hier ist die Ausgabe ein UTF-8 codiertes Text- File. Die Ausgabe des Stylesheets ist hello world. 70

71 Fortsetzung: hello world Wir ergänzen das obige Beispiel um eine weitere Regel: <?xml version="1.0" encoding="utf-8"?> <xsl:stylesheet version="2.0" xmlns:xsl=" <xsl:output method="text" encoding="utf-8"/> <xsl:template match="people"> hello world </xsl:template> <xsl:template match="person"> I am here </xsl:template> </xsl:stylesheet> Trotz der zusätzlichen Regel für person lautet die Ausgabe wiederum bloss hello world. Damit die zweite Regel ausgeführt wird, müsste sie im people-template explizit aufgerufen werden. Fortsetzung: hello world Wir löschen die people Regel aus dem obigen Beispiel: <?xml version="1.0" encoding="utf-8"?> <xsl:stylesheet version="2.0" xmlns:xsl=" <xsl:output method="text" encoding="utf-8"/> <xsl:template match="person"> I am here </xsl:template> </xsl:stylesheet> In diesem Stylesheet fehlt die people-regel. Das bedeutet, dass die Default Regel zum Einsatz kommt, welche alle (direkten) Nachfolger des Root-Knotens (people) sucht, im Stylesheet nach Regeln dafür sucht, und diese ausführt. Da das people Element mehrere person und address Kinder hat, werden person und address Regeln gesucht und ausgeführt. Die "person"- Regel wird für jedes gefundene <person>- Element ausgeführt. Es gibt im Stylesheet keine Regel für address-elemente, also wird die Default Regel ausgeführt. Diese kopiert alle Text-Kinder von <address> (vgl. Kapitel: Default Template Regeln) Die Ausgabe ist darum: I am here I am here I am here I am here Great Britain London Germany Ulm USA Queens, NY Switzerland Basel Great Britain Cambridge USA Princeton 71

72 8.3 Die wichtigsten XSLT Befehle Es kann hier nur eine Auswahl von XSL Befehlen und Konstrukten behandelt werden. Die ganze Liste der Befehle mit Beispielen finden Sie zum Beispiel auch unter xsl:apply-templates, xsl:call-template, xsl:for-each Welches Kind als nächstes behandelt werden soll, kann explizit durch ein select-attribut ausgewählt werden <xsl:apply-templates select="person"/> Der Befehl xsl:apply-templates sucht im XML den angegebenen Pfad, eine Regel dazu und führt diese aus. Der Befehl <xsl:apply-templates/> sucht alle Kind (-Elemente) des aktuellen Knotens und führt deren Templates aus. (Mit "Kind" sind jeweils nur die direkten Nachfolger gemeint). Beispiele: <?xml version="1.0" encoding="utf-8"?> <xsl:stylesheet version="2.0" xmlns:xsl=" <xsl:output method="text" encoding="utf-8"/> <xsl:template match="people"> <xsl:apply-templates select="person"/> </xsl:template> <xsl:template match="person"> I am here </xsl:template> </xsl:stylesheet> Die gleiche Ausgabe erhalten wir durch Aufruf der folgenden Templates: <xsl:template match="people"> <xsl:call-template name="templ1"/> </xsl:template> <xsl:template name=" templ1"> <xsl:apply-templates select="person"/> </xsl:template> <xsl:template match="person"> I am here </xsl:template> Oder als dritte Möglichkeit: <xsl:template match="people"> <xsl:for-each select="person"> I am here </xsl:for-each> </xsl:template> 72

73 xsl:value-of Das XSL <xsl:value-of> Element kann benutzt werden, um den Wert bestimmter Knoten auszugeben. Beispiele: <xsl:value-of select="lastname"/> <xsl:value-of select="firstname"/> <xsl:value-of select="hobby" separator=", " /> value-of berechnet den Wert eines Ausdrucks oder XML Knotens nach den folgenden Regeln: Element: der Text-Inhalt eines Elementes, nachdem alle Referenzen aufgelöst sind. Text: der Text selber Attribut: der Wert des Attributes <xsl:value-of select=". "/> gibt den Wert des aktuellen Knotens zurück. <?xml version="1.0" encoding="utf-8"?> <xsl:stylesheet version="2.0" xmlns:xsl=" <xsl:output method="xhtml" encoding="utf-8"/> <xsl:template match="people" > <html> <head> <title>famous Scientists</title> </head> <body> <h4> Famous Scientists</h4> <xsl:apply-templates select="person"/> </body> </html> </xsl:template> Die Ausgabe der Transformation: <html> <head><title> Famous Scientists</title></head> <body> <h4> Famous Scientists</h4> <p>turing Alan</p> <p>feynman Richard</p> <p>einstein Albert</p> <p>euler Leonhard</p> </body> </html> <xsl:template match="person"> <p><xsl:apply-templates select="name"/></p> </xsl:template> <xsl:template match="name"> <xsl:value-of select="lastname"/> <xsl:text> </xsl:text> <xsl:value-of select="firstname"/> </xsl:template> </xsl:stylesheet> Das obige XSL-Stylesheet erzeugt ein HTML-Dokument. Die HTML-Tags gehören nicht zu XSL. Sie werden darum einfach in die Ausgabe kopiert (literal result element). Das people Template verpackt den Output in ein HTML-Dokument, mit head, title und body. Danach wird das person Template aufgerufen. Das person- Template fängt einen neuen Abschnitt an (<p>) und ruft das name- Template auf. Im name Template wird durch das <xsl:text> Element sichergestellt, dass zwischen dem Namen und dem Vornamen ein Abstand (Space) eingefügt wird. <xsl:text>mytext</xsl:text> kopiert den String mytext (unverändert) in das Ausgabe-Dokument (inkl. Whitespace). 73

74 Adressieren von Attributen Für das Adressieren von Attributen wird das verwendet. <xsl:value-of select= born/@date /> liefert den Wert des date Attributes im born Element. <xsl:template match="person"> <b><xsl:apply-templates select="name"/></b> <xsl:text> </xsl:text> <small> ( <xsl:value-of select="born/@date"/> <xsl: value-of select="died/@date"/>) </small> <p/> </xsl:template> Template mit Modes Es ist möglich, für denselben Knoten mehrere verschiedene Templates zu definieren, die dann kontextabhängig angewendet werden. Der Aufruf des Templates sowie das Template selber erhalten ein mode Attribute. Damit können zum Beispiel Inhaltsverzeichnisse, Querverweise oder verschiedene Darstellungen der gleichen Datenelemente erzeugt werden. <xsl:stylesheet version="1.0 " xmlns:xsl=" <xsl:template match="people"> <html> <head> <title> Famous Scientists</title> </head> <body> <h3> Famous Scientists, Mode</h3> <h4> Table of Contents </h4> <ul> <xsl:apply-templates select="person" mode ="toc"/> </ul> <xsl:apply-templates select="person"/> </body> </html> </xsl:template> Der erste Durchgang wird durch <xsl:template match="person" mode="toc"> gebildet, der zweite durch <xsl:template match="person"> <xsl:template match="person" mode ="toc"> <xsl:apply-templates select="name" mode="toc"/> </xsl:template> <xsl:template match="person"> <p> <xsl:apply-templates select="name"/> <small> (<xsl:apply-templates select="born/@date"/> <xsl:apply-templates select="died/@date"/> ) </small> </p> </xsl:template> <xsl:template match="name" mode ="toc"> <li> <xsl:value-of select="lastname"/> </li> </xsl:template> <xsl:template match="name">... --> vgl. Beispiel vorher </xsl:template> </xsl:stylesheet> 74

75 xsl:if <xsl:if test="lastname = 'Euler'">... </xsl:if> filtert nur die Elemente mit lastname gleich Euler. <xsl:if test="born/@date > 1900" >... </xsl:if> behandelt nur die Personen, welche nach 1900 geboren sind. Im Template: <xsl:template match="person"> <xsl:if test="born/@date > 1900 "> <xsl:apply-templates select="name"/> </xsl:if> </xsl:template> Die Bedingungen können mit Hilfe von and oder or verbunden werden. <xsl:template match="person"> <xsl:if test="born/@date > 1850 and name/firstname!= 'Alan' "> <xsl:apply-templates select="name"/> </xsl:if> </xsl:template> Das Template gibt nur die Namen der Personen aus, welche später als 1900 geboren sind. Komplizierte Bedingungen können mit runden Klammern gruppiert werden: (... and... ) or (... or... <xsl:template match="person"> <xsl:if test="born/@date > 1900 or (name/firstname = 'Leonhard' and name/lastname='euler')" > <xsl:apply-templates select="name"/> </xsl:if > </xsl:template> 75

76 xsl:choose Es gibt in XSL kein if-else Konstrukt. Anstatt eines if-else gibt es ein xsl:choose. Verzweigungen werden aus xsl:when und xsl:otherwise zusammengesetzt. <xsl:choose> <xsl:when test="...">... </xsl:when> <xsl:otherwise>... </xsl:otherwise> </xsl:choose> xsl:choose ist vergleichbar mit einem Switch-Case-Statement in Java oder C++. Nur der erste when-ast, welcher zu true evaluiert, wird ausgeführt. Falls keiner der when-tests zu true evaluiert, wird otherwise ausgeführt. Ein Beispiel <xsl:template match="people">... vgl. Beispiel vorher <xsl:apply-templates select="person"/>... </xsl:template> <xsl:template match="person"> <xsl: choose > <xsl: when test="profession='mathematician' "> <font color="blue"> <xsl:apply-templates select="hobby"/> </font> </xsl: when > <xsl: when test="profession='cryptographer' "> <font color="red"> <xsl:apply-templates select="hobby"/> </font> </xsl: when > <xsl: otherwise > <xsl:apply-templates select="hobby"/> </xsl: otherwise > </xsl: choose > </xsl:template> blau für Mathematiker rot für Kryptologen sonst schwarz <xsl:template match="hobby"> <li><xsl:value-of select="."/></li> </xsl:template> 76

77 xsl:sort Um eine Sequenz von Knoten während der Transformation (nach einem gewählten Schlüssel) zu sortieren, gibt es das sort Element: <xsl:sort select="name/lastname"/> xsl:sort kann entweder innerhalb eines <xsl:apply-templates> oder eines <xsl:for-each> Elements vorkommen. Das select-attribut gibt an, nach welchem Schlüssel sortiert werden soll. Falls numerisch sortiert werden soll (der Sortier-Schlüssel eine Zahl ist) muss dies mit dem data-type Attribut angegeben werden: <xsl:sort select = "..." data-type="number" /> Beispiel: Sortieren mit xsl:apply-templates oder mit xsl:for-each <xsl:template match="people"> <html> <head> <title> Famous Scientists, xsl:sort</title> </head> <body> <h3>famous Scientists</h3> <xsl: apply-templates select="person"> Alle Personen sortiert aufzählen <xsl:sort select="name/lastname" order="ascending"/> </xsl:apply-templates> <br/> <b>hobbies of the Famous</b> <ul> <xsl: for-each select="person/hobby"> Alle Hobbies sortiert aufzählen <xsl:sort select="." order="descending"/> <li><xsl:value-of select="."/></li> </xsl:for-each> </ul> </body> </html> </xsl:template> Der apply-templates Befehl sammelt alle Knoten unter dem XPath (hier person). Der Sort-Befehl bewirkt, dass alle person-elemente vor deren Verarbeitung nach ihrem Namen sortiert werden. Der for-each Befehl sammelt hier alle Hobby Elemente aller Personen und sortiert sie vor deren Ausgabe. 77

78 xsl:variable In XSL können auch Konstanten definiert werden: <xsl:variable name="ntext"> value_of_variable </xsl:variable> Der Wert der Konstanten ntext kann mit $ntext gelesen werden: <xsl:value-of select="$ntext"/> Der Wert von ntext kann dann nicht mehr verändert werden! Dies sind keine Variablen, wie man sie in C++ oder Java kennt, sondern eher von der Art der Variablen wie man sie im funktionalen Programmieren kennt (benannte Konstanten). Trotzdem können diese Variablen sehr nützlich sein. Beispiel: Berechnen einer gewichteten Summe Wir nehmen das Beispiel einer Bestellung. <?xml version="1.0"?> <order> <book> <title>xml</title> <price>24.20</price> <quantity>2</quantity> </book> <book> <title>uml</title> <price>43.20</price> <quantity>1</quantity> </book> <book>... </book> </order> Von dieser Bestellung wollen wir den Gesamt-Preis berechnen. <xsl:template match="totalbetrag"> <xsl:variable name="tmp"> <tmpprice> <xsl:for-each select="book"> <item> <xsl:value-of select="price * quantity"/> </item> </xsl:for-each> </tmpprice> </xsl:variable> <xsl:value-of select="sum($tmp/tmpprices/item)"/> </xsl:template> Der Inhalt der Variablen tmp ist dann: Der sum Befehl zählt diese Werte zusammen. 78

79 Auflösen von key / keyref Paaren mit Hilfe von Variablen <xsl:template match="born"> <xsl:value-of select="../name/lastname"/>, <xsl:value-of select="name()"/> <xsl:text> </xsl:text> <xsl:value-of select="@date"/> <xsl:text> in </xsl:text> <xsl:variable name="myref" select="@addressref"/> <xsl:value-of select="//address[@id=$myref]/city"/> </xsl:template> Address-ID in der Variable abspeichern die gefundene Adresse ausgeben Dieses Vorgehen ist allerdings nicht effizient. Wir werden später ein besseres Verfahren kennen lernen. xsl:param Beim Aufruf von Templates können Parameter übergeben werden: <xsl:apply-templates select="title"> <xsl:with-param name="p1"> <xsl:value-of select="irgendein Wert"/> </xsl:with-param> </xsl:apply-templates> Verwendung im Template: <xsl:template match="title"> <xsl:param name="p1"/>... verwenden von $p1... </xsl:template> Es können auch mehrere Parameter übergeben werden: <xsl:template match="people"> <xsl:apply-templates select="person"> <xsl: with-param name="a1"> <xsl:value-of select="address[1]/city"/> </xsl:with-param> <xsl: with-param name="a2"> <xsl:value-of select="address[2]/country"/> </xsl:with-param> </xsl:apply-templates> </xsl:template> Der Wert der Parameter kann im Template (analog zu den Variablen) mit $a1, bzw. $a2 gelesen werden. Ausserdem kann ein Default-Wert angegeben werden, falls im Aufruf ein Parameter fehlt. <xsl:template match="person"> <xsl:param name="a1"/> beide Parameter einlesen <xsl:param name="a2"> Germany Default Wert für a2 </xsl:param> <xsl:value-of select="name/lastname"/> <xsl:value-of select="$a1"/> <xsl:value-of select="$a2"/> </xsl:template> 79

80 xsl:for-each-group Das folgende Template gibt alle Adressen gruppiert nach Ländern aus. Adressen aus dem selben Land werden durch ein Komma separiert. <xsl:template match="people"> <xsl:for-each-group select="address" group-by="country"> <xsl:value-of select="country"/>: <xsl:value-of select="current-group()/city" separator=", "/> <br/> </xsl:for-each-group> </xsl:template> Die Ausgabe ist dann: Great Britain: London, Cambridge Germany: Ulm USA: Queens, NY, Princeton Switzerland: Basel Importieren von Stylesheets Die Befehle <xsl:import href="uri"> und <xsl:include href="uri"> fügen das unter der angegebenen Adresse gefundene Stylesheet ein. Der Pfad kann dabei relativ <xsl:include href="ss.xsl"/> oder absolut sein: <xsl:include href=" Eingefügte Stylesheets können selber ebenfalls wieder mit xsl:include oder xsl:import andere Stylesheets einlesen (Vorsicht: Zyklen!). Beim Transformieren werden sowohl die Regeln des importierten als auch des importierenden Stylesheets angewandt. Durch <xsl:import> werden die Regeln beider Stylesheets benutzt. Falls sich Regeln widersprechen wird die Regel des lokalen Stylesheets benutzt. <xsl:include> kopiert den Inhalt des angegebenen Stylesheets in das einlesende Stylesheet. Falls sich Regeln widersprechen (durch Templates mit gleichen Namen oder gleichen Pattern), tritt normalerweise ein Fehler auf. 80

81 9 Grundlegendes zu XSLT 9.1 Default Template Regeln Was geschieht mit den Knoten, wenn es im Stylesheet dafür kein Template gibt? Auch wenn im Stylesheet keine explizite Regel für die Behandlung eines Knotens angegeben ist, gibt es (abhängig vom Typ des Knotens) eine Regel für diesen Knoten. Es gibt sieben Typen von Knoten in XML-Dokumenten Root-Knoten Element-Knoten Attribut-Knoten Text-Knoten Kommentar-Knoten Verarbeitungs-Anweisungen (Processing-Instructions) Namespace-Knoten Für jeden Knoten-Typ gibt es eine Default Template Regel, welche angibt, was mit einem solchen Knoten passieren soll, falls im Stylesheet keine Regel dafür vorhanden ist. Text- und Attribut-Knoten Von Text- und Attribut-Knoten wird der Wert des Textes (des Attributes) in das Ausgabe-Dokument kopiert. Als XSL-Template sieht dies wie folgt aus: <xsl:template match= " "> <xsl:value-of select="."/> </xsl:template> Wir können uns vorstellen, dass in jedem Stylesheet diese Regel mit drin steht (auch wenn sie nicht explizit vorhanden ist). Die folgende Regel: <xsl:template match="name"> <xsl:apply-templates select="firstname"/> <xsl:text> </xsl:text> <xsl:apply-templates select="lastname"/> </xsl:template> sagt zum Beispiel nichts darüber aus, was mit dem (Text-) Inhalt des firstname-, bzw. lastname-knotens (Alan, Euler, Turing,...) geschehen soll (falls es kein entsprechendes Template gibt). Falls es für firstname oder lastname keine Regel im Stylesheet gibt, wird automatisch die Default-Regel angewandt, welche den Text (Alan, Euler, Turing,...) unverändert in die Ausgabe kopiert. 81

82 Root- und Element-Knoten Vom Root- und von allen Element-Knoten werden per Default die Template-Regeln aller Kindknoten aufgerufen. Als XSL-Template sieht dies wie folgt aus: <xsl:template match= " / * "> <xsl:apply-templates/> </xsl:template> Falls es also im Stylesheet keine Regel für das Root-Element oder für "/" gibt, wird die Regel für dessen Kind-Knoten gesucht und ausgeführt. Falls es im Stylesheet für einen beliebiges Element keine Regel gibt, werden ebenfalls dessen Kind-Knoten gesucht und deren Regeln ausgeführt. Kommentare und Verarbeitungsanweisungen Falls es keine explizite Regel dafür gibt, werden Kommentare und Processing Instructions nicht ausgegeben. Als XSL-Template sieht dies wie folgt aus: <xsl:template match= "processing-instructions() comment()" /> Es gibt keine Adressierung (keinen XPath Ausdruck) für Namespace-Knoten. Kommentare, Namespaces und Verarbeitungsanweisungen machen im Ziel Dokument normalerweise keinen Sinn mehr. 82

83 9.2 Template Driven vs. Data Driven Stylesheets In allen Beispielen, welche wir bisher betrachtet haben, bestimmt das Template im Stylesheet, welche Regel als nächstes benutzt werden soll. Diesen Programmierstil bezeichnet man als Template-Driven. Dies ist immer dann sinnvoll, wenn die Source Dokumente stark struktuiert sind. Daten-bezogene XML- Dokumente sind üblicherweise stark strukturiert. Anders sieht es aus, wenn die XML Dokumente keinen strikten Aufbau haben. Dies findet man zum Beispiel in Dokumenten, welche Texte, Briefe oder Webseiten Inhalte beschreiben. Ein Beispiel XML Dokument, ohne strikten Aufbau <?xml version='1.0'?> <book-review> <title>this Book</title> by <author>this Author</author>, published by <publisher>the Publisher</publisher> on <date>date</date>, is indeed a good book. However, the book titled <title> Bad Book</title> by the same publisher is very bad. The reviewer is left to wonder whether this is because <title>bad Book</title> was written by <author>bad Author</author>, or because it was published on <date>date</date>. </book-review> Für solche Dokumente ist es sehr schwierig, im Stylesheet die Reihenfolge der zu benutzenden Templates festzulegen. Viel einfacher ist es, das Stylesheet Data-Driven zu implementieren: d.h. xsl:apply-templates ohne select-attribut. Im folgenden Stylesheet bestimmt allein das XML Dokument, in welcher Reihenfolge die Regeln aufgerufen werden. <xsl:stylesheet version="1.0" xmlns:xsl=" <xsl:template match="/"> <html><body> <xsl:apply-templates/> </body></html> </xsl:template> <xsl:template match="book-review"> <p> <xsl:apply-templates/> </p> </xsl:template> <xsl:template match="title"> <span style="font-weight:bold"> <xsl:value-of select="."/> </span> </xsl:template> Die Ausgabe <xsl:template match="author"> <span style="font-style:italic"> <xsl:apply-templates/> </span> </xsl:template> <xsl:template match="publisher"> <span style="color:blue"> <xsl:apply-templates/> </span> </xsl:template>... </xsl:stylesheet> Die beiden Modelle (Template-Driven und Data-Driven) lassen sich in einem Stylesheet nach Bedarf mischen. 83

84 10 XPath: Die XSL Adressierungssprache Die Templates im Stylesheet können nur dann richtig (an der richtigen Stelle) angewandt werden, wenn die Adressierung (match) korrekt ist. XSL muss beliebige Knoten des XML-Dokumentes adressieren (identifizieren) können. Dafür benutzt XSL die Sprache XPath. Die W3C Spezifikation für XPath finden Sie unter Einige Beispiele name alle <name> Kinder des aktuellen Knotens name/firstname alle <firstname> Kinder aller / der Root Knoten des Dokumentes. der aktuelle Knoten.. der Vorgänger (Parent) des aktuellen Knotens //name alle <name> Elemente des Dokumentes.//name alle <name> Nachfolger (direkte und indirekte) des aktuellen Knotens <name> Kinder des aktuellen Knotens //name/firstname alle <firstname> Elemente, welche Nachfolger von <name> sind. // ist die Abkürzung für descendant-or-self, d.h. für alle direkten und indirekten Nachfolger, sowie den Knoten selber Die XPath Syntax Die XPath-Syntax sieht ähnlich aus wie die übliche Filesystem-Adressierung. Das Pattern matching ist abhängig vom Kontext: Ein XPath Ausdruck kann verschiedene Knoten bezeichnen, abhängig von der Stelle im Dokument, in welchem er steht. XPath findet alle passenden Knoten. Sollen nur gewisse Knoten aus dem Pfad selektiert werden, kann der Pfad (durch Prädikate) eingeschränkt werden. Ein XPath ist absolut, falls er mit einem Slash (" / ") anfängt, z.b. /person Ein Pfad ist zusammengesetzt auf einer Reihe von Schritten, welche durch "/" getrennt sind: people/person/born Attribute werden durch "@" markiert. born/@addressref Pfade können kombiniert werden durch " " (Auswahl) name/firstname profession hobby 84

85 Wildcards Pfade können die Wildcards und node() enthalten. node() selektiert alle Elemente selektiert alle Attribute selektiert alle Knoten Attribute, Text-Knoten, Kommentare oder Verarbeitungsanweisungen (Processing-Instructions) werden durch den Stern (*) nicht selektiert nur Attribute node() selektiert alle Knoten: Elemente, Attribute, Text-Knoten, Kommentare, Verarbeitungsanweisungen, Beispiele //* /* str/*/title //*/@id //*/@* findet alle Elemente im Dokument alle Kinder von Root (also das Root-Element) alle <title> Enkel von str alle Attribute mit Namen id alle Attribut Knoten im Dokument. XPath Prädikate XPath kann auch filtern. Dazu wird im select-attribut zum Pfad ein Prädikat mit angegeben <xsl:apply-templates select="person[name/firstname!= 'Alan']"/> Mögliche Filter-Operatoren sind: = gleich!= ungleich < kleiner als > grösser als XPath Filter können xsl:if Statements ersetzen und sind oft eleganter und effizienter. Prädikate können in select Attributen, aber auch in match Attributen verwendet werden: Die Regel <xsl:template match= person[@id] > gilt nur für person-elemente, welche ein id-attribut haben. (Vorsicht: für die anderen person-elemente benötigen Sie also eine separate Regel!) XPath Prädikat Beispiele: = 'gbc' ] alle <born> Kinder, welche ein addressref Attribut mit Wert "gbc" haben ] alle <died> Kinder, welche ein addressref Attribut haben person [born/@date > 1900 ]/name alle Namen von Personen, welche später als 1900 geboren sind name[last()] das letzte <name> Kind des aktuellen Knotens 85

86 Zu beachten ist, dass die Adressierungen vom Kontext abhängig sind: gibt nur dann ein Element zurück, wenn der aktuelle Knoten (Kontext) ein oder mehrere died Kinder hat, welche ein addressref Attribut haben. Doppelte Einschränkungen (nacheinander ausgeführt) gibt das letzte name-element zurück, falls dieses ein addressrefattribut hat. gibt das letzte name-element zurück, welches ein addressref-attribut hat. XPath Schritte Jeder Schritt im Pfad ist ein Bezeichner, ein Wildcard oder ein Prädikat. <xsl:template match="person"> <xsl:apply-templates </xsl:template> <xsl:template match="born died"> <xsl:value-of select="../*/lastname"/>, <xsl:value-of select="name(.)"/>: <xsl:value-of <xsl:variable name="var" <xsl:apply-templates <br/> </xsl:template> <xsl:template match="city"> in <xsl:value-of select="."/> </xsl:template> Die verwendeten Bezeichner --> people, Wildcards --> node() Prädikate Der Pfad wählt alle Kind-Knoten von person aus, welche ein date Attribut haben. Der Pfad // * [@id = $var] wählt alle Elemente Dokumentes aus, welche ein id-attribut haben, welches den gleichen Wert hat wie var (bzw. den gleichen Wert Gefunden werden die address Elemente und es wird der Inhalt des <city>-elements ausgegeben. Weitere Beispiele von Pfaden mit Prädikaten: //name/* alle Kinder von name //name/*[@*] alle Kinder von name, die ein Attribut haben //name/*[*] alle Kinder von name, welche keine Blätter sind //*[@*] alle Elemente, die ein Attribut haben //person[*/@id]/name alle name Kinder von person Elementen, die ein Kind mit einem id Attribut haben //*[@*]/* alle Kinder von Elementen, die ein Attribut haben 86

87 87

88 10.2 Adressierungs-Achsen preceding-sibling sind alle früheren, following-sibling alle im Dokument nachfolgenden Geschwister-Knoten von self. Die Begriffe preceding und following beziehen sich auf die Reihenfolge im XML-Dokument. following sind alle Knoten, welche im XML-Dokument hinter dem End-Tag des self-knoten stehen. preceding sind alle Knoten, die vor dem Start-Tag des self-knoten stehen und keine ancestors sind. Beispiele: child::people alle <people>-kinder des aktuellen Knotens following-sibling::profession alle <profession>- Geschwister des aktuellen Knotens, welche im XMLFile später auftreten. descendent::* alle (direkten und indirekten) Nachfolger des aktuellen Knotens ancestor::*/child::person alle <person> Kinder aller Vorgänger Knoten des aktuellen Knotens Für die wichtigsten Adressierungs-Achsen existieren (die bereits bekannten) Abkürzungen: child (leer) parent.. self. descendant-or-self // Die Bezeichnung "child::" kann immer weggelassen werden. /child::people/child::person/child::profession = /people/child::person/profession = /people/person/child::profession self wird vor allem im Zusammenhang mit value-of benutzt: <xsl:value-of select=" self::* "/> ist gleichbedeutend mit <xsl:value-of select=". "/> descendant-or-self kann absolut oder relativ verwendet werden: <xsl:apply-templates select= "//lastname />, d.h. alle lastname Elemente des Dokuments <xsl:apply-templates select= "person//lastname />, d.h. nur die lastname Nachfolger von person. Das Template <xsl:apply-templates select= "//lastname[string-length(text()) > 6]/.. "/> findet zum Beispiel alle parent Knoten von allen lastname Elementen, deren Text-Inhalt mehr als 6 Buchstaben lang ist. 88

89 10.3 Die wichtigsten XPath Funktionen Die W3C Recommendation zu XQuery 1.0 and XPath 2.0 Functions and Operators finden Sie unter Ausserdem finden Sie alle von saxon8 unterstützten XPath 2.0 Funktionen und Operatoren unter Einige Beispiele boolean( obj ), number( obj ), string( obj ) konvertiert das object obj falls möglich zu einem boolean/number/string... boolean(0) ist falsch, boolean(5) ist wahr boolean(nan) ist falsch, also auch boolean(number('a')). (NaN steht für not a Number.) boolean not (value) gibt true zurück, falls value zu false evaluiert (und umgekehrt). Funktionen auf Strings String concat( String s1, String s2, String s3,... ) setzt die Strings s1, s2, s3,... zusammen String substring(string s1, double start, double length) gibt den Teil-String von s1 ab Position start mit Länge length zurück. boolean contains( string s1, string s2 ) gibt true zurück, falls s2 ein Substring von s1 ist number string-length( string ) gibt die Länge des Strings zurück string translate( string s, string s1, string s2 ) ersetzt alle Vorkommnisse von s1 in s durch s2. boolean matches(string, pattern) gibt true zurück, falls der gegebene String das Pattern erfüllt. String replace(string1, pattern, string2) ersetzt in string1 alle Teile, welche das pattern erfüllen durch string2. Numerische Funktionen number abs(number), number avg(number), number max(items), number min(items) Absolutwert, Durchschnitt, Maximum, Minimum number round(number), number ceiling(number), number floor(number) Runden, Aufrunden, Abrunden atomictype sum(atomictype) summiert die Werte aller Werte auf. atomictype ist muss hier eine Zahl oder eine Zeitdauer (duration) sein. Falls ein Argument-Knoten von sum keine Zahl oder Zeitdauer ist, ist der Rückgabe-Wert "NaN" (Not a Number). sum(//number) summiert alle Werte unter //number, sum(//book/quantity) berechnet also zum Beispiel die Anzahl vorhandener Bücher. String format-number(value, picturestring) formatiert den value gemäss dem picturestring. format-number(500100, ' #.0 ') Ausserdem existieren die normalen Grundoperationen +, -, *, mod und div. 89

90 Funktionen auf Sequenzen (Listen von Knoten) number last() berechnet die Anzahl Knoten im Kontext //person[1] gibt die erste, //person[last()] gibt die letzte Person zurück. number position() gibt die Position des Kontext Knotens in der aktuell verarbeiteten Sequenz zurück. Während dem Abarbeiten der Sequenzen wir die Position laufend aktualisiert. Falls die Personen gefiltert oder sortiert werden, liefert position dennoch eine normale aufsteigende Nummerierung. number count( items) zählt die Knoten in der Sequenz items. z.b. count(//person) gibt 4, count(//address) gibt 6 zurück. remove(...), insert-before(...), reverse(...), subsequence(...) sind Funktionen auf Sequenzen zum Löschen, Einfügen, Umdrehen und Zerteilen der Sequenzen. boolean empty(items) true, falls items eine leere Sequenz ist. Datum und Zeit date current-date(), datetime currenttime() gibt das aktuelle Datum, bzw. die aktuelle Zeit zurück. Dieses kann nachher durch format-date(), bzw. format-datetime() formatiert werden. String format-date(date, picturestring) formatiert das Datum date gemäss picturestring. format-date(current-date(), ' [D]-[M]-[Y] ') for Ausdrücke Mit Hilfe von for Ausdrücken ist es möglich, in einem XPath Aufruf über alle Elemente der ganzen Sequenz zu iterieren. Die Syntax benutzt eine Iterator-Variable (hier z.b. x). Aus einem for $x in E return result evaluiert result für jedes Element der Sequenz E <xsl:value-of select="sum(for $x in book return $x/price * $x/quantity)"/> summiert die price * quantity Werte aller book Elemente auf. 90

91 Einlesen von XML Dokumenten Die Funktion document($srcval ) lädt das an der Adresse (URI) srcval gefundene Dokument. Durch Definition einer (globalen) Variable "input" kann folgendermassen auf die Elemente des Files "Daten.xml" zugegriffen werden. <xsl:variable name="input" select="document('daten.xml')/person"/> Diese Variable kann dann benutzt werden um die Namen der Personen im Daten File zu lesen: <xsl:value-of select="$input/name"/> xsl:key und key()-funktion Durch xsl:key kann eine Indexierung (Schlüssel) von Elementen angelegt werden. Dies erzeugt eine Hash-Tabelle, über deren Schlüssel auf die Werte zugegriffen werden kann. Die key-funktion hat zwei Auswirkungen: Sie kann den xsl-code vereinfachen und sie kann die Performance positiv beeinflussen, indem der Parser eine Indexierung für alle key-werte anlegt. Alle../born/@date-Attribute werden als Schlüssel für die name-elemente abgelegt: <xsl:key name="mykey1" match="name" use="../born/@date"/> Alle hobby-elemente werden unter ihrem Anfangsbuchstaben abgelegt: <xsl:key name="mykey2" match="hobby" use="substring(.,1,1)"/> Die XPath Funktion key() gibt dann die entsprechenden Elemente zurück. <xsl:apply-templates select="key('mykey1','1912')"/> gibt alle name-knoten mit Geburtstjahr 1912 zurück. <xsl:apply-templates select="key('mykey2','p')"/> gibt alle hobby-knoten mit Anfangsbuchstabe "p" zurück. 91

92 Ein Beispiel <?xml version="1.0" encoding="utf-8"?> <xsl:stylesheet version="2.0" xmlns:xsl=" <-- indexieren aller Personennamen nach Datum --> <xsl:key name="namekey" match="name" <-- indexieren aller Hobbys nach Anfangsbuchstaben --> <xsl:key name="hobbykey" match="hobby" use="substring(.,1,1)"/> <-- indexieren aller Adressen nach ihrer id --> <xsl:key name="addrkey" match="address" <xsl:template match="people"> <html> <body>  <ul> <xsl:for-each <xsl:sort order="descending"/> <li> <xsl:value-of <xsl:text> </xsl:text> <xsl:value-of <xsl:if <xsl:text>, </xsl:text> <xsl:value-of select="name()"/> in  <xsl:value-of <xsl:text> </xsl:text>  <xsl:value-of </xsl:if> </li> </xsl:for-each> </ul>  <p> <xsl:value-of select="key('hobbykey','p')" separator=", "/> </p> </body> </html> </xsl:template> </xsl:stylesheet> 92

93 xsl:function Beispiele von selber definierten XSL Funktionen <xsl:stylesheet xmlns:xsl=" version="2.0" xmlns:cs=" xmlns:xs=' <xsl:function name="cs:substring"> <xsl:param name="str" as="xs:string"/> <xsl:param name="n" as="xs:integer"/> <xsl:sequence select= "if( string-length($str) >=$n ) then substring($str,1,$n) else error() "/> </xsl:function> <xsl:function name="cs:numberofchildren"> <xsl:param name="node"/> <xsl:sequence select="count($node/*)"/> </xsl:function>... Solche selber definierten Funktionen können dann folgendermassen benutzt werden: <xsl:value-of select="cs:numberofchildren(/people)"/> 93

94 11 XSL-FO Einführung XSL-FO... bildet zusammen mit XSLT und XPath die XSL (extensible Stylesheet Language)... ist eine XML Applikation... definiert das visuelle Layout-Modell... wird mit Hilfe von einem Transformations-Tool (FOP, XEP,...) nach PDF, PostScript,... transformiert Dabei werden normalerweise keine FO-Dokumente direkt geschrieben, sondern die XML Daten werden mit Hilfe eines Stylesheets nach XSL-FO übersetzt, und dann mit Hilfe eines FO-Transformations-Tools nach Postscript, PDF,... transformiert Ein einfaches Beispiel <?xml version="1.0"?> <fo:root xmlns:fo=" <fo:layout-master-set> <fo:simple-page-master master-name="only" page-width="5.5cm" margin-left="1cm"> <fo:region-body/> </fo:simple-page-master> </fo:layout-master-set> <fo:page-sequence master-reference="only"> <fo:flow flow-name="xsl-region-body"> <fo:block font-size="18pt"> A small <fo:external-graphic src="fo.jpg"/> example </fo:block> </fo:flow> </fo:page-sequence> </fo:root>

95 11.2 Die wichtigsten FO Elemente Es gibt 56 XSL-FO Elemente fo:block, fo:block-container, fo:character, fo:external-graphic, fo:flow, fo:footnote, fo:inline, fo:layout-master-set, fo:leader, fo:list-block, fo:list-item, fo:list-item-body, fo:list-item-label, fo:page-number, fo:page-sequence, fo:region-after, fo:region-before, fo:region-body, fo:root, fo:simple-page-master, fo:table-and-caption, fo:table, fo:tablebody, fo:table-caption, fo:table-cell, fo:table-column, fo:table-footer, fo:table-header, fo:table-row,... Die Elemente von XSL-FO definieren die Struktur oder den Aufbau (Unterteilung in Abschnitte, Blöcke, TextFelder, Bilder,...) des Ausgabe- Dokuments. Die Attribute definieren das (lokale) Aussehen. Das Root Element XSL-FO Dokumente sind XML Dokumente. Darum beginnen FO-Dokumente mit der XML-Deklaration: <?xml version="1.0"?> XSL-FO Dokumente haben als Root-Element einen fo:root Knoten, in welchem der fo Namespace deklariert werden muss: xmlns:fo=" 95

96 Das Layout einer Seite Eine Seite ist aufgeteilt in die fünf Bereiche region-before, region-after, region-start, region-end und regionbody. Diese sehen in der üblichen Lesart (von links nach rechts, von oben nach unten) wie folgt aus: Normalerweise sind die Randbereiche (region-before, region-after,...) reserviert für statische (wiederkehrende) Ausgaben (Logos, Adresse, Seitenzahl,...), während der eigentliche Inhalt der Seite im Zentralbereich (body) ausgegeben wird. Die einzelnen Bereiche können dann weiter aufgeteilt werden in Blöcke (zum Beispiel durch fo:block, fo:table, fo:list-block,...). Das Layout Master Set Das layout-master-set enthält alle Seiten-Vorlagen für die verschiedenen Seiten-Arten wie Titelseiten, linke und rechte Seiten,... <fo:layout-master-set> <fo:simple-page-master master-name="first" page-height="297mm" page-width="210mm" margin-top="15mm" margin-bottom="15mm" margin-left="20mm" margin-right ="15mm"> <fo:region-body margin-top="20mm"/> <fo:region-before extent="15mm" region-name="fbefore"/> </fo:simple-page-master> <fo:simple-page-master master-name="odd"... </...> </fo:layout-master-set> Die einzelnen Seiten-Vorlagen sind dann verpackt in verschiedene page-master Elemente. Das layout-master-set Element hat keine Attribute, ist immer ein Kind-Knoten vom root-knoten und hat als (einzig mögliche) Kinder einen (oder mehrere) simple-page-master oder page-sequence-master Knoten. Mit dem simple-page-master Knoten werden die Seitenränder (margin) und ev. die Papiergrösse festgelegt. Weiter wird definiert, in wie viele Bereiche (regions) die Seite aufgeteilt werden soll (region-body, regionbefore, region-after,...). Die normalen A4 Seitengrösse ist page-height="29.7cm" und page-width="21cm" Pro Seitentyp (Titelseite, Index-Seite, Inhaltsverzeichnis,...) wird je eine separate Seiten-Vorlage definiert. 96

97 Die Platz-Verteilung für die Regionen <fo:root xmlns:fo= " <fo:layout-master-set> <fo:simple-page-master master-name="simple" page-height="10cm" page-width="9cm" margin-top="1.5cm" margin-bottom="1.5cm" margin-left="1cm" margin-right="1cm"> <fo:region-body margin-top="2cm" margin-bottom="1.5cm" background-color="#eeeeee" /> <fo:region-before extent="1cm" background-color="yellow"/> <fo:region-after extent="1cm" background-color="yellow"/> </fo:simple-page-master> </fo:layout-master-set> <fo:page-sequence master-reference="simple"> <fo:static-content flow-name="xsl-region-before"> <fo:block font-size="12pt"> Hier ist der Platz für das Region- Before </fo:block> </fo:static-content> <fo:static-content flow-name="xsl-region-after" > <fo:block font-size="12pt"> Region-After ist oberhalb vom unteren Rand </fo:block> </fo:static-content> <fo:flow flow-name="xsl-region-body"> <fo:block font-size="20pt" padding="0.5cm"> Region Body Region Body Region Body... </fo:block> </fo:flow> </fo:page-sequence> </fo:root> 97

98 Definieren und Benutzen von verschieden Seiten-Typen <fo:root xmlns:fo=" <fo:layout-master-set>  <fo:simple-page-master master-name="erste" margin-left="5cm" margin-right="5cm margin-top="2cm" margin-bottom="3cm"> <fo:region-body margin-top="3cm" margin-bottom="2cm"/> <fo:region-before extent="3cm" region-name="first-before"/> <fo:region-after extent="1.5cm" region-name="first-after"/> </fo:simple-page-master>  <fo:simple-page-master margin-bottom="3cm" margin-left="5cm" margin-right="5cm margin-top="5cm" master-name="restliche"> <fo:region-body margin-top="2.5cm" margin-bottom="2cm"/> <fo:region-before extent="2.5cm" region-name="rest-before"/> <fo:region-after extent="1.5cm" region-name="rest-after"/> </fo:simple-page-master>  <fo:page-sequence-master master-name="global"> <fo:repeatable-page-master-alternatives> <fo:conditional-page-master-reference master-reference="erste" page-position="first"/> <fo:conditional-page-master-reference master-reference="restliche" page-position="rest"/>  <fo:conditional-page-master-reference master-reference="restliche"/> </fo:repeatable-page-master-alternatives> </fo:page-sequence-master> </fo:layout-master-set>  <fo:page-sequence initial-page-number="1" master-reference="global"> <fo:static-content flow-name="first-before"> <fo:block> Hier ist der Titel der ersten Seite </fo:block> </fo:static-content> <fo:static-content flow-name="rest-before"> <fo:block> Der Titel der restlichen Seiten </fo:block> </fo:static-content> <fo:static-content flow-name="first-after"> <fo:block> Hier ist die Fusszeile der ersten Seite </fo:block> </fo:static-content> <fo:static-content flow-name="rest-after"> <fo:block> Hier ist die Fusszeile der restlichen Seiten </fo:block> </fo:static-content> <fo:flow flow-name="xsl-region-body">... hier kommt der Dokument Inhalt... </fo:flow> </fo:page-sequence> </fo:root> 98

99 Der Dokument Inhalt: fo:flow fo:flow ist ein Kind-Knoten von fo:page-sequence und enthält eine beliebige Anzahl von Blöcken mit Text, Tabellen, Listen und Bildern. Mit Hilfe des flow Elementes wird der Dokument-Inhalt (der Fliesstext) definiert. fo:flow hat als mögliche Kind-Elemente: fo:block (neuer Abschnitt) block-container (neuer Abschnitt an fixem Ort) table, table-and-caption (Tabelle) list-block (Listen) Ein Beispiel <fo:flow flow-name="xsl-region-body"> <fo:block font-size="16pt"> This is the document content. This is the <fo:external-graphic src="cup.gif"/> document content. This is the... </fo:block> </fo:flow> Die statischen Bereiche: fo:static-content In den Randbereichen befindet sich normalerweise wiederkehrende Information (Überschriften, Fussnoten, Seitenzahlen,...) <fo:static-content flow-name="xsl-region-after"> <fo:block text-align="end" font-size="10pt"> Seite <fo:page-number/> </fo:block> </fo:static-content> Abschnitte, Paragraphen,... fo:block fo:block erzeugt einen Bereich (ein oder mehrere Zeilen lang. fo:block wird benutzt, um zusammengehörende Ausgabe-Elemente (ein Textabschnitt, eine Titelzeile, eine Tabelle,...) zu gruppieren. <fo:block font-size="36pt"> Chapter 1: Introduction </fo:block> 99

100 Fest positionierte Felder: fo:block-container Ein fo:block-container Element kann an beliebiger Stelle auf des Seite positioniert werden <fo:block-container border-color="black" border-style="solid" border-width="1pt" height="1cm" width="4cm" padding="5pt" top="9.5cm" left="12cm" position="absolute" > <fo:block text-align="start" line-height="10pt" font-family="sans-serif" font-size="10pt"> Hier ist ein Text </fo:block> </fo:block-container> Format Änderungen in Zeilen: fo:inline Während mit fo:block ein neuer Abschnitt (eine neue Zeile) anfängt, kann fo:inline benutzt werden für Format-Änderungen innerhalb eines Blockes (einer Zeile). Typischerweise werden deshalb Blöcke entweder durch fo:block oder durch fo:inline Elemente unterteilt, je nachdem ob ein neuer Absatz erwünscht wird oder nicht. Einbinden von Bildern: fo:external-graphic Mit Hilfe von fo:external-graphic wird ein Bild in ein Dokument eingebettet. Mögliche Bildformate sind GIF und JPEG,... <fo:block> Look at this! <fo:external-graphic src="cup.jpg"/> </fo:block> 100

101 Erstellen von Listen, Aufzählungen,... Jedes fo:list-item Element enthält ein fo:list-item-label und ein fo:list-item-body Element. Ohne das start-indent Attribut im fo:list-item-body fängt der Inhalt der Auflistung am linken Rand an, und überschreibt das eventuell vorhandene Aufzählungs-Zeichen. <fo:list-block> <fo:list-item> <fo:list-item-label> <fo:block>a)</fo:block> </fo:list-item-label> <fo:list-item-body start-indent="body-start()"> <fo:block>dies ist das erste...</fo:block> </fo:list-item-body> </fo:list-item> <fo:list-item> <fo:list-item-label> <fo:block> </fo:block> </fo:list-item-label> <fo:list-item-body start-indent="body-start()"> <fo:block>dies ist das zweite...</fo:block> </fo:list-item-body> </fo:list-item>... </fo:list-block> 101

102 Erzeugen von Tabellen Zum Erzeugen von Tabellen gibt es die Elemente: fo:table, fo:table-body, fo:table-cell, fo:table-column, fo:table-footer, fo:table-header, fo:table-row fo:table enhält (optional) einen table-header und/oder table-footer sowie einen table-body. Der table-body besteht dann aus table-row Elementen, welche wiederum aus table-cell Knoten zusammengesetzt sind. Durch die table-column Elemente wird bestimmt, wie viele und wie breit die einzelnen Spalten werden sollen. Die Breite kann auch Proportional zur Gesamt-Breite des Dokuments definiert werden (zum Beispiel 25%): column-width="proportional-column-width(25)" table-header und table-body enthalten dann pro Zeile eine table-row, welche pro Spalte eine table-cell enthält. Falls die Tabelle einen Rahmen erhalten soll, kann dies entweder in fo:table (Rahmen um ganze Tabelle), in table-column (Rahmen um eine Spalte), in table-row (Rahmen um eine Zeile) oder in fo:table-cell (Rahmen um einzelne Zelle) angegeben werden. Das Attribut padding gibt den Abstand vom Inhalt der Zelle (Text) und dem Rand der Zelle an. 102

103 Beispiel einer Tabelle <fo:table background-color="#eeeeee" padding="3pt"> <fo:table-column column-width="20mm"/>  <fo:table-column column-width="30mm"/> <fo:table-header font-weight="bold" background-color="#cccccc> <fo:table-row> <fo:table-cell border="2pt solid black" padding="3pt"> <fo:block> HTML </fo:block> </fo:table-cell> <fo:table-cell border="2pt solid black" padding="3pt"> <fo:block> XML-FO </fo:block> </fo:table-cell> </fo:table-row> </fo:table-header> <fo:table-body> <fo:table-row> <fo:table-cell border="1pt solid black" padding="3pt"> <fo:block> THEAD </fo:block> </fo:table-cell> <fo:table-cell border="1pt solid black" padding="3pt">.... </fo:table-cell> </fo:table-row> </fo:table-body> </fo:table> 103

104 11.3 Die wichtigsten Attribute Attribute sind Properties Die Attribute der FO-Elemente sind Formatierungs-Anweisungen. Sie bestimmen das Aussehen des Inhalts. Es gibt mehr als 200 Format Properties (Attribute), welche oft in verschiedensten Elementen angegeben werden können. Properties werden von aussen nach innen abgearbeitet. Bei sich widersprechenden Angaben, überschreibt die lokale Angabe die globale. Eine Property, welche an verschiedenen Orten benutzt werden kann, hat immer dieselbe Bedeutung Character Properties Alle XSL-FO Elemente, welche Text enthalten können (fo:block, fo:inline,...), erlauben Attribute für das Setzen von Character Properties(color, font-size, font-family, text-decoration,...). <fo:block font-family="helvetica" font-size="12pt"> Hier ist ein <fo:inline text-decoration="underline"> wichtiger </fo:inline> <fo:inline color="red" font-weight="900"> Text </fo:inline> </fo:block> Character Property: Farbe Die color-property setzt die Schriftfarbe: <fo:inline color="green"> Text </fo:inline> Wie in CSS gibt es 16 vordefinierte Farben: Weitere Farben können als hexadezimale RGB-Trippel definiert werden: #RRGGBB. 104

105 Character Property: Font Die Property font-family definiert den zu benutzenden Font: <fo:inline font-family="times Roman" > Times Roman </fo:inline> Zur Verfügung stehen unter anderem die Schriften Serif, Sans Serif, Times Roman, Courier und Symbol. Es können als fall-back auch mehrere font-family Werte angegeben werden. font-family= Arial, Helvetica, sans-serif Ausserdem können mit FOP alle Systemfonts eingebettet werden Character Property: Schriftgrösse Die Property font-size definiert die zu benutzende Schriftgrösse: <fo:inline font-family="helvetica" ein Text in 24 Punkt Schrift </fo:inline> font-size="24pt"> Character Property: Schrift Style Der Style des Fonts wird definiert durch die Property font-style <fo:block font-family="times Roman" Times Roman italic </fo:block> font-style="italic"> Es gibt die Styles italic, normal, oblique, reverse-normal und reverse-oblique Character Property: Schrift-Dicke Die Dicke der Schrift wird definiert durch die Property font-weight: <fo:block font-family="times Roman" font-weight="bold"> Hier ist ein bold Text </fo:block> <fo:block font-family="times Roman" font-weight="normal"> Hier ist ein normaler Text </fo:block> 105

106 Character Property: Schrift-Dekorationen Unabhängig vom gewählten Font (Style, Farbe,...) können verschiedene Text Properties gesetzt werden. Die Property text-transform definiert, ob der ganze Text in Grossbuchstaben (uppercase), Kleinbuchstaben (lowercase) oder bloss die Anfangsbuchstaben in gross gesetzt werden sollen (capitalize). Die Property texttransform ist in FOP (noch) nicht implementiert. Die Property score-spaces definiert, ob im unter- (über/durch)-gestrichenen Text auch die Spaces unter (über/durch)-strichen sein sollen oder nicht. text-decoration="underline" --> unterstrichen text-decoration="overline" --> überstrichen text-decoration="line-through" --> durchgestrichen text-shadow="gray" --> Schattenschrift text-transform="capitalize" --> Alle Ersten Buchstaben Gross text-transform="uppercase" --> GROSSSCHRIFT text-transform="lowercase" --> kleinschrift Ein Beispiel: <fo:block text-align="start" line-height="12pt" font-family="sans-serif" font-size="10pt" text-decoration="underline" color="blue"> Ein blauer, unterstrichener sans-serif Text in 10pt Schrift. </fo:block> Sentence Properties Sentence Properties bestimmen den Platz zwischen den einzelnen Buchstaben (letter-spacing), zwischen einzelnen Wörtern im Text (word-spacing) und zwischen den einzelnen Linien im Text (line-height, text-depth, text-altitude,...), die Ausrichtung des Texts (text-align),... <fo:block font-family="helvetica" font-size="10pt" text-align="center" line-height="11pt"> Hier ist ein zentrierter Text. Hier ist ein zentrierter Text. Hier ist ein zentrierter Text. <fo:leader leader-pattern="rule" leader-length="6cm"/> <!- - Linie - -> </fo:block> <fo:block font-family="helvetica" font-size="10pt" text-align="justify" letter-spacing="1pt"> Hier ist ein gesperrter... Hier ist ein Text. Hier ist noch ein Text. <fo:leader leader-pattern="rule" leader-length="6cm"/> <!- - Linie - -> </fo:block> 106

107 107

108 Sentence Property: Zeilenabstand Der Zeilenabstand im Text kann kontrolliert werden durch die Properties line-height, text-depth und textaltitude. <fo:block font-size="10pt" line-height="16pt"...> Hier ist ein Text,... </fo:block> Die Sentence Property line-height-shift-adjustment legt fest, ob subscripts und superscripts den LinienAbstand vergrössern sollen oder nicht. Durch text-depth (text-altitude) wird zusätzlicher Abstand nach (vor) jeder Zeile eingefügt. <fo:block font-family="helvetica" font-size="10pt" text-align="left" text-depth="3pt" text-altitude="3pt" line-height="16pt"> Hier ist ein Text. Hier ist ein Text. Hier ist ein Text. </fo:block> Sentence Property: Text Ausrichtung Ob der Text linksbündig, rechtsbündig, zentriert oder im Blocksatz gesetzt werden soll, wird durch die Property textalign gesetzt. Diese kann die folgenden Werte annehmen: start oder left --> linksbündig center --> zentriert end oder right --> rechtsbündig justify --> Blocksatz <fo:flow flow-name="xsl-region-body" > <fo:block font-size="12pt" text-align="start"> Hier ist ein linksbündiger Text, der... </fo:block> <fo:block> <fo:leader leader-length="7cm" leader-pattern="rule"/> </fo:block> <fo:block font-size="12pt" text-align="center" line-height="20pt"> Hier ist ein zentrierter Text mit grossem... </fo:block> <fo:block> <fo:leader leader-length="7cm" leader-pattern="rule"/> </fo:block> <fo:block font-size="12pt" text-align="end"> Hier ist ein rechtsbündiger Text... </fo:block> <fo:block> <fo:leader leader-length="7cm" leader-pattern="rule"/> </fo:block> <fo:block font-size="12pt" text-align="justify"> Hier ist ein Blocksatz Text, der... </fo:block> </fo:flow> 108

109 109

110 Attribut Listen Zum Erlangen eines konsistenten Layouts sollten für die verschiedenen Text-Bereiche (Fliesstext, Header, Footer, Tabellen, Listen) jeweils entsprechende Styles definiert werden. Hier zum Beispiel die Definition des text-style für den Fliesstext (pagemaster.xsl): <xsl:attribute-set name="text-style"> <xsl:attribute name="font-family">arial, Helvetica, sans-serif</xsl:attribute> <xsl:attribute name="font-size">12pt</xsl:attribute> <xsl:attribute name="font-weight">normal</xsl:attribute> <xsl:attribute name="line-height">15pt</xsl:attribute> <xsl:attribute name="text-align">left</xsl:attribute> </xsl:attribute-set> Dieser wird dann wie folgt im Stylesheet benutzt (makefo.xsl): <fo:flow flow-name="xsl-region-body"> <fo:block xsl:use-attribute-sets="text-style"> <xsl:apply-templates select="doc"/> </fo:block> </fo:flow> Analog sollte für Tabellen, Listen,... vorgegangen werden Für die Übung: Einstellungen in oxygen für XSL-FO Beim Ankreuzen von FO Transformation ausführen wird das xml-dokument mit Hilfe des Stylesheets nach XSL-FO transformiert und das erzeugte fo-file danach mit FOP nach pdf umgewandelt. 110