Programmieren II XML. Heusch -- Ratz -- Institut für Angewandte Informatik

Transkript

1 Programmieren II XML Heusch -- Ratz -- KIT Universität des Landes Baden-Württemberg und nationales Großforschungszentrum in der Helmholtz-Gemeinschaft

2 Grundlegendes XML (Extensible Markup Language) XML ist eine Auszeichnungssprache. Mit XML können hierarchisch strukturierter Daten in Textdateien dargestellt werden. Daten können plattformunabhängig zwischen verschiedenen Anwendungen ausgetauscht werden. XML ist (ebenso wie HTML und XHTML) eine Untermenge von SGML (Standard Generalized Markup Language). Namespaces In XML gibt es Namensräume, in etwa vergleichbar mit den Packages in Java. Diese werden verwendet, damit (gleiche) Bezeichner in verschiedenen Zusammenhängen mit unterschiedlicher Bedeutung benutzt werden können. 2

3 Historie von Auszeichnungssprachen 1997 XML 1992 HTML WWW 1986 SGML 1960 Generalized Markup Internet 3

4 Eigenschaften von XML Konsequente Trennung zwischen Inhalt (Semantik) und Darstellung (Präsentation) Erweiterbar, eigene Tags können definiert werden Maschinen-les- und -prüfbar HTML ist ein Spezialfall von XML XML ist kein Ersatz für HTML, aber Ergänzung in vielen Bereichen Für normales Homepage-Design ist XML relativ uninteressant. HTML und CSS sind dafür längst zu leistungsfähig und angesichts ihrer Verbreitung kaum noch zu verdrängen 4

5 Grundlegende Struktur von XML-Dokumenten Ein XML-Dokument enthält strukturierte Elemente, die mittels Tags markiert werden. Ein Element kann einen Text oder weitere Elemente ( hierarchische Struktur) enthalten. Den Elementen können Attribute zugeordnet sein. Diese enthalten zusätzliche Informationen zu dem Element. Ein XML-Dokument besteht aus einer XML-Deklaration (optional), einem Wurzelelement mit seinen Unterelementen und ggf. weiteren Informationen wie Kommentaren. Beispiel: Party-Dokument <?xml version="1.0"?> <party datum=" "> <gast name="albert Angsthase"> <getraenk>wein</getraenk> <getraenk>bier</getraenk> <zustand ledig="true" nuechtern="false"/> </gast> </party> 5

6 Beschreibung der Struktur von XML-Dokumenten Zur formalen Beschreibung der Struktur von XML-Dokumenten gibt es hauptsächlich zwei Konzepte: DTD und XML Schema DTD (Document Type Definition) Eine DTD ist ein Satz an Regeln, um Dokumente eines bestimmten Typs zu deklarieren. Auf die DTD wird per DOCTYPE-Anweisung verwiesen. XML Schema Ein XML Schema definiert ebenfalls Art und Struktur von XML- Dokumenten und der enthaltenen Elemente. Leistungsfähiger als DTDs und sollen in Zukunft zunehmend DTDs ersetzen. 6

7 Formale Korrektheit von XML-Dokumenten Wohlgeformtheit (wellformed) Dokument syntaktisch korrekt? Passender Aufbau des XML-Dokumentes Korrekte Verschachtelung von Tags Attributwerte in " " Keine offenen Tags Gültigkeit (valid) Wohlgeformtheit und Entspricht einer DTD bzw. einem XML-Schema Die Gültigkeit von XML-Dokumenten kann man von XML- Parsern überprüfen lassen. Parser: Programme, welche ein Dokument analysieren, zerlegen und in eine für die Weiterverarbeitung brauchbare Darstellung umwandeln. 7

8 Gültigkeit von XML-Dokumenten XML-Dokument XML Grammatik DTD oder XML- Schema PARSER OK XML Validiertes XML- Dokument 8

9 Sprachunabhängige Programmierschnittstellen (1) Für die Verarbeitung von XML-Dokumenten wurden sprachunabhängige Programmierschnittstellen spezifiziert, insbesondere DOM und SAX. DOM (Document Object Model) Bei DOM wird das gesamte XML-Dokument in einer interne Struktur gespeichert. Der Zugriff auf die Elements erfolgt über einen Objektbaum. Mit DOM können XML-Dokumente sowohl gelesen als auch erzeugt und ausgegeben werden. DOM ist der W3C-Standard für die Programmierschnittstelle zur XML-Verarbeitung. DOM bietet komfortablen Zugriff auf die Elemente. DOM ist für große Dokumente aber weniger geeignet als SAX. 9

10 Sprachunabhängige Programmierschnittstellen (2) SAX (Simple API for XML) SAX basiert auf einem Ereignismodell (event-based Parser). Die XML-Datei wird wie ein Datenstrom sequentiell gelesen, und für erkannte Elemente (gemäß Vorgaben) wird ein Ereignis ausgelöst. Nachteil: wahlfreier Zugriff auf ein einzelnes Element ist (ohne Zwischenspeicherung) nicht möglich. SAX ist im Gegensatz zu DOM nicht so speicherhungrig, weil das XML-Dokument nicht vollständig im Speicher abgelegt ist. Es ist daher auch für sehr große Dokumente geeignet. Mit SAX können XML-Dokumente jedoch nur gelesen, nicht aber erzeugt werden (im Gegensatz zu DOM). SAX ist zum schnellen Verarbeiten sehr großer Dokumente geeignet. 10

11 Sprachunabhängige Programmierschnittstellen (3) Klassische Anwendungen für SAX sind: Darstellung von XML-Dateien in einem Browser Suche nach ganz bestimmten Inhalten Einlesen von XML-Dateien, um eine eigene Datenstruktur aufzubauen Für viele Anwendungen ist es jedoch erforderlich, die gesamte XML-Struktur im Speicher zu verarbeiten. Für diese Fälle ist eine Struktur, wie sie DOM erzeugt, notwendig. DOM ermöglicht: Interaktives Arbeiten mit dem XML-Dokument Erkennen der Beziehungen zwischen den einzelnen XML-Elementen 11

12 Komponenten für XML in Java (1) JAXP (Java API for XML Processing) (Auch: Java API for XML Parsing) API für XML-Verarbeitung in Java. Umfasst DOM, SAX und XSLT. Kann verschiedene XML-Parser einbinden. JAXP ist seit J2SE 1.4 in Java enthalten. JDOM (Java DOM), JDOM ist eine Open-Source Java-Bibliothek. Diese bietet eine an Java angepasste Programmierschnittstelle. JDOM erstellt aus dem XML-Dokument einen an Java angepassten Objekt-Baum. dom4j (DOM for Java) dom4j ist ebenfalls Open-Source und eine Alternative, die besonders viele Features beinhaltet. 12

13 Komponenten für XML in Java (2) JAXB (Java Architecture for XML Binding) JAXB bietet einen Mechanismus zum Erzeugen von Java-Objekten aus XML-Dokumenten (Unmarshalling) und zum Schreiben (Übertragen) von Java-Objekten als XML-Dokument (Marshalling). JAXM (Java API for XML Messaging) JAXM bietet einen Mechanismus zum Austausch asynchroner XML- Messages (z.b. für SOAP-Dokumente und ebxml). JAX-RPC (Java API for XML-Based Remote Procedure Call) Mechanismus zum Austausch synchroner XML-Messages als Remote Procedure Calls (z.b. für SOAP-RPC), bei denen ähnlich wie bei Funktionsaufrufen auf das Ergebnis gewartet wird. JAXR (Java API for XML Registries) Mechanismus zum Veröffentlichen und zur Suche verfügbarer Dienste in einer externen Registry. 13

14 XML-Dateien mit JAXP verarbeiten In dieser Vorlesung wird in den Beispielen und Aufgaben JAXP verwendet. Vorteile: JAXP ist Bestandteil von Standard-Java. Die DOM-Schnittstelle von JAXP ermöglicht ein einfaches Einlesen und 'in memory'-speichern eines Dokuments. Hierfür erzeugt JAXP eine interne Objektstruktur der XML- Datei. Sie ermöglicht es auch, diese Objekte zu manipulieren und wieder als XML-Dokument auszugeben. 14

15 XML-Parser in JAXP Über JAXP können verschiedene XML-Parser verwendet werden, zum Beispiel Xerces (Apache) und Crimson. Wenn keine besonderen Anforderungen vorliegen, kann einfach der im JAXP der API bereits enthaltenen Default- Parser verwendet werden. Man muss dabei nicht wissen, welcher Parser zu Grunde liegt. Aktuell wird die Java-Plattform mit Xerces ausgeliefert. 15

16 Interne Darstellung in DOM-Baum bei JAXP Der DOM-Parser wird in JAXP "DocumentBuilder" genannt, da er auch eine vollständige "in memory"- Darstellung des Dokuments liefert. Der DocumentBuilder erstellt eine Baumstruktur, die die Knoten im XML-Dokument ("Nodes") enthält. Die Wurzel des Dokument-Baums ist eine Document-Instanz. Für Knoten gibt es verschiedene Java-Datentypen, die die jeweiligen Datentypen aus dem XML-Dokument repräsentieren. Die wichtigsten Knotentypen sind: Elementknoten (Element-Instanzen) Attributknoten (Attr-Instanzen) Textknoten, die z.b. den Text zwischen Start- und End-Tag eines Elementes widerspiegeln (Text-Instanzen) 16

17 Beispiel für DOM-Baum (vereinfacht) <party datum=" "> <gast name="albert"> <getraenk>wein</getraenk> <zustand ledig="true" /> </gast> </party> document party Document Element datum Attr text \n Text Element gast name Albert Attr text \n Text 17 text \n Text getraenk text Wein Text text \n zustand text \n Text ledig true Element Text Element Attr document-knoten: Wurzel des Dokument-Baums party-knoten: Wurzelelement

18 Das Document-Interface in JAXP (1) Über das Interface Document (im Package org.w3c.dom) wird in JAXP ein Dokument definiert. Eine Document-Instanz ist die Wurzel des gesamten Dokument-Baums und repräsentiert zugleich das gesamte XML-Dokument. Es bietet den primären Zugang zu den Daten des Dokuments (d.h. zur Baum-Struktur der Knoten). 18

19 Das Document-Interface in JAXP (2) Methoden von Document (Auswahl): Element getdocumentelement() Liefert das Wurzelelement NodeList getelementsbytagname(string tagname); Liefert eine Liste aller in dem Dokument enthaltenen Elemente mit dem angegebene Tag-Namen (Knoten-Liste) Element createelement(string tagname) Erzeugt ein Element mit dem angegebenen Namen Element createelementns(string namepaceuri, String name) Erzeugt ein Element mit dem angegebenen Namen und dem angegebenen Namespace. API-Dokumentation zu Document: 19

20 Erzeugen eines Document-Objektes (1) Document-Instanzen können nicht per new erzeugt werden. Sie werden über eine "Factory" geliefert: Als erstes muss eine DocumentBuilderFactory erzeugt werden. Diese kann uns dann einen DocumentBuilder liefern. Und dieser kann danach ein neues Document-Objekt bereitstellen. 20 Methoden von DocumentBuilder zur Erzeugung eines Document-Objekts: Document newdocument() Liefert eine neue Instanz eines DOM-Dokuments. Mit ihr kann dann ein DOM-Baum erstellt werden. Document parse(file f), Document parse(inputstream is) Document parse(string uri) Parst den Inhalt des angegebenen Files (InputStream, URI) als ein XML- Dokument; liefert ein neues DOM-Document-Objekt. Eigenschaften des DocumentBuilders (Parsers) können konfiguriert werden (z.b. Beachtung von NameSpaces oder Überprüfung der Gültigkeit des XML-Codes).

21 Erzeugen eines Document-Objektes (2) Leeres Document-Objekt im Speicher erstellen: import javax.xml.parsers.documentbuilderfactory; import javax.xml.parsers.documentbuilder; import org.w3c.dom.document; DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); DocumentBuilder parser = factory.newdocumentbuilder(); Document doc = parser.newdocument(); Ohne Exceptionhandling! Document-Objekt aus einer Datei (mit Pfad filename) erzeugen: DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); factory.setnamespaceaware(true); // Namespace-Unterstützung DocumentBuilder parser = factory.newdocumentbuilder(); Document doc = parser.parse(new File(filename)); // Ab hier steht der Inhalt als DOM-Baum in "doc" zur Verfügung 21

22 Erzeugen eines Document Objektes (3) Mit Exception-Handling (im Java 1.7-Stil) import javax.xml.parsers.parserconfigurationexception; import org.xml.sax.saxexception; import java.io.ioexception;... try { DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); factory.setnamespaceaware(true); DocumentBuilder parser = factory.newdocumentbuilder(); Document doc = parser.parse(new File(filename)); // Ab hier steht der Inhalt als DOM-Baum in "doc" zur Verfügung //... } catch (ParserConfigurationException SAXException IOException ex) { }... System.err.println(ex.getMessage()); 22

23 Erzeugen eines Document-Objektes (4) Document-Objekt aus URL erzeugen: import javax.xml.parsers.documentbuilder; import javax.xml.parsers.documentbuilderfactory; import org.w3c.dom.document; public static void main(string[] args) { } try { DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); DocumentBuilder parser = factory.newdocumentbuilder(); Document doc = parser.parse( " // Name des Wurzelelements ausgeben System.out.println(doc.getDocumentElement().getNodeName()); } catch (Exception e) { } System.out.println(e.getMessage()); 23 Ausgabe: party

24 Ausgeben eines Document-Objekts als XML-Datei Mit Hilfe der Klassen javax.xml.transform.transformer und javax.xml.transform.stream.streamresult lässt sich der DOM- Baum als XML-Datenstrom ausgeben (z.b. in eine Datei oder Stream). Folgende Programmzeilen schreiben ein Document auf die Konsole: import javax.xml.transform.transformer; import javax.xml.transform.transformerfactory; import javax.xml.transform.outputkeys; import javax.xml.transform.dom.domsource; import javax.xml.transform.stream.streamresult; TransformerFactory tfactory = TransformerFactory.newInstance(); tfactory.setattribute("indent-number", 4); // Einrückung festlegen Transformer transformer = tfactory.newtransformer(); transformer.setoutputproperty(outputkeys.indent, "yes"); //schön! // Quelle: Kann ein (gesamtes) Document oder ein beliebiger Node // (Unterbaum!) sein Source source = new DOMSource(doc); // Ausgabe: Kann File, ein OutputStream oder Writer sein Result result = new StreamResult(System.out); // Transformation und Ausgabe anstoßen transformer.transform(source, result); 24

25 DOM-Knotentypen Die wichtigsten Knotentypen im DOM sind: Ein Dokumentknoten (org.w3c.dom.document) stellt die gesamte Baumstruktur dar. Ein Dokumentfragmentknoten (org.w3c.dom.documentfragment) stellt einen Teil der Baumstruktur dar. Ein Elementknoten (org.w3c.dom.element) entspricht genau einem Element in XML Ein Attributknoten (org.w3c.dom.attr) entspricht genau einem Attribut in XML Ein Textknoten (org.w3c.dom.text) stellt den textuellen Inhalt eines Elements oder einen sonstigen Text dar Ein Kommentarknoten (org.w3c.dom.comment) repräsentiert den Inhalt eines XML-Kommentars, d.h. den Inhalt zwischen '<!--' und '-->'. 25

26 Knotenname, -wert und -attribute für die verschieden DOM-Knotentypen Interface nodename nodevalue Attributes Attr Name des Attributs Wert des Attributs null CDATASection "#cdata-section" Inhalt der CDATA-Sektion null Comment "#comment" Inhalt des Kommentars null Document "#document" null null DocumentFragment "#document-fragment" null null DocumentType Name des document type Element Name des Tags null NamedNodeMap null null Entity Name des Entity null null EntityReference Name des referenzierten Entity null null Notation notation name null null ProcessingInstruction Target Gesamter Inhalt ohne das Target null Text "#text" Inhalt des Text-Knotens null 26

27 Das Superinterface Node der DOM-Knotentypen (1) Das Interface org.w3c.dom.node bildet das Superinterface all dieser Knotentypen. Methoden von Node (und damit aller Knotentypen): short getnodetype() liefert den Typ des Knotens entsprechend vordefinierten Werten (symbol. Konstanten der Klasse Node): ATTRIBUTE_NODE, CDATA_SECTION_NODE, COMMENT_NODE, DOCUMENT_NODE, DOCUMENT_FRAGMENT_NODE, DOCUMENT_TYPE_NODE, ELEMENT_NODE, ENTITY_NODE, ENTITY_REFERENCE_NODE, NOTATION_NODE, PROCESSING_INSTRUCTION_NODE, TEXT_NODE String getnodename() String getnodevalue() void setnodevalue(string nodevalue) NamedNodeMap getattributes() 27

28 Das Superinterface Node der DOM-Knotentypen (2) Fortsetzung (Methoden von Node) String gettextcontent() void settextcontent(string textcontent) NodeList getchildnodes() Node getfirstchild() Node getlastchild() Node getprevioussibling() Node getnextsibling() Node appendchild(node newchild) Node removechild(node oldchild) Die verschiedenen Subinterfaces von Node haben daneben noch spezifische Methoden der Knotentypen. 28

29 Die Interfaces NodeList und NamedNodeMap Eine NodeList ist eine geordnete Sammlung von Knoten. Das Interface NodeList bietet Zugriff auf die Knoten. Methoden von NodeList: Node item(int n) int getlength() liefert den n-ten Knoten einer NodeList liefert die Anzahl der Knoten Eine NamedNodeMap ist eine Sammlung von Knoten, die über Namen angesprochen werden können, z.b. Attributnamen. Das Interface NamedNodeMap bietet Zugriff auf die Knoten. Methoden von NamedNodeMap: Node getnameditem(string name) liefert den Knoten mit dem Knoten-Namen name Node item(int n) int getlength() liefert den n-ten Knoten der Liste liefert die Anzahl der Knoten 29

30 Beispiel für XML-Datei Beispiel: Die Datei party.xml habe folgenden Inhalt: <?xml version="1.0"?> <party datum=" "> <gast name="albert Angsthase"> <getraenk>wein</getraenk> <getraenk>bier</getraenk> <zustand ledig="true" nuechtern="false"/> </gast> <gast name="martina Mutig"> <getraenk>apfelsaft</getraenk> <zustand ledig="true" nuechtern="true"/> </gast> <gast name="zacharias Zottelig"> </gast> </party> Download: 30

31 Informationen im DOM-Baum ermitteln (1) // Erzeugen eines Dokuments aus der Datei party.xml DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); DocumentBuilder parser = factory.newdocumentbuilder(); Document doc = parser.parse( " // Lesen des Wurzelelements des DOM-Dokuments doc Element party = doc.getdocumentelement(); // Den ersten Gast auf der Party holen: Node albert = party.getelementsbytagname("gast").item(0); 31

32 Informationen im DOM-Baum ermitteln (2) // Wenn wir eine Namensliste aller Gäste der Party ausgeben wollen: NodeList gaeste = party.getelementsbytagname("gast"); // getelementsbytagname() liefert nur Knoten vom Typ Element for (int i=0; i<gaeste.getlength(); i++) { } System.out.println(gaeste.item(i).getAttributes().getNamedItem("name").getNodeValue()); Ausgabe: Albert Angsthase Martina Mutig Zacharias Zottelig // Wenn wir ausgeben wollen, was Albert trinkt: for (int i=0; i<albert.getchildnodes().getlength(); i++) { } if (albert.getchildnodes().item(i).getnodename().equals("getraenk")) { } Node getraenk = albert.getchildnodes().item(i); System.out.println(getraenk.getTextContent()); Ausgabe: Wein Bier 32

33 Informationen im DOM-Baum ermitteln (3) Hinweis zum Datentyp von albert in Folie 31: Die Methode item(n) liefert lediglich Node-Objekte. Falls man aber Element-Objekte benötigt, kann man den Typ der gelieferten Objekte abfragen und sie in Element-Objekte casten: // Den ersten Gast auf der Party holen: Node albert = party.getelementsbytagname("gast").item(0); Element albertalselement = null; if (albert.getnodetype()== Node.ELEMENT_NODE) albertalselement = (Element) albert; 33

34 Informationen im DOM-Baum ermitteln (4) oder man kann sie direkt casten, da getelementsbytagname() nur Elementknoten liefert:... // Den ersten Gast auf der Party holen (als Element): Element albertalselement = (Element) party.getelementsbytagname("gast").item(0); 34

35 Informationen im DOM-Baum ermitteln (5) Es gibt keine Methode, welche das k-te Element-Kind eines Node n mit einem bestimmten Namen name liefert. Man kann sich hierfür eine eigene Methode schreiben: // Liefert das k-te Element-Kind eines Knoten n mit Namen name // Zählung beginnt bei 0! public static Element getnamedchildelement (Node n, String name, int k) { for (int i=0; i<n.getchildnodes().getlength(); i++) { if (n.getchildnodes().item(i).getnodetype()== Node.ELEMENT_NODE && n.getchildnodes().item(i).getnodename().equals(name)) { if (k==0) return (Element) n.getchildnodes().item(i); k--; } } return null; } 35

36 Neue Elemente hinzufügen und Elemente löschen Ein weiteres Getränk zu Gast Albert hinzufügen: Node wasser = doc.createelement("getraenk"); wasser.settextcontent("wasser"); albert.appendchild(wasser); Albert will in Zukunft keinen Wein mehr trinken: Node wein = null; for (int i=0; i<albert.getchildnodes().getlength();i++) { } if (albert.getchildnodes().item(i).getnodename().equals("getraenk")) { } if (albert.getchildnodes().item(i).gettextcontent().equals("wein")) wein = albert.getchildnodes().item(i); if (wein!= null) albert.removechild(wein); 36

37 Attributinhalte lesen und ändern Lesen und ausgeben des name-attributs von Albert (Wied.): System.out.println(albert.getAttributes().getNamedItem("name").getNodeValue()); // Ausgabe: Albert Angsthase 37 Martina schnappt sich Albert, wenn er noch ledig ist: Node zustand = null; for (int i=0; i<albert.getchildnodes().getlength();i++) { if (albert.getchildnodes().item(i).getnodename().equals("zustand")) { zustand = albert.getchildnodes().item(i); } } if (zustand!=null) if (zustand.getattributes().getnameditem("ledig").getnodevalue().equals("true")) // Attribut setzen zustand.getattributes().getnameditem("ledig").setnodevalue("false"); } // entsprechend auch bei Martina ändern!

38 Beispiel Erzeugung eines neuen DOM-Baums: DOM-Baum mit Fibonacci-Zahlen DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); DocumentBuilder parser = factory.newdocumentbuilder(); Document doc = parser.newdocument(); Element fib = doc.createelement("fibonacci_numbers"); doc.appendchild(fib); // Wurzelelement int low = 1; int high = 1; //Erzeugen der Unterelemente for (int i = 1; i <= 10; i++) { Element fibonacci = doc.createelement("fibonacci"); fibonacci.setattribute("index", String.valueOf(i)); fibonacci.settextcontent(string.valueof(low)); fib.appendchild(fibonacci); int temp = high; high += low; low = temp; } 38

39 Erzeugter DOM-Baum (in XML) <?xml version="1.0" encoding="utf-8" standalone="no"?> <Fibonacci_Numbers> <fibonacci index="1">1</fibonacci> <fibonacci index="2">1</fibonacci> <fibonacci index="3">2</fibonacci> <fibonacci index="4">3</fibonacci> <fibonacci index="5">5</fibonacci> <fibonacci index="6">8</fibonacci> <fibonacci index="7">13</fibonacci> <fibonacci index="8">21</fibonacci> <fibonacci index="9">34</fibonacci> <fibonacci index="10">55</fibonacci> </Fibonacci_Numbers> 39