2.4 Vorteile der Kombination von Java und XML
Werbung
Java und XML Seminarbeitrag von Ralph-Peter Noll Oldenburg, den 23.05.2001 Inhalt 1. Einleitung ................................................................................................................................... 3 2. Grundlagen................................................................................................................................. 4 2.1 XML..................................................................................................................................... 4 2.2 Exkurs: XML in „10“ Punkten .............................................................................................. 4 2.3 Java ...................................................................................................................................... 5 2.4 Vorteile der Kombination von Java und XML...................................................................... 6 2.5 Probleme dieser Kombination ............................................................................................... 7 3. Parsing von XML-Dokumenten .................................................................................................. 8 3.1 SAX...................................................................................................................................... 8 3.2 Erweiterungen bei SAX 2.0................................................................................................. 10 3.3 Diskussion SAX.................................................................................................................. 10 3.4 DOM .................................................................................................................................. 10 3.5 DOM Level 2...................................................................................................................... 13 3.6 Ausblick auf DOM Level 3 ................................................................................................. 15 3.7 Diskussion DOM ................................................................................................................ 15 3.8 JAXP .................................................................................................................................. 15 3.9 JDOM................................................................................................................................. 16 4 Anwendungen der Kombination Java und XML ........................................................................ 17 4.1 Java-gestützte Transformation von XML ............................................................................ 17 4.2 XML für Datenaustausch und Datenpersistenz .................................................................... 18 5. Fazit ......................................................................................................................................... 20 Anhang: Java und XML - Werkzeuge........................................................................................... 21 Parser ....................................................................................................................................... 21 IBM XML and Web Services Development Environment......................................................... 21 Apache ..................................................................................................................................... 21 Quellen......................................................................................................................................... 23 2 1. Einleitung XML, die "Extensible Markup Language", ist viel mehr als eine Sprache zur Beschreibung von Textdokumenten. Eine XML-Datei sieht einer HTML-Datei ähnlich, doch dies ist auch schon die einzige Gemeinsamkeit. Die HTML-artigen ‚Tags' werden bei XML nicht nur zur Formatierung von Text verwendet, sondern dienen zur Identifikation der Art der Daten, die in den Dokumenten vorkommen, so daß diese Daten leicht in verschiedene Darstellungen umgewandelt und allgemein leicht verarbeitet werden können. Eine wesentliche Rolle bei der Organisation und Finanzierung der Entwicklung der Sprache XML spielte die Firma Sun, Urheber der plattformunabhängigen Programmiersprache Java [Bray00]. Java wird von Sun als die ideale Plattform für server- und clientseitige XML-Verarbeitung dargestellt. Mit Java lassen sich leicht portable und wartbare Programme schreiben, mit denen die ebenfalls plattformunabhängigen, wiederverwendbaren XML-Datenbestände gelesen werden können. Neben den Produkten von Drittherstellern, hier sind vor allem IBM und Apache, aber auch Microsoft zu nennen, gibt es auch von Sun einige Erweiterungen der "Java-Plattform" zur Entwicklung XML-basierter Anwendungen. Nun soll der Aufbau der Arbeit vorgestellt werden: In einem ersten Teil werden die Grundlagen zu den Themen XML und Java beschreiben, um die Voraussetzungen für das Verständnis der folgenden Kapitel zu schaffen. Daran wird sich ein umfangreicher Abschnitt über das Parsen von XML anschließen. Parsen bedeutet, daß der XML-Text gelesen und in eine passende programminterne Darstellung umgewandelt wird. Als dritter Teil soll eine Übersicht über mögliche Anwendungsfelder der Kombination Java und XML gegeben werden. Abschließend werden einige Werkzeuge für die Arbeit und Programmentwicklung mit den Technologien XML und Java kurz vorgestellt. 3 2. Grundlagen 2.1 XML Einfach erklärt handelt es sich bei XML (Extensible Markup Language) um ein System von Regeln, anhand derer Informationen gekennzeichnet oder „etikettiert“ werden können. XML ist deshalb so wichtig, weil es den Austausch von Informationen vereinfacht, und weil es auf syntaktischer Ebene einen branchenübergreifenden Standard bietet, der universell zur Verarbeitung und Verwaltung von Daten eingesetzt werden kann. Die XML-Spezifikation bietet eine Sammlung verbindlicher Regeln, um sich für den eigenen Bedarf eine HTML-artige Syntax zu definieren. Dokumente in dieser Syntax sind insbesondere leicht auf deren korrekten formalen Einsatz verifizierbar und damit sehr gut für eine automatische Verarbeitung geeignet. Strukturierten Daten kann so eine Form gegeben werden, die sowohl von Menschen als auch von Maschinen ‚verstanden‘ werden kann. 2.2 Exkurs: XML in „10“ Punkten Bert Bos, ein Mitglied des W3C, beschreibt XML unter der Überschrift „XML in 10 Punkten“ folgendermaßen [Bos99]: 1. XML ist ein Verfahren, strukturierte Daten in Textdokumente zu verpacken. "Strukturierte Daten" sind beispielsweise Tabellen, Finanztransaktionen, Konfigurationsparameter oder Baupläne. Diese müssen häufig auf Datenträgern gespeichert werden, entweder in einem binären Format oder als Text. Text hat den Vorteil, daß man ihn auch ohne spezielle Programme betrachten kann. XML ist eine Sammlung von Regeln, um das Format solcher Textdateien zu entwerfen. Ziele dabei sind - Maschinenlesbarkeit: Daten sind leicht automatisch zu generieren / analysieren. - Eindeutigkeit - Allgemeinheit, Erweiterbarkeit - leichte Internationalisierbarkeit - Plattformunabhängigkeit - Interoperabilität zwischen Produkten verschiedener Hersteller 2. XML sieht zwar aus wie HTML, ist aber anders. In XML werden, genauso wie in HTML, Tags (<Tagname>) und Attribute (Attributname="wert") verwendet. Im Gegensatz zu HTML, wo die Tags und Attribute und ihre Bedeutung fest spezifiziert sind, ist die Interpretation bei XML beliebig. Tags dienen hier dazu, Daten zu benennen und voneinander abzugrenzen, wobei nur das jeweils lesende Programm weiß, welche Bedeutung diesen zukommt. Ein <p> in HTML steht für einen neuen Absatz, in XML kann es ein Preis, Produkt, Parameter - oder irgendetwas sein, das nicht mit ‚P' anfängt. 3. XML ist Text, wird aber normalerweise nicht von Menschen gelesen. XML-Dateien eignen sich noch weniger als HTML-Dateien dazu, von Menschen gelesen (oder geschrieben) zu werden. Die textuelle Codierung wurde gewählt, um die Programmentwicklung zu erleichtern, und in Notfällen per Texteditor Korrekturen vornehmen zu können. Die Syntaxregeln von XML sind jedoch viel strenger als bei HTML, so daß etwa ein fehlendes Tag oder fehlende Anführungszeichen die gesamte Datei unbrauchbar machen. Programme dürfen, so ist es in der XML-Spezifikation festgeschrieben, keinesfalls versuchen, den Inhalt ungültiger XML-Dateien zu erraten. 4 4. XML umfaßt eine ganze Sammlung von Technologien. In der Spezifikation XML 1.0 wurde definiert, was ein Tag und was ein Attribut ist. Zusäzlich existieren immer mehr optionale Module, in denen solche Tags und Attribute oder Richtlinien für bestimmte Anwendungen festgeschrieben werden. Xlink beschreibt beispielsweise einen Standart, wie Hyperlinks in XML dargestellt werden. XPointer und XFragments sind Schreibweisen, um Teile eines XML-Dokuments zu benennen. CSS, die "Stylesheet"-Sprache, läßt sich sowohl auf HTML auch auf XML anwenden. XSL ist eine erweiterte Notation um Stylesheets zu beschreiben, die auf XSLT basiert, einer Transformationssprache, die ebenfalls auch außerhalb XSL verwendet werden kann. Mit XSLT können Tags und Attribute neu gruppiert, hinzugefügt oder gelöscht werden. Das DOM ist eine Sammlung von Funktionsaufrufen um XML (oder HTML) aus einer Programmiersprache zu verändern. XML "Namespaces" heißt eine Spezifikation, mit der jedem einzelnen Tag und Attribut eine URL zugewiesen werden kann (etwa um deren Datentypen festzulegen etc.). XML "Schemas" sollen Entwicklern ermöglichen, ihre XML-basierten Dateiformate präzise zu spezifizieren. 5. XML ist ausführlich, aber das ist kein Problem XML-Dateien sind in der Regel erheblich größer als äquivalente binäre Kodierungen. Den damit verbundenen Nachteilen kann auf einer anderen Ebene begegnet werden. Der Preis großer Massenspeicher sinkt stetig, außerdem können XML-Dateien schnell und effektiv mit Programmen wie zip und gzip komprimiert werden. Zusätzlich können Kommunikationsprotokolle wie HTTP/1.1 die Daten während der Übertragung komprimieren, so daß nicht mehr Bandbreite beansprucht wird als bei Binärformaten. 6. XML ist neu, aber nicht zu neu. XML wurde seit 1996 entwickelt und 1998 als W3C-Standart verabschiedet. Trotz des geringen Alters der Sprache kann diese Technologie heute als recht ausgereift angesehen werden, da sie einerseits auf SGML fußt, das seit den 80er Jahren für große technische Dokumentationsprojekte verwendet wird, und andrerseits mit HTML seit 1990 eine weitere bekannte Grundlage für XML existiert. XML versucht nun die besten Teile von SGML mit den Erfahrungen mit HTML zu kombinieren. So soll XML die gleiche Mächtigkeit wie SGML bieten, jedoch in sich regulärer und leichter anzuwenden sein. 7. XML ist kostenlos, plattformunabhängig und weit verbreitet. Mit der Entscheidung, XML als Grundlage für ein Projekt zu verwenden, erschließt man sich eine reichhaltige Auswahl an Werkzeugen und erfahrenem Personal. Mit dieser Auswahl verhält es sich ähnlich wie mit der Entscheidung für SQL als Datenbanksprache: Man muß immer noch sein eigenes Programm implementieren, seine eigene Datenbank entwerfen, kann sich dabei aber von erfahrenen Experten und mächtiger Software unterstützen lassen. Man ist mit der freien W3C-Technologie auch nicht an einen Anbieter gebunden. XML mag nicht immer die Ideallösung darstellen, sollte jedoch grundsätzlich erwägt werden. 2.3 Java Die Ausführungen in diesem Abschnitt basieren wesentlich auf [Sun01] und [Bergmann98]. Java ist eine recht junge, plattformunabhängige Programmiersprache des Workstation-Herstellers Sun, die einen Kompromiß darstellt zwischen folgenden Anforderungen: • • • • • • Einfachheit und Kompaktheit Objektorientierung, Umsetzung moderner Konzepte Robustheit Sicherheit Plattformunabhängigkeit, Portabilität der Anwendungen Leistung Die Sprache soll einfach und leicht erlernbar sein, so daß sich die Programmierung einem möglichst großen Kreis von Menschen erschließt. Java ist eine Weiterentwicklung von C++, wobei hier auf fehlerträchtige Konstrukte und bekannte Fallstricke dieser älteren Sprache verzichtet wurde. Aus diesem Grunde ist der Lernaufwand gerade für C/C++ - Programmierer besonders gering. 5 Das objektorientierte Programmierparadigma hat sich in der Softwareentwicklung längst durchgesetzt. Im Idealfall erzeugt man mit objekt-orientierter Programmierung wiederverwendbare Klassen. Ein Satz Klassenbibliotheken für Standardaufgaben wird zur Sprache Java mitgeliefert. Durch den Verzicht auf die fehlerträchtigen Teile der Sprache C++ und durch die Möglichkeiten eines mächtigen Laufzeitsystems wird Java robust, das heißt die Einhaltung der Programmspezifikation ist leichter zu erreichen und vorhandene Programmierfehler haben weniger katastrophale Auswirkungen. Java bietet neben der Robustheit durchdachte Sicherheits- und Schutzmechanismen, mit denen sich die Ausführung „gefährlicher“ Anweisungen verhindern läßt. Fertig kompilierte Java-Programme sind portabel, sie laufen auf vielen verschiedenen Zielmaschinen. Dies wird dadurch ermöglicht, daß diese nicht als Programmcode einer bestimmten Architektur sondern in Form von allgemeinem, sogenanntem Bytecode gespeichert werden. Dieser Bytecode wird dann zur Laufzeit interpretiert. Bytecode kann natürlich nicht so schnell ausgeführt werden wie nativer Code. Eine Gemeinsamkeit mit XML: Auch hier wird eine höhere Komplexität in Kauf genommen mit der Hoffnung, daß sich dieser Nachteil durch die fortschreitende technische Entwicklung relativiert. Auch optimierende und dynamisch kompilierende Interpreter helfen, sich der Geschwindigkeit nativer Hochsprachenprogramme anzunähern. 2.4 Vorteile der Kombination von Java und XML In diesem Abschnitt soll dargestellt werden, warum „Java und XML“ eine gute Kombination darstellt. Die Beschreibung der beiden Technologien läßt einige Parallelen erkennen: Beide sind unabhängig von der technologischen Plattform und sehr allgemein abgefaßt, so daß eine breite Anwendbarkeit gewährleistet ist. Beide sind mit Blick auf das globale Netzwerk entwickelt worden. Datenaustausch und WWWAnbindung dürften also bei einem darauf aufbauenden Projekt leicht zu ergänzen sein, wenn sie nicht sogar den Kern der Anwendung bilden. Beide begünstigen eine schnelle Programmentwicklung. Bei XML ist es insbesondere die Transparenz und Verfügbarkeit von Tools, bei Java die konsistente Verwendung moderner Sprachkonzepte, die zu diesem Vorteil führt. Nach [Patrizio00] kann identische Funktionalität im Vergleich zu C++ in Java mit einem Bruchteil der Programmzeilen hergestellt werden. Schnelle Entwicklung begünstigt im geschäftlichen Umfeld eine höhere Flexibilität und eine schnellere Reaktion auf Marktchancen. Beide sind verbreitete Technologien, die auf einem festen Standard aufbauen. Es ist also die Kompatibilität verschiedener Produkte gewährleistet, seien es selbstentwickelte BusinessApplikationen oder angeschaffte Werkzeuge. Überhaupt ermöglichte die Standardisierung und Normung erst die Entwicklung eines derart breiten Angebots von Bibliotheken und Werkzeugen, wie es heute von Sun, IBM, Oracle und vielen weiteren wichtigen Herstellern verfügbar ist. So ist man nach der Entscheidung für ein Produkt auch nicht auf Gedeih und Verderb an das Angebot eines bestimmten Anbieters gebunden. Betrachtet man die beiden Untersuchungsobjekte dieser Ausarbeitung auf einer abstrakten Ebene nicht als Programmiersprache und Datenformat, sondern als Technologien des ECommerce mit 6 bestimmten Stärken und Schwächen (wie etwa in [Sun01b]), so fällt auf, daß sich die komplementären Profile dieser Standards ideal ergänzen: Java bildet die Plattform, die Grundlage, ein neues System mit einer spezifischen Verarbeitungslogik auszustatten. Dazu gehören Algorithmen und Schnittstellen zu Benutzern und zu anderen technischen Systemen. Aufgrund der positiven Eigenschaften von Java, wie sie oben dargestellt wurden, ist es in vielen Fällen anderen Plattformen vorzuziehen. Keinen Vorteil bietet Java jedoch, wenn es darum geht, Daten mit bestehenden, oft alten (aber wertvollen, weil ausgereiften) Systemen in Unternehmen auszutauschen. Hier wären eher Plattformen im Vorteil, die denen bestehender Systeme ähneln. Hinzu kommt mit XML das zukünftig wohl dominierende Datenformat. Mehr als ein Datenformat ist die XML-Technologie jedoch nicht. XML kann per se keine Algorithmen beschreiben, keine Funktionalität erfüllen. Es erfordert deshalb allerdings auch keine Festlegung auf bestimmte Programmierplattformen und bietet so die Möglichkeit, unterschiedlichste Systeme beim Datenaustausch die gleiche Sprache sprechen zu lassen. Eine Schwäche von XML kann mit Java sehr gut ausgeglichen werden: XML verträgt sich nicht gut mit SQL-Datenbanken. XML läßt viel mehr Spielraum bei Datentypen, Struktur und Navigation, also Dinge, die man mit ‚flachen‘ SQL-Daten nicht realisieren kann. Man benötigt also eine Zwischenschicht, wie sie sich mit Java leicht realisieren läßt [Patrizio00]. 2.5 Probleme dieser Kombination In diesem Abschnitt sollen noch einmal die möglichen Kritikpunkte erläutert werden, die sich im Wesentlichen aus den Charakteristika der beiden Einzeltechnologien ergeben: Effizienz: Java als interpretierte Sprache kann auf den üblichen Rechnerplattformen nie die quantitative Leistung erzielen wie nativer Code. Verschlimmernd kommt hinzu, daß XML in ähnlicher Weise durch einen erhöhten Overhead die Leistung reduziert. Hier ist einerseits mit optimierenden Java-Laufzeitumgebungen (Just-In-Time-Compiler) und andererseits durch Wahl effizienter, ggf. nativer per JNI eingebundener Bibliotheken für das XML Parsing eine gewisse Optimierung möglich. Kosten: Durch den rasanten Erfolg der beschriebenen Technologien drängt sich der Verdacht auf, es handele sich um Modeerscheinungen. Ob dem so ist, ob also das Interesse an Java und insbesondere XML mit zunehmender Verbreitung wieder abnimmt, sei dahingestellt. Fest steht jedoch, daß Produkte, die sich mit diesen Worten schmücken können, teurer angeboten werden können als andere, welche je nach Verwendungszweck eine ähnliche Leistung bieten. Ebenso teuer wird die Beschaffung qualifizierten Personals, das sich ‚wirklich‘ mit Java und dem Dschungel der XML-Produkte auskennt. Als Abschluß der Diskussion von Java und XML läßt sich feststellen, daß aufgrund von ähnlichen Zielsetzungen und komplementären Stärken der beiden Technologien diese Kombination sehr sinnvoll erscheint. Die gefundenen Schwächen sind demgegenüber eher grundsätzlicher Natur und sollten (wie viele andere Problemstellungen) im Rahmen des Software-Entwicklungsprozesses berücksichtigt und umgangen bzw. ausgeglichen werden. 7 3. Parsing von XML-Dokumenten Um die Daten aus XML-Dateien weiterverarbeiten zu können, müssen diese aus der XML-Syntax in programminterne Strukturen umgewandelt werden. Dazu benötigt man eine Programmkomponente, die den XML-Text liest, dessen Struktur erkennt und für Einheiten im Text Datenelemente zurückliefert. Die meisten XML-basierten Programme stützen sich dabei auf die SAX- und DOM-APIs. Es existiert eine Reihe von Parsern für XML-Texte, einige davon sind Standalone-Parser, das heißt man kann ihnen ein Dokument übergeben und sie liefern einfach nur zurück, ob dieses syntaktisch korrekt ist oder nicht. Da wir jedoch am Inhalt interessiert sind, wollen wir hier solche Parser betrachten, die extrahierte Informationen während der Analyse an das aufrufende Programm zurückliefern. Diese nennt man ereignisgesteuerte Parser. Für die Rückgabe der Daten benötigt man eine Programmierschnittstelle, und zwar möglichst eine einheitliche Schnittstelle für XMLLeser verschiedener Hersteller. 3.1 SAX Der populärste Standard für ereignisgesteuerte Parser heißt SAX (Simple API for XML). Er entstand als Ergebnis der Diskussion auf der xml-dev-Mailingliste [XMLDev]. Ziel der Standardisierung war unter anderem die Austauschbarkeit verschiedener Parser, die ja im Grunde alle sehr ähnlich vorgehen, und der leichtere Transfer von Know-How zwischen XML-basierten Programmen. Die meisten dieser Parser wurden in Java implementiert. Neben den im Folgenden erklärten Informationen läßt sich eine umfassende Darstellung von SAX unter [Megginson01] abrufen. SAX ist ein Interface nur für ereignisgesteuerte Parser. Das heißt, daß der Parser die XML-Datei von vorne bis hinten sequentiell liest und, wenn er auf bestimmte syntaktische Einheiten trifft, vom Programm bereitgestellte Callback-Methoden mit den extrahierten Daten als Parameter aufruft. Die Prüfung der Korrektheit der XML-Syntax ist dabei eher ein Nebeneffekt. Solche Parser sind leicht zu implementieren, da sie nur minimale interne Daten verwalten müssen. Anstatt interne Strukturen aufzubauen, liefert ein SAX-Parser Informationen nur der Reihe nach durch besondere Methodenaufrufe zurück, wie das folgende Beispiel aus [Megginson01] verdeutlicht: Die XML-Datei <?xml version="1.0"?> <doc> <para>Hello, world!</para> </doc> führt zu dieser Abfolge von Aufrufen selbst bereitgestellter Methoden: DocumentHandler.startDocument(); DocumentHandler.startElement(…, „doc“, …); DocumentHandler.startElement(…, „para“, …); DocumentHandler.characters(„Hello, world!“,…); DocumentHandler.endElement(…, „para“, …); 8 DocumentHandler.endElement(…, „doc“, …); DocumentHandler.endDocument(); Dieser effiziente Ansatz zum Parsing eignet sich besonders für große Datenmenten (große Dateien, kontinuierliche Streams) und für Fälle, in denen nur geringe Anteile der Daten herausgelesen werden sollen. Die Definition der Callback-Methoden bildet den Kern von SAX. Java-Klassen können diese Methoden implementieren, indem sie von den entsprechenden ‚org.xml.sax.*‘ Interfaces erben. Im einzelnen sind dies: • • • • • • • Parser DocumentHandler AttributeList ErrorHandler Locator DTDHandler EntityResolver Die Klasse, die das Interface Parser ausfüllt, stellt den eigentliche Funktionalität zur Verfügung. Der Parser läßt sich über entsprechende get/set-Methoden mit Instanzen von DocumentHandler, ErrorHandler, DTDHandler, EntityResolver und Locale bestücken. Außerdem wird eine Methode ‚parse‘ zur Verfügung gestellt, der eine Referenz auf XML-Text übergeben werden kann. Diese Methode ruft dann während des Parsens die Methoden der übergebenen Hilfsklassen auf. Dem DocumentHandler werden die grundlegenden Elemente der XML-Datei übergeben, also insbesondere Tags und Attribute. Ereignisse, die zum Aufruf einer DocumentHandler-Methode führen, umfassen Dokumentanfang und -ende, Anfangs- und End-Tag, Zeichenketten zwischen Tags und spezielle Steueranweisungen in der XML-Datei. Wenn der Parser auf ein XML-Start-Tag trifft, wird die entsprechende DocumentHandler-Prozedur aufgerufen. Da die Anzahl der Attribute nicht von vornherein feststeht, können diese nicht als Parameter übergeben werden. Stattdessen liefert der Parser zum StartTag ein AttributeList-Objekt, mit dessen Methoden etwa jeweils Typ, Name und Wert des i-ten Attributs abgefragt werden können. Datentypen und eventuelle Default-Werte werden dabei gegebenenfalls der DTD (oder Schema) entnommen. Eine Anwendung kann sich über das ErrorHandler Interface über aufgetretene Probleme informieren lassen. Dabei wird zwischen Warnungen, Fehlern und kritischen Fehlern unterschieden. Locator-Objekte dienen dazu, eine Position im XML-Text zu identifizieren. Konkret kann man dem Parser zu Beginn eine solche Instanz übergeben und dann, etwa nach Auftreten eines Fehlers, an dieser die aktuelle Datei, Zeile und Spalte ablesen. DTD Handler bekommen externe Daten übergeben, die sich nicht an die XML Syntax halten. Binäre Dateien, auf die in der XML-Datei bezug genommen wird, können so beispielsweise mit externen Programmen verarbeitet werden. Mit den oben genannten Interfaces ist die den SAX-Parser verwendende Anwendung unabhängig von der physischen Struktur der XML-Daten. Ein EntityResolver-Objekt bietet dem Parser eine 9 abstrakte Sicht auf die Daten, indem diese immer als einheitlicher Datenstrom zum Parser geliefert werden. In speziellen Fällen kann es jedoch hilfreich sein, diesen EntityResolver durch eine eigene Klasse zu ersetzen, um erstens stets über die aktuelle Position im XML-Text informiert zu sein und zweitens den zum Parser gelieferten Datenstrom manipulieren zu können. 3.2 Erweiterungen bei SAX 2.0 In der zweiten Version des Standards sind einige Erweiterungen hinzugekommen, zu diesen gehören • • • Namespaces, Filter und erweiterte Parsersteuerung. Die neuen sogenannten Namespaces ordnen Tags und Attributen einen erweitertern, global eindeutigen Namen zu. Dabei können Filter gesetzt werden, die bestimmen, welche Ereignisse zum Client zurückgeliefert werden sollen und welche nicht. Parsersteuerung: Es können allgemeine und parserspezifische Optionen definiert werden, die sich durch standardisierte Aufrufe an- uns ausschalten lassen. Ein Beispiel für eine solche Option ist die parallele Syntaxprüfung des Parsers. Die Option wird dabei durch einen global eindeutigen URIString bezeichnet. 3.3 Diskussion SAX Vorteile: • Die SAX Kern-API ist weniger umfangreich als etwa DOM (vgl. Abschnitt über DOM) oder viele herstellerspezifische Produkte. Damit wird eine schnelle Einarbeitung ermöglicht. • Bei sehr vielen Anwendungen werden nur triviale Verarbeitungsschritte mit den extrahierten Daten durchgeführt, z.B. einfache Formatkonversion, Extraktion von Teilinhalten aus großen Dateien etc. Hier ist der einfache Aufbau von SAX-Parsern von Vorteil. Durch den Verzicht auf umfangreiche Datenspeicherung im Parser sind diese sehr speicher- und laufzeiteffizient implementiert. • SAX ist damit auch in der Lage, Daten zu verarbeiten, die nicht in Gänze in den Speicher passen oder die als Datenstrom schon vor ihrem vollständigen Eintreffen bearbeitet werden sollen. Nachteile: • Das den Parser benutzende Programm muß seine eigenen Datenstrukturen aufbauen, was je nach Anwendung eine komplexe, fehlerträchtige Aufgabe sein kann. • Der Standard sieht keine Funktionen zum Schreiben oder Ändern von XML vor. Die in den angebotenen Parsern teilweise vorhandenen Routinen zum Erzeugen von Dokumenten sind daher herstellerzpezifisch unterschiedlich anzusprechen. 3.4 DOM Die meisten XML-Parser sind in der Lage, aus dem Dokument ein baumförmiges Modell von dessen Struktur zu erstellen, auf das die Applikation mittels einer Schnittstelle zugreifen kann. Aus 10 den gleichen Gründen wie bei SAX wurde auch hier ein Standard vorgeschlagen, insbesondere auch weil die damals führenden Browserhersteller einen einheitlichen Zugriff auf HTML-Elemente aus Skripten in HTML-Seiten gewährleisten wollten. Das Document Object Model (DOM) als Standard für Parser, die eine solche Datenstruktur zurückliefern, wurde vom W3C hauptsächlich mit diesem Ziel entwickelt. Der Kern der DOMSpezifikation ist sowohl auf HTML- als auch auf XML-Dokumente anwendbar, er beschreibt den Umgang mit Elementen, Attributen, Kommentaren, Verarbeitungsanweisungen und Text. Diese Ausführungen über DOM basieren auf [Apparao98] und [Helfrich99]. Eine typische Anwendung für einen DOM-Parser ist das Parsen von HTML-Dokumenten. Auch die Sprache HTML ist als Anwendung von XML definiert, so daß sich das Document Object Model auch und insbesondere auf wohlgeformte HTML-Strukturen anwenden läßt. Ein Beispiel aus [Helfrich99]: <TABLE> <TBODY> <TR> <TD>Shady Grove</TD> <TD>Aeolian</TD> </TR> <TR> <TD>Over the River, Charlie</TD> <TD>Dorian</TD> </TR> </TBODY> </TABLE> Dieser Ausschnitt aus einer HTML-Datei beschreibt eine Tabelle aus zwei Zeilen und zwei Spalten. Diese Struktur würde in folgenden Baum überführt werden: Abbildung 1: DOM-Baum In dem aufgebauten Baum kann das aufrufende Programm anschließend leicht navigieren und beliebig Knoten lesen, schreiben, löschen, erzeugen usw. Der objektorientierte Ansatz von DOM eignet sich unter anderem besonders gut für die Implementierung in der Sprache Java. Hier werden 11 die in DOM festgelegten Klassen einfach durch Verwendung der entsprechenden Packages des Parser-Herstellers eingebunden. Die wesentlichen Funktionen von DOM dienen zur Manipulation der Knoten des Syntaxbaums. Diese Knoten beschreiben Elemente, Text, Kommentare, Verarbeitungsanweisungen, externe nichtXML-Daten, Referenzen, Deklarationen und ganze Dokumente. Jeder Knoten, also jede Instanz der Klasse Node oder einer Unterklasse, besitzt eine Reihe von Methoden, die sich in drei Kategorien einteilen lassen. Es gibt Aufrufe, um dessen Eigenschaften (Name, Typ, Wert) oder den Kontext im Baum (Eltern, Nachbarn, Kinder) anzufragen oder den von dem Knoten repräsentierten Inhalt (aus den Kindknoten) zu verändern. Jedem Knoten wird ein (nicht unbedingt eindeutiger) Name und ein Typ zugeordnet, die sich über dessen Methoden abfragen lassen. Über den Typ kann entschieden werden, zu welchem Interface (bzw. von Node abgeleiteten Klasse) der Knoten gehört, ob der Knoten also für das ganze Dokument, ein Element, ein Attribut etc. steht. Der Name kann dann in einigen Fällen notwendige Zusatzinformationen liefern, etwa die Bezeichnung eines Attributs. Den zugeordneten Wert, der wiederum nur bei einigen Knotentypen definiert wird, kann man mit entsprechenden Methoden sowohl lesen als auch schreiben. Die Hierarchie des Dokuments spiegelt sich in den Nachbarschaftsbeziehungen der Knoten wider. Für die auswertende Anwendung ist es besonders wichtig, in diesem Baum navigieren zu können. Dazu existieren verschiedene Methoden, die für den Knoten gegebenenfalls den Elternknoten und die Liste der Kinder liefern. Diese Knoten, und damit die Struktur der XML-Datei, lassen sich mit einer dritten Klasse von Funktionen manipulieren. Knoten (oder Teilbäume) können gelöscht, hinzugefügt, ersetzt, verschoben oder kopiert werden. Weitere Eigenschaften der Knoten unterscheiden sich je nach Subtyp: • • • • • • Document Element Attribute CharacterData Entity, EntityReference Hilfsklassen Ein Document-Knoten steht für das gesamte XML-Dokument. Spezielle Methoden erlauben die Bestimmung von Meta-Daten über das Dokument (z.B. den Dokumenttyp) sowie Fähigkeiten des Parsers und des Wurzelknotens der eigentlichen XML-Struktur. Der Dokumenttyp setzt sich dabei aus dem in der Datei angegebenen Typ-Namen, den Entities und Notations der Datei und ihrer DTD zusammen. Weiterhin besitzt die Document-Klasse ‚Factory‘-Methoden, mit denen sich neue Knoten der verschiedenen Typen erstellen lassen und Methoden, die die Gesamtdatei nach bestimmten Elementen absuchen. Einer der häufigsten Knotentypen ist das Element. Hier gibt es zwei Typen von zusätzlichen Aufrufen: Allgemeine und Attribut-Management Methoden. Zu den allgemeinen Methoden gehört unter anderem eine Funktion ‚getElementsByTagName‘, um Elemente zu einem bestimmten Namen in diesem Teilbaum zu suchen und eine Funktion ‚normalize‘, die benachbarte Textnodes im Teilbaum zusammenfaßt. Attributmanagement umfaßt das Schreiben, Lesen, Anlegen und Löschen von Attribut-Strings zu einem Element. 12 Ist der Name eines Attributs nicht bekannt, oder soll zwischen Attributen verschiedenen Typs unterschieden werden etc., so können auch direkt die entsprechenden Knoten ausgewertet werden. Hier läßt sich der Name und Typ und die Information, ob dieser Wert als Default-Wert aus der DTD stammt, auslesen. Der Attributwert läßt sich lesen und verändern. Er ergibt sich im Regelfall aus einem einzelnen Kindknoten vom Typ Text, hier können jedoch auch Knoten vom Typ EntityReference den Wert liefern. Die Klasse CharacterData dient wiederum als Basisklasse für weitere Knotentypen. Sie bietet eine Reihe nützlicher Prozeduren zur Verarbeitung von Text. So läßt sich der Wert des Knotens als Text auslesen und verändern, es lassen sich Teilstrings zurückliefern, einfügen, löschen und ersetzen. Beispiele für CharacterData-Knoten sind solche für Text, Verarbeitungsanweisungen und Kommentare. Text-Knoten haben zusätzlich zu den CharacterData-Methoden noch einen Aufruf ‚splitText‘, mit dessen Hilfe sich aus einem Text-Knoten zwei benachbarte Knoten mit jeweils einem rechten und einem linken Teilstring bis zum i-ten Zeichen erzeugen lassen. Die Commentund ProcessingInstruction-Klassen entsprechen in ihrer Funktionalität der Klasse CharacterData und stehen für Kommentare wie <!-- Kommentar> und XML-Steueranweisungen wie <?ACME page-preak>. Entities sind in XML Platzhalter für Text. Hier müssen Definitionen und Anwendungen unterschieden werden. Die DOM-Implementierung kann die Definitionen beim Parsen entweder direkt einsetzen oder entsprechende Entity- und EntityReference-Knoten in den Baum einfügen. EntityReference-Knoten besitzen keinen Wert, sondern statt dessen (nicht-veränderbare) Kindknoten, die durch die Ersetzung entstehen. In einigen Fällen kann es sinnvoll sein, auch die Definitionen mit in den DOM-Baum aufzunehmen, etwa wenn externe Binärdateien statt Text eingefügt werden. Dazu dient die Entity-Klasse, die das Node-Interface um Methoden erweitert, um Name („Boot“), Ort („pictures/boat.gif“) und Notation („GIF“) abzufragen. Für Notations gibt es ebenfalls eine Abart von Nodes, die Auskunft über das Format der (im Allgemeinen nicht zu parsenden) Daten gibt. Um eine Folge von Knoten behandeln zu können, etwa wenn das Dokument nach bestimmten Elementen abgesucht wird oder alle Kindknoten zurückgeliefert werden sollen, wurde die Klasse NodeList eingeführt. Spielt die Reihenfolge der Knoten keine Rolle, soll also etwa eine Menge von Attributen behandelt werden, kann man diese zu einer NamedNodeMap zusammenfassen. Weiterhin gibt es einen Nodetyp DocumentFragment, in dem sich temporär Dokumentabschnitte wie in einer Zwischenablage speichern lassen. 3.5 DOM Level 2 In der Entwicklung von DOM gab es bisher zwei wichtige Meilensteine, nämlich die Verabschiedung von der W3C Recommendation für DOM Level 1 und die Veröffentlichung von DOM Level 2 als ‚Public Draft‘. Level 1 bietet bereits die volle Unterstützung für wohlgeformte (well-formed) XML-Dokumente, also XML-Texte, die Instanzen beliebiger XML-DTDs sind, und HTML-Dokumente (HTML Version 4.0 mit Frames). Level 1 enthält jedoch noch keinen Mechanismus für eine Validierung. In DOM Level 2 werden zusätzlich vor allem Interfaces spezifiziert, die den Zugriff auf Mechanismen anbieten, die vorher bereits von DHTML angeboten wurden. Die neuen Features von Level 2 kann man grob in drei Themengebiete aufteilen: Stylesheet Modell, Event Modell und erweiterte Navigation und Manipulation. Die ersten beiden Teilgebiete machen deutlich, daß DOM 13 als Nachfolger von DHTML gedacht ist und vor allem für den Einsatz für das Scripting in WebBrowsern konzipiert wurde. Das Stylesheet Modell von DOM Level 2 definiert zunächst ganz allgemein Stylesheet-Objekte, die nicht auf eine bestimmte Stylesheet-Sprache festgelegt sind (Interface StyleSheet). Darüberhinaus gibt es Behälter-Objekte für Stylesheet-Objekte, die Sammlungen von alternativen Layouts für ein einzelnes Dokument darstellen (Interface StyleSheetCollection). Der größte Teil des Stylesheet Modells, wie es sich in DOM Level 2 darstellt, ist jedoch auf Cascading Style Sheets Level 2 spezialisiert (Interface CSSStyleSheet). Ein Objekt, das CSSStyleSheet implementiert, ist ein Behälter für CSS2-Regeln, die wiederum nach ihrem Typ unterschieden werden. Einige DOM Core Interfaces müssen um Methoden für die Assoziation mit Stylesheets bzw. mit einzelnen Regeln erweitert werden. Das Event-Modell unterscheidet zunächst verschiedene Event-Typen, die in drei Gruppen eingeteilt werden können: • User Interface Events (z.B. Maus-Klick) • Mutation Events (durch Ändern der Dokumentstruktur ausgelöst) • HTML Events (FORMs) Zusätzlich sind benutzerdefinierte Event-Typen vorgesehen. Jedes Event hat ein Node-Objekt als Event-Target, für ein Node-Objekt kann man mehrere Event-Listener registrieren. Event-Objekte sind durch das Interface Event charakterisiert und werden bei Auslösung als Argument an EventListeners übergeben. Von Event abgeleitete Interfaces bieten eine genauere Beschreibung des Ereignisses (z.B. Maus-Koordinaten beim Interface UIEvent). Der Mechanismus des EventCapturing ermöglicht das Abfangen von Events beim Absteigen in der Node-Hierarchie. Hierzu muß ein Node-Objekt das Interface EventCapturer implementieren. Manche Event-Typen unterstützen Event-Bubbling, d.h. das Aufsteigen von Events in der Node-Hierarchie. Das Bubbling kann von Node-Objekten abgebrochen werden, indem das cancelBubble-Attribut des Event-Objekts gesetzt wird. Über den Mechanismus Event-Cancellation kann man das Standardverhalten bestimmter Events unterbinden. Erweiterte Navigation und Manipulation umfaßt hier die neuen Klassen Iterator, Filter und Range. Ein Iterator ist ein bekanntes Design-Pattern im objektorientierten Umfeld. DOM-Iteratoren verbergen die Organisationsstruktur von Behältern für Node-Objete (z.B. als Baum oder als Liste). Es ist vorgesehen, die Interfaces Node und NodeList um sogenannte Factory-Methoden zum Erzeugen von Iterator-Objekten zu erweitern. Funktionen, die Iterator-Objekte als Argument erwarten, sind allgemeiner einsetzbar. Der Erzeuger eines Iterator-Objekts soll die Kontrolle darüber besitzen, ob der erzeugte Iterator "live" ist, d.h. ob anschließende Veränderungen der Dokumentstruktur reflektiert werden, oder ob die verwalteten Objekte unabhängige Kopien sind. Das Interface Filter hat lediglich die Methode acceptNode, die ein Node-Objekt als Argument erwartet und einen boole'schen Wert zurückliefert. Mit einem Filter-Objekt kann man beispielsweise Iteratoren erzeugen, die nur die gewünschte Klasse von Nodes darbieten. Bereiche werden durch das Interface Range unterstützt und identifizieren einen zusammenhängenden Bereich eines Dokuments. Bereiche können beispielsweise die Grundlage für Operationen wie Kopieren, Ausschneiden und Einfügen bilden. 14 3.6 Ausblick auf DOM Level 3 Zukünftige Schritte in der Standardisierung, die bereits in den "DOM Requirements" vom September 1997 festgelegt wurden, betreffen den Zugriff auf die zugrundeliegende XML-DTD, den Zugriff auf das zugrundeliegende Windows-System (hiermit ist kein herstellerspezifisches System gemeint) und ein Sicherheitsmodell. Außerdem wird es in DOM Level 3 erweiterte Möglichkeiten zum Zugriff auf den Dokumentenbaum geben, etwa Suche nach Attributwerten oder direktes Verschieben von Knoten im Baum. Mit dem XSP-Prozessor besteht die Möglichkeit, beliebige Logik in Java zu implementieren. Diese Funktion ist bisher als spezielles Feature einzelner DOM-Implementierungen wie der von Sun verfügbar. Auch das Speichern von XML und die Aufnahme von Formatierungsinformationen in den Dokumentbaum wird angegangen werden. 3.7 Diskussion DOM Vorteile: • DOM ermöglicht einen einheitlichen Zugriff auf XML-Dokumente in verschiedenen Sprachen (neben Java und C++ etwa Perl und Python). • Mit DOM hat man nach dem Parsen einen gezielten und schnellen Zugriff auf bestimmte Einheiten des Dokuments. • In der Regel muß weniger als bei SAX neu programmiert werden. • Mit DOM läßt sich leicht dynamischer Inhalt aus XML-Dokumenten generieren. Nachteile: • Es gibt in der ursprünglichen DOM-Spezifikation keine Funktionen für das automatische Durchschreiten und Auswerten des Baums. Diese Funktionen werden von den Parsern zwar angeboten, sind jedoch wieder herstellerabhängig. Die Austauschbarkeit der Parser ist damit eingeschränkt. • Das gleiche gilt für das Schreiben von XML-Dateien. Mit der Speicherdarstellung der Dokumentstruktur ist man diesem Ziel jedoch schon erheblich näher als bei SAX, insbesondere wenn umfangreiche Änderungen an bestehenden Dokumenten durchgeführt werden sollen. • Die konsequente Baumorientierung kann sich als zu umständlich erweisen, insbesondere die Speicherung von Attributen als Kindknoten von Tags bedeutet sowohl einen gewissen Programmieraufwand als auch Laufzeit- und Speicheroverhead. • Durch die Sprachunabhängigkeit von DOM mußte hier auf spezielle Eigenschaften der Sprache Java verzichtet wurden. Die Verwendung von Containerklassen, Objektinstanzen etc. wird damit inkonsistent zu anderem Java-Quelltext. 3.8 JAXP JAXP (Java API for XML Process), eine Obermenge von DOM 1.0 und SAX 1.0 in Java mit Funktionen auf einem höheren Abstraktionsniveau. Auf „Java und XML“ bezogen stellt JAXP damit eine Art Komplettlösung dar, die die Möglichkeiten der beiden Ansätze miteinander verbindet. JAXP kann auch als eine Art Zusatz-API zu DOM und SAX angesehen werden, das einen einheitlicheren und vor allem herstellerneutralen Zugriff auf die beiden Teil-APIs ermöglichen soll. So genannte Builder und Factories verbergen die herstellerspezifische Implementierung vor dem API-Nutzer. Werden lediglich die spezifizierten API-Methoden genutzt, läßt sich das JAXP des eines Herstellers leicht durch das eines anderen austauschen. 15 JAXP wurde von der Firma Sun entwickelt und wird in einer kommenden Version ein Bestandteil der der Sprache Java, der „Java Plattform“. JAXP 1.1 wird dann auch SAX2, DOM2 und CSL unterstützen. Konkrete Parser, die dieses API ausfüllen, stammen etwa von Apache (Xerces) und IBM (XML4J), und werden natürlich nicht mit dem JDK ausgeliefert. Es existiert jedoch auch eine frei verfügbare Referenzimplementation von Sun. 3.9 JDOM JDOM ist ein relativ neues OpenSource-API, das nach einer Spezifikation von Jason Hunter und Brett McLaughlin entstanden ist - unter Mithilfe von James Duncan Davidson, dem Autor der JAXP-Spezifiaktion. Ziel von JDOM ist es unter anderem, die teilweise recht umständlichen Methoden zur Generierung und Manipulation eines DOM zu vereinfachen. Darüber hinaus ist JDOM, anders als die DOM API, speziell auf die Sprache Java zugeschnitten und somit in einigen Bereichen stark optimiert. JDOM will als eine Art Nachfolger zu SAX und DOM gesehen werden, der das Beste aus den beiden Standards vereint. Es soll sich dabei auf „80% der Anwendungsfälle“ eines Parsers konzentrieren und dabei mit „20% des Programmieraufwandes“ für das verwendende Programm auskommen. Um zu verdeutlichen, wie sich dies äußert, mochte ich hier die Erfahrungen wiedergeben, die in [Kleber01] und [Webreference01] beschrieben werden. Dadurch, daß DOM und SAX ausschließlich aus Interfaces bestehen, ist der häufige Einsatz von Fabrikmethoden oder sogar von Parser-spezifischen Methoden nötig. Das macht DOM verwirrender und fehleranfälliger als JDOM. Außerdem erfordert der Einsatz von DOM häufig die Entwicklung eines Wrappers. In diesem muß Funktionalität implementiert werden, die zumindest teilweise schon in JDOM enthalten ist. Für einen ausführlichen, technischen Vergleich verweise ich auf [Webreference01]. 16 4 Anwendungen der Kombination Java und XML Beispielhaft möchte ich hier typische Anwendungen von Java und XML aufzählen. Selbstverständlich existiert hier jedoch eine Unzahl von möglichen Verwendungsmöglichkeiten der Kombination Programmiersprache Java mit Datenformat XML. 4.1 Java-gestützte Transformation von XML Häufig werden sprachliche Inhalte, etwa Zeitungsartikel, in einer anwenderspezifischen XMLSyntax gespeichert, um sie dann je nach Verwendungszweck in verschiedenen Formaten zu präsentieren: HTML für die verschiedenen Webbrowser, Postscript zum Drucken, Adobe PDF zum Download, andere XML-Formate für die Weiterverarbeitung etc. Auch strukturierte Daten wie Tabellen und Pläne kann man als XML speichern und dann später in leichter verständliche Formate wandeln. Die Notwendigkeit einer Transformation des Text-Datenformats XML in andere Textdarstellungen verdeutlicht folgendes Beispiel, das aus einer Kundendatenbank stammen könnte [Partl00]. <person id="p4681" > <vorname>Hubert</vorname> <vorname>Hans</vorname> <zuname>Partl</zuname> <titel>Dr.</titel> <adresse>Muthgasse 18</adresse> <plz>A-1190</plz> <ort>Wien</ort> <geburtstag> <tag>8</tag> <monat>März</monat> <jahr>1949</jahr> </geburtstag> </person> Diese Darstellung ist äußerst unübersichtlich. Durch Transformation in HTML könnte etwa folgende Form erzielt werden: HUBERT HANS PARTL Muthgasse 18 A-1190 Wien geb. 8. März 1949 Es stellt sich also die Frage, wie XML-Quelltext in eine für den Betrachter ansprechende Form überführt werden kann. Hier kann man nach dem Zeitpunkt der Konvertierung verschiedene Möglichkeiten unterscheiden: • • • Einmalige Transformation (i.d.R. in HTML) Transformation on the fly bei der Anfrage Verarbeitung von XML- (und XSL) im Browser Die zweite Möglichkeit bietet dabei den Vorteil, daß der Inhalt dynamisch passend auf die Fähigkeiten des Browsers zugeschnitten werden kann. Aus der Sicht des Websurfers ist dies völlig 17 transparent. Beim Server tritt ein Skript in Aktion, das Stylesheet und Dokument miteinander kombiniert und HTML ausgibt. Signalisiert der Browser in seiner Anfrage XML-Fähigkeiten können diese Daten auch direkt durchgereicht werden (siehe Abbildung). datei.xml DOM-Parser DOMRepräsentation serverinterne Verarbeitung StylesheetProzessor Ausgabe, z.B. HTML Abbildung 2: XML-Transformation [Mintert00] Auch stellt sich die Frage, wie man Inhalte auf XML-Ebene effizient dynamisch erzeugen kann. Eine Lösung dafür ergibt sich aus den ‚Processing Instructions‘, die man in XML angeben kann. Indem man in den XML-Text einen ‚Aufruf‘ etwa einer Javascript-Datei einbaut, können direkt nach dem Parsen, aber noch vor der Anwendung der XSL Stylesheets, Manipulationen auf den DOM-Objekten durchgeführt werden. Diese Technik nennt sich DCP, Dynamic Content Processor, wobei auch andere Sprachen als Java(-script) denkbar sind. 4.2 XML für Datenaustausch und Datenpersistenz Unter dem Stichwort Integration (auch: EAI, Enterprise application integration) sind Anstrengungen bekannt geworden, mit der Technologie XML als gemeinsamem Nenner Anwendungssysteme verschiedener Herkunft miteinander zu verknüpfen. Dazu ist es notwendig, sich auf eine standardisierte semantische Beschreibung zu einigen, welches Tag welches Datenelement auszeichnet. Darauf aufbauend können dann Schemata für XMLDateien entwickelt werden, die dann als Input für XML-Tools und als Basis für selbstentwickelte Programme dienen: Häufig werden zunächst Konverter zur Konvertierung von XML-Daten in Inhouse-Daten und zurück sowie Programme zur Kommunikationssteuerung erstellt. Auf technischer Ebene sind zwei Standards definiert worden, wie Programme (im Sinne verteilter Systeme) miteinander über XML Kommunikation betreiben können: SOAP (Simple object access protocol) und JAXP (Java API for XML Messaging). Diese zwei konkurrierenden Übertragungsprotokolle sollen den Austausch strukturierter Daten über synchrone oder asynchrone Standardprotokolle wie z.B. HTTP und SMTP normieren. Ziel dabei ist Robustheit und Effzienz durch den Einsatz von vorhandener, optimierter Technik. Teile eines solchen Standards sind (Beispiel SOAP): • • • Nachrichtenaufbau in XML (Envelope, Header, Body) Kodierung von Datentypen, Serialisierung von Klassen RPC-Mechanismen für Prozeduraufrufe 18 Neben der Kommunikation zwischen Systemen spielt auch immer die Datenhaltung eine wichtige Rolle. Hier kommen Datenbanken oder einfache Dateien zum Einsatz. Dafür wurden in der Vergangenheit oft proprietäre Formate geschaffen. Dies wird sich auch mit XML nicht ändern, denn oft können spezifische Anforderungen nicht mit Standardformaten erfüllt werden. Mit XML kann man jedoch zumindest auf einem festen Meta-Format aufbauen. Diese Darstellung erleichtert die Programmentwicklung durch die größere Transparenz und die Verfügbarkeit von Standardwerkzeugen. Durch die Spezifikation als XML-Schema können die Daten so abgefaßt werden, daß die Konvertierung zwischen verschiedenen XML-Formaten vollständig automatisch ablaufen kann. 19 5. Fazit XML stellt eine interessante neue Technologie zur Speicherung und Übertragung von Information dar. Durch eine klare Standardisierung ermöglicht es insbesondere die Verknüpfung von Systemen über die Grenzen von Organisationen hinweg. Um wie erhofft die Kosten der Anwendungsentwicklung zu reduzieren und die korrekte Einhaltung des Standards zu gewährleisten, bietet es sich an, fertige Produkte für das Generieren und Einlesen von XML-Daten zu verwenden. Das reichste Angebot an Standards und Funktionsbibliotheken steht bei Verwendung der Sprache Java zur Verfügung. Weiterhin ist festzustellen, daß zwischen den beiden Technologien Java und XML zahlreiche konzeptionelle Parallelen zu ziehen sind. Dazu gehört die Plattformunabhängigkeit, die Eignung für den Datenaustausch insbesondere in Netzwerken, die Verabschiedung als ‚offener‘, also für jedermann erhältlicher, Standard, sowie die breite Palette verfügbarer Werkzeuge aufgrund der weiten Verbreitung. XML und Java können als komplementäre Produkte angesehen werden, die sich, wie beschrieben, ideal ergänzen. In vielen Anwendungsfällen dürften diese Vorteile den Nachteil der geringeren Effizienz von Java und den Overhead durch das Parsing wieder ausgleichen. Zusammenfassend läßt sich also sagen, daß die Kombination dieser beiden Konzepte etwa für die aufgezeigten typischen Anwendungsfelder durchaus als empfehlenswert angesehen werden kann. 20 Anhang: Java und XML - Werkzeuge Für die Arbeit mit Java und XML existiert eine Fülle von Bibliotheken und Werkzeugen. Als Ausblick und Anregung für eigene Recherche will ich hier einige Beispiele der führenden Hersteller aufzählen. Weitere Beispiele finden sich zum Beispiel auf [Damore01]. Parser • • • IBM XML Parser for Java: Hierbei handelt es sich um einen validierenden XML-Parser, der in reinem Java implementiert wurde. Zusätzlich enthält das Java Package Methoden um XMLDokumente zu generieren, manipulieren und zu validieren (DOM 2, SAX 2). Der IBM-XML Parser for Java gilt als sehr robust und standardkonform. (Zu IBMs XML-Projekten siehe [Alphaworks01]) Apache Xerces XML Parser in Java, C++: Auf dem IBM Parser aufbauend unterstützt das Apache-Produkt ebenfalls DOM- und SAX 2. Xerces läßt sich neben Java auch über C++, Perl und Microsoft COM ansprechen. Auch von Sun gibt es, wie oben erwähnt, mit JAXP 1.1 einen XML-Parser. IBM XML and Web Services Development Environment Eine der Firmen, die sich am stärksten auf dem Markt für XML-Produkte engagiert, ist IBM. Bei IBM entstand ein ganzes Paket an XML-spezifischen Programmen, das für alle typischen Aufgabenbereiche passende Werkzeuge bereithält. Beim XML and Web Services DE handelt es sich um eine plattformneutrale Entwicklungsumgebung, die HTML, Java, SQL und XML zusammenführt. Ziel ist die effektive Entwicklung von E-Business-Applikationen, wobei der Grad der Vollständigkeit dieser Sammlung sicherlich seinesgleichen sucht. Zentrale Komponenten sind: • • • • • Visual XML Builder für die Entwicklung von XML-Dokumemten Visual DTD für die visuelle Entwicklung von DTDs Visual XML Creation für das Generieren von XML-Dokumenten aus SQL-Abfragen Visual XML Transformation als XSL-Transformator Visual XML Query für das Erzeugen von XML-Abfragen Apache Mit dem Apache-XML-Projekt werden die verschiedenen XML-relevanten Entwicklungen koordiniert. Unter der Federführung der Apache Software Foundation (ASF) entsteht eine mächtige Publishing-Plattform, die neben dem eigentlichen Webserver alle erforderlichen Tools zur Bearbeitung und Veröffentlichung von XML-basierten Content umfasst. Das Apache-XML-Projekt enthält aktuell sieben Einzelprojekte: • • Xerces: XML-Parser Xalan: XSLT-Stylesheet-Prozessor 21 • • • • • Cocoon: XML-basiertes Web-Publishing (XML generieren, verarbeiten, nach HTML konvertieren) FOP: XSL-Formatierungsobjekte Xang: Entwicklungsumgebung für dynamische Server Pages SOAP: Simple Object Access Protocol Batik: SVG-Toolkit 22 Quellen Datum des letzten Zugriffs auf die angegebenen Webseiten: 22.5.2001 [Alphaworks01]http://www.alphaworks.ibm.com/ [Apparao98]Apparao, Byrne u.a. Document Object Model Level 1 Specification http://www.w3c.org/TR/1998/REC-DOM-Level-1-19981001 [Bergmann98]Christoph Bergmann / ACCESS Internet, http://java.seite.net/wasisjava.html [Bos99] Bos, Bernd, XML in 10 points, http://www.w3.org/XML/1999/XML-in-10-points [Bray00] Bray, Paoli u.a. Extensible Markup Language http://www.w3.org/TR/2000/REC-xml20001006 [Damore00] D‘Amore, Stefan, Zukunft XML, http://www.tecchannel.de/internet/452/ [Damore01] D’Amore, Stefan, XML-Werkzeugkisten, http://www.tecchannel.de/internet/617/ [Helfrich99] Helfrich, Christoph, Document Object Model http://www2.informatik.uniwuerzburg.de/staff/wolfram/lehre/9899ws_semdok/dom/ausarbeitung/ [Kleber01] Kleber, Oliver, Dom versus JDOM http://home.tonline.de/home/Oliver.Kleber/DOMvsJDOM.html [Megginson01] Megginson, David, SAX Homepage, http://www.megginson.com/SAX/ [Mintert00] Stefan Mintert, Serving XML, iX 4/00 [Partl00] Partl, Hans Hubert, XML-Extensible Markup Language, http://www.boku.ac.at/htmleinf/xmlkurz.html [Patrizio00] Patrizio, Andy, Java And XML: Complementarily Yours, http://www.informationweek.com/795/java.htm [Quark01] Quark Deutschland, Was ist XML, http://www.quark.de/avenue.quark/xml.html [Sun01] Sun Microsystems, Inc.,http://developer.java.sun.com/developer/onlineTraining/new2java/overview.html [Sun01b] Sun Microsystems, Inc., XML und Java Technologies, http://www.sun.ch/d/java/01_xmljava.html [W3C00] The W3C committee, http://www.w3.org/XML/ [Webreference01]Webreference.com, JDOM the Java DOM, http://webreference.com/xml/column25/ [XMLDev] XML-Dev Mailingliste http://www.lists.ic.ac.uk/hypermail/xml-dev/ 23
