Softwaretechnologien Teil: XML-Technologien und Programmierung Master-Studiengang IKT Herbst 2010

Softwaretechnologien Teil: XML-Technologien und Programmierung Master-Studiengang IKT Herbst 2010 Matthias K. Krause, Hochschule für Telekommunikation, Leipzig 7. Oktober 2010 Dieses Skript ist hier http://www.hft-leipzig.de/~krause/lehre/m_ikt_swt_2010/swt_masterikt10.pdf... und ergänzendes Material zur Veranstaltung liegt hier http://www.hft-leipzig.de/~krause/lehre/m_ikt_swt_2010/ 1

Inhaltsverzeichnis 1 Themen 3 2 Ein kurzer Exkurs zu ant 4 3 Extended Markup Language (XML) 7 3.1 XML......................................... 7 3.1.1 Document Type Description (DTD)................... 9 3.1.2 XML Schema................................ 11 3.2 XSL/XSLT..................................... 15 3.2.1 XSL in der XML-Sprachfamilie...................... 15 3.2.2 Einfache Transformationen mit Schleifen................. 16 3.2.3 Bedingungen................................ 17 3.2.4 Gruppierungen............................... 17 3.2.5 Templates.................................. 18 3.2.6 Fremdschlüssel............................... 20 3.2.7 Durchschleifen von XML-Tags..................... 21 3.3 Ein komplettes Beispiel.............................. 21 4 XML-API-Programmierung 26 4.1 Java API for XML Processing (JAXP)...................... 26 4.1.1 Simple API for XML (SAX)........................ 26 4.1.2 Document Object Model (DOM)..................... 31 4.1.3 XSLT.................................... 35 5 Grundlegende Probleme 39 5.1 Konfigurationsdaten und Internationalisierung (I18n).............. 39 5.2 Datenbank-Programmierung mit JDBC..................... 42 2

1 Themen Der Vorlesungsteil beschäftigt sich schwerpunktmäßig mit XML-Technologien: Einführend wird ein Softwaretool namens ant vorgestellt, dessen Steuerdateien im XML-Format dargestellt werden. ant dient der Automatisierung von Abläufen, anhand der Steuerdateien wird ersichtlich, wie XML prinzipiell aufgebaut ist und wie der Rahmen XML, der an sich ohne jegliche inhaltliche Bedeutung ist, als Behälter für etwas wie eine Ablaufprogrammierung dienen kann. Der nächste Teil beschreibt XML (Extended Markup Language) mit ihren Eigenschaften und Bestandteilen, im weiteren wird gezeigt, wie mit der XML-Sprache XSLT (Extended Stylesheet Language Transformations) Transformationen zwischen verschiedenen XML-Formaten durchgeführt werden können. Weiterhin geht es um dem Umgang mit XML-Dokumenten aus Programmiersprachen heraus, hier insbesondere am Beispiel von Java. Ergänzend werden einige grundlegende Themen wie Ablage von Konfigurationsdaten durch Programme, Internationalisierung und Datenbankprogrammierung innerhalb von Java angerissen. 3

2 Ein kurzer Exkurs zu ant ant ist ein Produkt der Apache Software Foundation. Es ist ein Tool, welches, ähnlich wie make, in einem automatisierten Ablauf eine Reihe von Handlungen abarbeiten kann und dabei Schritte bedingt ausführen kann. So kann man mit ant z.b. Compilieren und/oder Linken, wenn beim Linken festgestellt wird, daß der Quellcode neuer als der Objektcode ist, wird vorher noch compiliert. ant bedient sich einer Konfigurationsdatei, die in XML geschrieben ist, was in diesem Kurs als Einstieg in XML verwendet werden soll. Andererseit ist die Leistung von ant an sich interessant und an vielen Stellen für die Automatisierung von Abläufen verwendbar. Von Vorteil ist die Tatsache, daß das Tool betriebssystemunabhängig ist, Voraussetzungen sind nur die im Folgenden genannten Software-Voraussetzungen: ant (die Software und Informationen dazu befinden sich im jwsdp, in der Java Enterprise Edition oder kann bei der Apache Software Foundation bezogen werden) Java-Standard-Edition Ein Blick ins ant-manual [1] bringt uns Infos zum Aufruf (das Makefile heißt build.xml) ant [options] [target [target2 [target3]...]] Options: -help, -h print this message -version print the version information and exit -quiet, -q be extra quiet -verbose, -v be extra verbose -debug, -d print debugging information -lib <path> specifies a path to search for jars and classes -buildfile <file> use given buildfile (default: build.xml) -file <file> -f <file> -D<property>=<value> use value for given property -propertyfile <name> load all properties from file with -D properties taking precedence... und im Teil Using ant einen Überblick zu seinen wesentlichen Bestandteilen: project, das Rootelement, welches alle Informationen zum Build-Vorgang enthält. Das Default-Target (default-attribut) wird bei Aufruf ohne Targetangabe verwendet: 1 <project name="myproject" default="dist" basedir="."> 2 <description> 3 simple example build file 4 </description> 5 6... HIER STEHEN ALLE ANDEREN ELEMENTE DER STEUERDATEI 7 8 </project> properties sind Eigenschaften, die an zentraler Stelle gesetzt und dann an verschiedenen Stellen im Skript genutzt werden können (Vorsicht: properties sind NICHT änderbar, ist der Wert gesetzt, bleibt er so, auch wenn er scheinbar im Text überschrieben wurde!!!) 4

1... 2 <property name="src" location="src"/> 3 <property name="build" location="build"/> 4 <property name="dist" location="dist"/> 5 <property name="who" value="peter"/> 6... targets sind Container für Tasks, die beim Ruf angegeben und ausgeführt werden können. Über ein depends-attribut können andere Targets angegeben werden, die, falls ihr Produkt nicht aktuell ist, vorher ausgeführt werden. 1 <target name="copyshop" depends="init"...> 2 <mkdir... /> 3 <copy... /> 4 </target> Hier enthält das Target zwei Tasks mit den Namen mkdir und copy. Ist das Target init nicht aktuell (das bedeutet, das der Zustand der Ergebnisse der Abarbeitung von init nicht aktuell ist) wird init aufgerufen. Danach werden die beiden eingeschlossenen Tasks abgearbeitet. tasks sind Aufgaben, die ausgeführt werden können, hier beschreibt der Elementname schon den Charakter der Task, Beispiele sind: Compilieren von Javacode: javac, Kopieren von Files: copy, Verpacken mit dem Zip-Mechanismus: zip, Durchführen einer XSL Transformation: Xslt/Style Folgendes Listing bringt einen Einblick in die Möglichkeiten, die sich mit ant eröffnen: Listing 1: einfaches Makefile build.xml 1 <project name="myproject" default="dist" basedir="."> 2 <description> 3 simple example build file 4 </description> 5 <!-- set global properties for this build --> 6 <property name="src" location="src"/> 7 <property name="build" location="build"/> 8 <property name="dist" location="dist"/> 9 10 <target name="init"> 11 <!-- Create the time stamp --> 12 <tstamp/> 13 <!-- Create the build directory structure used by compile --> 14 <mkdir dir="${build}"/> 15 </target> 16 17 <target name="compile" depends="init" 18 description="compile the source " > 19 <!-- Compile the java code from ${src} into ${build} --> 20 <javac srcdir="${src}" destdir="${build}"/> 21 </target> 22 5

23 <target name="doc" depends="compile" 24 description="generate the javadoc docu" > 25 <!-- Create the doc directory --> 26 <mkdir dir="${dist}/doc"/> 27 <javadoc destdir="${dist}/doc"> 28 <fileset dir="${src}" /> 29 </javadoc> 30 </target> 31 32 <target name="dist" depends="compile,doc" 33 description="generate the distribution" > 34 <!-- Create the distribution directory --> 35 <mkdir dir="${dist}/lib"/> 36 37 <!-- Put everything in ${build} into the MyProject-${DSTAMP}.jar file --> 38 <jar jarfile="${dist}/lib/myproject-${dstamp}.jar" basedir="${build}"/> 39 </target> 40 41 <target name="clean" description="clean up" > 42 <!-- Delete the ${build} and ${dist} directory trees --> 43 <delete dir="${build}"/> 44 <delete dir="${dist}"/> 45 </target> 46 </project> Das File ist nahezu selbsterklärend, hingewiesen werden soll lediglich auf die Erzeugung eines Zeitstempels (Timestamp - Zeile 12) und die Nutzung des zugehörigen Datumsstempels (Zeile 35). Übung 1 Schreiben Sie ein build-file für ant, durch das eine Verzeichnisstruktur (Angabe in einer property) in ein Zip-File verpackt wird, dessen Name das Datum in der Form...yyyymmdd... enthält! Im weiteren Verlauf werden wir ant auch verwenden, um Aufgaben im Bereich XML/XSLT zu realisieren: XmlValidate (optional task, validiert eine XML-Datei, im Beispiel ist die DTD in der XML-Datei angegeben) <xmlvalidate file="data.xml"/> XSLT (core task, macht eine XSL-Transformation ohne Validierung) <xslt in="data.xml" style="style.xsl" out="data.html"/> SchemaValidate (optional task, validiert eine XML-Datei, speziell zur Validierung gegen ein XMLSchema) <schemavalidate nonamespacefile="schema.xsd" file="data.xml" /> Das File data.xml selbst enthält selbst keine Schemadeklaration bzw. Namespaces 6

3 Extended Markup Language (XML) Folgenden Stoff wollen wir behandeln: Aufbau und Gestaltung von XML-Files inhaltliche Restriktionen mit DTD und XMLSchema textuelle Transformationen mit XSLT 3.1 XML Unter http://www.w3.org/tr/rec-xml finden Sie die Empfehlung des W3C zur Extensible Markup Language (XML) 1.0 (Second Edition), DIE Quelle zur Spezifikation von XML. Es gibt dort auch eine deutsche Übersetzung, die allerdings, da nicht sämtliche Links im Dokument vorhanden sind, nicht so gut navigierbar ist wie das Original. Unter http://www.edition-w3c.de (12.3.2003) ist eine navigierbare deutsche Übersetzung zu finden. Kurz und handlich ist XML kurz & gut [2] Im Java Enterprise Tutorial [3, Kap. Introduction To XML] finden Sie eine kurze Einführung in XML, Publikationen wie Java ist auch eine Insel [10] und das HTML-Kompendium Selfhtml [9] von Stefan Münz enthalten mittlerweile auch gute Einführungen bzw. Zusammenfassungen. Zu XML etc. gibt es eine umfangreiche Sammlung von Tutorials, die genutzt werden können, z.b. http://www.aboutwebdesign.de/awd/content/1024415102.shtml Sie sollten ein XML-File verstehen, aber auch selbst aus einem Datensatz entwickeln können. Folgende Teile sollten Ihnen geläufig sein: der Prolog mit seinen Teilen und Attributen eine einfache DTD Kommentare Elemente und Attribute Processing Instructions Struktur eines Dokuments: Prolog: XMLDeclaration (optional, immer 1.Zeile): <?xml version="1.0" encoding="iso-8859-1" standalone="yes"?> DocumentTypeDeclaration(optional): <!DOCTYPE Buchladen SYSTEM "_bsp.dtd"> Wurzel-Element: ein Dokument enthält genau ein (Wurzel-)Element, welches wiederum Elemente und/oder Charakterdaten enthält. Ein Element besteht aus einem Starttag (ggf. mit Parametern), Inhalt (Elemente, Charakterdaten) und einem Endetag 7

<elementname parm1="wert1"...> Inhalt </elementname> oder aber ist leer und besteht aus einem Anfangs- und Endetag mit Parametern (oder ohne) <elementname parm1="wert1"... /> Ein typisches Beispiel für ein leeres Element ohne Parameter ist <br/>, der Linebreak im XHTML, der entsprechend dem XML-Standard nicht als einzelnes öffnendes Tag <br>, wie oft im HTML genutzt, erscheinen darf. Verschiedenes (Miscellaneous) (an beliebigen Stellen von Prolog oder Element, aber nicht in Tags): Kommentare: <!-- This is a comment --> Processing Instructions: <?target instructions?> oft im Prolog eines XML-Datensheets mit Hinweis auf das entsprechende Stylesheet Mögliche oder notwendige Eigenschaften eines XML-Dokuments: Wohlgeformtheit (Well Formedness): Das Dokument entspricht in der Struktur der W3C-Empfehlung (allen Well Formedness Constraints der Empfehlung), jedes XML-Dokument muss dieser Eigenschaft genügen Gültigkeit (Validity): Die Element- und Attribut-Zusammensetzung entspricht einer Document Type Description (DTD) (siehe 3.1.1) oder einem XML Schema (siehe 3.1.2) (allen Validity Constraints der Empfehlung), ein Dokument kann diese Eigenschaft haben. Namespaces (Namensräume) Die Vereinbarung von Namespaces erfolgt die Angabe eines Attributes xmlns:nsname="http://my.com" innerhalb eines Elementes, wobei nsname der zu vergebende Namespacename ist Die Nutzung durch die Angabe des Namespacenamens als Präfix nsname:elementname Beispiel: der XSL-Namespace im XSL Stylesheet Beispiele für XML-Dateien Listing 2: zunächst ein einfaches File mit (optionaler) xml-deklaration 1 <?xml version= 1.0 encoding= ISO-8859-1 standalone= yes?> 2 3 <Buchladen 4 Ort="Leipzig" 5 Strasse="Heldenplatz" 6 > 7 <!-- ein Kommentar --> 8

8 9 <Buch Genre="Prosa"> 10 <Autor> Peter Traurig </Autor> 11 <Titel> Großes Drama </Titel> 12 <Verlag> Weinheim Heuler </Verlag> 13 </Buch> 14 15 <Buch Genre="Sachbuch"> 16 <Einband Quelle="c2736251627.gif"/> 17 <Autor> Hans Hansen </Autor> 18 <Titel> Neue Sichten </Titel> 19 <Verlag> Taschen </Verlag> 20 </Buch> 21 22 </Buchladen> 3.1.1 Document Type Description (DTD) Ein XML-Dokument kann durch die Angabe einer Document Type Description inhaltlichen Zwängen der Elementzusammensetzung und -struktur unterworfen werden. Eine DTD enthält im Wesentlichen ELEMENT-Beschreibungen <!ELEMENT elementname typangabe> wobei es für die Typangabe verschiedene Möglichkeiten gibt: ANY (bedeutet beliebiger Inhalt) die Typangabe kann in Klammern gesetzt werden, z.b. (#PCDATA) (von Parsed Character Data) eine Komma-Liste von Elementen, dann ist die Reihenfolge zwingend, oder eine Auswahl (mit Trenner ), dazu optional die RegExpr-Wiederholungszeichen (*,+,? für 0 bis beliebig oft, 1 bis beliebig oft, optional) Beschreibungen von Attributlisten von Elementen <!ATTLIST elementname attributliste> wobei attributliste eine spaceseparierte Liste aus Attributbeschreibungen mit ist. Attributname, Typ (CDATA Auswahl ID..eindeutiger Schlüssel im Dokument IDREF spaceseparierte IDREFS...), Defaultdeklaration (#REQUIRED #IMPLIED (#FIXED)? Defaultwert) Entity-Definitionen <!ENTITY entityname "ersetzungszeichen"> 9

Nutzung im Text mit &entityname; Es gibt eine ganze Reihe vordefinierte Entities: & < > " &apos; für & < > "... und die XML-Datei von oben mit einem Link auf eine externe DTD ( die DTD bzw. ein XML Schema ist zwingend, wenn es sich um gültiges XML handeln soll) Listing 3: XML-File mit Link auf externe DTD 1 <?xml version= 1.0 encoding= ISO-8859-1?> 2 3 <!DOCTYPE Buchladen SYSTEM "_bsp.dtd"> 4 5 <Buchladen 6 Ort="Leipzig" 7 Strasse="Heldenplatz" 8 > 9 10... 11... 12 13 </Buchladen>... mit der dazugehörigen Document Type Definition (_bsp.dtd)... Listing 4: externe DTD 1 <?xml version= 1.0 encoding= ISO-8859-1?> 2 3 <!-- 4 DTD fuer einen Buchladen 5 --> 6 7 <!ELEMENT Buchladen (Buch*)> 8 <!ATTLIST Buchladen 9 Ort CDATA #REQUIRED 10 Strasse CDATA #REQUIRED 11 Besitzer CDATA #IMPLIED 12 > 13 <!ELEMENT Buch (Einband?, Autor, Titel, Verlag)> 14 <!ATTLIST Buch 15 Genre (Prosa Lyrik Sachbuch) #IMPLIED 16 > 17 <!ELEMENT Einband EMPTY> 18 <!ATTLIST Einband 19 Alternative CDATA #IMPLIED 20 Quelle CDATA #REQUIRED 21 Typ CDATA "image/gif" 22 > 23 <!ELEMENT Autor (#PCDATA)> 24 <!ELEMENT Titel (#PCDATA)> 25 <!ELEMENT Verlag (#PCDATA)> 26 <!ENTITY copyright "&#xa9"> 10

Die DTD kann auch, quasi inline, im XML-File liegen, hier Auszüge aus einer solchen Version: Listing 5: XML-File mit inline DTD 1 <?xml version= 1.0 encoding= ISO-8859-1?> 2 3 <!DOCTYPE Buchladen [ 4 <!ELEMENT Buchladen (Buch*)> 5... 6... 7 <!ELEMENT Titel (#PCDATA)> 8 <!ELEMENT Verlag (#PCDATA)> 9 ]> 10 11 <Buchladen 12 Ort="Leipzig" 13 Strasse="Heldenplatz" 14 > 15 <!-- ein Kommentar --> 16 17... 18 19 </Buchladen> Übung 2 In einem XML-File soll eine Semestergemeinschaft gespeichert werden. Die Semestergemeinschaft hat einen Namen und enthält Studenten, die eine Matrikelnummer, einen Namen, einen Vornamen und ein Geburtsdatum haben. Geben Sie ein entsprechendes XML-File mit min. einem Studenten und einer dazu passenden inline-dtd an. 3.1.2 XML Schema Im Gegensatz zur DTD bietet XML Schema umfangreiche Möglichkeiten der Festlegung von Datentypen und Restriktionen. Folgende Dokumente beinhalten die Definition von XML Schema: XML Schema Part 0: Primer Second Edition http://www.w3.org/tr/xmlschema-0/ ein Tutorial mit Beispielen und Einführungen XML Schema Part 1: Structures Second Edition http://www.w3.org/tr/xmlschema-1/ XML Schema Part 2: Datatypes Second Edition http://www.w3.org/tr/xmlschema-2/ Es ist selbst in XML formuliert, was die Möglichkeit der Behandlung mittels XML-Tools bietet. Jede XML Schema definition besteht aus einem Wurzelelement schema, der Name des Namespaces ist nicht vorgeschrieben: <xsd:schema xmlns:xsd="http://www.w3.org/2001/xmlschema">... </xsd:schema> Auf diese Schemadefinition wird, bei Arbeit ohne Namespaces im XML-File, folgendermaßen verwiesen: 11

<documentroot xmlns:xsi="http://www.w3.org/2001/xmlschema-instance" xsi:nonamespaceschemalocation= Buchladen.xsd >... </documentroot> Wesentliche Bestandteile einer XML Schema Definition: element Attribute: name ref type Inhalt: anstelle des Attributes type kann auch ein Typ-Element (simpletype, complextype) oder Struktur-Element (sequence,... ) eingebettet sein simpletype Standardtypen (sind bereits definiert): string, int, integer, positiveinteger, nonpositiveinteger, date,...... oder mit dem XML-Element simpletype eigene Typen definieren! restriction Constraints on Simple Type Definition Schema Components (siehe Part 2) können mit Facetten (facets) realisiert werden: pattern, minlength, minexclusive, mininclusive, max...,... (alles XML-Elemente) complextype charakterisiert eine (komplexe) Datenstruktur, nicht nur einen Einzelwert sequence stellt eine geordnete Reihenfolge von Elementen dar, die im Defaultfall jedes genau einmal vorkommen choice, genau ein Element erscheint Listing 6: XML Schema für den Buchladen 1 <xsd:schema xmlns:xsd="http://www.w3.org/2001/xmlschema"> 2 3 <xsd:annotation> 4 <xsd:documentation xml:lang="de"> 5 XML Schema fuer Buchladen 6 </xsd:documentation> 7 </xsd:annotation> 8 9 <xsd:element name="buchladen" type="buchladentyp"/> 10 11 <xsd:complextype name="buchladentyp"> 12 <xsd:sequence> 13 <xsd:element name="buch" type="buchtyp" 14 minoccurs="0" maxoccurs="unbounded"/> 15 </xsd:sequence> 16 <xsd:attribute name="ort" type="xsd:string" use="required"/> 17 <xsd:attribute name="strasse" type="xsd:string" use="required"/> 18 <xsd:attribute name="besitzer" type="xsd:string"/> 19 </xsd:complextype> 12

20 21 <xsd:complextype name="buchtyp"> 22 <xsd:sequence> 23 <xsd:element name="einband" type="xsd:string" minoccurs="0"> 24 <xsd:attribute name="alternative"/> 25 <xsd:attribute name="quelle" use="required"/> 26 <xsd:attribute name="typ" default="image/gif"/> 27 </xsd:element> 28 <xsd:element name="autor" type="xsd:string"/> 29 <xsd:element name="titel" type="xsd:string"/> 30 <xsd:element name="verlag" type="xsd:string"/> 31 </xsd:sequence> 32 <xsd:attribute name="genre" type="xsd:genrestyp"/> 33 </xsd:complextype> 34 35 <xsd:simpletype name="genrestyp"> 36 <xsd:restriction base="xsd:string"> 37 <xsd:enumeration value="prosa"/> 38 <xsd:enumeration value="lyrik"/> 39 <xsd:enumeration value="sachbuch"/> 40 </xsd:restriction> 41 </xsd:simpletype> 42 43 </xsd:schema> Der folgende Schemaausschnitt verdeutlicht am Beispiel der Definition eines einfachen Datentyps für numerische IP-Adressen, wie mit regulären Ausdrücken das Aussehen von Strings gewissen Regeln unterworfen werden kann. Der Name des Datentypes, auf den dann in Element- oder Attributdefinitionen Bezug genommen werden kann, ist IP4Num. Er beruht auf dem Datentyp string und ist einer durch ein pattern-element formulierten Bedingung unterworfen. Listing 7: Datentyp für numerische IP-Adresse 1 <xsd:simpletype name="ip4num"> 2 <xsd:restriction base="xsd:string"> 3 <xsd:pattern value="\d{1,3}(\.\d{1,3}){3}"/> 4 </xsd:restriction> 5 </xsd:simpletype> Und das folgende XML Schema aus dem XML Schema Part 0: Primer Second Edition soll ergänzend einige Bestandteile von XML Schema zeigen: Listing 8: XSD aus Part 0 Primer 1 <xsd:schema xmlns:xsd="http://www.w3.org/2001/xmlschema"> 2 3 <xsd:annotation> 4 <xsd:documentation xml:lang="en"> 5 Purchase order schema for Example.com. 6 Copyright 2000 Example.com. All rights reserved. 7 </xsd:documentation> 8 </xsd:annotation> 9 13

10 <xsd:element name="purchaseorder" type="purchaseordertype"/> 11 12 <xsd:element name="comment" type="xsd:string"/> 13 14 <xsd:complextype name="purchaseordertype"> 15 <xsd:sequence> 16 <xsd:element name="shipto" type="usaddress"/> 17 <xsd:element name="billto" type="usaddress"/> 18 <xsd:element ref="comment" minoccurs="0"/> 19 <xsd:element name="items" type="items"/> 20 </xsd:sequence> 21 <xsd:attribute name="orderdate" type="xsd:date"/> 22 </xsd:complextype> 23 24 <xsd:complextype name="usaddress"> 25 <xsd:sequence> 26 <xsd:element name="name" type="xsd:string"/> 27 <xsd:element name="street" type="xsd:string"/> 28 <xsd:element name="city" type="xsd:string"/> 29 <xsd:element name="state" type="xsd:string"/> 30 <xsd:element name="zip" type="xsd:decimal"/> 31 </xsd:sequence> 32 <xsd:attribute name="country" type="xsd:nmtoken" 33 fixed="us"/> 34 </xsd:complextype> 35 36 <xsd:complextype name="items"> 37 <xsd:sequence> 38 <xsd:element name="item" minoccurs="0" maxoccurs="unbounded"> 39 <xsd:complextype> 40 <xsd:sequence> 41 <xsd:element name="productname" type="xsd:string"/> 42 <xsd:element name="quantity"> 43 <xsd:simpletype> 44 <xsd:restriction base="xsd:positiveinteger"> 45 <xsd:maxexclusive value="100"/> 46 </xsd:restriction> 47 </xsd:simpletype> 48 </xsd:element> 49 <xsd:element name="usprice" type="xsd:decimal"/> 50 <xsd:element ref="comment" minoccurs="0"/> 51 <xsd:element name="shipdate" type="xsd:date" minoccurs="0"/> 52 </xsd:sequence> 53 <xsd:attribute name="partnum" type="sku" use="required"/> 54 </xsd:complextype> 55 </xsd:element> 56 </xsd:sequence> 57 </xsd:complextype> 58 59 <!-- Stock Keeping Unit, a code for identifying products --> 60 <xsd:simpletype name="sku"> 61 <xsd:restriction base="xsd:string"> 62 <xsd:pattern value="\d{3}-[a-z]{2}"/> 63 </xsd:restriction> 14

64 </xsd:simpletype> 65 66 </xsd:schema> 3.2 XSL/XSLT Software-Voraussetzung: ein XSLT-fähiger Browser (Internetexplorer, Mozilla, Firefox,... )... oder ein XSLT-Prozessor (der ab Java 1.4 bereits in der Standardbibliothek enthalten ist) 3.2.1 XSL in der XML-Sprachfamilie Während XML ganz allgemein eine Markup-Sprache zur Speicherung beliebiger Daten/Informationen ist, wurden zur Trennung von Daten und Formatierung weitere Empfehlungen für ebenfalls auf XML beruhenden Sprachen und damit verbundene Spezifikationen wie XSL, XSLT, XPath und viele andere durch das W3C entwickelt: XML (Extensible Markup Language (XML) 1.0 (Second Edition)) http://www.w3.org/tr/rec-xml die Empfehlung zum Aufbau jedes XML-Dokumentes Extensible Stylesheet Language (XSL) Version 1.0 http://www.w3.org/tr/xsl/ beschreibt die Möglichkeit, xml-daten mittels Stylesheet (auch XML) in beliebige Zielformate formatieren zu können XSL Transformations (XSLT) Version 1.0 http://www.w3.org/tr/xsl/ beschreibt die Möglichkeit, xml-daten mittels Stylesheet (auch XML) rein textuell transformieren zu können XML Path Language (XPath) Version 1.0 http://www.w3.org/tr/xpath Ausdruckssprache (expression language) für den Zugriff auf XML-Elemente, die in XSLT genutzt wird, sie enthält XPath-Funktionen (The default prefix for the function namespace is fn, and the URI is http://www.w3.org/2005/02/xpath-functions) Für eine Transformation werden also im Allgemeinen Daten und eine Transformationsanweisung benötigt. Einige XSLT-Tutorials: http://www.heise.de/ix/artikel/2001/01/167/ XSLT-Tutorial I: Grundlagen und erste Beispielanwendung http://www.topxml.com/xsl/tutorials/intro/default.asp XSLT & XPath Tutorial http://www.w3schools.com/xsl/ XSLT Tutorial 15

3.2.2 Einfache Transformationen mit Schleifen Listing 9: Einfaches Beispiel eines Datenfiles gw.xml 1 <?xml version="1.0" encoding="iso-8859-1" standalone="no"?> 2 <?xml-stylesheet href="gw.xsl" type="text/xsl"?> 3 <x> 4 <xy a="1"> <b>1</b> <xyz> A </xyz> </xy> 5 <xy a="1"> <b>1</b> <xyz> B </xyz> </xy> 6 <xy a="2"> <b>2</b> <xyz> D </xyz> <opt> 12 </opt> </xy> 7 <xy a="3"> <b>3</b> <xyz> E </xyz> </xy> 8 <xy a="3"> <b>3</b> <xyz> F </xyz> <opt> 17 </opt> </xy> 9 <xy a="4"> <b>4</b> <xyz> G </xyz> </xy> 10 <xy a="1"> <b>1</b> <xyz> C </xyz> </xy> 11 </x> welches über eine Transformation mittels gw.xsl, wie die Instruktionsanweisung in der 2. Zeile des Datenfiles besagt, transformiert werden soll. Die Einbettung des Namens des Transformationssheets in das xml-file ist nicht unbedingt nötig, sie wird vor allem dort verwendet, wo eine feste Zuordnung gewünscht bzw. notwendig ist, wenn z.b. das xml-file direkt durch den Browser angefordert wird. Durch die folgende Transformation wird ein Teil der Daten (das Attribut a und der Inhalt von b) aller Datensätze ausgegeben: Listing 10: Das XSLT-File gw.xsl zum Datenfiles gw.xml 1 <?xml version="1.0" encoding="iso-8859-1"?> 2 3 <!-- <xsl:stylesheet xmlns:xsl="http://www.w3.org/tr/wd-xsl"> 4... working draft (fuer IE 5.x zu verwenden) 5 --> 6 7 <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/xsl/transform" 8 version="1.0"> 9 <xsl:template match="/"> 10 Attr_a b 11 <xsl:for-each select="x/xy"> 12 Datensatz <xsl:value-of select="@a" /> <xsl:value-of select="b" /> 13 </xsl:for-each> 14 </xsl:template> 15 </xsl:stylesheet> Das durch die Transformation erzeugte Produkt sieht folgendermaßen aus: Attr_a b Datensatz 1 1 Datensatz 1 1 Datensatz 2 2 Datensatz 3 3 Datensatz 3 3 Datensatz 4 4 Datensatz 1 1 16

An diesem Beispiel wird ersichtlich, daß die Transformationsanweisungen des xsl-files innerhalb des template-tags beliebigen Text enthalten kann, wodurch dann auch ein beliebiges Output-Format (z.b. html, oder auch NICHT-XML) entstehen kann. 3.2.3 Bedingungen Soll es zur Abarbeitung von Teilen des Transformationsskriptes unter bestimmten Bedingungen kommen, kann man den Befehl <xsl:if test="...">... </xsl:if> verwenden. Wollen wir beispielsweise aus der xml-datei des letzten Abschnittes (siehe 3.2.2, S.16) für jedes <xy>-element den Inhalt von <xyz> und, falls vorhanden, von <opt> drucken, machen wir das mittels folgender XSLT-Befehle: 1... 2 <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/xsl/transform" 3 version="1.0"> 4 <xsl:template match="/"> 5 <xsl:for-each select="x/xy"> 6 <xsl:value-of select="xyz"/> <xsl:if test="opt"> 7 <xsl:value-of select="opt"/> 8 </xsl:if> 9 </xsl:for-each> 10 </xsl:template> 11 </xsl:stylesheet> 3.2.4 Gruppierungen An dieser Stelle erscheint es nun interessant, nach übereinstimmenden Werten von Attributen oder Elementen zu gruppieren. Das kann für das Attribut a folgendermaßen geschehen: Listing 11: Realisierung einer Gruppierung 1 <?xml version="1.0" encoding="iso-8859-1"?> 2 <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/xsl/transform" 3 version="1.0"> 4 <xsl:template match="/"> 5 ANFANG 6 <xsl:for-each select="x/xy[not(@a=preceding-sibling::xy/@a)]"> 7 Attr_a = <xsl:value-of select="@a" /> 8 b xyz 9 <xsl:for-each select="/x/xy[@a=current()/@a]"> 10 Datensatz <xsl:value-of select="b" /> 11 <xsl:value-of select="xyz" /> 12 </xsl:for-each> 13 </xsl:for-each> 14 ENDE 15 </xsl:template> 16 </xsl:stylesheet> Das Stylesheet enthält zwei geschachtelte for-each-schleifen. Die äußere macht die Trennung der Gruppen, dazu wird eine Bedingung genutzt, daß das Element nur selektiert wird, wenn sein Attribut a (Attribute werden mit dem at-zeichen @ gekennzeichnet) keinem schon gefundenen a eines vorangegangenen Geschwisterelementes (siehe XPath: preceeding-sibling, das ist eine Achse) gleicht. Die innere for-each-schleife läuft nun innerhalb dieser Gruppe über alle Elemente mit gleichem a. 17

Es ergibt sich folgendes Produkt: ANFANG Attr_a = 1 b xyz Datensatz 1 A Datensatz 1 B Datensatz 1 C Attr_a = 2 b xyz Datensatz 2 D Attr_a = 3 b xyz Datensatz 3 E Datensatz 3 F Attr_a = 4 b xyz Datensatz 4 G ENDE 3.2.5 Templates Bisher haben wir das xsl-element template nur zum Greifen des Wurzelelements verwendet, die Bearbeitung wurde mit xsl:for-each realisiert, was wir für Konstrukte wie Gruppierungen auch weiterhin verwenden werden! Die gebräuchliche Art, Transformationen zu realisieren, sind aber Templates (für jedes zu transformierende Element wird ein Template angelegt) und der Befehl <xsl:apply-templates... />. xsl:template Der Parameter match (entsprechend XPath) kennzeichnet die Elemente, für die das Template gilt. xsl:apply-templates Der optionale Parameter select (entsprechend XPath) kennzeichnet die Elemente, die getroffen werden sollen. Fehlt er, werden alle Kindelemente des aktuellen Elements rekursiv verarbeitet. Wird für ein Element ein Template gefunden, wird es verarbeitet, ansonsten werden die Inhalte der Elemente ausgegeben (Testen!). Listing 12: XML-Datenfile eines CD- und Buchverzeichnisses 1 <?xml version="1.0" encoding="iso-8859-1" standalone="no"?> 2 3 <?xml-stylesheet href="shop.xsl" type="text/xsl"?> 4 5 <Shop> 6 <CD> 7 <Title>Cruel</Title> 8 <Artist>The Singer</Artist> 9 <Track Nr="1" Length="24"> Part One </Track> 10 <Track Nr="2" Length="29"> Part Two </Track> 11 </CD> 18

12 13... 14 15 <book> Dies ist ein Buch! </book> 16 <book> Dies ist noch ein Buch! <autor> Hillu Hilbert </autor> </book> 17 </Shop> Listing 13: Das entsprechende Transformationsfile 1 <?xml version="1.0" encoding="iso-8859-1"?> 2 3 <xsl:stylesheet version="1.0" 4 xmlns:xsl="http://www.w3.org/1999/xsl/transform" 5 xmlns="http://www.w3.org/tr/rec-html40"> 6 <xsl:output method="html" /> 7 <xsl:template match="/"> 8 <html> 9 <head><title>shop</title></head> 10 <body> 11 <xsl:apply-templates /> 12 <!-- <xsl:apply-templates select="shop/book" /> --> 13 </body> 14 </html> 15 </xsl:template> 16 17 <xsl:template match="book"> 18 <br/> Buch: Autor 19 <xsl:value-of select="autor" /> 20 </xsl:template> 21 22 <xsl:template match="cd"> 23 <br/> CD : <xsl:value-of select="artist" /> : 24 <xsl:value-of select="title" /> 25 Länge: <xsl:value-of select="sum(track/@length)" /> 26 </xsl:template> 27 </xsl:stylesheet> Die Länge der CDs werden durch die Aggregatfunktion sum(...) berechnet, die in XPath beschrieben ist. Listing 14: Transformationsprodukt HTML 1 <html xmlns="http://www.w3.org/tr/rec-html40"> 2 <head> 3 <title>shop</title> 4 </head> 5 <body> 6 <br/> CD : The Singer : 7 Cruel 8 Länge: 53 9 <br/> CD : The Singer : 10 Awesome 11 Länge: 42.57 12 <br/> CD : Tim Tom : 13 Lieder 19

14 Länge: 7.8 15 <br/> Buch: Autor 16 <br/> Buch: Autor 17 Hillu Hilbert 18 </body> 19 </html> Die html-igen Umlautcodierungen entstehen durch das method-attribut mit dem Wert html im output-tag 3.2.6 Fremdschlüssel Wie in relationalen Datenbanken kann man im XML Attribute als Fremdschlüssel (IDREF(S)) auf Attribute, die Schlüssel (ID) darstellen, zeigen lassen, wie die Definition der Fremdschlüssel und Sclüsselkandidaten in den RDBMS ist hier die Verwendung der Attributtypen ID und IDREF nicht notwendig für die Referenzen, sondern nur hilfreich für das Gewährleisten der referenziellen Integrität, deren Verletzung im XML zu einem ungültigen Dokument führt. Folgendes Beispiel ist eine Modifikation des obigen Shop-Beispiels, wobei die Artist-Elemente aus den CD-Elementen ausgelagert und durch Referenzen ersetzt wurden: Listing 15: Anlegen von Fremdschlüsseln 1 <?xml version="1.0" encoding="iso-8859-1" standalone="no"?> 2 3 <?xml-stylesheet href="shop_fk_html.xsl" type="text/xsl"?> 4 <Shop> 5 <CD ArtistID="a01"> <Title>Cruel</Title> </CD> 6 <CD ArtistID="a01"> <Title>Awesome</Title> </CD> 7 <CD ArtistID="a02"> <Title>Lieder</Title> </CD> 8 <Artist ArtistID="a01">The Singer</Artist> 9 <Artist ArtistID="a02">Tim Tom</Artist> 10 </Shop> Im dazugehörigen Stylesheet werden nur die CD-Templates berücksichtigt, die benötigten Artist-Daten jedoch über die Referenz ArtistID geholt: 1... Listing 16: Nutzung der Fremdschlüssel in der Transformation 2 <xsl:apply-templates select="shop/cd" /> 3... 4 5 <xsl:template match="cd"> 6 <br/> 7 <xsl:value-of select="/shop/artist[@artistid=current()/@artistid]" /> : 8 <xsl:value-of select="title" /> 9 </xsl:template> 10 </xsl:stylesheet> Übung 3 Transformieren Sie mittels XSLT das XML-File von Übung 2 (S.11) in ein XHTML-File, welches die Daten (Matrikelnummer, Name, Vorname, Geburtsdatum) der Studenten in einer Tabelle ausgibt. Erweitern Sie das XML-File um einige Studenten. 20

3.2.7 Durchschleifen von XML-Tags Enthält ein Element eines XML-Files XML-Tags, die 1:1 weitergegeben werden sollen (z.b., wenn man HTML-Tags wie <br/>, <ul>, <li>... zur Formatierung benutzen will,) arbeitet man mit Templates. Das Element, welches die Tags enthält, wird mittels <xsl:apply-templates... /> aufgerufen, die entsprechenden Tags müssen ihrerseits über Templates verfügen: 1... 2 <Beschreibung> Listing 17: Die XML-Daten 3 Folgende Teile sind zu berücksichtigen: 4 <ul> 5 <li>der linke Teil</li> 6 <li>der rechte Teil 7 <br/> unter besonderer Beachtung des rechten oberen Teils ;-) 8 </li> 9 </ul> 10 </Beschreibung> 11... 1... Listing 18: Die XSLT-Transformation 2 <xsl:apply-templates select="beschreibung" /> 3... 4 <xsl:tempate match="beschreibung"> <!-- kann auch wegfallen --> 5 <xsl:apply-templates /> 6 </xsl:template> 7 8 <xsl:tempate match="br"> 9 <br/> 10 </xsl:template> 11 12 <xsl:tempate match="ul"> 13 <ul> 14 <xsl:apply-templates /> 15 </ul> 16 </xsl:template> 17 18 <xsl:tempate match="li"> 19... 3.3 Ein komplettes Beispiel Das vorliegende Beispiel soll zeigen, wie ein XML-Datensatz (Listings 19 bzw. 21) mit DTD (Listing 20) bzw. XMLSchema (Listing 22) validiert werden kann. Eine Transformation des Datensatzes in HTML erfolgt durch das in Listing 23 dargestellt Stylesheet. Die Validierungen und Transformationen können mit Targets des in Listing 24 ant-build- Files realisiert werden. Listing 19: Ein XML-Datenfile shop4.xml mit Bezug auf DTD (Listing 20) 1 <?xml version="1.0" encoding="iso-8859-1" standalone="no"?> 21

2 3 <!DOCTYPE Shop SYSTEM "shop4.dtd"> 4 5 <Shop> 6 <CD ArtistID="a01"> 7 <Title>Cult</Title> 8 <Track Nr="01" Length="3.1">Path</Track> 9 <Track Nr="02" Length="3.43">Struggle</Track> 10 <Track Nr="03" Length="3.45">Romance</Track> 11 </CD> 12 13... 14 <!-- as much CDs you ever want --> 15 16 <Artist ArtistID="a01">Apocalyptica</Artist> 17 <Artist ArtistID="a02">Manu Chao</Artist> 18 </Shop> Listing 20: Die zugehörige DTD shop4.dtd 1 <?xml version= 1.0 encoding= ISO-8859-1?> 2 3 <!ELEMENT Shop (CD*,Artist*)> 4 <!ELEMENT CD (Title,Track+)> 5 <!ATTLIST CD 6 ArtistID IDREF #REQUIRED 7 CDNr CDATA #IMPLIED 8 > 9 <!ELEMENT Title (#PCDATA)> 10 <!ELEMENT Artist (#PCDATA)> 11 <!ATTLIST Artist 12 ArtistID ID #REQUIRED 13 > 14 <!ELEMENT Track (#PCDATA)> 15 <!ATTLIST Track 16 Nr CDATA #REQUIRED 17 Length CDATA #REQUIRED 18 > 19 20 <!ENTITY copyright " "> Listing 21: XML-Datenfile shop4xsd.xml (Auszug) mit Bezug auf Schema (Listing 22) 1 <?xml version="1.0" encoding="iso-8859-1" standalone="no"?> 2 3 <Shop 4 xmlns:xsi="http://www.w3.org/2001/xmlschema-instance" 5 xsi:nonamespaceschemalocation="shop4xsd.xsd" 6 > 7 8... 9 10 </Shop> 22

Listing 22: Das zugehörige XMLSchema shop4xsd.xsd 1 <?xml version= 1.0 encoding= ISO-8859-1?> 2 3 <xsd:schema xmlns:xsd="http://www.w3.org/2001/xmlschema"> 4 5 <xsd:annotation> 6 <xsd:documentation xml:lang="de"> 7 XML Schema fuer einen Shop 8 </xsd:documentation> 9 </xsd:annotation> 10 11 <xsd:element name="shop" type="shoptyp"/> 12 13 <xsd:complextype name="shoptyp"> 14 <xsd:sequence> 15 <xsd:element name="cd" type="cdtyp" 16 minoccurs="0" maxoccurs="unbounded"/> 17 <xsd:element name="artist" type="artisttyp" 18 minoccurs="0" maxoccurs="unbounded"/> 19 </xsd:sequence> 20 </xsd:complextype> 21 22 <xsd:complextype name="cdtyp" > 23 <xsd:sequence> 24 <xsd:element name="title" type="xsd:string"/> 25 <xsd:element name="track" minoccurs="1" maxoccurs="unbounded"> 26 <xsd:complextype> 27 <xsd:simplecontent> 28 <xsd:extension base="xsd:string"> 29 <xsd:attribute name="nr" type="xsd:string" use="required"/> 30 <xsd:attribute name="length" type="xsd:decimal"/> 31 </xsd:extension> 32 </xsd:simplecontent> 33 </xsd:complextype> 34 </xsd:element> 35 </xsd:sequence> 36 <xsd:attribute name="artistid" type="xsd:idref" use="required"/> 37 <xsd:attribute name="cdnr" type="xsd:string"/> 38 </xsd:complextype> 39 40 <xsd:complextype name="artisttyp" > 41 <xsd:simplecontent> 42 <xsd:extension base="xsd:string"> 43 <xsd:attribute name="artistid" type="xsd:id" use="required"/> 44 </xsd:extension> 45 </xsd:simplecontent> 46 </xsd:complextype> 47 48 49 </xsd:schema> Listing 23: Das XSL-Transformationsfile shop4.xsl mit HTML-Output 1 <?xml version="1.0" encoding="iso-8859-1"?> 23

2 3 <xsl:stylesheet version="1.0" 4 xmlns:xsl="http://www.w3.org/1999/xsl/transform" 5 xmlns="http://www.w3.org/tr/rec-html40"> 6 7 <xsl:output method="html" /> 8 9 <xsl:template match="/"> 10 <html> 11 <head><title>shop</title></head> 12 <body> 13 <xsl:for-each select="shop/cd 14 [not(@artistid=preceding-sibling::cd/@artistid)]"> 15 <font color="red" size="+1"> 16 <xsl:value-of select="/shop/artist 17 [@ArtistID=current()/@ArtistID]" /> 18 </font> <br/> 19 <xsl:apply-templates select="/shop/cd 20 [@ArtistID=current()/@ArtistID]" /> 21 </xsl:for-each> 22 </body> 23 </html> 24 </xsl:template> 25 26 27 <xsl:template match="cd"> 28 Album: <strong><xsl:value-of select="title" /></strong> 29 (<xsl:value-of 30 select="0.01*round(100.*sum(track/@length))" /> min.) 31 <ol> 32 <xsl:for-each select="track"> 33 <li><xsl:value-of select="." /> 34 (<xsl:value-of select="./@length" /> min.) 35 </li> 36 </xsl:for-each> 37 </ol> 38 </xsl:template> 39 </xsl:stylesheet> Listing 24: ant-build-file für Validierung und Transformation mit den Files aus Listings 19 bis 23 1 <project name="xslttrans" basedir="."> 2 <property name="src" location="."/> 3 <property name="dest" location="./out"/> 4 5 <target name="v"> 6 <xmlvalidate file="${src}/shop4.xml"/> 7 </target> 8 9 <target name="vs"> 10 <schemavalidate file="shop4xsd.xml" /> 11 </target> 12 13 <target name="t" depends="v"> 24

14 <xslt in="${src}/shop4.xml" style="${src}/shop4.xsl" 15 out="${dest}/shop4.html"/> 16 </target> 17 18 <target name="ts" depends="vs"> 19 <xslt basedir="${src}" includes="shop4xsd.xml" destdir="${dest}" 20 extension=".html" style="${src}/shop4.xsl"/> 21 </target> 22 23 </project> 25

4 XML-API-Programmierung Es existieren eine Reihe von APIs für XML (Java, Perl,... ). Prinzipiell kann man all diese für XML-Handling verwenden, wir wollen uns hier konkret den Java-APIs zuwenden. 2 grundlegende Kategorien: dokumenten-orientiert Java API for XML Processing (JAXP) enthält alles, was benötigt wird, um XML-Files zu parsen (SAX), in einen Objektbaum (DOM) zu wandeln und entsprechend XSLT-Transformationsinstruktionen zu transformieren prozedur-orientiert Java API for XML-based RPC (JAX-RPC) die Java-API zur Entwicklung und Nutzung von Web-Services (sends SOAP method calls to remote parties over the Internet and receives the results) Java API for XML Messaging (JAXM) sends SOAP messages over the Internet in a standard way Java API for XML Registries (JAXR) provides a standard way to access business registries and share information Das Java Enterprise Tutorial liefert eine gute Einführung in XML, als Software ist die Java Standard Edition hinreichend. (Eine recht umfangreiche Einführung in die Probleme um Java und XML wird auch in [8] gegeben.) Folgenden Stoff wollen wir behandeln: Sequentielles Parsen und Verarbeiten von XML-Files mit der Simple API for XML (SAX) das Document Object Model (DOM) als baumartige Objektstruktur zur Haltung und Bearbeitung von XML-Datei-Inhalten XML Stylesheet Language for Transformations (XSLT) Zur XML-XSL-XSLT-Problemetik gibt es auch dasxalan-projekt (http://xml.apache.org/xalan-j/), das auch die hier von uns benötigte Java-APIs enthält 4.1 Java API for XML Processing (JAXP) Software-Voraussetzung: Java-Standard-Edition Beispiele zu den unterschiedlichen Teilen der JAXP finden Sie unter anderem im examples- Verzeichnis des Java Web Services Tutorial [5]. Ab JDK1.4.xx sind die JAXP-Klassen bereits in der Standard-rt.jar enthalten. 4.1.1 Simple API for XML (SAX) Informationen zum SAX-Projekt (auch zu Features and Properties) findet man unter http://www.saxproject.org/. SAX realisiert ein sequentielles Parsen einer XML-Quelle und die Möglichkeit, auf Parser- Ereignisse zu reagieren. Dabei wird ein eventorientiertes, mit dem AWT-Eventhandling vergleichbares System verwendet. Trifft der SAXParser im geparsten XML auf eine bestimmte 26

inhaltliche Struktur (ein Element, ein Kommentar, Text,... ), ruft er eine dieser Struktur entsprechende Methode des bei ihm (als Parameter im Ruf der parse(... )-Methode) gemeldeten Handlers auf. Trifft der Parser z.b. auf das öffnende Tag eines Elementes, ruft er die Methode startelement(...). Abb. aus [5] Der Handler kann z.b. von der Klasse org.xml.sax.helpers.defaulthandler (vergleichbar mit so etwas wie MouseAdapter, in der Abb.(aus [5]) ist der Handler aus unerfindlichen Gründen als SAXReader bezeichnet), abgeleitet werden. org.xml.sax.helpers.defaulthandler implementiert die Interfaces ContentHandler, ErrorHandler, DTDHandler, und EntityResolver mit leeren Methodenkörpern. Soll eine Reaktion erfolgen, müssen die entsprechenden Methoden überschrieben werden. Hier sind die Köpfe der Handlermethoden des folgenden Beispiels (Listing 25) zusammengefaßt: - public void startdocument()... - public void enddocument()... - public void startelement(string namespaceuri, String sname, // simple name String qname, // qualified name Attributes attrs )... - public void endelement(string namespaceuri, String sname, // simple name String qname // qualified name )... 27

- public void characters(char buf[], int offset, int len)... Die Namen sind sprechend, so daß der Quelltext eigentlich selbsterklärend ist. Für die Behandlung des Elementnamens, der Attribute etc. werden den entsprechenden Methoden Parameter übergeben. Ein Beispiel aus dem Java Web Services Tutorial [5] ist Echo01.java, ein nicht validierender Parser (kann aber umgestellt werden, ein validierender, erweiterter Parser ist Echo10.java) ist im folgenden Listing dargestellt. Die Klasse Echo01 beinhaltet sowohl die main()-methode, die den Ablauf durch das hier oft verwendete Entwurfsmuster mit Einsatz einer Factory realisiert, als auch die benötigten Handler-Methoden (durch Ableitung von der Klasse DefaultHandler und Überschreiben der relevanten Methoden). Im main(...) wird ein Exemplar der Klasse (Zeile 21) zur Verwendung beim Parsen (Zeile 31) instantiiert. Die SAXParserFactory (Zeile 24) schafft einen SAXParser (Zeile 30), welcher mit seiner Methode parse(file f, DefaultHandler h) ein File f parst und dem DefaultHandler h immer dann eine Nachricht sendet (d.h. die entsprechende Handlermethode ruft), wenn im XML-File eine entsprechende XML-Struktur gefunden wurde. In den Zeilen 41-100 sind die Handlermethoden definiert, die etwas konkretes tun sollen. 1 import java.io.*; Listing 25: Auszug aus Echo01 [5] 2 3 import org.xml.sax.*; 4 import org.xml.sax.helpers.defaulthandler; 5 6 import javax.xml.parsers.saxparserfactory; 7 import javax.xml.parsers.parserconfigurationexception; 8 import javax.xml.parsers.saxparser; 9 10 public class Echo01 extends DefaultHandler 11 { 12 13 public static void main(string argv[]) 14 { 15 if (argv.length!= 1) { 16 System.err.println("Usage: cmd filename"); 17 System.exit(1); 18 } 19 20 // Use an instance of ourselves as the SAX event handler 21 DefaultHandler handler = new Echo01(); 22 23 // Use the default (non-validating) parser 24 SAXParserFactory factory = SAXParserFactory.newInstance(); 25 try { 26 // Set up output stream 27 out = new OutputStreamWriter(System.out, "UTF8"); 28 29 // Parse the input 30 SAXParser saxparser = factory.newsaxparser(); 31 saxparser.parse( new File(argv[0]), handler); 32 28

33 } catch (Throwable t) { 34 t.printstacktrace(); 35 } 36 System.exit(0); 37 } 38 39 static private Writer out; 40 41 //=========================================================== 42 // SAX DocumentHandler methods 43 //=========================================================== 44 45 public void startdocument() 46 throws SAXException 47 { 48 emit("<?xml version= 1.0 encoding= UTF-8?>"); 49 nl(); 50 } 51 52 public void enddocument() 53 throws SAXException 54 { 55 try { 56 nl(); 57 out.flush(); 58 } catch (IOException e) { 59 throw new SAXException("I/O error", e); 60 } 61 } 62 63 public void startelement(string namespaceuri, 64 String sname, // simple name 65 String qname, // qualified name 66 Attributes attrs) 67 throws SAXException 68 { 69 String ename = sname; // element name 70 if ("".equals(ename)) ename = qname; // not namespaceaware 71 emit("<"+ename); 72 if (attrs!= null) { 73 for (int i = 0; i < attrs.getlength(); i++) { 74 String aname = attrs.getlocalname(i); // Attr name 75 if ("".equals(aname)) aname = attrs.getqname(i); 76 emit(" "); 77 emit(aname+"=\""+attrs.getvalue(i)+"\""); 78 } 79 } 80 emit(">"); 81 } 82 83 public void endelement(string namespaceuri, 84 String sname, // simple name 85 String qname // qualified name 86 ) 29

87 throws SAXException 88 { 89 String ename = sname; // element name 90 if ("".equals(ename)) ename = qname; // not namespaceaware 91 emit("</"+ename+">"); 92 } 93 94 public void characters(char buf[], int offset, int len) 95 throws SAXException 96 { 97 String s = new String(buf, offset, len); 98 emit(s); 99 } 100 101 //=========================================================== 102 // Utility Methods... 103 //=========================================================== 104 105 // Wrap I/O exceptions in SAX exceptions, to 106 // suit handler signature requirements 107 private void emit(string s) 108 throws SAXException 109 { 110 try { 111 out.write(s); 112 out.flush(); 113 } catch (IOException e) { 114 throw new SAXException("I/O error", e); 115 } 116 } 117 118 // Start a new line 119 private void nl() 120 throws SAXException 121 { 122 String lineend = System.getProperty("line.separator"); 123 try { 124 out.write(lineend); 125 } catch (IOException e) { 126 throw new SAXException("I/O error", e); 127 } 128 } 129 } Das Befähigen des Parsers, mit Namespaces umzugehen, erfolgt durch Umstellen der SAXParserFactory mittels Ruf von setnamespaceaware(true). Übung 4 Parsen Sie ein XML-File mit SAX, geben Sie es als XML wieder aus (Echo01 des JWSDP), lassen Sie validierend parsen! Nutzen Sie das Programm als Ausgangspunkte, um eine Applikation zu programmieren, die ein XML-File (XHTML) parst und alle href- Attribute von a-elementen (<a href=xxxxxx>... </a>) erfasst und ausgibt! 30

4.1.2 Document Object Model (DOM) Die DOM-Spezifikationen liegen beim W3C (http://www.w3.org/tr/dom-level-2-core/). Das Interface beschreibt, wie ein Dokument, welches einen XML-Baum abbildet, als Objektbaum aufgebaut werden kann und mit welchen Methoden es manipulierbar sein soll. Dabei spielt die mögliche Implementierung keine Rolle. Abb. aus [5] Das folgende Beispiel (aus dem Java Web Services Tutorial [5]) dokumentiert den Aufbau eines DOM an einem einfachen Beispiel. Es wird entsprechend des allgemeinen Entwurfsmusters zunächst eine DomBuilderFactory instantiiert (Zeile 26), diese produziert durch einen entsprechenden Methodenruf einen neuen DomBuilder (Zeile 31), welcher nun (siehe API- Doc) ein DOM (Klasse Document) durch Parsen eines XML-Files generieren kann (Zeile 32). Es kann aber auch durchaus ein leeres DOM (siehe weiter unten) hergestellt werden, dem dann im weiteren Verlauf Elemente hinzugefügt werden. In Zeile 28 und 29 wird gezeigt, wie die Factory in die Lage versetzt wird, einen validierenden und mit Namespaces umgehen könnenden DomBuilder zu bauen. Listing 26: DomEcho01.java [5] 1 import javax.xml.parsers.documentbuilder; 2 import javax.xml.parsers.documentbuilderfactory; 3 import javax.xml.parsers.factoryconfigurationerror; 4 import javax.xml.parsers.parserconfigurationexception; 5 6 import org.xml.sax.saxexception; 7 import org.xml.sax.saxparseexception; 8 9 import java.io.file; 10 import java.io.ioexception; 11 12 import org.w3c.dom.document; 13 import org.w3c.dom.domexception; 14 15 public class DomEcho01{ 16 // Global value so it can be ref d by the tree-adapter 17 static Document document; 18 19 public static void main(string argv[]) 31

20 { 21 if (argv.length!= 1) { 22 System.err.println("Usage: java DomEcho filename"); 23 System.exit(1); 24 } 25 26 DocumentBuilderFactory factory = 27 DocumentBuilderFactory.newInstance(); 28 //factory.setvalidating(true); 29 //factory.setnamespaceaware(true); 30 try { 31 DocumentBuilder builder = factory.newdocumentbuilder(); 32 document = builder.parse( new File(argv[0]) ); 33 34 } catch (SAXParseException spe) { 35 // Error generated by the parser 36 System.out.println("\n** Parsing error" 37 + ", line " + spe.getlinenumber() 38 + ", uri " + spe.getsystemid()); 39 System.out.println(" " + spe.getmessage() ); 40 41 // Use the contained exception, if any 42 Exception x = spe; 43 if (spe.getexception()!= null) 44 x = spe.getexception(); 45 x.printstacktrace(); 46 47 } catch (SAXException sxe) { 48 // Error generated during parsing) 49 Exception x = sxe; 50 if (sxe.getexception()!= null) 51 x = sxe.getexception(); 52 x.printstacktrace(); 53 54 } catch (ParserConfigurationException pce) { 55 // Parser with specified options can t be built 56 pce.printstacktrace(); 57 58 } catch (IOException ioe) { 59 // I/O error 60 ioe.printstacktrace(); 61 } 62 } // main 63 } Der folgende Auszug aus der DOM-Spezifikation soll anhand von zwei Interfaces (node, element) zeigen, wie die Spezifikation Konstanten zur Charakterisierung von Zuständen und Signaturen von Methoden zur Bearbeitung eines Documents vorschreibt. Durch diese Spezifikation wird gewährleistet, das für das Handling mit DOM-Implementationen in verschiedenen Programmiersprachen de facto keine Unterschiede bestehen. 1 interface Node { Listing 27: Auszug aus der DOM-Spezifikation (interface Node) 32

2 3 // NodeType 4 const unsigned short ELEMENT_NODE = 1; 5 const unsigned short ATTRIBUTE_NODE = 2; 6 const unsigned short TEXT_NODE = 3; 7 const unsigned short CDATA_SECTION_NODE = 4; 8 const unsigned short ENTITY_REFERENCE_NODE = 5; 9 const unsigned short ENTITY_NODE = 6; 10 const unsigned short PROCESSING_INSTRUCTION_NODE = 7; 11 const unsigned short COMMENT_NODE = 8; 12 const unsigned short DOCUMENT_NODE = 9; 13 const unsigned short DOCUMENT_TYPE_NODE = 10; 14 const unsigned short DOCUMENT_FRAGMENT_NODE = 11; 15 const unsigned short NOTATION_NODE = 12; 16 17 readonly attribute DOMString nodename; 18 attribute DOMString nodevalue; 19... 20... 21 22 Node insertbefore(in Node newchild, 23 in Node refchild) 24 raises(domexception); 25 26 Node replacechild(in Node newchild, 27 in Node oldchild) 28 raises(domexception); 29 30 Node removechild(in Node oldchild) 31 raises(domexception); 32 33 Node appendchild(in Node newchild) 34 raises(domexception); 35 36 boolean haschildnodes(); 37 38... 39 }; Auf node-ebene werden hier Methoden zum Einfügen, Ersetzen, Löschen von Nodes etc. festgelegt, die dann genau so auch von der speziellen Node-Klasse Element ohne eine Neudefinition genutzt werden können. Methoden zur Manipulation von Attributen finden wir dann in der Beschreibung von Element, welches von Node abgeleitet ist. Listing 28: Auszug aus der DOM-Spezifikation (interface Element) 41 interface Element : Node { 42 43... 44 45 void setattribute(in DOMString name, 46 in DOMString value) 47 raises(domexception); 48 33

49 void removeattribute(in DOMString name) 50 raises(domexception); 51 52 Attr getattributenode(in DOMString name); 53 54 Attr setattributenode(in Attr newattr) 55 raises(domexception); 56 57 Attr removeattributenode(in Attr oldattr) 58 raises(domexception); 59 60 NodeList getelementsbytagname(in DOMString name); 61 62... 63 }; Im folgenden Listing wird wieder ein DOM aufgebaut, hier allerdings ein leeres (Zeile 7). Dieses noch leere Dokument wird benutzt, um ein neues XML-Element mit dem Namen rootelement zu kreieren, welches noch keinen strukturellen Bezug zum Dokument hat. Erst in Zeile 11 wird dieses Element dem Dokument hinzugefügt, es wird zum Rootelement des Dokumentes, da dieses vorher leer war. Ihm wird in Zeile 12 ein Attribut hinzugefügt. An das Rootelement mit Namen rootelement werden TextNodes angehängt (Zeilen 13 bis 15). Es ist zu beachten, daß die Java-Variablennamen (z.b. root auf Zeile 9) NICHTS mit den Namen der XML-Elemente zu tun haben! Listing 29: Aufbau eines Documents 1 public static void builddom() 2 { 3 DocumentBuilderFactory factory = 4 DocumentBuilderFactory.newInstance(); 5 try { 6 DocumentBuilder builder = factory.newdocumentbuilder(); 7 document = builder.newdocument(); // Create from whole cloth 8 9 Element root = 10 (Element) document.createelement("rootelement"); 11 document.appendchild(root); 12 root.setattribute("attr","wert"); 13 root.appendchild( document.createtextnode("some") ); 14 root.appendchild( document.createtextnode(" ") ); 15 root.appendchild( document.createtextnode("text") ); 16 17 // document.normalize(); 18 19 20 } catch (ParserConfigurationException pce) { 21 // Parser with specified options can t be built 22 pce.printstacktrace(); 23 24 } 25 } // builddom 34

Übung 5 Bauen Sie einen Datenbank - XML bzw. DOM - Adapter. Dazu schreiben Sie in Anlehnung an Übung 15 eine Methode public Document gettable(string tabname, Connection c), die alle Datensätze einer Datenbank-Tabelle in einem DOM zurückgibt. Das Root-Element soll den Namen der Tabelle (z.b. Kunden) tragen, bei jedem Datensatz soll der Elementname aus ds und dem Tabellennamen zusammengesetzt sein (z.b. dskunden), jeder Datensatz soll wieder Elemente mit den Spaltennamen haben, deren Inhalt mit getstring(...) erhaltene PCDATA sind. Alternativ geben Sie die Daten als XML-String zurück! Übung 6 Lesen Sie das XML-File von Übung 2 (S.11), nachdem Sie es um einige Studenten erweitert haben, in ein DOM ein. Übung 7 Lesen Sie eine Datenbanktabelle und bauen Sie die Daten in ein Dokument (DOM) ein, stellen Sie dazu eine Konvention für die Namen von Tabelle und einzelnem Datensatz im DOM auf! 4.1.3 XSLT Empfehlungen des W3C: Extensible Stylesheet Language (XSL) Version 1.0 (http://www.w3.org/tr/xsl) XSL Transformations (XSLT) (http://www.w3.org/tr/xslt) Abb. aus [5] Für Transformationen gibt es z.b. den XSLT-Transformer-Prozeß des XALAN-Projektes: java org.apache.xalan.xslt.process -IN data.xml -XSL view.xsl [-OUT personen.html] (Java 1.4, in 1.5 ist die Klasse verschoben, und main() heißt _main()), den Prozessor saxon (gibt es auch in Perl) oder man benutzt einfach ant mit der Task Xslt. 35