XML-Verarbeitung in Javafiedler/teaching/ws2005/iis/XML... · SAX und DOM sind sprachunabh¨angige...

.................................................................................................................................................................................................................................................................................. ..................................................................................................................................................................................................................................................................................

Content

Concept Topic

Information

XML-Verarbeitung in JavaPraktikum zur Vorlesung Intelligente Informationssysteme

WS 2004/05

Gunar Fiedler ([email protected])

Question1: When should I use XML?

Answer: When you need a buzzword in your resume.

1 XML

Die EXtensible Markup Language ist eine Sprache zur Beschreibung von Daten.Dabei bedient man sich einer Menge von Markierungselementen, den sogenanntenTags. Anders als bei HTML ist die Menge der Tags nicht vorbestimmt, jeder kannsich seine eigenen Tags definieren.Die Syntax eines XML-Dokuments ist einfach:

<?xml version="1.0" encoding="ISO-8859-1"?><tour><artist>R.E.M.</artist><title>Tour 2005</title><event><place name="ColorLine Arena"><address>Sylvesterallee, 22525 Hamburg</address>

</place><date day="17" month="2" year="2005" hour="20" minute="0" />

</event></tour>

Jedes Dokument beginnt mit der XML declaration, welche die XML-Version und dieZeichencodierung der Datei angibt:

<?xml version="1.0" encoding="ISO-8859-1"?>

Momentan wird immer XML-Version 1.0 verwendet, ISO-8859-1 bezeichnet denZeichensatz Latin 1/West European.

1www.w3schools.com/xml/xml_whatis.asp

www.w3schools.com/xml/xml_whatis.asp

1 XML XML-Verarbeitung

<tour>

Das erste Tag bezeichnet das Wurzelelement des Dokuments, in das alle anderenElemente eingebettet sind. Jedes XML-Dokument hat genau 1 Wurzelelement. ImUnterschied zu HTML wird in XML bei der Definition von Bezeichnern zwischenGroß- und Kleinschreibung unterschieden.Da jeder seine eigenen Tags definieren kann, wurde bald großes Chaos herrschen,und niemand konnte unterscheiden, wer ein bestimmtes Tag mit welcher Bedeutungdefiniert hat. Aus diesem Grund werden Tagnamen in Namensraume eingeteilt. EinNamensraum ist ein weltweit eindeutiger Bezeichner, also eine URI2. Dieser URIwird im Wurzelelement ein symbolischer Bezeichner zugewiesen:

<tour xmlns="http://www.is.informatik.uni-kiel.de/events"xmlns:h="http://www.w3.org/1999/xhtml">

<artist><h:h1>R.E.M.</h:h1></artist></tour>

Namespaces werden durch xmlns:XX-Attribute festgelegt, wobei XX dem symboli-schen Bezeichner entspricht. Dem eigentlichen Tag-Namen wird dieser Bezeichnervorangestellt, im Beispiel wurde aus dem HTML-Tag h1 ein Tag h:h1, da derXHTML-Namespace, in dem h1 definiert ist, mit dem symbolischen Bezeichner hversehen wurde. Tags ohne explizite Namespace-Angabe werden dem Standard-Namespace zugeordnet. Dessen Definition erfolgt durch das xmlns-Attribut des Wur-zelknotens.

<artist>R.E.M.</artist>

Das Element artist wird Kindelement des ihm ubergeordneten Elements tour ge-nannt. Analog sind title und event Kinder von tour; place und date sind Kin-der von event. Jedes ”offnende“ Tag (<tour>, <artist>, <date>, ...) muss wiedergeschlossen werden. Dies geschieht durch Angabe des Tag-Namens mit einem voran-gestellten Schragstrich (/), z.B. </tour>. Besitzt das Element keine Kindelemente,wie z.B. das Element date, so kann der Schragstrich auch vor die schließende Klam-mer des offnenden Tags geschrieben werden (<date />), diese Schreibweise ist zu<date></date> aquivalent.Ein Kind-Element muss sich vollstandig innerhalb des Eltern-Elements befinden, d.h.es wird nach dem offnenden Tag des Eltern-Elements definiert und vor dem schlie-ßenden Tag des Eltern-Elements geschlossen. Durch diese Konstruktionsvorschriftbilden die Elemente eines XML-Dokuments einen Baum, dessen Wurzelknoten ge-rade das Wurzelelement des Dokuments ist.Besitzt ein XML-Element mehrere Kinder, so bilden die Kind-Elemente eine Listeund keine Menge oder Multimenge.

<date day="17" month="2" year="2005" hour="20" minute="0" />

2wobei es sich um einen URN und nicht um eine URL handelt

2 WS 2004/05, Gunar Fiedler, ISE@CAU

XML-Verarbeitung in Java 2 XML-Verarbeitung

Jedes Element kann Attribute haben. Attribute besitzen einen Namen und einenWert aus dem Wertebereich eines atomaren Datentyps, z.B. eine Zeichenkette odereine Zahl. Attribute werden innerhalb der Klammern des offnenden Tags eines Ele-ments durch die Angabe name="value" definiert. Der Wert des Attributs muss stetsin Hochkommata eingeschlossen werden. Ein Element kann beliebig viele Attributebesitzen. Auch Attribute werden in Namespaces eingeteilt.

<artist>R.E.M.</artist>

Jedes Element kann Text beinhalten. Es ist moglich, Kind-Elemente und Text-Abschnitte zu mischen. Falls der Text eines Elements selbst Tags enthalt, die abernicht interpretiert werden sollen (wie <pre>-Abschnitte in HTML bzw. die verbatim-Umgebung in LATEX), so muss er in eine CDATA-Section eingeschlossen werden:

<event><travelinfo><![CDATA[ <strong>PKW</strong><br />Fahren Sie ...]]>

</travelinfo></event>

Neben den vorgestellten Strukturierungselementen gibt es noch zwei weitere: Kom-mentare und Processing Instructions. Ein Kommentar wird durch die Markierungen eingeschlossen:



Eine Processing Instruction ist, wie der Name schon sagt, eine Verarbeitungsanwei-sung fur die Anwendung, welche das XML-Dokument liest und verarbeitet. Sie wirdin <? und ?> Markierungen eingeschlossen. Eine wichtige Processing Instruction istz.B. die Angabe eines fest zugeordneten Stylesheets (siehe auch Abschnitt 4.1):

<?xml-stylesheet type="text/xsl" href="renderAsHTML.xsl"?>

Ein XML-Dokument heißt ”well formed“, wenn es die dargestellte Syntax einhalt.Falls es zusatzlich einem gegebenen Schema bzw. einer DTD3 entspricht, nennt manes ”valid“.

2 XML-Verarbeitung

XML-Dokumente sind zunachst einmal reine Textdateien. Um mit den Informatio-nen in diesen Dateien arbeiten zu konnen, muss ein Programm den Inhalt der Datei

3Document Type Definition, eine alternative Moglichkeit, die Struktur festzulegen, siehe auchAbschnitt 3

WS 2004/05, Gunar Fiedler, ISE@CAU 3

2 XML-Verarbeitung XML-Verarbeitung

analysieren und die kodierten Informationen extrahieren. Vor dieser Aufgabe stehtjedes Programm, das XML-Daten verarbeitet, deshalb existieren diverse Laufzeitbi-bliotheken, die diese Schritte unterstutzen.Fur die Verarbeitung von XML-Daten haben sich zwei wesentliche Ansatze durch-gesetzt: SAX und DOM. Die ”Simple API for XML“ (SAX) stellt eine API bereit,mit deren Hilfe das Programm wahrend des Parsens der Datei auf gefundene To-ken (offnende und schließende Tags, Textelemente, ...) reagieren kann. Im Gegensatzdazu stellt das ”Document Object Model“ (DOM) eine objektorientierte Datenstruk-tur bereit, die das Dokument als Baum darstellt und Funktionen zum Traversierenanbietet.SAX und DOM sind sprachunabhangige Spezifikationen, es existieren Implementie-rungen fur alle in der Praxis eingesetzten Programmiersprachen. Wir konzentrierenuns hier auf die Java API for XML und die Bibliothek ”Xerces“.

2.1 Einlesen von XML-Dokumenten mittels SAX

SAX bietet dem Programmierer ein ereignisgesteuertes Zugriffsmodell auf XML-Datenstrome. Ein Parser analysiert das XML-Dokument und erzeugt bei Auftreteneines bestimmten Tokens ein Ereignis, auf welches das Programm reagiert.Folgende Ereignisse werden durch den SAX-Parser erzeugt:

• startDocument: Beginn des Parsens eines Dokuments

• endDocument: Ende des Parsens eines Dokuments

• startElement(namespace, name, qname, attrs): Ein offnendes Tag wurdegefunden. Der Parser teilt dem Programm den Namespace, den Namen, denqualifizierten Namen4 und die Attributliste mit.

• endElement(namespace, name, qname): ein schließendes Tag wurde gefun-den

• characters(buf[], offset, len): Liefert len Zeichen im Puffer buf[] ander Stelle offset

• ... analoge Ereignisse fur die restlichen Elemente

2.1.1 Das Grundgerust eines SAX-basierten Programms

Der SAX-Parser braucht ein Handler-Objekt, an das er seine Ereignisse schickenkann. Die Klasse dieses Objekts muss das ContentHandler-Interface implementie-ren. Dieses Interface stellt zu den Ereignissen korrespondierende Methoden bereit.Die Klasse DefaultHandler entspricht diesen Anforderungen, sie implementiert lee-re Methoden fur alle SAX-Ereignisse. Man kann seine eigenen Handler-Klassen vonDefaultHandler ableiten:

4Die Kombination aus Namespace und Namen, falls der Parser Namespaces nicht bearbeitet, sinddie Parameter namespace und name leer.



pub l i c c l a s s MyHandler extends De fau l tHand l e r{

/∗ . . . ∗/}

Als nachstes mussen die Methoden fur die gewunschten Ereignisse uberschriebenwerden. Angenommen, wir wollen unser Beispiel-XML-Dokument bearbeiten und dieNamen aller Veranstaltungsorte ausgeben. Wir mussen also das Ereignis startElementabfangen und das name-Attribut ausgeben:

pub l i c c l a s s MyHandler extends De fau l tHand l e r{

pub l i c void s t a r tE l emen t ( S t r i n g namespaceURI ,S t r i n g sName ,S t r i n g qName ,A t t r i b u t e s a t t r s )

throws SAXException{

// Element−NameS t r i n g eName = sName ;

// F a l l s Namespaces n i c h t v e r a r b e i t e t werden , nehmen w i r qNamei f ( ””. e qua l s ( eName ) ) eName = qName ;

i f ( ( ”p l a c e ”. e qua l s ( eName) && ( nu l l != a t t r s ) ){

// name−A t t r i b u t suchenf o r ( i n t i = 0 ; i < a t t r s . ge tLength ( ) ; i++){

S t r i n g aName = a t t r s . getLocalName ( i ) ;i f ( ””. e qua l s (aName ) ) aName = a t t r s . getQName ( i ) ;i f ( ”name ”. e qua l s (aName ) ){

// Ausgabe des WertesSystem . out . p r i n t l n ( a t t r s . ge tVa lue ( i ) ) ;

}}

}}

}

Auch die anderen SAX-Ereignisse werden durch Uberschreiben der jeweils korre-spondierenden Methoden behandelt, nahere Hinweise sind in der Dokumentationder API des ”Java Web Service Development Packs“ unter ContentHandler undDefaultHandler zu finden.



Soll ein XML-Dokument verarbeitet werden, mussen folgende Schritte unternommenwerden:

1. Ein geeigneter Handler ist zu implementieren.

2. Ein Parser ist zu instanziieren. Es existieren verschiedene Parser-Implementierungen,jeweils mit eigenen Starken und Schwachen. Die Instanziierung erfolgt nachdem Factory-Prinzip5.

3. Durch den Aufruf der Methode parse wird der Vorgang gestartet.

// D ie s e B i b l i o t h e k e n und K la s s en werden t y p i s c h e r w e i s e b e n o e t i g timport org . xml . sax . ∗ ;import org . xml . sax . h e l p e r s . De f au l tHand l e r ;import j a v a x . xml . p a r s e r s . SAXParserFactory ;import j a v a x . xml . p a r s e r s . P a r s e rC o n f i g u r a t i o nE x c e p t i o n ;import j a v a x . xml . p a r s e r s . SAXParser ;

/∗ . . . ∗/

pub l i c void parseDocument ( F i l e f ){

t ry{

// i n s t a n z i i e r e n des Hand l e r sDe fau l tHand l e r h and l e r = new MyHandler ( ) ;

// Fac to r y e r zeugenSAXParserFactory f a c t o r y = SAXParserFactory . new Ins tance ( ) ;

// Parse r−I n s t a n z e r zeugenSAXParser p a r s e r = f a c t o r y . newSAXParser ( ) ;

// pa r s en mit unserem Hand le rp a r s e r . p a r s e ( f , h and l e r )

}catch ( Excep t i on e ){

e . p r i n t S t a c kT r a c e ( ) ;/∗ . . . ∗/

}}

/∗ . . . ∗

5siehe Software-Pattern



2.2 Verarbeiten von XML-Dokumenten mit DOM

Im Gegensatz zum parsenden Ansatz von SAX ist DOM ein speicherinternes Formatzum Bearbeiten von XML-Daten. DOM definiert eine Reihe von Interfaces, mit derenHilfe man sich durch die Baumstruktur des Dokuments bewegen kann.

2.2.1 Die Elemente von DOM

DOM stellt ein Dokument als eine Hierarchie von Node-Objekten dar. Je nach Kno-tentyp implementieren diese Objekte auch spezialisierte Interfaces. Die wichtigstenInterfaces sind:

Document reprasentiert ein XML-DokumentDocumentFragment reprasentiert einen ”Teilwald“ des Dokumenten-BaumsElement reprasentiert ein Element des XML-DokumentsAttr reprasentiert ein Attribut eines ElementsText reprasentiert einen TextabschnittComment reprasentiert einen Kommentar

Diese Interfaces definieren Methoden zum Durchmustern der Hierarchie. Nahere In-formationen zum Datenmodell findet man unter http://www.w3.org/DOM/DOMTR.

2.2.2 Die Arbeit mit DOM

Die Arbeit mit DOM-Strukturen impliziert folgende Teilaufgaben:

Einlesen / Erstellen eines Dokuments Es existieren zwei Wege, eine DOM-Strukturzu erzeugen: ”from scratch“ oder durch Einlesen bestehender XML-Daten. BeidenMethoden ist gemeinsam, dass ein Dokumenten-Baum durch einen sogenanntenDocumentBuilder initialisiert wird:

DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();DocumentBuilder builder = factory.newDocumentBuilder();

Ein neues, leeres Dokument wird durch den Aufruf der Methode newDocument er-zeugt:

Document doc = builder.newDocument();

Ein bestehendes Dokument, z.B. eine XML-Datei oder ein XML-Datenstrom auseiner anderen beliebigen Quelle, kann uber einen Parser in einen DOM-Baum uber-fuhrt werden. Im Standardfall geschieht dies uber den Aufruf der Methode parse:

Document doc = builder.parse( new File("inputfile.xml"));

Neben Objekten der Klasse File sind auch InputStreams, InputSources und URIsmogliche Datenquellen fur den Parser.


http://www.w3.org/DOM/DOMTR


Traversieren und Verandern Die Knoten-Objekte eines DOM-Baums sind diesemBaum fest zugeordnet. Neue Knoten werden uber die entsprechenden createXXX-Methoden des Dokumentenobjekts erzeugt:

Element tour = doc.createElement("tour");Element artist = doc.createElement("artist");Text artistValue = doc.createTextNode("R.E.M.");/* ... */

Fur Attribute eines Elements existiert im Interface Element die setAttribute-Methode:

Element place = doc.createElement("place");place.setAttribute("name","ColorLine Arena");

Nach ihrer Definition mussen die Elemente zu einem Baum zusammengefugt werden:

artist.appendChild(artistValue);tour.appendChild(artist);doc.appendChild(tour); // das Wurzelelement

Weiterhin stellen die DOM Interfaces Methoden zum Traversieren des Baumes zurVerfugung:

getDocumentElement gibt den Wurzelelement des Baumes zuruckgetAttribute gibt den Wert eines Attributs zuruckgetElementsByTagName liefert eine Liste aller Kindelemente mit einem bestimmten

Tag-NamengetChildNodes gibt eine Liste aller Kindelemente zuruckgetPreviousSibling gibt den Knoten zuruck, der den gleichen Vaterknoten hat

und in der Liste der Kinder des Vaters vor dem Ausgangs-knoten liegt

getNextSibling analoggetParentNode gibt den Vaterknoten zuruck...

Zum Verandern des Baumes stehen ebenfalls Methoden bereit:

insertBefore fugt einen neuen Knoten einsetAttribute setzt ein Attribut eines ElementsremoveAttribute entfernt ein AttributremoveChild entfernt einen Knoten aus der Liste der KinderreplaceChild ersetzt einen Knoten in der Liste der KinderimportNode importiert einen Knoten aus einem anderen Dokument, der

Knoten kann anschließend in die Struktur eingefugt werden...



Ausschreiben / Serialisieren Eine DOM-Hierarchie ist eine interne Speicherstruk-tur. Zum Abspeichern oder fur den Datenaustausch ist es notwendig, das DOM-Dokument wieder in ein XML-Dokument, also eine Textdatei bzw. einen Zeichen-strom, umzuwandeln. Dies kann auf verschiedene Art und Weise geschehen; z.B. zuFuß, indem man den Baum traversiert und entsprechende Ausgaben tatigt.Da diese Aufgabe fur XML-verarbeitende Programme haufig anfallt, bietet die Xerces-Bibliothek vorgefertigte Klassen, um den Prozess der Serialisierung zu automatisie-ren. Durch ein Objekt der Klasse XMLSerializer kann man sich aus einem DOM-Dokument einen XML-Datenstrom erzeugen lassen. Mit Hilfe der Klasse OutputFormatstellt man notwendige Format-Parameter ein:

OutputFormat format = new OutputFormat(doc);format.setEncoding("UTF-8"); // Kodierung setzenformat.setIndenting(true); // Einruckung aktivierenformat.setIndent(2); // 2 Zeichen einruckenformat.setLineWidth(75); // maximale Zeilenbreite

FileOutputStream f = new FileOutputStream("outputfile.xml");XMLSerializer out = new XMLSerializer(f,format);out.serialize(doc);f.close();

Notwendige Packages Um mit DOM zu arbeiten, werden typischerweise folgendePackages benotigt:

javax.xml.parsers.* DocumentBuilder, DocumentBuilderFactory, etc.org.xml.sax.* parser-spezifische Klassenjava.io.* Ein- und Ausgabeorg.w3c.dom.* die DOM Interfacesorg.apache.xml.serialize.* Serialisierung (Xerces-spezifisch)

2.2.3 Ein zusammenhangendes Beispiel

Das folgende Listing zeigt ein Codefragment, das ein DOM-Dokument einliest, umeinen Teilbaum erweitert und ausschreibt. Zu Begin habe die Datei diesen Inhalt:

<?xml version="1.0" encoding="UTF-8"?><tour><artist>R.E.M.</artist><title>Tour 2005</title><event><place name="ColorLine Arena"><address>Sylvesterallee, 22525 Hamburg</address>

</place>



<date day="17" hour="20" minute="0" month="2" year="2005"/></event>

</tour>

Das Listing:

import j a v a x . xml . p a r s e r s . ∗ ;import org . xml . sax . ∗ ;import j a v a . i o . ∗ ;import org . w3c . dom . ∗ ;import org . apache . xml . s e r i a l i z e . ∗ ;

/∗ . . . ∗/

// Erzeugen des DokumentsDocumentBu i lde rFacto ry f a c t o r y = DocumentBu i lde rFacto ry . new Ins tance ( ) ;DocumentBui lder b u i l d e r = f a c t o r y . newDocumentBui lder ( ) ;Document doc = b u i l d e r . newDocument ( ) ;

// tou r i s t das Wurze le l ementElement t ou r = doc . getDocumentElement ( ) ;

// Erzeugen de r Elemente und E r s t e l l u n g des Te i lbaumsElement even t = doc . c r e a t eE l emen t ( ”even t ” ) ;Element p l a c e = doc . c r e a t eE l emen t ( ”p l a c e ”) ;p l a c e . s e t A t t r i b u t e ( ”name ” , ”Arena L e i p z i g ” ) ;Element add r e s s = doc . c r e a t eE l emen t ( ”add r e s s ” ) ;a dd r e s s . appendCh i ld ( doc . c reateTextNode ( ”Am Sport forum , 04105 L e i p z i g ” ) ) ;p l a c e . appendCh i ld ( add r e s s ) ;e ven t . appendCh i ld ( p l a c e ) ;Element date = doc . c r e a t eE l emen t ( ”date ”) ;date . s e t A t t r i b u t e ( ”day ” , ”13 ”) ;date . s e t A t t r i b u t e ( ”month ” , ”2 ”) ;date . s e t A t t r i b u t e ( ”yea r ” , ”2005 ”) ;date . s e t A t t r i b u t e ( ”hour ” , ”20 ”) ;date . s e t A t t r i b u t e ( ”minute ” , ”0 ”) ;even t . appendCh i ld ( date ) ;

// w i r fuegen das neue Element vo r dem e r s t e n ”even t ” e i n// f a l l s b i s h e r k e i n ”even t ” e x i s t i e r t , w i rd das neue E r e i g n i s// am Ende de r K i n d l i s t e e i n g e f u e g tNodeL i s t e v en t s = tou r . getElementsByTagName ( ”even t ” ) ;i f ( e v en t s . ge tLength ( ) > 0 ){

t ou r . i n s e r t B e f o r e ( event , e v en t s . i tem ( 0 ) ) ;}e l s e{

t ou r . i n s e r t B e f o r e ( event , nu l l ) ;


XML-Verarbeitung in Java 3 XML Schema

}

// Aus s ch r e i b en de r Date iOutputFormat format = new OutputFormat ( doc ) ;fo rmat . s e tEncod ing ( ”UTF−8”) ;fo rmat . s e t I n d e n t i n g ( true ) ;fo rmat . s e t I n d e n t ( 2 ) ;fo rmat . s e tL ineWid th ( 7 5 ) ;fo rmat . s e tP r e s e r v eSpa c e ( f a l s e ) ;

F i l eOutputSt r eam f o s = new F i l eOutputSt r eam ( ”o u t p u t f i l e . xml ” ) ;XMLSe r i a l i z e r output = new XMLSe r i a l i z e r ( fo s , fo rmat ) ;output . s e r i a l i z e ( doc ) ;f o s . c l o s e ( ) ;

/∗ . . . ∗/

Die Datei outputfile.xml hat anschließend diesen Inhalt:

<?xml version="1.0" encoding="UTF-8"?><tour><artist>R.E.M.</artist><title>Tour 2005</title><event><place name="Arena Leipzig"><address>Am Sportforum, 04105 Leipzig</address>

</place><date day="13" hour="20" minute="0" month="2" year="2005"/>

</event><event><place name="ColorLine Arena"><address>Sylvesterallee, 22525 Hamburg</address>

</place><date day="17" hour="20" minute="0" month="2" year="2005"/>

</event></tour>

3 XML Schema

In den ersten Abschnitten haben wir XML allgemein als Datenbeschreibungsspracheeingefuhrt. Damit ein Programm XML-Daten verarbeiten kann, muss es allerdingswissen, welche Tags an welcher Stelle welche Bedeutung haben. Zumindest fur dieBeschreibung der Syntax eines XML-Dokuments gibt es explizite Beschreibungsmit-tel: Document Type Defintions (DTDs) und XML-Schemata. Mit letzterem wollenwir uns hier beschaftigen.


3 XML Schema XML-Verarbeitung

Ein XML-Schema ist selbst wieder ein XML-Dokument, in dem festgehalten wird,welche Elemente auf welche Art und Weise innerhalb eines Instanz-Dokuments vor-kommen durfen. Der Tag-Name des Wurzelelements des Schema-Dokuments istschema aus dem Namespace http://www.w3.org/2001/XMLSchema:

<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"targetNamespace="http://www.is.informatik.uni-kiel.de/events"xmlns="http://www.is.informatik.uni-kiel.de/events">



</xsd:schema>

Mittels des Attributs targetNamespace wird der Namespace angegeben, dessen Ele-mente hier beschrieben werden. Mit Hilfe von xsd:element-Tags werden einzelneElemente definiert. Es wird unterschieden zwischen einfachen und komplexen Ty-pen. Ein Element mit einem einfachen Typ enthalt genau einen Textwert aus demWertebereich des Typs, z.B. eine Zeichenkette oder eine Zahl. Elemente mit kom-plexem Typ enthalten Attribute, Unterelemente und / oder gemischten Inhalt. FurUnterelemente und Attribute lassen sich Kardinalitatsbedingungen und Standard-werte angeben. Um die Wiederverwendung von Schema-Elementen zu unterstutzen,bietet XML-Schema diverse Mechanismen zur Definition und Verwaltung von Typenan.Eine Moglichkeit, das Schema unseres Beispieldokuments zu beschreiben, ist diefolgende:

<?xml ver s ion=”1 .0 ” encod ing=”UTF−8”?><xsd : schema xm ln s : x s d=”h t t p : //www.w3 . org /2001/XMLSchema”

targetNamespace=”h t t p : //www. i s . i n f o rma t i k . uni−k i e l . de/ even t ”xmlns=”h t t p : //www. i s . i n f o rma t i k . uni−k i e l . de/ even t ”>

<!−− e i n w i ede r v e rwendba r e r komplexe r Typ −−><xsd :complexType name=”eventType ”>

<!−− d i e Elemente s o l l e n i n de r angegebenenRe i h e n f o l g e a u f t r e t e n −−>

<x s d : s e qu en c e><!−− 1 . K inde l emen t : p l a c e −−><x s d : e l emen t name=”p l a c e ”>

<!−− e i n anonymer komplexe r Typ −−><xsd :complexType>

<x s d : s e qu en c e><!−− 1 . Kinde lement von p l a c e : a dd r e s s −−><x s d : e l emen t name=”add r e s s ” type=”x s d : s t r i n g ” />

</ x s d : s e qu en c e><!−− A t t r i b u t : name −−><x s d : a t t r i b u t e name=”name ” type=”x s d : s t r i n g ”

use=”r e q u i r e d ” />

XML-Verarbeitung in Java 3 XML Schema

</ xsd :complexType></ x s d : e l emen t><!−− 2 . K inde l ement : date −−><x s d : e l emen t name=”date ”>

<xsd :complexType><!−− A t t r i b u t : day −−><x s d : a t t r i b u t e name=”day ”>

<x sd : s imp l eType><!−− e i n e I n t e g e r−Zahl von 1 b i s 31 −−>< x s d : r e s t r i c t i o n base=”x s d : i n t e g e r ”>

<x s d : m i n I n c l u s i v e v a l u e=”1 ” /><x s d :ma x I n c l u s i v e v a l u e=”31 ” />

</ x s d : r e s t r i c t i o n></ x sd : s imp l eType>

</ x s d : a t t r i b u t e><!−− A t t r i b u t month , w i r l a s s e n d i e E in sch raenkung

de r U e b e r s i c h t l i c h k e i t wegen weg −−><x s d : a t t r i b u t e name=”month ” type=”x s d : i n t e g e r ” /><!−− A t t r i b u t e y ea r −−><x s d : a t t r i b u t e name=”yea r ” type=”x s d : i n t e g e r ” /><!−− A t t r i b u t hour −−><x s d : a t t r i b u t e name=”hour ” type=”x s d : i n t e g e r ” /><!−− A t t r i b u t minute −−><x s d : a t t r i b u t e name=”minute ” type=”x s d : i n t e g e r ” />

</ xsd :complexType></ x s d : e l emen t>

</ x sd : s e qu en c e></ xsd :complexType>

<!−− das Wurze le l ement t ou r −−><x s d : e l emen t name=”tou r ”>

<xsd :complexType><x s d : s e qu en c e>

<!−− zunaechs t e i n Kinde lement a r t i s t −−><x s d : e l emen t name=”a r t i s t ” type=”x s d : s t r i n g ” /><!−− danach e i n Kinde lement t i t l e −−><x s d : e l emen t name=” t i t l e ” type=”x s d : s t r i n g ”

minOccurs=”1 ” maxOccurs=”1 ” /><!−− e i n e L i s t e von event−Elementen −−><x s d : e l emen t name=”even t ” type=”eventType ”

minOccurs=”0 ” maxOccurs=”unbounded ” /></ x s d : s e qu en c e>

</ xsd :complexType></ x s d : e l emen t>

</ xsd : schema>


4 XSL Transformationen XML-Verarbeitung

4 XSL Transformationen

Aufbauend auf dem XML-Standard ist die EXtensible Stylesheet Language eineSprache, um Transformationen von XML-Dokumenten zu beschreiben. In sogenann-ten Stylesheets werden Regeln angegeben, wie ein XML-Dokument einer bestimmtenStruktur in ein Dokument mit einer anderen Struktur uberfuhrt wird. Das Ausgabe-Dokument ist entweder wieder ein XML- oder Text-Dokument, bei Nutzung vonFormating Objects (FOs) kann aber z.B. auch ein PDF-Dokument gerendert wer-den.

4.1 Stylesheets

Ein Stylesheet ist selbst eine XML-Datei, welche die Transformationsregeln be-schreibt. Das Wurzelelement jedes Stylesheets ist ein stylesheet-Element aus demNamespace http://www.w3.org/1999/XSL/Transform:

<xsl:stylesheet version="1.0"xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

<xsl:output method="html"/>



</xsl:stylesheet>

Mit Hilfe des Elements xsl:output wird der Typ des Ausgabedokuments bestimmt,z.B. html oder xml. Im Anschluss konnen die Transformationsregeln definiert wer-den. Dies geschieht uber Templates. Einem Template wird ein XPath-Ausdruck6

zugeordnet. Erfullt ein zu verarbeitendes Element mit seinen Eigenschaften diesenAusdruck, so wird das Template fur dieses Element ausgefuhrt und erzeugt eineAusgabe. Was ausgegeben werden soll, wird in den Rumpf des Templates geschrie-ben. Beispielsweise soll das Wurzelelement tour unseres Dokuments transformiertwerden. Dafur definieren wir ein Template, das bei Auftreten von /tour - also tourdirekt an der Wurzel - aufgerufen wird.

<xsl:template match="/tour"><html><head><title>Veranstaltungskalender</title></head><body><h1><xsl:apply-templates select="artist" />:<xsl:apply-templates select="title" />

</h1>

6siehe Abschnitt 4.2

XML-Verarbeitung in Java 4 XSL Transformationen

<xsl:apply-templates select="event" /></body>

</html></xsl:template>

Die xsl-Elemente veranlassen den Stylesheet-Prozessor zu bestimmten Aktionen.Alles, was nicht dem xsl-Namespace entstammt, wird in die Ausgabe kopiert. Imobigen Beispiel sehen wir ein wichtiges xsl-Tag: xsl:apply-templates. Mit Hilfedieses Tags werden kontext-abhangig weitere Templates aufgerufen. Das select-Attribut enthalt einen XPath-Ausdruck, der relativ zum aktuellen Element die zubearbeitenden Elemente auswahlt.

<xsl:template match="artist"><xsl:value-of select "text()" />

</xsl:template>

Mit Hilfe des xsl-Elements value-of kann der Wert eines Ausdrucks bestimmt wer-den. Dies kann z.B. ein Element, ein Attribut, der Aufruf einer xsl-Funktion, aberauch eine komplexere Berechnung sein.

<xsl:value-of select="date/@day" />.

Dieser Ausdruck gibt zum Beispiel den Wert des Attributs day des Unterelementsdate zuruck. Attributnamen wird stets das @-Zeichen vorangestellt.XSL definiert eine Reihe von Tags zur Ablaufsteuerung, die wichtigsten sind in dernachfolgenden Tabelle zusammengestellt:

<xsl:if test=""></xsl:if> wenn der Ausdruck im Attribut test wahr ist,wird der eingeschlossene Teil des XSL-Codesausgefuhrt. <xsl:if> unterstutzt kein else. MitHilfe von test="XPath-Ausdruck" lasst sich dieExistenz eines Elements (oder Atributs) uber-prufen: <xsl:if test="artist"> pruft, ob einUnterelement artist existiert.

<xsl:for-each select=""> iteriert uber eine Menge von Elementen.<xsl:choose> analog zu switch- oder case-Statements

wird ein bestimmter Code-Block abhan-gig von einer Bedingung ausgefuhrt. Dieeinzelnen Bedingungen und Blocke werdendurch <xsl:when test="">-Blocke definiert.<xsl:otherwise> definiert den ”else“-Block.Man beachte, dass ein if-then-else-Block mitHilfe von xsl:choose formuliert werden muss.

<xsl:text> erzeugt Ausgabetext<xsl:comment> erzeugt einen Kommentar



<xsl:copy> kopiert das aktuelle Element in den Ausgabe-strom

<xsl:copy-of select="" /> kopiert einen Teilbaum, der per XPath imselect-Attribut ausgewahlt wird, in die Aus-gabe

Daruber hinaus bietet XSL einige weitere Moglichkeiten, z.B. fur die Parametrisie-rung und Wiederverwendung von Stylesheets und Templates. Es sei auf weiterfuh-rende Literatur verwiesen.

4.2 XPath

4.2.1 Grundlagen der Adressierung

Eine haufige Aufgabenstellung innerhalb von XSL-Stylesheets ist das Selektierenvon Elementen. Dies geschieht navigierend uber die Definition von relativen oderabsoluten Pfaden.XPath-Ausdrucke erinnern stark an Verzeichnisnamen und sind folgendermaßen auf-gebaut:

• der Schragstrich / wird als Separator zwischen Bezeichnern benutzt: event/place

• absolute Pfade, die beim Wurzelelement starten, beginnen mit einem Schrag-strich: /tour/artist, alle anderen Pfade sind relativ zum aktuellen Element(dem aktuellen Kontext) definiert.

• zwei Punkte verweisen auf das Elternelement des aktuellen Elements: ../place

• ein Punkt referenziert das aktuelle Element: ./date

Ein Ausdruck wie event/place selektiert alle place-Elemente unter allen event-Elementen. Mochte man in dieser Liste ein bestimmtes Element referenzieren, sofugt man den Index in eckigen Klammern an den Bezeichner an. event[1]/placeselektiert alle place-Elemente des ersten event-Elements. Falls weitere OperationenEindeutigkeit erfordern, wird jeweils das erste Element der Liste genutzt.Attributen wird das @-Zeichen vorangestellt: event/place/@name selektiert das name-Attribut des Elements unter event/place.

4.2.2 XPath-Ausdrucke und Wildcards

Bedingungen an Elemente werden in eckigen Klammern dem Bezeichner angehangt.place[@name=’ColorLine Arena’] selektiert das place-Element, dessen Attributname den Wert ColorLine Arena hat. event[date] selektiert alle event-Elemente,die ein date-Unterelement haben.Ein Stern (*) anstelle eines Bezeichners fungiert als Wildcard, er selektiert alle Be-zeichner. Analog selektiert @* alle Attribute. Der Ausdruck /*/* selektiert jedes Ele-ment auf der zweiten Hierarchieebene. Mochte man ein Element auf einer beliebigen


XML-Verarbeitung in Java 4 XSL Transformationen

Ebene selektieren, so schreibt man //: .//place selektiert alle place-Elemente, dieirgendwo im aktuellen Teilbaum stehen.

4.3 Ein zusammenhangendes Beispiel

Das folgende Listing zeigt ein Stylesheet, das fur unser Beispieldokument eine HTML-Ausgabe erzeugt:

<?xml ver s ion=”1 .0 ” encod ing=”UTF−8” ?>

< x s l : s t y l e s h e e t vers ion=”1 .0 ”xm l n s : x s l=”h t t p : //www.w3 . org /1999/XSL/Transform ”>

<x s l : o u t p u t method=”html ”/>

<x s l : t e m p l a t e match=”/ ”><x s l : a p p l y −t emp l a t e s s e l e c t=”tou r ” />

</ x s l : t e m p l a t e>

<x s l : t e m p l a t e match=”tou r ”><html>

<head>< t i t l e>Ve r a n s t a l t u n g s k a l e n d e r</ t i t l e></head><body>

<h1><x s l : a p p l y −t emp l a t e s s e l e c t=” a r t i s t ” /> :<x s l : a p p l y −t emp l a t e s s e l e c t=” t i t l e ” />

</h1><t a b l e c o l s=”3 ”>

<x s l : a p p l y −t emp l a t e s s e l e c t=”even t ” /></ t a b l e>

</body></html>


<x s l : t e m p l a t e match=”a r t i s t ”><x s l : v a l u e −o f s e l e c t=”t e x t ( ) ” />


<x s l : t e m p l a t e match=” t i t l e ”><x s l : v a l u e −o f s e l e c t=”t e x t ( ) ” />


<x s l : t e m p l a t e match=”even t ”><t r>

<td><x s l : v a l u e −o f s e l e c t=”date /@day ” /> .<x s l : v a l u e −o f s e l e c t=”date /@month ” /> .<x s l : v a l u e −o f s e l e c t=”date /@year ” />

</ td>



<td><x s l : v a l u e −o f s e l e c t=”date /@hour ” /> :<x s l : v a l u e −o f s e l e c t=”date /@minute ” />

</ td><td>

<x s l : v a l u e −o f s e l e c t=”p l a c e /@name ” /></ td>

</ t r></ x s l : t e m p l a t e>

</ x s l : s t y l e s h e e t>

4.4 XSLT mit Xalan

Die Xalan-Bibliothek bietet Klassen, mit deren Hilfe XSL Transformationen durch-gefuhrt werden konnen. Die zentrale Klasse ist javax.xml.transform.Transformer.Sie erzeugt aus einem Eingabedokument und einem Stylesheet ein Ausgabedoku-ment:

// d i e b e no e t i g t e n Packagesimport j a v a x . xml . t r an s f o rm . ∗ ;import j a v a x . xml . t r an s f o rm . st ream . ∗ ;import j a v a x . xml . t r an s f o rm . dom . ∗ ;

/∗ . . . ∗/

// d i e E i ngabeda t e i e nStreamSource s t y l e s h e e t =

new StreamSource (new F i l e ( ” s t y l e s h e e t . x s l ” ) ) ;StreamSource i n F i l e =

new StreamSource (new F i l e ( ”i npu t . xml ” ) ) ;

// Ausgabedate iSt reamResu l t o u t F i l e = new St reamResu l t (new F i l e ( ”output . html ” ) ) ;

// Erzeugen des Trans fo rme r s uebe r e i n e Fac to ryTrans fo rme rFac to r y f a c t o r y = Trans f o rme rFac to r y . new Ins tance ( ) ;Trans fo rmer t r a n s f o rme r = f a c t o r y . newTransformer ( s t y l e s h e e t ) ;t r a n s f o rme r . t r an s f o rm ( i n F i l e , o u t F i l e ) ;

Anstelle der StreamSources und StreamResults konnen auch DOMSources und DOMResultsgenutzt werden, um DOM-Dokumente zu verarbeiten.Die Xalan-Bibliothek bietet auch einen XSL-Prozessor fur die Kommandozeile, derfolgendermaßen aufgerufen werden kann:

java org.apache.xalan.xslt.Process -IN inFile.xml \-XSL stylesheet.xsl -OUT outFile.html


XML-Verarbeitung in Java 5 Weiterfuhrende Literatur

5 Weiterfuhrende Literatur

• http://www.w3schools.com eine Menge guter Tutorials rund ums ThemaXML

• http://www.w3.org/TR/REC-xml W3C XML Recommendation

• http://www.w3.org/TR/xmlschema-0 W3C XML Schema Recommendation

• http://www.w3.org/TR/xsl W3C XSL Recommendation

• http://java.sun.com/xml/jaxp/docs.html Dokumentation zu JAXP

• http://xml.apache.org Dokumentation zu Xerces und Xalan


http://www.w3schools.com

http://www.w3.org/TR/REC-xml

http://www.w3.org/TR/xmlschema-0

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

http://java.sun.com/xml/jaxp/docs.html

http://xml.apache.org

XML-Verarbeitung in Javafiedler/teaching/ws2005/iis/XML... · SAX und DOM sind sprachunabh¨angige...

Documents

Transcript of XML-Verarbeitung in Javafiedler/teaching/ws2005/iis/XML... · SAX und DOM sind sprachunabh¨angige...