XML extensible Markup Language www.w3.org/xml Dr. Beatrice Amrhein
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
Verarbeiten von XML Dokumenten SAX: Simple Application Interface for XML org.xml.sax DOM: Document Object Model www.w3.org/dom StAX: Streaming API for XML javax.xml.stream 37
4 SAX: Simple Application Interface for XML 4.1 Was ist SAX? SAX definiert ein einfaches API für einen Event basierten Parser. Event basiert heisst, der Parser liest ein XML Dokument von Anfang bis Ende und benachrichtigt bei jeder erkannten syntaktischen Struktur (Element, Prozess Instruktion, Kommentar, Namespace-Definition,...) die Applikation. Die Benachrichtigung erfolgt durch Aufruf der entsprechenden Funktionen startdocument startelement endelement enddocument.... SAX funktioniert wie ein serieller I/O Stream In SAX ist kein Random Access möglich. Der Parser läuft linear durch das Dokument, zurückgehen auf eine frühere Position ist nicht möglich. SAX ist darum vor allem dann nützlich, wenn wir die Daten des XML Dokuments lesen oder gewisse Elemente heraus filtern (aber das Dokument nicht verändern oder bearbeiten) wollen. 4.2 Wofür ist SAX geeignet? Sax ist geeignet für das schnelle, effiziente Lesen oder Validieren von XML Dokumenten. für grosse Dokumente wenn wenig Speicher zur Verfügung steht. SAX benötigt wenig Speicher, da die gelesenen Daten nicht intern abgespeichert, sondern direkt an die Applikation weitergeleitet werden. falls keine Änderungen in der XML Struktur nötig sind. Wenn die XML Struktur oder die XML Daten verändert werden sollen oder die Daten nicht linear durchlaufen werden sollen, ist SAX nicht geeignet. Für solche Anwendungen sind XSLT, StAX oder DOM geeigneter. 4.3 Wie funktioniert SAX? Ganz zu Beginn beim Lesen wird ein startdocument Event erzeugt. Danach werden abhängig von der Struktur des XML Dokuments die folgenden Events erzeugt. <name> > 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. 38
4.4 Übersicht über das SAX API XMLReaderFactory Erzeugen eines XML Readers XMLReader Setzen der Parser Eigenschaften (validating, namespace-aware,...) ContentHandler Bietet verschiedene parse() Methoden an (aus File, InputStream, URI,...). Interface für die verschiedenen Event Handler Methoden start / enddocument, start / endelement(), characters,... ErrorHandler EntityResolver DefaultHandler Interface für die Fehlerbehandlung: error(), fatalerror(), warning() Interface für das Einlesen von Entities: resolveentity() Implementation der (Event-)Handler Interfaces. Implementiert (leere) Methoden für start-/enddocument start-/endelement, characters,... 39
Funktionsweise des XML Readers Main XMLReader ContentHandler ErrorHandler parse() start/enddocument() XML Document start/endelement() characters() Application EventHandler 4.5 Implementation des Default Handlers Um einen Sax-Parser zu schreiben, überschreibt man üblicherweise einfach die Klasse Default Handler. Da dort bereits alle vom Interface geforderten Methoden leer implementiert sind, müssen wir nur noch die von uns benötigten Methoden überschreiben. startdocument / enddocument Beim Parsen des XML Dokuments wird als erstes die Methode startdocument() aufgerufen. In dieser können alle Initialisierungs-Schritte ausgeführt werden. Ganz am Ende wird dann die Methode enddocument() aufgerufen, die zum Freigeben und Aufräumen aller benutzten Ressourcen verwendet werden kann. startelement public void startelement( String uri, // Namespace URI String lname, // lokaler Name String qname, // qualifizierter Name Attributes attrs) // Attribut-Liste throws SAXException Die Methode startelement() wird immer dann aufgerufen, wenn der Parser ein Start-Tag liest. Den Tag-Namen finden wir im Parameter qname (Tag-Name mit Namespace-Prefix, falls vorhanden), oder als lname (lokaler Name) und uri (Namespace). uri und lname können leere Strings sein, falls der Parser den Namespace ignoriert (durch Setzen der entsprechenden namespace-property). Im attrs-argument befindet sich die Liste aller Attribute. Falls keine Attribute vorhanden sind, ist attrs eine leere Attribut-Liste. In startelement können wir also die Attribute (name und value) des Elements lesen: if (attrs!= null) { for(int i = 0; i < attrs.getlength(); i++) { // Attribute name (local or qualified) String aname = attrs.getlocalname(i); if ("".equals(aname)) aname = attrs.getqname(i); // Attribute value String val = attrs.getvalue(i); 40
Die Attribute haben entweder einen lokalen Namen String getlocalname(int i) oder einen qualifizierten Namen (mit Namespace) String getqname(int i) Den Wert des Attributes erhalten wir entweder über den Listen-Index String getvalue(int i) oder über den Namen String getvalue(string aname). characters Der Parser ruft für jeden Textknoten (einmal oder mehrmals) die Methode characters auf. StringBuffer textbuffer = new StringBuffer(); public void characters( char chars[], // die Zeichen aus dem XML Dokument int start, // die Start-Position im Array int length ) // die Anzahl Zeichen, welche gelesen werden können throws SAXException { // Auslesen der Zeichen aus dem Puffer chars und // abspeichern in den Text-Puffer textbuffer.append(chars, start, length); Ein SAX Parser kann alle Zeichen des Dokuments auf einmal zurückgeben, oder sie in verschiedene Blöcke zerteilen. Das Argument start gibt an, wo im Puffer chars die für diesen Textknoten relevante Information anfängt. length gibt an, wie viele Zeichen des Puffers (ab Position start) zu diesem Aufruf gehören. endelement public void endelement( String uri, // Namespace URI String lname, // lokaler Name String qname ) // qualifizierter Name throws SAXException { // verarbeite den Inhalt des Elements // ev. aufräumen. Die endelement Methode wird bei jedem XML End-Tag (oder am Ende eines leeren Elements) aufgerufen. Da der Text Inhalt eines Elements oft in mehreren Blöcken eingelesen wird, ist es sinnvoll, den Text-Puffer aus der characters Methode erst in der endelement Methode zu verarbeiten. IgnorableWhitespace Die Methode ignorablewhitespace dient zur Behandlung der Whitespace Zeichen zwischen den Elementen. Leerzeichen wie Tabs oder Zeilenumbrüche zwischen den Elementen werden normalerweise ignoriert. Die Methode ignorablewhitespace kann zum Lesen/Behandeln dieser Zeichen verwendet werden. 41
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. 4.6 Fehlerbehandlung: ErrorHandler Warnungen werden während der Verarbeitung des DTD oder des Schemas erzeugt: Unnötige (doppelte) Deklarationen für Entities, Attribute oder Notations oder Fehler im Schema können zum Aufruf der Methode warning() führen. Ein Fehler (Aufruf von error()) entsteht, falls das XML-Dokument nicht dem Schema oder DTD entspricht, also das XML-Dokument nicht gültig ist. Die Methode fatalerror() wird aufgerufen, falls das XML-Dokument nicht wohlgeformt ist. Bei einem fatalerror bricht der Parser normalerweise ab. Um diese Fehler erkennen und bearbeiten zu können, ist es wichtig den ErrorHandler sinnvoll zu implementieren und Fehlermeldungen auszugeben. Die SAXParseException kennt die Zeile/Spalte, wo der Fehler im Dokument aufgetreten ist: e.getlinenumber() --> Ausgabe der Zeilen Nummer e.getcolumnnumber() --> Ausgabe der Spalten Nummer e.getlocalizedmessage() --> Ausgabe der Fehlermeldung 42
Ein SAX Beispiel Der DefaultHandler import org.xml.sax.*; import org.xml.sax.helpers.*; public class SAXExample extends DefaultHandler { public void startdocument() { System.out.println("StartDocument"); public void enddocument() { System.out.println("EndDocument"); public void startelement(string uri, String lname, String qname, Attributes attrs) { System.out.println("StartElement: " + qname); for (int i = 0; i < attrs.getlength(); i++) System.out.println(" " + attrs.getlocalname(i) + " = " + attrs.getvalue(i)); public void endelement(string uri, String lname, String qname) { System.out.println("EndElement: " + qname); public void characters(char[] chars, int start, int length) { String s = new String(chars, start, length); if ((s.trim()).length() > 0) System.out.println("Characters: " + s); public void warning(saxparseexception e) { System.out.print("Warning: at line " + e.getlinenumber() + " in column " + e.getcolumnnumber() + ": "); System.out.println(e.getLocalizedMessage()); public void error(saxparseexception e) { System.out.print("Error at line " + e.getlinenumber() + " in column " + e.getcolumnnumber() + ": "); System.out.println(e.getLocalizedMessage()); public void fatalerror(saxparseexception e) throws SAXException { System.out.print("Fatal error at line " + e.getlinenumber() + " in column " + e.getcolumnnumber() + ": "); throw new SAXException(e.getLocalizedMessage()); 43
Die Main Klasse import org.xml.sax.*; import org.xml.sax.helpers.xmlreaderfactory; public class Main { public static final String filename = "XML/catalog.xml"; private static final String schemafile = "catalog.xsd"; private static final String schemasource = "http://java.sun.com/xml/jaxp/properties/schemasource"; private static final String schemalanguage = "http://java.sun.com/xml/jaxp/properties/schemalanguage"; private static final String w3schema = "http://www.w3.org/2001/xmlschema"; private static final String validation = "http://xml.org/sax/features/validation"; private static final String schemavalidation = "http://apache.org/xml/features/validation/schema"; private static final String namespaces = "http://xml.org/sax/features/namespaces"; static public void main(string[] argv) { try { XMLReader xr = XMLReaderFactory.createXMLReader(); // XMLReader xr.setfeature(namespaces, false); xr.setfeature(validation, true); xr.setfeature(schemavalidation, true); xr.setproperty(schemalanguage, w3schema); xr.setproperty(schemasource, schemafile); SAXExample handler = new SAXExample(); // ContentHandler xr.setcontenthandler(handler); xr.seterrorhandler(handler); xr.parse(filename); catch (SAXParseException e) { System.out.println(e.getMessage()); catch (SAXException e) { System.out.println(e.getMessage()); catch (IOException e) { System.out.println(e.getMessage()); Ein vollständiges SAX Beispiel finden Sie auf der Übungsseite. 44
5 DOM: Das Document Object Model Was ist DOM? DOM definiert einen Standard zum Lesen und Bearbeiten von XML-Dokumenten. DOM stellt XML-Dokumente als Baumstruktur dar. DOM definiert eine Menge von Interfaces (Node, NodeList, Element, Attr,...) und eine Menge von Methoden darauf. DOM ist Plattform- und Sprach-unabhängig definiert. DOM ist ein W3C Standard. Die DOM Node Typen Der W3C Standard definiert die folgenden Knoten-Typen: Node nodename() nodevalue() attributes NodeType() Attr name of attribute value of attribute null 2 CDATASection #cdata-section content of the CDATA Section null 4 Comment #comment content of the comment null 8 Document #document null null 9 DocumentFragment #document-fragment null null 11 DocumentType document type name null null 10 Element tag name null NamedNode Map 1 Entity entity name null null 6 EntityReference name of entity referenced null null 5 Notation notation name null null 12 ProcessingInstruction target entire content excluding the target null 7 Text #text content of the text node null 3 45
5.1 Die org.w3c.dom Java Interfaces Für jeden Knoten-Typ definiert Java ein entsprechendes Interface im org.w3c.dom Package. Element für Elementknoten Attr für Attribute Text für Text Knoten Document für das Document Element Node für beliebige Knoten NodeList für Listen von Knoten ProcessingInstruction für Verarbeitungs-Anweisungen... Das Node Interface Das Node Interface definiert die Methoden zum Lesen und Bearbeiten von DOM Knoten: Node appendchild(node newchild) fügt einen neuen Knoten am Ende der Liste der Kind-Knoten ein. Node clonenode(boolean deep) Kopiert diesen Knoten (deep=true --> mit allen Kind-Knoten) NamedNodeMap getattributes() gibt eine NamedNodeMap zurück, welche die Attribute dieses Elements enthält oder null, falls der Knoten kein Elementknoten ist. NodeList getchildnodes() gibt eine NodeList mit allen Kindknoten zurück. Node getfirstchild() / getlastchild() gibt den ersten/letzten Kind-Knoten dieses Knotens zurück. String getlocalname() gibt den lokalen Namen (ohne Namespace Prefix) zurück. short getnodetype() / String getnodevalue() der Node Type / Node Value (gemäss Tabelle in Abschnitt 8.2) Node getparentnode() gibt den Elternknoten dieses Knotens zurück (falls er existiert). Node removechild(node oldchild) entfernt oldchild aus der Liste der Kinder dieses Knotens.... Das NodeList Interface Das NodeList Interface definiert Methoden zum Bearbeiten von (geordneten) Knotenmengen. Eine NodeList erhalten wir zum Beispiel als Rückgabewert von getchildnodes. Das NodeList Interface definiert die beiden Methoden int getlength() gibt die die Länge der Liste zurück. Node item(int n ) gibt das n-te Element der Liste (beginnend bei 0) zurück. 46
Das Document Interface Die wichtigsten Methoden des Document Interfaces sind NodeList getelementsbytagname(string tagname) NodeList getelementsbytagnamens(string namespace, String localname) gibt eine NodeList mit allen Elementen mit dem Namen tagname zurück. Die Reihenfolge der Liste ist die gleiche wie im XML-Dokument. Diese Methode ist im allgemeinen einfacher zu benutzen als die Methode getchildnodes, da hier alle zurückgegebenen Knoten Elementknoten sind. void normalizedocument() hat den gleichen Effekt, wie wenn das Dokument gespeichert und neu geladen würde. Das bedeutet, dass (beim validierenden DOM) erneut die Gültigkeit des Dokuments geprüft wird. So kann geprüft werden, ob ein Dom-Baum im Memory immer noch der im Schema vorgegebenen Struktur entspricht. Element getelementbyid(string id) gibt das eindeutige Element mit der ID id zurück (falls das Element existiert und die id als Id deklariert ist). Mit Hilfe dieser Methoden können Referenzen aufgelöst werden. Das Element Interface Die wichtigsten Methoden des Element Interfaces sind String getattribute(string name) String getattributens(string namespace, String localname) gibt den Inhalt des entsprechenden Attributs zurück (ohne / mit Namespace). void removeattribute(string name) removeattributens(string namespace, String localname) Löscht im Element das Attribute name (ohne / mit Namespace) void setattribute(string name, String value) / void setattributens(string ns, String name, String value) Fügt in das Element ein neues Attribut ein. NodeList getelementsbytagname(string tagname) NodeList getelementsbytagnamens(string namespace, String localname) gibt alle Nachfolger dieses Elements mit Namen tagname zurück (ohne/mit Namespace). void setidattribute(string name, boolean isid) void setidattributens(string ns, String localname, boolean idid) Falls isid gleich true ist, wird das entsprechende name Attribute zu einem ID-Attribut (es gibt keine Methode setidelement). Diese Methode wird vorallem im Zusammenhang mit getelementbyid() gebraucht. 47
48
49
50
51