Echt cooles Java. Cleverer Code, Open-Source-Bibliotheken und Projektideen. von Brian D. Eubanks, Dorothea Heymann-Reder. 1.

Transkript

1 Echt cooles Java Cleverer Code, Open-Source-Bibliotheken und Projektideen von Brian D. Eubanks, Dorothea Heymann-Reder 1. Auflage Hanser München 2006 Verlag C.H. Beck im Internet: ISBN Zu Inhaltsverzeichnis schnell und portofrei erhältlich bei beck-shop.de DIE FACHBUCHHANDLUNG

2 Echt cooles Java Brian D. Eubanks Cleverer Code, Open-Source-Bibliotheken und Projektideen ISBN Leseprobe Weitere Informationen oder Bestellungen unter sowie im Buchhandel

3 3 Verarbeitung von XML und HTML

4 44 3 Verarbeitung von XML und HTML 3 Verarbeitung von XML und HTML Im vorigen Kapitel hatten wir Strings mit Hilfsmethoden erzeugt, gelesen und verarbeitet. Mit regulären Ausdrücken und der in Kapitel 2 beschriebenen Klasse Scanner können wir nunmehr eigene Parser schreiben, um Daten aus strukturiertem Text herauszuholen. Das geht ganz einfach, wenn man es mit einem einfachen Kontext zu tun hat, aber der Einsatz solcher Techniken bei sehr komplexen Strukturen würde einen hohen Programmieraufwand erforderlich machen. In diesem Kapitel werden wir mit einer sehr gebräuchlichen Art von strukturiertem Text arbeiten: der Extensible Markup Language (XML). Wir betrachten besondere Techniken für die Verarbeitung von XML, generieren einen Parser für ein Nicht-XML-Dokument und konvertieren eine willkürlich ausgewählte Grammatik in ein XML-Dokument. Dieses Kapitel setzt eine gewisse Vertrautheit mit XML voraus. Wir werden uns nicht lange mit den XML-Grundlagen aufhalten, sondern mit einem sehr kurzen Überblick über XML beginnen, um Ihr Gedächtnis aufzufrischen. 3.1 Mal schnell XML: Eine Auffrischung XML ist eine allgemeine Auszeichnungssprache zur Beschreibung von strukturierten, hierarchischen Daten. Die Entwickler von XML wollten eine Sprache erschaffen, die für Computer und Menschen gleichermaßen lesbar ist, und kein binäres Format, das sich nur mit speziellen Werkzeugen verarbeiten lässt. Heute ist XML zwar erst ein paar Jahre alt, hat aber für die Kommunikation zwischen Anwendungen und für viele andere Aspekte der Programmierung bereits große Bedeutung erlangt. Web-Entwicklung, Semantikdarstellung, Konfigurationsdateien und Business-to-Business-Webdienste sind nur einige Beispiele für die vielen Einsatzbereiche von XML: Sie können XML-Dokumente aus jeder beliebigen Programmiersprache oder Plattform erzeugen oder verarbeiten, nicht nur in Java. XML-Dokumente sind stark strukturiert, und alle in ihnen vorliegenden Daten müssen unter einem einzelnen Wurzelelement in Hierarchien gespeichert werden. Wenn ein Dokument diese Vorgabe einhält und zusätzlich einige Syntaxregeln befolgt, nennt man es wohlgeformt. Elemente oder Tags (Auszeichnungen) enthalten die Daten; die Struktur und Namen dieser Tags sind anwendungsspezifisch. XML-Dokumente sind maschinenlesbar, wenn sie wohlgeformt sind. Die XML-Spezifikation beschreibt eine generische Syntax, um ein Dokument in Tokens zu zerlegen, und jeder Dokumenttyp baut mit eigenen Tag- Namen und einer hierarchischen Struktur darauf auf. Simple API for XML (SAX) ist eine API, die XML-Dokumente auf niedriger Ebene liest. Ein SAX-Parser erzeugt Events, die Einzelteile des Dokuments darstellen (beispielsweise Startelemente, Zeichendaten und Endelemente). Ihr Programm lauscht

5 3.1 Mal schnell XML: Eine Auffrischung 45 auf diese Events mit einem Event-Handler. SAX merkt sich keine vergangenen Events, diese Aufgabe muss Ihr Event-Handler übernehmen. Document Object Model (DOM) ist eine API, die ein vollständiges Dokument in den Arbeitsspeicher einliest und als Objekthierarchie speichert, in der die Daten als Baum dargestellt werden. Ihr Programm kann Daten aus dem Dokumentbaum aktiv extrahieren oder modifizieren, indem es DOM-Methoden aufruft, während SAX eher ein passiver Prozess ist (Ihr Programm wartet darauf, Daten zu empfangen). Ein XML-Dokument könnte wie der folgende Text aussehen. Die Tag-Namen und der Textinhalt würden von einer Anwendung in einer für sie sinnvollen Weise interpretiert. In diesem Fall ist die Anwendung ein imaginäres Witzverwaltungssystem: <?xml version="1.0"?> <programmiersprachen> <sprachenname="java"> <witz>eine Insel</witz><witz>ein Drink</witz> </sprache> <sprachenname="c"> <witz>bedeutet</witz><witz>das Meer</witz> <witz>eine Musiknote</witz><witz>ja</witz> </sprache> </programmiersprachen> So blöd dieses Beispiel ist, so zeigt es doch anschaulich, dass Sie Ihre eigenen Tag-Namen anlegen können. Doch am einfachsten erfolgt der Datenaustausch mit anderen Programmen, wenn Sie sich an einen wohlbekannten XML-Standard halten. Links zu einigen gebräuchlichen XML-Standards finden Sie auf der Website zu diesem Buch, Viele Codebeispiele dieses Kapitels, die für die XML-Verarbeitung geschrieben sind, funktionieren auch mit HTML. Wenn das Dokument wohlgeformt ist, kann es als XML verarbeitet werden. Vielleicht möchten Sie ja ein Programm schreiben, das Daten aus einer Webseite extrahiert, oder einen Spider, der den Links eines Dokuments folgt. Ob das Extrahieren der Daten aus einem HTML-Dokument sinnvolle Informationen liefert, ist allerdings eine andere Frage (wie Sie weiter unten in diesem Kapitel noch sehen werden). In diesem Kapitel werden wir auch die Verarbeitung komplexer Strukturen erörtern, die nicht im XML- oder HTML-Format vorliegen. Wir werden einen Parser für das einfache Logdateiformat erstellen, das in Kapitel 2 beschrieben wurde, und das Dateiformat auf dieser Grundlage in XML konvertieren. Dieselben Konzepte lassen sich auch auf die Konvertierung anderer Nicht-XML-Grammatiken in XML übertragen. Sobald Ihre Daten in einem XML-Dokument vorliegen, können Sie sie mit allen Tools und APIs verarbeiten, die für XML zur Verfügung stehen.

6 46 3 Verarbeitung von XML und HTML 3.2 Datenbankdaten auf XML gebürstet: Erzeugung von XML mit WebRowSet Java 5+ In Java 5 und höher gibt es eine bequeme Möglichkeit, Daten aus einer Datenbank in ein XML-Dokument zu laden. Dieses neue Mitglied der JDBC-Familie heißt WebRowSet. Es ist ein Interface aus dem Paket javax.sql.rowset, und die Core-API hat eine Implementierung namens WebRowSetImpl von ihm. Mit dieser Klasse können Sie leicht die Ergebnismenge (das ResultSet) einer Datenbankabfrage in eine XML-Darstellung konvertieren. Aus einer JDBC-Ergebnismenge können Sie dann folgendermaßen ein WebRowSet mit Inhalt füllen: import com.sun.rowset.webrowsetimpl; ResultSet rs = statement.executequery("select * from MyTable"); WebRowSetImpl data = new WebRowSetImpl(); data.populate(rs); data.writexml(system.out); Dieses Beispiel sendet die XML-kodierten Daten an die Konsole, doch man könnte sie e- bensogut an einen Writer oder OutputStream schicken. Wenn Sie ein WebRowSet füllen, werden die Daten vom ursprünglichen ResultSet getrennt, und Sie können die Ergebnismenge, die Anweisung und die Datenbankverbindung schließen. Natürlich setze ich hier voraus, dass Sie sich bereits mit einer Datenbank verbunden und ein Statement-Objekt erzeugt haben. (Wenn Sie nicht genau wissen, wie, schauen Sie bitte auf einer der vielen Websites oder in einem der Bücher nach, wo der Datenbankzugriff mit JDBC erklärt wird.) Sobald die Daten in XML vorliegen, können Sie sie mit jeder nachfolgend in diesem Kapitel beschriebenen XML-Technik verarbeiten, an andere Anwendungen weitergeben oder mit XSL-T in einem anderen Format stylen. Im JDBC-Abschnitt der Java 5- Dokumentation werden die Klasse WebRowSet und ihr XML-Format genauer beschrieben. 3.3 SAX-o-phil: Tag-Beziehungen in SAX Java 1.4+ Wenn Sie masochistisch veranlagt wären, könnten Sie Ihren eigenen XML-Parser schreiben, alle Zeichen einzeln einlesen und die Elemente, den Text und die Attribute aus dem Eingabestrom herausziehen. Um das zu leisten, müsste Ihr Programm jedes Detail der XML-Syntax kennen. Sie müssten Escape-Sequenzen einbeziehen, Elemente und Attribute parsen und Entities ersetzen. Doch nichts davon ist eigentlich nötig, denn für Java sind viele (und gute) XML-Parser bereits erhältlich. SAX ist eine Parsing-Möglichkeit für XML. Mit einem SAX-Parser können Sie eine E- vent-listener-klasse schreiben, die aus dem XML-Dokument mithilfe von Callback-Methoden Daten empfängt, welche die Tokens des Dokuments repräsentieren. Diese Schnittstelle arbeitet auf einer relativ niedrigen Ebene, allerdings nicht ganz so niedrig wie das

7 3.3 SAX-o-phil: Tag-Beziehungen in SAX 47 zeichenweise Einlesen von Daten. Das Schwierigste beim Schreiben von SAX- Programmen ist es, die Dokumenthierarchie im Auge zu behalten, denn der SAX-Parser merkt sich keine Tags und Texte, die zuvor eingetroffen sind. Ihr Programm ist wie ein Pferd mit Scheuklappen: Es sieht immer nur einen kleinen Teil des Gesamtbilds. Doch SAX ist nützlich, da es sehr umfangreiche Dokumente verarbeiten kann, die mit einem Baumverfahren wie DOM nicht zu bewältigen wären. Um komplexere Dokumente zu parsen, sollte man allerdings einen Baum-Ansatz verfolgen, da diese Schnittstelle einfacher und auf einer höheren Ebene als SAX funktioniert. Arbeiten Sie allerdings mit einem Dokument von gewaltiger Größe, so haben Sie keine Wahl. Und wenn das Programm das Dokument aus einem Netzwerk bezieht, weiß es im Voraus nicht, ob die Daten später Ausmaße annehmen, die nicht mehr in den Arbeitsspeicher passen. Da JDK 1.4 dem Java-Core einen SAX-Parser hinzugefügt hat, steht allen Java-Programmen bereits ein solcher Parser zur Verfügung er muss nicht erst installiert werden. Schauen wir uns doch einmal die Arbeitsweise von SAX anhand einer sehr einfachen SAX-Anwendung an. Wir betrachten nur drei Methoden aus dem Interface ContentHandler dem Interface, das Programme implementieren, wenn sie über Events, die vom Parser stammen, informiert werden möchten. Es gibt noch andere Methoden für die esoterischeren Bestandteile einer Dokumentstruktur, doch für viele Anwendungen reicht die Implementierung dieser drei ContentHandler-Methoden bereits aus. Hier sehen Sie einen SAX-Event-Handler für die Verarbeitung von XML-Inhalt: import org.xml.sax.helpers.defaulthandler; import org.xml.sax.saxexception; import org.xml.sax.attributes; /* DefaultHandler ist eine Basisimplementierung von ContentHandler und wenn wir diese Klasse erweitern, müssen wir nicht alle Methoden aus ContentHandler implementieren. */ public class SimplestContentHandler extends DefaultHandler public void startelement(string uri, String localname, String qname, Attributes attributes) throws SAXException System.out.println("Opening tag " + localname + ""); public void characters(char[] ch, int start, int length) throws SAXException String text = new String(ch, start, length); System.out.print(text); public void endelement(string uri, String localname, String qname) throws SAXException System.out.println("Closing tag " + localname); Wie unschwer zu erraten ist, entsprechen diese drei Methoden einem Startelement (öffnendes Tag), den Zeichendaten und einem Endelement (schließendes Tag). Es ist wie ein Sandwich: die öffnenden und schließenden Tags sind die Brote, und dazwischen liegt die Wurst (der Text). Allerdings können noch Käse und Senf dazukommen, denn die Methode characters kann durchaus mehrere Male aufgerufen werden, um einen ganzen Textblock darzustellen! Mit anderen Worten: Ihr Event-Handler muss die Daten aus mehreren Aufru-

8 48 3 Verarbeitung von XML und HTML fen der characters-methode sammeln und irgendwo in einem String oder StringBuffer ablegen. Hier wird die Sache knifflig, denn ehe Sie einem bestimmten Tag Text zuweisen können, müssen Sie wissen, an welcher Stelle des Dokuments Sie sich befinden. Wenn die characters-methode aufgerufen wird, wird zu den Daten keine Kontextinformation mitgeliefert. Viele Anwendungen verwenden boolean-flags, um das Behälterelement des aktuellen Texts zu markieren. Im Folgenden wird ein Beispiel gezeigt, in dem ein java.util.stack die zuletzt betrachteten schließenden Tags im Auge behält. Achten Sie darauf, nicht einfach alles einzusammeln, was Sie in dem char-array finden, da dieses auch den Puffer für das gesamte Dokument enthalten kann! Sie müssen mit den Parametern start und length ermitteln, wie viel von den Daten zum aktuellen Text gehört. Am einfachsten lässt sich dies mit dem String-Konstruktor machen, der nur einen Teil eines Zeichenpuffers kopiert, wie es im letzten Stück des Codebeispiels gezeigt wird. Die Klasse StringBuffer verfügt über eine append-methode mit ähnlichen Parametern. Normalerweise würden Sie den ContentHandler nicht einfach so ausführen. Sie würden einen Treiber benötigen, um eine Parser-Instanz zu erzeugen, Ihren Handler damit verbinden und das Dokument durch den Parser strömen lassen. Der folgende Code erstellt einen Parser, schließt den Handler an und liest ein Dokument aus einem URL: import org.xml.sax.contenthandler; import org.xml.sax.xmlreader; import org.xml.sax.helpers.xmlreaderfactory; public class SimplestSAXDriver public static void main(string[] args) throws Exception XMLReader parser = XMLReaderFactory.createXMLReader(); ContentHandler handler = new SimplestContentHandler(); parser.setcontenthandler(handler); String url = " + "xml/office/ubl-order-1.0-office-example.xml"; parser.parse(url); Wir wollen nun ein SAX-Programm zur Dokumentverarbeitung schreiben. Für das Beispiel werden wir Daten aus einem Universal Business Language (UBL)-Dokument extrahieren. UBL ist ein neuer XML-Standard zur Kodierung von Geschäftsdokumenten wie beispielsweise Bestellungen, Versandbenachrichtigungen und Rechnungen. (Einen Link dazu finden Sie auf der Website zu diesem Buch.) Wir werden eine der Beispieldateien (den soeben verwendeten URL) von der UBL-Spezifikation verwenden: eine Büromaterial-Bestellung von einem Händler. Da das Beispiel die Zeilenelemente der Bestellung in den Mittelpunkt stellt, werde ich einige Details weglassen, um nicht seitenweise XML abdrucken zu müssen. Hier sehen Sie also den allgemeinen Inhalt der Datei: <Order>      <OrderLine> <LineItem> <BuyersID>1</BuyersID>

9 3.3 SAX-o-phil: Tag-Beziehungen in SAX 49 <Quantity quantityunitcode="pkg">5</quantity> <LineExtensionAmount>12.50</LineExtensionAmount> <Item> <Description>Pencils, box #2 red</description> <SellersItemIdentification> <ID> </ID> </SellersItemIdentification> <BasePrice> <PriceAmount>2.50</PriceAmount> </BasePrice> </Item> </LineItem> </OrderLine> <OrderLine>... </OrderLine> <OrderLine>... </OrderLine> </Order> Stellen Sie sich vor, Sie arbeiten für eine Firma, deren Politik es ist, eine besondere Genehmigung für Auftragsposten einzuholen, deren Gesamtwert 30 US$ übersteigt. Wir können ein Programm schreiben, das einen Bericht über die genehmigungspflichtigen Posten schreibt, indem wir das Dokument mit SAX durchlesen und LineExtensionAmount- Werte über 30 suchen. Das wäre einfach, da wir nur nach dem LineExtensionAmount- Tag Ausschau halten müsse. Wir setzen ein boolean-flag, wenn wir das geöffnete Tag finden, und setzen es auf false zurück, sobald das Tag geschlossen wird. Dann holen wir (mit der Methode characters) die Zeichendaten nur so weit ab, wie das Flag true ist. So erhalten wir die Daten für den Dollarbetrag. Wenn wir allerdings noch weitere Kennzeichnungsinformationen abfragen wollten, wie beispielsweise die Beschreibung des Auftragspostens, dann wäre ein besseres Mittel erforderlich, um sich den aktuellen Kontext im Dokument zu merken und die verwandten Daten weiter vorne im Dokument im Auge zu behalten. Um Tag-Hierarchien im Auge zu behalten, könnten wir Elementnamen in der startelement-methode auf einen Stack legen und in der endelement-methode wieder daraus entnehmen. Um den Text festzuhalten, speichern wir ihn einfach in einer Map und verwenden den Tag-Namen als Schlüssel. Das funktioniert jedoch nur, wenn die Tag- Namen in dem Dokument eindeutig sind und wir nichts mit den Attributwerten angestellt haben, doch diese Probleme lassen sich leicht lösen. (Bitte beachten Sie auch, dass diese auf Stacks und Maps beruhende Vorgehensweise in einer Multithreading-Umgebung nicht sicher ist.) Hier sehen Sie unsere neue Handler-Klasse: public class LineItemReportHandler extends DefaultHandler private java.util.stack path = new java.util.stack(); private java.util.hashmap values = new java.util.hashmap(); public void startelement(string uri, String localname, String qname, Attributes attributes) throws SAXException // Elementname auf den Stack legen path.push(localname); // Werte sind in der Map, die den XML-Text aufnimmt // den Text für dieses Element beim Öffnen des Tags entfernen values.put(localname, ""); public void characters(char[] ch, int start, int length) throws SAXException String text = new String(ch, start, length); // Was war das letzte Tag?

10 50 3 Verarbeitung von XML und HTML String currenttag = (String) path.peek(); // Welchen Wert hat bisher der Text darin? String currentvalue = (String) values.get(currenttag); // Aktuellen Text anfügen und in die Map schreiben currentvalue = currentvalue + text; values.put(currenttag, currentvalue); public void endelement(string uri, String localname, String qname) throws SAXException path.pop(); if (localname.equals("lineitem")) String amount = (String) values.get("lineextensionamount"); if (Double.parseDouble(amount) >= 30.0) System.out.print("Quantity "); System.out.print(values.get("Quantity")); System.out.print(" of \""); System.out.print(values.get("Description")); System.out.print("\" costs $"); System.out.println(amount); Dieser SAX-Handler gibt nach der Verarbeitung der UBL-Beispieldatei folgendes Ergebnis aus: Quantity 10 of "Photocopy Paper- case" costs $ Quantity 10 of "Pens, box, blue finepoint" costs $50.00 Quantity 3 of "Tape, 1in case" costs $37.50 Die obige XML-Datei war ein vereinfachtes UBL ohne die Namensraum- oder Schema- Verarbeitung. Links zu UBL und Informationen über Namensräume und Schemata finden Sie auf der Website der Online-Ressourcen zu diesem Buch. 3.4 SAX-o-phon: ContentHandler direkt füttern Java 1.4+ Im vorigen Abschnitt 3.3 zeigten wir, dass Parser anhand der Eingabe aus einem XML- Dokument SAX-Events generieren. Außerdem lernten wir einige der Methoden aus dem Interface ContentHandler kennen. In dem Beispiel schrieben wir einen einfachen Event- Handler zur XML-Verarbeitung und sammelten die Daten in Kellerstapeln und Maps. Manchmal muss man aber auch in umgekehrter Richtung vorgehen, nämlich eigene SAX- Events an einen ContentHandler abfeuern. Dies ist zwar nicht der einfachste Weg zur Erstellung eines Dokuments, aber unter Umständen die einzige Möglichkeit, wenn ein extrem großes Dokument angelegt werden soll. Es ist möglich, einen ContentHandler unmittelbar zu füttern, indem man eine Instanz von ihm anlegt und seine Methoden direkt aufruft. Das folgende Beispiel basiert auf dem einfachen Handler, den wir bereits früher benutzt hatten und der einen Teil des Bestellungsdokuments anlegt, indem er SAX-Events auslöst: ContentHandler handler = new SimplestContentHandler(); handler.startdocument(); //... hier wurde ein Teil des Dokuments weggelassen handler.startelement("", "Item", "Item", new AttributesImpl());

11 3.4 SAX-o-phon: ContentHandler direkt füttern 51 handler.startelement("", "Description", "Description", new AttributesImpl()); String text = "Pencils, box #2 red"; handler.characters(text.tochararray(), 0, text.length()); // nicht vergessen: Elemente in umgekehrter Reihenfolge schließen! handler.endelement("", "Description", "Description"); handler.endelement("", "Item", "Item"); //... hier wurde ein Teil des Dokuments weggelassen handler.enddocument(); Wir beginnen die Dokumentverarbeitung, indem wir zuerst startdocument dann für die öffnenden Tags startelement und für die schließenden endelement aufrufen. Wenn wir ein Tag öffnen, müssen wir außerdem eine Attributes-Collection übergeben, die mithilfe der Klasse AttributesImpl angelegt werden kann (Attributes ist ein Interface und kann nicht direkt instanziiert werden). Selbst wenn Sie keine Attribute hinzufügen, müssen Sie ein leeres Attributes-Objekt übergeben, weil das Interface ContentHandler es verlangt. Der leere String, der an die Start- und Endelemente übergeben wird, ist der XML- Namensraum (engl. namespace). Er wird in diesem Beispiel zwar nicht verwendet, aber das Interface verlangt dennoch einen leeren String als Wert. Das zweite Exemplar des Tag- Namens ist der qualifizierte Name, also ein Tag-Name, dem der Namensraum (obwohl er nicht benutzt wird) als Präfix vorangestellt ist. Da die echte UBL Namensräume und Schemata verwendet, sollten Sie sich mit diesen bereits vertraut machen, wenn Sie UBL in der Produktion einsetzen möchten. Auf der Website mit den Online-Ressourcen finden Sie genauere Informationen. Wenn Sie eine Menge SAX-Events generieren, kann es nützlich sein, einige Hilfsmethoden zu schreiben, die den Code lesbarer machen, wie in diesem Beispiel, das ein UBL- Dokument für einen Bestellungswiderruf anlegt. Auch wenn es ein wenig unkonventionell ist: Eine kleine Einrückung auf jeder Ebene der geschachtelten Tags verbessert die Lesbarkeit des Codes (und erinnert Sie daran, die Tags zu schließen!): handler.startdocument(); open("ordercancellation"); // OrderCancellation-Tag öffnen tagtext("id", " X"); // ID-Tag mit eingebettetem Text tagtext("issuedatetime", " T09:30:47"); tagtext("cancellationnote", "order replaced"); open("orderreference"); tagtext("buyersid", " "); tagtext("issuedate", " "); close("orderreference"); open("buyerparty"); open("party"); open("partyname"); tagtext("name", "Bills Microdevices"); close("partyname"); close("party"); close("buyerparty"); open("sellerparty"); open("party"); open("partyname"); tagtext("name", "Joes Office Supply"); close("partyname"); close("party"); open("ordercontact"); tagtext("name", "Betty Jo Beoloski"); close("ordercontact"); close("sellerparty"); close("ordercancellation"); // OrderCancellation-Tag schließen handler.enddocument();

12 52 3 Verarbeitung von XML und HTML Der Vollständigkeit halber sehen Sie hier die Definition meiner Methoden open, close und tagtext: public class OurSAXGenerator private ContentHandler handler; // wurde vorher initialisiert private void open(string tag) throws SAXException handler.startelement("", tag, tag, new AttributesImpl()); private void close(string tag) throws SAXException handler.endelement("", tag, tag); private void tagtext(string tag, String value) throws SAXException open(tag); handler.characters(value.tochararray(), 0, value.length()); close(tag); Sie können auch noch ausgefeiltere Methoden schreiben, die für Ihre eigene Anwendung sinnvoller sind. Da wir in diesem Beispiel keine Namensraum-Präfixe oder Attribute verwendeten, konnten wir durch den Einsatz selbst erstellter Methoden den Code ordentlicher gestalten. Denken Sie daran, dass es einfachere Möglichkeiten gibt, um XML-Inhalt zu generieren, als einen ContentHandler mit SAX-Events zu füttern, doch aus Performance- Gründen oder wegen der Arbeitsspeicherbeschränkungen im Hinblick auf sehr große Dokumente ist es manchmal nötig, zu diesem Mittel zu greifen. Dies funktioniert aber nur dort, wo XML keine Systemgrenzen überspringen muss, da Ihr Generatorprogramm Zugriff auf die Handler-Instanz benötigt. Im nächsten Abschnitt 3.5 werden noch weitere Techniken für die Arbeit mit SAX-Events vorgestellt. 3.5 SAX-ische Spezialität: ContentHandler gefiltert füttern Java 1.4+ Nun, da Sie einen hungrigen ContentHandler füttern können, wie wir es im letzten Abschnitt 3.4 getan haben, können Sie die SAX-Methoden auch von einem anderen Programmteil aufrufen lassen und sich darauf beschränken, das SAX-Sandwich mit Senf zu bestreichen (oder die Majonäse runterzukratzen). Das ist nicht nur witzig gemeint; es gibt nämlich tatsächlich eine Art von Vorverarbeitung, die Sie den XML-Daten angedeihen lassen können, während Sie sie an einen ContentHandler übergeben. Im vorigen Absatz ü- bergaben Sie SAX-Events direkt an eine ContentHandler-Klasse, ohne einen Parser zu nutzen. Das kann für manche Anwendungen sinnvoll sein; häufiger ist jedoch ein Szenario, bei dem Daten aus einem XML-Dokument gelesen und der Inhalt gefiltert oder hinzugefügt werden, ehe das Dokument verarbeitet wird.

13 3.5 SAX-ische Spezialität: ContentHandler gefiltert füttern 53 Das Interface org.xml.sax.xmlfilter ist eine Kombination aus ContentHandler und XMLReader: ein Parser und Event-Handler in einem. Mithilfe dieses Interfaces können Sie eine Zwischenebene zwischen den Eingabe-Events, die von einem XMLReader kommen, und den Ausgabe-Events, die an den ContentHandler gehen, einziehen. Für den XMLReader sieht es wie ein ContentHandler und für den ContentHandler wie ein XMLReader aus. Abbildung 3.1 zeigt, wie der Filterprozess abläuft. XML Reader Parent XMLFilter Interne Filterung ContentHandler 1. Erzeuge die XMLFilter-Instanz. 2. Rufe die setparent-methode des Filters auf. 3. Rufe die Methode setcontenthandler auf. 4. Rufe die parse-methode des Filters auf. Content Handler Abbildung 3.1: XMLFilter-Fluss Da dieses Interface viele Methoden hat, werden Sie möglicherweise die Standardimplementierung verwenden, anstatt alles von Grund auf neu zu schreiben. Für diesen Zweck gibt es die Klasse XMLFilterImpl im Paket org.xml.sax.helpers. Die Standardimplementierung sendet SAX-Methoden direkt an den verbundenen Event-Handler. Dabei kommt ein Dokument heraus, das exakt der Eingabe entspricht. Um einen Filter zu erstellen, erweitern Sie die Klasse, indem Sie die ContentHandler-Methoden überschreiben. Wenn die überschriebenen SAX-Methoden im Filter von dem übergeordneten XMLReader aufgerufen werden, werden die Events an den Ziel-Handler nur dann übergeben, wenn Sie

14 54 3 Verarbeitung von XML und HTML die entsprechende Oberklassenmethode aufrufen (z.b. super.characters). Auf dieselbe Weise können Sie neue Inhalte erstellen oder vorhandene modifizieren, indem Sie die Methoden super.startelement und super.endelement mit den Daten aufrufen, die Sie an den Ziel-Handler übergeben möchten. Im folgenden Code habe ich einen Filter implementiert, der Tags und Text in einem Ignore -Tag übergeht: import org.xml.sax.attributes; import org.xml.sax.saxexception; import org.xml.sax.helpers.xmlfilterimpl; public class IgnoringFilter extends XMLFilterImpl // Dieser Filter funktioniert nicht mit geschachtelten Ignore-Tags! boolean ignoring = false; public void startelement(string url, String localname, String qname, Attributes att) throws SAXException if (localname.equals("ignore")) ignoring = true; if (!ignoring) super.startelement(url, localname, qname, att); public void characters(char[] data, int start, int length) throws SAXException if (!ignoring) super.characters(data, start, length); public void endelement(string url, String localname, String qname) throws SAXException if (localname.equals("ignore")) ignoring = false; else if (!ignoring) super.endelement(url, localname, qname); Um den Filter einzusetzen, gehen Sie folgendermaßen vor: XMLReader parser = XMLReaderFactory.createXMLReader(); ContentHandler handler = new SimplestContentHandler(); IgnoringFilter filter = new IgnoringFilter(); filter.setcontenthandler(handler); filter.setparent(parser); filter.parse("c:/projects/wcj3/test.xml"); Beachten Sie, dass der Filter in manchen Fällen nicht alle Events abfangen wird, da wir nur die drei SAX-Methoden implementiert haben. Das gilt zum Beispiel für die Zuordnung der Namensraum-Präfixe und die Whitespace-Zeichen. Um einen kompletten Filter für alle Lebenslagen zu bekommen, müssen Sie eventuell auch andere Methoden aus dem SAX- Interface implementieren. In der Dokumentation zu ContentHandler und XMLFilter des JDK finden Sie genauere Informationen. Sie können auch mehrere Filter aneinanderhängen. Wir werden nun einen weiteren Filter hinzufügen, der ein signedby-attribut in jedes Element des Dokuments einfügt. Die Filterklasse sehen Sie hier: import org.xml.sax.attributes; import org.xml.sax.saxexception;

15 3.6 Aus-Lese: XML-Dokumente mit DOM4J lesen 55 import org.xml.sax.helpers.attributesimpl; import org.xml.sax.helpers.xmlfilterimpl; public class SignatureFilter extends XMLFilterImpl public void startelement(string url, String localname, String qname, Attributes att) throws SAXException // beginne mit den vorhandenen Attributen AttributesImpl moreatt = new AttributesImpl(att); // füge neues Attribut hinzu: // Typ ist CDATA, Name ist signedby, Wert ist SignatureFilter moreatt.addattribute("", "signedby", "signedby", "CDATA", "SignatureFilter"); // übergib dies an den Listener super.startelement(url, localname, qname, moreatt); Diesen Filter verketten wir nun mit dem, den wir weiter oben angelegt hatten: XMLReader parser = XMLReaderFactory.createXMLReader(); IgnoringFilter filter = new IgnoringFilter(); SignatureFilter signer = new SignatureFilter(); signer.setcontenthandler(new SimplestContentHandler()); filter.setcontenthandler(signer); filter.setparent(parser); filter.parse("c:/projects/wcj3/test.xml"); Dies erzeugt einen in zwei Phasen arbeitenden Filter. Die Daten werden vom XMLReader (dem Parser) übergeben, gehen durch den IgnoringFilter in den SignatureFilter und dann an den Ziel-Content-Handler, nämlich SimplestContentHandler. Mit solchen Prozessflüssen können Sie komplexen XML-Inhalt unter Verwendung von SAX-Events in mehreren Phasen erstellen. Wenn Sie die gefilterten SAX-Events in einen Dokumentbaum einlesen, können Sie ausgewählte Teile eines sehr großen XML-Dokuments verarbeiten, das normalerweise nicht in den Arbeitsspeicher passen würde. Diese Möglichkeit wird in einem späteren Abschnitt noch genauer untersucht. 3.6 Aus-Lese: XML-Dokumente mit DOM4J lesen DOM 4J DOM-Programme sind oft umständlich und schwer lesbar. Manche der DOM-Methoden zum Lesen und Bearbeiten von XML sind nicht gerade die besten. Das Open-Source- Projekt DOM4J stellt eine bessere API zur Verfügung, die XML viel reibungsloser verarbeitet. Da sie nicht zum Java-Core gehört, müssen Sie allerdings die DOM4J-Bibliothek herunterladen und Ihrem Klassenpfad hinzufügen. Manche DOM4J-Objekte sind Analogien von DOM-Objekten, haben aber eine andere API und verwenden andere Methoden und Klassen. Passen Sie nur auf, dass Sie nicht die DOM-Klassen und -Pakete des Java- Core mit denen von DOM4J durcheinander bringen! Den größten Unterschied zwischen den beiden werden Sie beim Lesen von XML-Dokumenten feststellen. Um diesen Unterschied zu veranschaulichen, werden wir nun Daten aus einer UBL-Bestellung (wie in den obigen Beispielen beschrieben) mithilfe von DOM lesen und dann den entsprechenden

16 56 3 Verarbeitung von XML und HTML DOM4J-Code zeigen. Sehen Sie hier als Erstes den DOM-Code zum Laden des Dokuments und zum Abfragen der Werte von BuyersID, IssueDate und LineExtensionTotalAmount: // Dies ist DOM-Code. Die Importe wurden zur Abkürzung weggelassen DocumentBuilderFactory fact = DocumentBuilderFactory.newInstance(); DocumentBuilder parser = fact.newdocumentbuilder(); String url = "C:/projects/wcj3/purchaseOrder.xml"; Document doc = parser.parse(url); // hole das Wurzelelement Element root = doc.getdocumentelement(); NodeList list = root.getelementsbytagname("buyersid"); Element idelem = (Element) list.item(0); String buyersid = idelem.gettextcontent(); System.out.println("Buyers ID is " + buyersid); list = root.getelementsbytagname("issuedate"); Element issueelem = (Element) list.item(0); String issuedate = issueelem.gettextcontent(); System.out.println("Issue date is " + issuedate); list = root.getelementsbytagname("lineextensiontotalamount"); Element totalelem = (Element) list.item(0); String total = totalelem.gettextcontent(); System.out.println("Total amount is " + total); Die ersten vier Anweisungen laden den Parser und parsen das XML-Dokument in ein DOM-Dokumentobjekt. Dann holen wir das Wurzelelement. Der fett gedruckte Code ist der komplizierteste Teil von DOM. Für jeden der drei Werte müssen wir zuerst das Kindelement nach dem Namen abrufen und seinen Kind-Text beschaffen. Hierfür hat das DOM eine Methode, die eine Knotenliste zurückgibt. Wir holen das erste Element der Liste und den unter ihm stehenden Text, indem wir gettextcontent aufrufen. Der entsprechende DOM4J-Code sieht dagegen viel sauberer aus: // Dies ist DOM4J-Code. String url = "C:/projects/wcj3/purchaseOrder.xml"; org.dom4j.io.saxreader reader = new org.dom4j.io.saxreader(); org.dom4j.document doc = reader.read(url); org.dom4j.element root = doc.getrootelement(); String buyersid = root.elementtext("buyersid"); System.out.println("Buyers ID is " + buyersid); String issuedate = root.elementtext("issuedate"); System.out.println("Issue date is " + issuedate); String total = root.elementtext("lineextensiontotalamount"); System.out.println("Total amount is " + total); Beachten sie, dass hier die Klassen org.dom4j.document und org.dom4j.element aus DOM4J stammen, es sind nicht die aus DOM! Die fett gedruckten Zeilen sind äquivalent zu den fett gedruckten Zeilen aus dem DOM-Beispiel. Wie Sie sehen, hat DOM4J eine sehr bequeme Art, Text aus einem Kindelement abzufragen. DOM4J hat noch andere Methoden für eine einfache Verarbeitung von XML-Daten. Das folgende Beispiel gibt die Käufer- und Verkäuferdaten aus der Bestellung zurück. Wenn wir dieselbe DOM4J-doc-Instanz wie zuvor zugrunde legen (org.dom4j.document), finden wir den Namen, die Firma und die Adresse des Käufers, indem wir den Baum durchsuchen: // Dies ist DOM4J-Code Element root = doc.getrootelement(); // hole Element für root->buyerparty->party Element party = root.element("buyerparty").element("party");

17 3.7 Nicht fad, der Pfad: Daten extrahieren mit XPath 57 // hole Firmenname aus Party->PartyName->Name String company = party.element("partyname").elementtext("name"); // Party->Address Element address = party.element("address"); // Address -> StreetName, BuildingNumber, etc String street = address.elementtext("streetname"); String building = address.elementtext("buildingnumber"); String city = address.elementtext("cityname"); String zip = address.elementtext("postalzone"); String state = address.elementtext("countrysubentitycode"); // Party->Contact->Name String contact = party.element("contact").elementtext("name"); Wenn Sie sich die API zur XML-Verarbeitung aussuchen können, wird Ihr Code mit DOM4J sauberer und wartungsfreundlicher sein. Überdies kann DOM4J mit DOM- und SAX-Parsern zusammenarbeiten, sodass Sie ganz einfach Ihr DOM4J-Programm in vorhandenen Code integrieren können. Und zusätzlich hat es noch viele andere nette Features. Eines davon wird im nächsten Abschnitt beschrieben. 3.7 Nicht fad, der Pfad: Daten extrahieren mit XPath DOM 4J Im vorigen Abschnitt 3.6 zeigten wir, wie Sie mit DOM4J-Daten aus einem XML-Dokument lesen können. Mit den Methoden element und elementtext holten wir Daten aus Baumelementen heraus. Hier lernen Sie eine andere Möglichkeit kennen, einen DOM4J- Baum zu durchqueren: eine Ausdruckssprache namens XPath. Mit XPath können wir einen Pfad von der Dokumentwurzel bis zu jedem beliebigen Punkt im Baum gehen, indem wir eine Abkürzung verwenden, die ein wenig wie der Verzeichnispfad von Unix aussieht. Wir wollen wieder das XML der Warenbestellung als Beispiel heranziehen. Die Allgemeinen Geschäftsbedingungen finden wir, indem wir vom Wurzelelement Order bis zu seinem Kindelement DeliveryTerms und dann zu dem Kindelement SpecialTerms und seinem Text gehen. Dies können Sie mit dem folgenden XPath-Ausdruck sagen: /Order/DeliveryTerms/SpecialTerms In DOM4J können Sie sehr einfach den Wert dieses Ausdrucks als String abrufen. So erhalten Sie den Text unterhalb des Tags SpecialTerms: String terms = doc.valueof("/order/deliveryterms/specialterms"); Diese Methode funktioniert mit jeder Art von DOM4J-Node, wie beispielsweise Element oder Document, und sie kann sogar ein relativer Ausdruck sein, der einen Wert in Abhängigkeit vom aktuellen Knoten ermittelt. Sie können den Wert eines XPath-Ausdrucks als Node abrufen, der Text und möglicherweise weitere Kindelemente enthält. Es gibt eine Version, die einen einzelnen Knoten zurückgibt, und eine, die eine java.util.list-knotenliste liefert (zur Bearbeitung mehrerer passender Ergebnisse). Um dies zu veranschaulichen, wollen wir nun die Zeilenelemente aus dem Bestelldokument lesen: List items = doc.selectnodes("/order/orderline"); Iterator iter = items.iterator();

18 58 3 Verarbeitung von XML und HTML while (iter.hasnext()) Element orderline = (Element) iter.next(); String qty = orderline.valueof("lineitem/quantity"); String desc = orderline.valueof("lineitem/item/description"); String price = orderline.valueof("lineitem/item/baseprice/priceamount"); System.out.println(qty + " " + desc + " at " + price); Die erste Codezeile liest die Elemente der Bestellung in eine Knotenliste (List) ein. Wir durchlaufen diese Liste mit relativen XPath-Ausdrücken, um den Text jedes Elements zu extrahieren. Mit XPath konnten wir mit wenigen Codezeilen einen weitaus größeren Teil des Dokuments lesen. XML (und HTML) in DOM4J zu erzeugen ist genauso einfach. Im nächsten Beispiel nutzen wir DOM4J, um eine XHTML-Seite zum Anzeigen der vorhin gesammelten Elemente zu erzeugen. XHTML ist HTML-Inhalt, der zugleich korrektes XML ist (in dem beispielsweise Tags richtig geschlossen werden und Attribute in Anführungszeichen stehen). Wenn das Programm läuft, erzeugt es eine HTML-Ausgabedatei, wie Abbildung 3.2. veranschaulicht Abbildung 3.2: HTML-Ergebnis von DOM4J Wir erstellen als Erstes ein neues Dokument mit der Methode createdocument von DocumentHelper. Dann rufen wir, wenn nötig, die Methoden addelement und addtext auf, um den HTML-Inhalt zu erzeugen. In diesem Beispiel arbeiten wir mit zwei DOM4J- Dokumenten: einem zum Lesen der XML-Eingabe und einem zum Generieren der HTML- Ausgabedatei. Vor dem Programmcode sehen Sie hier die Importe: import java.io.filewriter; import java.io.ioexception; import java.util.iterator; import java.util.list; import org.dom4j.document; import org.dom4j.documentexception;

19 3.7 Nicht fad, der Pfad: Daten extrahieren mit XPath 59 import org.dom4j.documenthelper; import org.dom4j.element; import org.dom4j.io.htmlwriter; import org.dom4j.io.outputformat; import org.dom4j.io.saxreader; Und hier folgt der Code, allerdings ohne Exception-Handling: // Lies das XML-Eingabedokument (purchase order) String url = "C:/projects/wcj3/purchaseOrder.xml"; SAXReader reader = new SAXReader(); Document po = reader.read(url); // Erzeuge die Ausgabe als HTML-Dokumentobjekt Document htmldoc = DocumentHelper.createDocument(); // Füge einen Titel mit der extrahierten Kundennummer hinzu String buyerid = po.valueof("/order/buyersid"); String title = "Purchase Order #" + buyerid; // Erzeuge das HTML-Wurzelelement und den Dokumenttitel Element html = htmldoc.addelement("html"); html.addelement("head").addelement("title").settext(title); // Erzeuge einen Body-Tag und die H1-Titelüberschrift Element body = html.addelement("body"); body.addelement("h1").addtext(title); // Lege die HTML-Tabelle mit Rand an Element table = body.addelement("table").addattribute("border", "1"); // Lege Überschriftzeile an Element header = table.addelement("tr"); header.addelement("th").addtext("quantity"); header.addelement("th").addtext("description"); header.addelement("th").addtext("price"); header.addelement("th").addtext("subtotal"); // Hole die Liste der Zeilenelemente des Dokuments List items = po.selectnodes("/order/orderline"); Iterator iter = items.iterator(); while (iter.hasnext()) Element item = (Element) iter.next(); // Füge eine Tabellenzeile hinzu Element row = table.addelement("tr"); // Füge eine Zelle für die Mengenangabe hinzu row.addelement("td").addtext(item.valueof("lineitem/quantity")).addattribute("align","right"); // Füge eine Zelle für die Beschreibung hinzu row.addelement("td").addtext(item.valueof("lineitem/item/description")); // Füge eine Zelle für den Stückpreis hinzu String priceamount = item.valueof("lineitem/item/baseprice/priceamount"); row.addelement("td").addtext(priceamount).addattribute("align","right"); // Füge eine Zelle für die Zwischensumme hinzu row.addelement("td").addtext(item.valueof("lineitem/lineextensionamount")).addattribute("align","right"); // Erstelle die Zeile für die Gesamtsumme Element totalrow = table.addelement("tr"); totalrow.addelement("th").addattribute("colspan", "3").addText("Total"); String total = po.valueof("/order/lineextensiontotalamount"); totalrow.addelement("th").addtext(total);

20 60 3 Verarbeitung von XML und HTML // Sende das HTML-Ausgabedokument als Strom auf die Festplatte // Mit "pretty printing" produzieren wir leicht lesbares HTML // Ohne diese Maßnahme hätten die Tags weder Einrückung noch Whitespace OutputFormat format = OutputFormat.createPrettyPrint(); FileWriter file = new FileWriter("order.html"); HTMLWriter writer = new HTMLWriter(file, format); writer.write(htmldoc); writer.close(); Dieser Code zeigt, auf welch ungewöhnliche Weise DOM4J-Programme oft ihre Methodenaufrufe aneinander hängen, wenn sie Kindelemente anlegen. Diese Verkettung ist möglich, da die Methode addelement das neu erzeugte Element zurückgibt und die Methoden addtext und addattribute das Originalelement (dem Sie den Text hinzugefügt hatten). Wenn Sie noch nie mit HTML gearbeitet haben, müssen Sie vielleicht in einer HTML- Referenz nachschlagen (siehe Website zu diesem Buch), um die Tabellen-Tags und die Attribute zu verstehen, die das Layout einer Tabelle beeinflussen. Um keine Verwechslung der Elements, die zum Lesen der Daten verwendet werden, und der Elements, die zur Erstellung der Ausgabe verwendet werden, zu riskieren, habe ich die Daten fast nur durch XPath-Ausdrücke extrahiert (indem ich die Methode valueof auf dem po-objekt aufrief). Das einzige Element, das Eingabedaten darstellt, ist die Variable item in der while- Schleife, und diese enthält die aktuelle Zeile, die gerade verarbeitet wird. Alle anderen E- lements werden zur Erstellung des Ausgabedokuments benutzt. Diese HTML-Erzeugung hätte auch durch ein XSL-Stylesheet ganz ohne Java-Code erledigt werden können. Auf der Website zu diesem Buch finden Sie Links zu Informationen, die Ihnen verraten, wie Sie mit XSL aus einer XML-Datei HTML erstellen. 3.8 Unsichtbare Tags: Dokumente vor dem Laden in DOM4J filtern DOM 4J Java 1.4+ Wenn Sie ein XML-Dokument in DOM4J laden, muss es klein genug sein, um vollständig in den Arbeitsspeicher zu passen. Für sehr große Dokumente besteht allerdings die Möglichkeit, sie vor dem Einlesen in den Arbeitsspeicher zu filtern. Etwas Ähnliches haben wir im Abschnitt 3.5 ( SAX-ische Spezialität: ContentHandler gefiltert füttern ) bereits gesehen, als wir die SAX-Events mit einem SAXFilter herausfilterten. Doch anstatt einen Baum aufzubauen, verarbeitete unser Programm die SAX-Events unmittelbar. Die meisten Dokumentobjekt-Bäume werden ursprünglich aus SAX-Events erstellt. Indem Sie jedoch zwischen die SAX-Events und den Handler, der den Baum erzeugt, einen XMLFilter stellen, können Sie einen Teil des Inhalts für den Baumerstellungsprozess unsichtbar machen. Diese Baumfilterung lässt sich an dem Beispiel mit der Bestellung verdeutlichen. Wir wollen jetzt lediglich die Daten des Verkäufers in einen DOM4J-Baum laden, die nur einen kleinen Teil des Dokuments darstellen. Erinnern Sie sich an den Beginn dieses Abschnitts

21 3.8 Unsichtbare Tags: Dokumente vor dem Laden in DOM4J filtern : Eine Bestellung in der UBL enthält die Daten des Käufers (Buyer) und Verkäufers (Seller) sowie die Lieferbedingungen (DeliveryTerms) und die Auftragspositionen (OrderLine) mit ihren Einzelposten (LineItem). Im Folgenden sehen Sie eine Kurzversion des bisher in diesem Kapitel verwendeten XML, aus der die übergeordnete Struktur des Dokuments ersichtlich ist: <Order> <BuyersID> </BuyersID> <IssueDate> </IssueDate> <LineExtensionTotalAmount>438.50</LineExtensionTotalAmount> <BuyerParty>  </BuyerParty> <SellerParty>  </SellerParty> <Delivery>  </Delivery> <DeliveryTerms> <SpecialTerms>Signature Required</SpecialTerms> </DeliveryTerms> <OrderLine> <LineItem>  </LineItem> </OrderLine> <OrderLine> <LineItem>  </LineItem> </OrderLine>  </Order> Auch wenn es im wirklichen Leben eher unwahrscheinlich sein mag: Stellen Sie sich vor, Sie haben ein extrem großes Bestellungsdokument im Umfang von vielen Gigabytes. (Wir befinden uns in einer fernen Zukunft, und es handelt sich um die Bestellung von Ersatzteilen für den Warp-Antrieb eines Raumschiffs.) Die Chefin will, dass nur die Verkäuferdaten aus dem Dokument angezeigt werden, und verlangt die Verwendung einer Baumstruktur. Natürlich können wir nicht einfach das ganze Dokument in den Baum laden (jedenfalls nicht auf meinem heutigen Computer). Das würde nicht nur den Arbeitsspeicher überfordern, sondern wäre auch Platzverschwendung, da wir nur einen Teil des Dokuments benötigen. Also erstellen wir wie vorhin einen Filter, der alles außer den Verkäuferdaten ignoriert. Hierzu schreiben wir eine Unterklasse von XMLFilterImpl, die nur Inhalte zwischen einem SellerParty-Start-Tag und dem dazugehörigen End-Tag als Ausgabe an den SAX- Handler schickt. Hier sehen Sie eine stark vereinfachte Version dieses Filters: public class SellerFilter extends XMLFilterImpl private boolean ignoring = true; public void startelement(string url, String localname, String qname, Attributes att) throws SAXException if (localname.equals("sellerparty")) ignoring = false; if (!ignoring)

22 62 3 Verarbeitung von XML und HTML super.startelement(url, localname, qname, att); public void characters(char[] arg0, int arg1, int arg2) throws SAXException if (!ignoring) super.characters(arg0, arg1, arg2); public void endelement(string url, String localname, String qname) throws SAXException if (!ignoring) super.endelement(url, localname, qname); if (localname.equals("sellerparty")) ignoring = true; Der Filter dreht den Hahn auf, wenn er auf das richtige öffnende Tag stößt (SellerParty) und dreht den Hahn wieder zu, wenn das schließende Tag auftaucht. Um diesen Filter in den DOM4J-Builder zu integrieren, setzen wir ihn zwischen den SAX-Parser, der den Eingabestrom erzeugt, und den Builder, der den Baum aufbaut. Die Klasse SAXReader in DOM4J hat eine wunderbare Methode namens setxmlfilter, um dieses zu erledigen: org.dom4j.io.saxreader parser = new org.dom4j.io.saxreader(); SellerFilter filter = new SellerFilter(); parser.setxmlfilter(filter); org.dom4j.document doc = parser.read("c:/projects/wcj3/test.xml"); Darüber hinaus verfügt DOM4J über einen eigenen Baumschnitt-Mechanismus, der sich ein wenig vom SAX-Filterprozess unterscheidet. Die DOM4J-Dokumentation beschreibt den anderen Ansatz und stellt Codebeispiele vor. In dem Beispiel des vorliegenden Abschnitts wurde derselbe Filterprozess wie von SAX verwendet, da er allgemeingültiger ist und der resultierende Filter auch als Teil einer Kette von SAX-Filtern eingesetzt werden könnte. 3.9 Sinn-Taxen: Parser für alle Lebenslagen mit JavaCC JavaCC Manchmal haben Sie das Glück, mit Daten arbeiten zu können, die eine wohlbekannte Syntax aufweisen, wie zum Beispiel XML oder HTML. Dies war auch bisher in diesem Kapitel der Fall. In solchen Fällen können Sie auf bereits vorhandene Parser zurückgreifen. Doch für andere Datenstrukturen kann es sein, dass Sie einen eigenen Parser schreiben müssen. Im Grunde haben wir genau dies in Kapitel 2 im Abschnitt 2.7 ( Vertrackt, aber geknackt: Komplexe Syntax mit der Scanner-Klasse parsen ) bereits getan: Wir kodierten unsere Kenntnis der Grammatik, die Beziehungen zwischen allen Teilen der Daten, in das Programm selbst ein. Wenn bei der Umwandlung der Grammatik in Programmlogik keine Fehler auftreten, funktioniert das ganz prima. Doch bei komplexen Grammatiken steigt die

23 3.9 Sinn-Taxen: Parser für alle Lebenslagen mit JavaCC 63 Gefahr von Logikfehlern, und das Programm ist viel schwerer zu schreiben und zu warten. Dies ist der Grund dafür, warum fast jeder einen vorhandenen Parser für XML oder HTML benutzt, anstatt einen eigenen zu schreiben! Wenn Sie eine Grammatik für etwas anderes etwa eine benutzerdefinierte Sprache verarbeiten möchten, ist es besser, die Regeln der Grammatik zuerst in einer Spezifikationssprache zu kodieren. Dann, nachdem Sie die Grammatikregeln selbst getestet haben, können Sie um diese Grammatik herum einen Parser bauen. Sie können nachts besser schlafen, wenn Sie wissen, dass die Grammatik korrekt ist, bevor Sie damit beginnen, die Programmlogik zu schreiben. Um strukturierten Text zu verarbeiten, müssen Sie ihn vorab in Tokens zerlegen, also in Objekte, die unteilbare Dateneinheiten darstellen. Die Erstellung von Tokens aus einem Eingabetext bezeichnet man als Scannen (oder auch als lexikalische Analyse oder Lexing). So werden beispielsweise beim Scannen eines mathematischen Ausdrucks alle Zahlen, Variablennamen, Funktionsnamen, Klammern und Operatoren getrennte Tokens. Weiter oben haben wir bereits eine einfache lexikalische Analyse vorgenommen, als wir den Domain- Namen aus einer URL herausholten, indem wir einen regulären Ausdruck mit Capturing Groups verwendeten. Man kann sagen, dass jede Capturing Group ein Token erstellt. Wenn eine Anwendung einen Eingabestrom in Tokens zerlegt, bekommt sie eine Liste von Objekten, welche die Tokens in der Reihenfolge ihres Auftretens im Text repräsentieren. Im nächsten Schritt muss eine Datenstruktur ein abstrakter Syntaxbaum (abstract syntax tree, AST) aufgebaut werden, um die Beziehungen zwischen den Tokens darzustellen. Ein mathematischer Ausdruck ist ein häufig auftretender Typ eines Syntaxbaums, ein XML-Dokument ist ein anderer. Ein Parser verarbeitet einen Eingabestrom, um einen AST auf der Grundlage einer Grammatik zu erstellen, die beschreibt, welche Tokens in dem Baum zulässig sind und nach welchen Regeln sie gebraucht werden. Parser werden normalerweise aus einer Grammatikspezifikation generiert und nicht manuell programmiert. Ein Parser-Generator konvertiert die Grammatik in ein Programm, welches diese Grammatik erkennt. Betrachten wir einmal eine einfache Grammatik, nämlich die der weiter oben beschriebenen Logdatei: eventtype year month day time type-dependent-data Wir werden nun mit einem Open-Source-Parser-Generator namens JavaCC einen Javabasierten Parser aus einer Grammatikspezifikation erstellen. Jede Grammatik besteht aus einer Reihe von Produktionsregeln, die erklären, wie der Syntaxbaum aus den Tokens aufgebaut wird. Der JavaCC-Compiler liest eine.jj-datei, in der die Grammatikregeln beschrieben sind, und generiert den Java-Quellcode für einen Parser. Die Eingabedatei enthält ebenfalls Java-Code für die Logik, die zusätzlich noch in die Parser-Klasse eingebunden werden soll. Der erste Teil einer.jj-datei definiert den Kern der Parser-Klasse. PARSER_BEGIN(LogParser) public class LogParser public static void main(string[] args) try LogParser parser = new LogParser(System.in); parser.alllines(); catch (ParseException e) System.out.println("Error: This is not a valid file.");