XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es...

110
XML extensible Markup Language www.w3.org/XML Dr. Beatrice Amrhein

Transcript of XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es...

Page 1: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

XML

extensible Markup Languagewww.w3.org/XML

Dr. Beatrice Amrhein

Page 2: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

2

Page 3: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

Inhaltsverzeichnis

1 XML Grundlagen...........................................................................................................................................5 1.1 Die wichtigsten Punkte.........................................................................................................................5 1.2 XML Sprachen und Anwendungen........................................................................................................7 1.3 Der Aufbau eines XML Dokuments.......................................................................................................7 1.4 Elemente...............................................................................................................................................8 1.5 Attribute.............................................................................................................................................10 1.6 Zeichen- und Entity-Referenzen..........................................................................................................11 1.7 Kommentare und Verarbeitungsanweisungen....................................................................................11 1.8 Die XML Deklaration...........................................................................................................................11 1.9 XML Knotentypen und Nachfolger......................................................................................................12 1.10 Wohlgeformtheit: Zusammenfassung...............................................................................................12

2 Namespaces................................................................................................................................................13 2.1 Wozu dienen Namespaces?................................................................................................................13 2.2 Definition eines Namespaces..............................................................................................................14 2.3 Qualifizierte Element-Namen.............................................................................................................15

3 XSD: XML Schema Definition.......................................................................................................................18 3.1 Deklarationen <--> Definitionen..........................................................................................................20 3.2 Deklaration von einfachen Typen........................................................................................................22 3.3 Vordefinierte primitive Schema Typen................................................................................................23 3.4 Attribut Deklarationen........................................................................................................................25 3.5 Komplexe Schema Typen....................................................................................................................26 3.6 Spezielle Schema Elemente................................................................................................................29 3.7 Schlüssel.............................................................................................................................................32

4 SAX: Simple Application Interface for XML..................................................................................................38 4.1 Was ist SAX?........................................................................................................................................38 4.2 Wofür ist SAX geeignet?......................................................................................................................38 4.3 Wie funktioniert SAX?.........................................................................................................................38 4.4 Übersicht über das SAX API.................................................................................................................39 4.5 Implementation des Default Handlers................................................................................................40 4.6 Fehlerbehandlung: ErrorHandler........................................................................................................42 Ein SAX Beispiel.........................................................................................................................................43

5 DOM: Das Document Object Model............................................................................................................45 Was ist DOM?...........................................................................................................................................45 Die DOM Node Typen...............................................................................................................................45 5.1 Die org.w3c.dom Java Interfaces.........................................................................................................46 5.2 Benutzen des DOM Parsers.................................................................................................................48

6 StAX: Streaming API for XML.......................................................................................................................50 6.1 Was ist StAX?......................................................................................................................................50

7 JAXB: Java Architecture for XML Binding.....................................................................................................54 7.1 Die JAXB Architektur...........................................................................................................................54 7.2 Das Binding.........................................................................................................................................55 7.3 Übersetzung verschiedener Basis-Datentypen....................................................................................56 7.4 Erzeugen der Java Klassen...................................................................................................................57 7.5 Einlesen der XML Daten......................................................................................................................58 7.6 Schreiben der Daten in ein XML File...................................................................................................58 7.7 Anpassen der generierten Java Klassen und Member Variablen.........................................................59 7.8 Externe Binding-Deklaration...............................................................................................................60 7.9 Erzeugen von Schematas....................................................................................................................61 7.10 Schreiben von XML Daten ohne ObjectFactory.................................................................................63

8 Die Transformations-Sprache XSLT..............................................................................................................68

3

Page 4: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

8.1 Wie funktioniert XSLT?........................................................................................................................68 8.2 Der Aufbau eines Stylesheets: Templates...........................................................................................70 8.3 Die wichtigsten XSLT Befehle...............................................................................................................72

9 Grundlegendes zu XSLT...............................................................................................................................81 9.1 Default Template Regeln.....................................................................................................................81 9.2 Template Driven vs. Data Driven Stylesheets......................................................................................83

10 XPath: Die XSL Adressierungssprache.......................................................................................................84 10.1 Die XPath Syntax...............................................................................................................................84 10.2 Adressierungs-Achsen.......................................................................................................................88 10.3 Die wichtigsten XPath Funktionen....................................................................................................89

11 XSL-FO Einführung....................................................................................................................................94 11.2 Die wichtigsten FO Elemente............................................................................................................95 11.3 Die wichtigsten Attribute................................................................................................................104

4

Page 5: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

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

Page 6: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

Ein XML Beispiel

XML Dokumente sind reine Datenfiles und enthalten im Gegensatz zu HTML normalerweise keine Präsentations-Hinweise.

<?xml version="1.0"?><!-- file people.xml --><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 zurDarstellung von Informationen

XML ist eine erweiterbare Menge struktureller und inhaltlicherElemente und enthält die Beschreibung und die Struktur derInformationen

6

Page 7: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

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• ...

1.3 Der Aufbau eines XML Dokuments

XML-Dokumente müssen wohlgeformt sein. Das heisst, sie müssen nach gewissen Regeln aufgebaut sein.EinXML-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

Page 8: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

Ein Beispiel

<?xml version="1.0"?> Prolog<!-- file people.xml --> optionaler Kommentar <people>

<person><name>Alan Turing</name><profession>

computer scientist</profession>

</person>

<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

<person><name>Alan Turing</name><profession>

computer scientist</profession>

</person>

Jedes Element beginnt mit einem Start-Tag (hier <person>) und endet mit einem End-Tag </person>. Start-Tag 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 Ungültige Namen <Drivers_License_Number> <Driver's_License_Number> <year-month-day> <year/month/day> <firstName> <first Name>

8

Root / Document-element

Start-Tag

End-Tag

Inhalt

Page 9: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

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 aufbeliebigen 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

Page 10: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

Im zugehörigen XML Baum hat das biography Kinder darum Elemente und Text-Knoten als Kinder.

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

biography

name profession

AlanTuring computer

scientist

was one of the ...

Page 11: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

1.6 Zeichen- und Entity-Referenzen

Sonderzeichen können als Zeichen Referenzen (Entity) mit dem entsprechenden Unicode eingefügt werden: <copyright> Copyright &#xA9; 2001</copyright>

Beispiele von Zeichen Referenzen:&#xA9; © (Copyright) &#x20AC; € (Euro)

Für die Zeichen &, <, >, ', " gibt es spezielle Entity ReferenzenZeichen Entity-Referenz & &amp; < &lt; > &gt; ' &apos; " &quot;

<publisher>O&apos;Reilly &amp; Associates

</publisher>

Durch Angabe des entsprechenden Zeichensatzes wie zum Beispiel <?xml version="1.0" encoding="ISO-8859-1"?>

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

<!-- These links need to be verified -->

Kommentare dürfen ausser am Anfang (<!--) und am Ende (-->) keine "--" Sequenz enthalten.

Verarbeitungsanweisungen (Processing Instructions) liefern Informationen für bestimmte Anwendungen und stehen normalerweise im Prolog des XML-Dokuments

<?robots index="yes" follow="no"?>

Eine spezielle Verarbeitungsanweisung ist die XML Deklaration zu Beginn des Dokumentes <?xml version="1.0" encoding="ISO-8859-1"?>

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-8859-1"?>

Das Encoding gibt die für das XML Dokument verwendete Codierung an.

11

Page 12: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

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 --> <!-- Kommentar --> • Verarbeitungsanweisungen --> <? processing introduction ?>

Wir betrachten das folgende Beispiel: <people> <!-- Personenbeschreibung--> <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 Root-Element 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 Kommentar-Knoten 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.

1.10 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

Page 13: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

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="http://www.w3.org/2000/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="http://www.w3.org/1999/xhtml"> <body> <h4>Can your browser display Presentation MathML?</h4> <p> <m:math xmlns:m="http://www.w3.org/1998/Math/MathML"> <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

Page 14: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

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>2000-08-22</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

Ein Namespace wird durch einen URI definiert:xmlns:dc=“http://purl.org/dc“xmlns:m="http://www.w3.org/1998/Math/MathML"

• 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 http://schemas.microsoft.com/... oder OpenOffice die Namespaces http://openoffice.org/...

14

description painting

creatortitle

date

artist

day

month

year

description painting

dc:creator pt:title

pt:date

pt:artist

pt:day

pt:month

pt:year

dc:title

dc:date

Page 15: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

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="http://purl.org/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="http://purl.org/dc" xmlns:pt="http://vangoghgallery.com/pt">

<dc:description > <dc:title>Impressionist Paintings</dc:title>

<dc:creator>Elliotte Rusty Harold</dc:creator><dc:date>2000-08-22</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="http://www.w3.org/1999/xhtml"> <head><title>Presentation Examples</title></head> <body> <h4>This is a Presentation of MathML</h4>

<math xmlns="http://www.w3.org/1998/Math/MathML"> <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

Page 16: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

16

Page 17: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

XSD

XML Schema Definition

www.w3.org/XML/Schema

17

Page 18: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

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

Page 19: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

Ein Beispiel Schema <?xml version="1.0"?><xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"

targetNamespace="http://www.note.org" 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örendann zum Target- Namespace (www.note.org).

Ein dazu passendes Instanz Dokument<?xml version="1.0"?><note xmlns="http://www.note.org" xmlns:xsdi="http://www.w3.org/2001/XMLSchema-instance" xsdi:schemaLocation="http://www.note.org 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="http://www.note.org" ist der vom Schema definierte Namespace (hier als Default Namespace gesetzt).

xmlns:xsdi="http:// ... /XMLSchema-instance" definiert den xsdi Namespace (für alle xsdi- Befehle).

xsdi:schemaLocation= "http://www.note.org note.xsd" gibt das Schema File an: im File note.xsd wird die im Instanz-Dokument benutzte Sprache (zum Namespace http://www.note.org) definiert.

19

Page 20: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

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

Page 21: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

Eine Definition definiert einen Typ (hier productType), welcher dann in einer Element- oder Attribut-Deklaration 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

Page 22: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

3.2 Deklaration von einfachen Typen

Beispiele von einfachen Elementen mit atomaren Typen <lastName>Schmid</lastName>

<age>34</age> <born>1968-03-27</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

Page 23: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

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 2001-03-28 (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 (2001-03-28T21: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. http://www.isbe.ch• 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

Page 24: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

Numerische Datentypen

• integer: Eine (beliebig grosse) ganze Zahl• nonPositiveInteger: Eine negative Zahl (inklusive 0)• negativeInteger: Eine negative Zahl (ohne 0)• long: Der Bereich von -9223372036854775808 bis 9223372036854775807 • int: Der Bereich von -2147483648 bis 2147483647 • short: Der Bereich von 32768 bis 32767 • byte: Der Bereich von -128 bis 127• nonNegativeInteger: Von 0 bis unendlich• unsignedLong: Von 0 bis 18446744073709551615 • unsignedInt: Von 0 bis 4294967295 • unsignedShort: Von 0 bis 65536 • unsignedByte: Von 0 bis 255• positiveInteger: Von 1 bis unendlich • decimal: Eine beliebig lange Zahl der Form 117.08, -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

Page 25: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

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 DeklarationenEin 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> 4 35 45 213 34 24 12 </regNumber>Eine Liste der Länge 4: <shortRegNumber> 5 13 63 14 </shortRegNumber>

Ein Union-Typ ist eine Vereinigung von einfachen Typen: <xs:simpleType name="UnoType">

<xs:union memberTypes="xs:int xs:boolean"/> </xs:simpleType>

Elemente vom Typ UnoType wären also zum Beispiel <unoElem>41</unoElem>

oder <unoElem>true</unoElem>

25

Page 26: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

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

Page 27: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

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

Page 28: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

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>2001-07-13 </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

Page 29: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

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. http://www.w3.org/TR/xmlschema-0.

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

Page 30: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

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 Spezifiziert eine obere Schranke für numerische Werte (kleiner oder gleich)

maxLength Spezifiziert die maximal erlaubte Anzahl Buchstaben oder Listenelemente (grösser oder gleich null)

minExclusive 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

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"> <!--oder [a-zA-Z]{3} -->

<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]"/> <!--oder [0-9]{4} --> </xs:restriction> </xs:simpleType>

30

Page 31: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

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

\ Escape, um Instanzen von Zeichen zu finden, welche als Metazeichen benutzt werden (wie Punkt, Klammer, ... )

. Ein beliebiges Zeichen (ausser newline)x Eine Instanz von x

^x Jedes Zeichen ausser x[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)

{x} Der Ausdruck muss genau x Mal vorkommen{x,} Der Ausdruck muss mindestens x Mal vorkommen{x,y} 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 \D \d : Abkürzung für [0-9] (digits) \D : alles ausser Ziffern\s \S \s : Whitespace (spaces, tabs, newlines, ...) \S : kein Whitespace

31

Page 32: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

3.7 Assertions (Zusicherungen)

Mit Hilfe von Zusicherungen können weitere Einschränkungen an Werte von Elementen oder Attributen definiert werden. Werte von Elementen oder Attributen können Verglichen oder in Beziehung gesetzt werden. Es können auch komplexe Bedingungen an Werte definiert werden.

Beispiele mit xs:assertDie Namen (Vorname und Nachname) sollen verschieden sein.

<xs:complexType name="nameType"><xs:sequence>

<xs:element name="first_name" type="xs:string"/><xs:element name="last_name" type="xs:string"/>

</xs:sequence> <xs:assert test="first_name != last_name"/></xs:complexType>

Das Start-Datum soll nach dem End-Datum liegen (soll grösser sein).

<xs:complexType name="pType"> <xs:sequence> <xs:element name="name" type="nameType"/> </xs:sequence> <xs:attribute name="startDate" type="xs:date"/> <xs:attribute name="endDate" type="xs:date"/> <xs:assert test="@startDate > @endDate"/> </xs:complexType>

Die Anzahl Eigenschaften (profession und hobby) sollen dem Wert des properties Attributs entsprechen.

<xs:complexType name="personType"> <xs:sequence> <xs:element name="name" type="nameType"/> <xs:element name="profession" type="xs:string" maxOccurs="9"/> <xs:element name="hobby" type="xs:string" maxOccurs="9"/> </xs:sequence> <xs:attribute name="properties" type="xs:int"/> <xs:assert test="@properties eq count(profession | hobby)"/> </xs:complexType>

Ein gültiges Instanz-Dokument <person properties="2"> <name> <first_name>Richard</first_name> <middle_name>P.</middle_name> <last_name>Feynman</last_name> </name> <born addressRef="unq" date="1918"/> <died date="1988"/> <profession>physicist</profession> <hobby>African drum music</hobby> </person>

32

Page 33: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

Beispiele mit xs:assertion

Für komplexe (inhaltliche) Einschränkungen an einfache Datentypen gibt es das xs:assertion Element. Der Wert soll kleiner als 1800 oder grösser als 1900 sein, aber ungleich null.

<xs:simpleType name="spezType"> <xs:restriction base="xs:int"> <xs:assertion test="($value &lt; 1800 or $value > 1900) and $value != 0"/> </xs:restriction> </xs:simpleType>

Der (integer) Wert soll ungerade sein. <xs:simpleType name="oddType"> <xs:restriction base="xs:int"> <xs:assertion test="($value mod 2 != 0)"/> </xs:restriction> </xs:simpleType>

33

Page 34: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

3.8 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 xpath="@id"/>

</xs:key>

Die Schlüsseldefinition befindet sich normalerweise in der Deklaration des Root-Elements des XML-Dokuments. 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 xpath="@id"/> </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 xpath="@ref"/> </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 Attributnamens 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="http://www.w3.org/2001/XMLSchema"> <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 xpath="@id"/> <-- alle Adress-Ids sind verschieden --> </xs:key>

34

Page 35: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

<xs:keyref name="bornRef" refer="addressID"><xs:selector xpath="person/born"/> <-- addressRef bezieht sich <xs:field xpath="@addressRef"/> auf eine Adress-Id -->

</xs:keyref>

<xs:keyref name="diedRef" refer="addressID"> <xs:selector xpath="person/died"/>

<xs:field xpath="@addressRef"/> </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="http://www.w3.org/2001/XMLSchema-instance"

xsi:noNamespaceSchemaLocation="People.xsd"> <person> <name> <firstName>Alan</firstName> <lastName>Turing</lastName> </name> <born date="1912" addressRef="gbl"/> <!-- Referenz auf eine Adresse--> <died date="1954" addressRef="gbc"/> <!-- Referenz auf eine Adresse--> <profession>computer scientist</profession> <profession>mathematician</profession> <profession>cryptographer</profession> <hobby>philosophy</hobby> <hobby>biology</hobby> </person> <address id="gbl"> <!-- Schlüssel --> <country>Great Britain</country> <city>London</city> </address> <address id="gbc"> <!-- Schlüssel --> <country>Great Britain</country> <city>Cambridge</city> </address></people>

35

Page 36: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

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-DokumentDas 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>

36

Page 37: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

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="http://www.example.org/address" schemaLocation="address.xsd"/>

Include erweitert also das Schema um weitere Typen desselben Namespaces. Import hingegen erlaubt das Benutzen von Typen aus anderen Namespaces.

Typen überschreiben: xs:override

Ab Schema Version 1.1 können (einzelne) Schema Typen in einem anderen Schema überschrieben und dadurch neu definiert werden.

<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"# xmlns:vc="http://www.w3.org/2007/XMLSchema-versioning" vc:minVersion="1.1"> <xs:override schemaLocation="OverrideBase.xsd"> <xs:simpleType name="DressSizeType"> <xs:restriction base="xs:integer"> <xs:minInclusive value="2"/> <xs:maxInclusive value="16"/> </xs:restriction> </xs:simpleType> </xs:override><xs:element name="newSize" type="DressSizeType"/></xs:schema>

37

Page 38: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

38

Page 39: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

Verarbeiten von XML Dokumenten

SAX: Simple Application Interface for XMLorg.xml.sax

DOM: Document Object Modelwww.w3.org/DOM

StAX: Streaming API for XMLjavax.xml.stream

39

Page 40: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

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 StreamIn 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> --> startElement() <first_name> --> startElement()

Alan --> characters() </first_name> --> endElement() <last_name> --> startElement()

Turing --> characters() </last_name> --> endElement() </name> --> 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.

40

Page 41: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

4.4 Übersicht über das SAX API

XMLParserFactory Erzeugen eines SaxParsers

SAX Parser Setzen der Parser Eigenschaften (validating, namespace-aware, ...)Bietet verschiedene parse() Methoden an (aus File, InputStream, URI, ...).

DefaultHandler Implementiert die verschiedenen Handler (Interfaces) leer.ContentHandler Interface für die verschiedenen Event Handler Methoden

start / endDocument, start / endElement(), characters, ...

ErrorHandler Interface für die Fehlerbehandlung: error(), fatalError(), warning()

DTDHandler Implementation der DTD Anweisungen (wird normalerweise nicht mehr gebraucht)

Funktionsweise des SAX Parsers

41

Page 42: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

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 vonuns 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, // Namespace URI String lName, // lokaler Name String qName, // qualifizierter Name Attributes attrs) // Attribut-Liste throws SAXExceptionDie 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); } } 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).

42

Page 43: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

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-PuffertextBuffer.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.

ProcessingInstruction

Die Methode processingInstruction dient zur Behandlung von Verarbeitungs-Anweisungen.Verarbeitungs-Anweisungen werden normalerweise vom Parser ignoriert. Die Methode processing-Instruction 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.

43

Page 44: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

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

Ein SAX BeispielEin vollständiges SAX Beispiel finden Sie auf der Übungsseite.

44

Page 45: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

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 NamedNodeMap

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 excludingthe target

null 7

Text #text content of the text node null 3

45

Page 46: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

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 NodeListerhalten 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.

Das Document Interface

Die wichtigsten Methoden des Document Interfaces sind

46

Page 47: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

• 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

Page 48: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

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 =

"http://xml.org/sax/features/namespaces";

static public void main(String[] argv) { try { // create validating document builder factory DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); factory.setFeature(namespaces, 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.

48

Page 49: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

Falls ein Knoten kopiert werden soll, muss er zuerst durch clone() verdoppelt werden. Das boolesche Argument (true/false) gibt an, ob der ganze Unterbaum neu angelegt werden soll.

Node clone = aNode.cloneNode(true); // kopiere den Knoten aNode Node parent = node.getParentNode(); parent.appendChild(clone); // 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 Listen-Elemente 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

Page 50: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

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

Page 51: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

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"); --> <?xml version="1.0"?> outWriter.writeStartElement(name); --> <name> outWriter.writeAttribute(attr, value) --> <... attr=“value“> outWriter.writeCharacters(string) --> string outWriter.writeComment(comment) --> <!-- comment --> outWriter.writeEndElement(); --> </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

Page 52: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

52

Page 53: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

JAXB

Java Architecture for XML Binding

jaxb.java.net

53

Page 54: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

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 Bindings-Deklarationsfile 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

Page 55: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

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 wirddabei 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, DOM-Knoten, ...) zurückgeschrieben werden. Während des Schreibens der Daten (marshal) können diese wiederum durch das Schema validiert werden.

55

Page 56: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

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 java.lang.String

xsd:integer java.math.BigInteger

xsd:int int

xsd.long long

xsd:short short

xsd:decimal java.math.BigDecimal

xsd:float float

xsd:double double

xsd:boolean 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

Page 57: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

7.4 Erzeugen der Java Klassen

Die Java-Klassen und Member Variablen werden gemäss dem Schema erzeugt:

<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"targetNamespace="http://sws.people.org"elementFormDefault="qualified" xmlns="http://sws.people.org">

<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

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:

57

People

List<PersonType> person; List<AddresType> address;

List<PersonType> getPerson(); List<AddressType> getAddress();

PersonType

NameType name; BornType born; . . .

NameType getName(); void setName(NameType name); . . .

Page 58: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

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

Page 59: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

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 diegenerierte Address-Klasse aussehen soll (vgl. Beispiel auf der Übungsseite)

<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"targetNamespace="http://sws.people.org"xmlns:jxb="http://java.sun.com/xml/ns/jaxb" jxb:version="2.0"elementFormDefault="qualified" xmlns="http://sws.people.org">

<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

Page 60: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

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. www.sws.bfh.ch/~amrhein/XML/JAXB/People):

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="http://java.sun.com/xml/ns/jaxb" xmlns:xs="http://www.w3.org/2001/XMLSchema" schemaLocation="People.xsd">

<!-- die hobby-Elemente der Personen sollen in (der „PersonType“ Klasse in) einer Member-Variablen „hobbyList“ abgelegt werden. -->

<jxb:bindings node="//xs:complexType[@name='personType']"> <jxb:bindings node=".//xs:element[@name='hobby']"> <jxb:property name="hobbyList"/> </jxb:bindings> </jxb:bindings> <!-- die addressRef Attribute in born sollen in addrRef unbenannt werden --> <jxb:bindings

node="//xs:complexType[@name='personType']/xs:sequence/xs:element[@name='born']"> <jxb:bindings node=".//xs:attribute[@name='addressRef']"> <jxb:property name="addrRef"/> </jxb:bindings> </jxb:bindings>

<!-- alle firstname elemente sollen nach givenName umbenannt werden --> <jxb:bindings node="//xs:element[@name='firstName']"> <jxb:property name="givenName"/> </jxb:bindings>

<!-- die name-Elemente der Personen sollen in einer Klasse „Name“ abgelegt werden. --> <jxb:bindings node="//xs:complexType[@name='nameType']"> <jxb:class name="Name"/> </jxb:bindings> </jxb:bindings>

Dies bewirkt, dass die Klasse PersonType neu wie folgt aussieht:

60

PersonType

Name name; BornType born; List<String> hobbyList; . . .

NameType getName(); void setName(NameType name); . . .

Page 61: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

7.9 Erzeugen von Schematas

Aus einer Java Klassen-Hierarchie lässt sich umgekehrt mit Hilfe von Annotationen das dazu passende Schema generieren

• @XmlType --> erzeugen eines Schema Types (mit angegebener Reihenfolge)• @XmlElement --> erzeugen eines Schema Elements • @XmlAttribute --> erzeugen eines Schema Attributs• . . .

Der Aufruf zum Erzeugen eines Schemas lautet schemagen.exe package\*.java

Ein Beispiel:

Die People Klasse

import java.util.*;import javax.xml.bind.annotation.*;

@XmlAccessorType(XmlAccessType.FIELD)@XmlType(propOrder = { "person", "address"})@XmlRootElement(name = "people")public class People {

@XmlElement(required = true) protected List<Person> person; @XmlElement(required = 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

Page 62: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

Die Address Klasse

import javax.xml.bind.annotation.*;

@XmlAccessorType(XmlAccessType.FIELD)@XmlType(name = "addressType", propOrder = { "country", "city"})public class Address {

@XmlElement(required = true) protected String country; @XmlElement(required = true) protected String city; @XmlAttribute(name = "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="http://sws.people.org" xmlns:tns="http://sws.people.org" xmlns:xs="http://www.w3.org/2001/XMLSchema">

<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

Page 63: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

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

Page 64: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

64

Page 65: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

XSLT / XPath / XSL-FO

Die Transformations- und Adressierungs-Sprachen für XML

http://www.w3.org/TR/xslt20

http://www.w3.org/TR/xpath20

http://www.w3.org/TR/xslfo20

65

Page 66: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

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 2007XSLT: www.w3.org/TR/xslt20XPath: www.w3.org/TR/xpath-functions

W3C Recommendation des XSL- Formatting Objects Teil vom Dezember 2006XSL-FO: www.w3.org/TR/xsl11

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; Die h1 Header sollen mit einer sans-serif Schrift der Grösse 48 font-size: 48pt } ausgegeben werden.

p { font-size: 8pt; Alle <p> - Elemente sollen in einer 8pt Schrift in blauer Farbe color: blue } ausgegeben werden.

Die Browser kennen diese HTML Tags und verwenden ein CSS (Default-) Stylesheet für deren Darstellung.

66

Page 67: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

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

Page 68: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

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 Ausgabe-Dokument 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

Page 69: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

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="http://www.abc.ch/mystyle.xsl"?> <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 absoluteAdresse.

69

Page 70: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

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="http://www.w3.org/1999/XSL/Transform">

<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 XML-Dokumentes.

• 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

Page 71: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

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="http://www.w3.org/1999/XSL/Transform"> <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="http://www.w3.org/1999/XSL/Transform"> <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 gesuchtund 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

Page 72: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

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 http://www.saxonica.com/documentation

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="http://www.w3.org/1999/XSL/Transform"> <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

Page 73: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

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="http://www.w3.org/1999/XSL/Transform"> <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>

<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>

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>

• 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. Danachwird 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

Page 74: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

Adressieren von AttributenFür das Adressieren von Attributen wird das Zeichen @ 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="http://www.w3.org/1999/XSL/Transform">

<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>

<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>

Der erste Durchgang wird durch <xsl:template match="person"

mode="toc">gebildet, der zweite durch <xsl:template match="person">

74

Page 75: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

xsl:if<xsl:if test="lastName = 'Euler'"> ... </xsl:if>filtert nur die Elemente mit lastName gleich Euler.

<xsl:if test="born/@date &gt; 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

Page 76: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

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"> blau für Mathematiker <xsl:apply-templates select="hobby"/> </font> </xsl: when > <xsl: when test="profession='cryptographer' "> <font color="red"> rot für Kryptologen <xsl:apply-templates select="hobby"/> </font> </xsl: when > <xsl: otherwise > sonst schwarz <xsl:apply-templates select="hobby"/> </xsl: otherwise > </xsl: choose > </xsl:template>

<xsl:template match="hobby"> <li><xsl:value-of select="."/></li> </xsl:template>

76

Page 77: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

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

Page 78: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

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 Wertezusammen.

78

Page 79: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

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"/> Address-ID in der

Variable abspeichern <xsl:value-of select="//address[@id=$myref]/city"/> die gefundene Adresse </xsl:template> 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

Page 80: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

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, CambridgeGermany: UlmUSA: Queens, NY, PrincetonSwitzerland: 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="http://www.sowieso.ch/ss.xsl"/>

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 Regelnwidersprechen (durch Templates mit gleichen Namen oder gleichen Pattern), tritt normalerweise ein Fehler auf.

80

Page 81: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

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= " text() | @* "><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

Page 82: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

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

Page 83: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

9.2 Template Driven vs. Data Driven Stylesheets

In allen Beispielen, welche wir bisher betrachtet haben, bestimmt das Template im Stylesheet, welche Regelals 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="http://www.w3.org/1999/XSL/Transform"> <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

Page 84: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

10 XPath: Die XSL AdressierungsspracheDie 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 www.w3.org/TR/xpath20/

Einige Beispiele

name alle <name> Kinder des aktuellen Knotens

name/firstName alle <firstName> Kinder aller <name> Kinder des aktuellen Knotens

/ 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/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.

10.1 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

Page 85: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

Wildcards

Pfade können die Wildcards *, @* und node() enthalten.

* selektiert alle Elemente @* selektiert alle Attribute node() selektiert alle Knoten

• Attribute, Text-Knoten, Kommentare oder Verarbeitungsanweisungen (Processing-Instructions) werden durch den Stern (*) nicht selektiert.

• @* selektiert nur Attribute• node() selektiert alle Knoten: Elemente, Attribute, Text-Knoten, Kommentare,

Verarbeitungsanweisungen, …

Beispiele//* findet alle Elemente im Dokument

/* alle Kinder von Root (also das Root-Element)str/*/title alle <title> Enkel von str//*/@id 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&lt; 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:born[ @addressRef = 'gbc' ]

alle <born> Kinder, welche ein addressRef Attribut mit Wert "gbc" haben

died[ @addressRef ] alle <died> Kinder, welche ein addressRef Attribut haben

person [born/@date &gt; 1900 ]/namealle Namen von Personen, welche später als 1900 geboren sind

name[last()]das letzte <name> Kind des aktuellen Knotens

85

Page 86: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

Zu beachten ist, dass die Adressierungen vom Kontext abhängig sind:died[@addressRef] 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)name[last()][@addressRef] gibt das letzte name-Element zurück, falls dieses ein addressRef-Attribut hat.name[@addressRef][last()] 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 select="*[@date]"/> </xsl:template> <xsl:template match="born | died"> <xsl:value-of select="../*/lastName"/>, <xsl:value-of select="name(.)"/>: <xsl:value-of select="@date"/> <xsl:variable name="var" select="@addressRef"/> <xsl:apply-templates select="//*[@id=$var]/city"/> <br/> </xsl:template>

<xsl:template match="city"> in <xsl:value-of select="."/> </xsl:template>

Die verwendetenBezeichner --> people, name, @date, ...

Wildcards --> *, @*, node()

Prädikate• Der Pfad *[@date] 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 wie @addressRef). 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

Page 87: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

87

Page 88: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

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 Knotensfollowing-sibling::profession alle <profession>- Geschwister des aktuellen Knotens, welche im XML-

File später auftreten.descendent::* alle (direkten und indirekten) Nachfolger des aktuellen Knotensancestor::*/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

Page 89: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

10.3 Die wichtigsten XPath Funktionen

Die W3C Recommendation zu XQuery 1.0 and XPath 2.0 Functions and Operators finden Sie unter http://www.w3.org/TR/xquery-operatorsAusserdem finden Sie alle von saxon8 unterstützten XPath 2.0 Funktionen und Operatoren unter http://www.saxonica.com/documentation

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 StringsString 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 Funktionennumber 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

Page 90: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

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 Sequenzzu 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

Page 91: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

Einlesen von XML Dokumenten

Die Funktiondocument($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

Page 92: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

Ein Beispiel<?xml version="1.0" encoding="UTF-8"?><xsl:stylesheet version="2.0"

xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

<-- indexieren aller Personennamen nach Datum --> <xsl:key name="nameKey" match="name" use="../*/@date"/>

<-- 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" use="@id"/>

<xsl:template match="people"> <html> <body> <!-- Geburtsjahr und Ort, absteigend sortiert auflisten --> <ul> <xsl:for-each select="//*[@date]"> <xsl:sort select="@date" order="descending"/> <li> <xsl:value-of select="key('nameKey', @date)/firstName"/> <xsl:text> </xsl:text> <xsl:value-of select="key('nameKey', @date)/lastName"/> <xsl:if test="key('addrKey', @address)"> <xsl:text>, </xsl:text> <xsl:value-of select="name()"/> in <!-- zum Datum die entsprechende Adresse ausgeben. --> <xsl:value-of select="key('addrKey', @address)/country"/> <xsl:text> </xsl:text> <!-- und das Datum selber --> <xsl:value-of select="@date"/> </xsl:if> </li> </xsl:for-each> </ul> <!-- alle Hobbies die mit 'p' anfangen auflisten --> <p> <xsl:value-of select="key('hobbyKey','p')" separator=", "/> </p> </body> </html> </xsl:template></xsl:stylesheet>

92

Page 93: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

xsl:function

Beispiele von selber definierten XSL Funktionen

<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="2.0" xmlns:cs="http://www.isbe.ch/catalogFunctions" xmlns:xs='http://www.w3.org/2001/XMLSchema'> <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) &gt;=$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

Page 94: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

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.

11.1.1 Ein einfaches Beispiel <?xml version="1.0"?> <fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format">

<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>

Page 95: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

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:table-body, 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, Text-Felder, 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="http://www.w3.org/1999/XSL/Format"

95

Page 96: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

Das Layout einer Seite

Eine Seite ist aufgeteilt in die fünf Bereiche region-before, region-after, region-start, region-end und region-body. 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, linkeund 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, region-before, 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

Page 97: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

Die Platz-Verteilung für die Regionen

<fo:root xmlns:fo= "http://www.w3.org/1999/XSL/Format"> <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

Page 98: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

Definieren und Benutzen von verschieden Seiten-Typen

<fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format"> <fo:layout-master-set>

<!-- Definition der ersten Seite--> <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>

<!-- Definition der restlichen Seiten--> <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>

<!-- Wann soll welche Definition benutzt werden --> <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"/> <!-- default --> <fo:conditional-page-master-reference master-reference="restliche"/>

</fo:repeatable-page-master-alternatives> </fo:page-sequence-master> </fo:layout-master-set>

<!-- Inhalt der verschiedenen Seiten --> <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

Page 99: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

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

Page 100: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

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

Page 101: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

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>&#183;</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

Page 102: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

11.2.1 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 zusammen-gesetzt 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

Page 103: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

Beispiel einer Tabelle

<fo:table background-color="#EEEEEE" padding="3pt"> <fo:table-column column-width="20mm"/> <!--Definition der Spalten-Breiten --> <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

Page 104: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

11.3 Die wichtigsten Attribute

11.3.1 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.

11.3.2 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>

11.3.3 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

Page 105: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

11.3.4 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.

11.3.5 Character Property: Schriftgrösse

Die Property font-size definiert die zu benutzende Schriftgrösse:

<fo:inline font-family="Helvetica" font-size="24pt"> ein Text in 24 Punkt Schrift

</fo:inline>

11.3.6 Character Property: Schrift Style

Der Style des Fonts wird definiert durch die Property font-style

<fo:block font-family="Times Roman" font-style="italic">Times Roman italic

</fo:block>

Es gibt die Styles italic, normal, oblique, reverse-normal und reverse-oblique.

11.3.7 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

Page 106: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

11.3.8 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 text-transform 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" --> unterstrichentext-decoration="overline" --> überstrichen text-decoration="line-through" --> durchgestrichen

text-shadow="gray" --> SchattenschriftSchattenschrift text-transform="capitalize" --> Alle Ersten Buchstaben Gross text-transform="uppercase" --> GROSSSCHRIFTtext-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>

11.3.9 Sentence Properties

Sentence Properties bestimmen den Platz zwischen deneinzelnen Buchstaben (letter-spacing), zwischen einzelnenWörtern im Text (word-spacing) und zwischen den einzelnenLinien im Text (line-height, text-depth, text-altitude, ...), dieAusrichtung 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

Page 107: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

107

Page 108: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

11.3.10 Sentence Property: Zeilenabstand

Der Zeilenabstand im Text kann kontrolliert werden durch die Properties line-height, text-depth und text-altitude. <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 Linien-Abstand 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>

11.3.11 Sentence Property: Text Ausrichtung

Ob der Text linksbündig, rechtsbündig, zentriert oder imBlocksatz gesetzt werden soll, wird durch die Property text-align gesetzt.Diese kann die folgenden Werte annehmen:

start oder left --> linksbündigcenter --> zentriertend 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

Page 109: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

109

Page 110: XML - BFHamrhein/Skripten/XML/XML.pdf · 2017. 1. 30. · XML-Dokument heisst wohlgeformt, wenn es die syntaktischen Regeln der Spezifikation einhält, bzw. wenn ein XML-Parser das

11.3.12 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.

11.3.13 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