<\/p>\n
Wir haben uns bereits in vielen Beiträgen mit dem Parsen von XML-Dokumenten befasst. Dabei haben wir immer den DOM-Parser verwendet, um die im XML-Dokument enthaltenen Daten zu lesen. In diesem Beitrag schauen wir uns eine Alternative namens SAX an. Während DOM das komplette XML-Dokument in den Speicher liest und darauf zugreift, liest SAX das Dokument zeilenweise ein. Im Folgenden erfahren Sie, welche Vor- und Nachteile die beiden Methoden haben und wie Sie mit SAX arbeiten können.<\/b><\/p>\n
Der DOM-Parser liest ein vollständiges XML-Dokument in den Speicher ein und kann dafür auf alle enthaltenen Elemente zugreifen. Sie können die Elemente damit nacheinander durchlaufen oder mithilfe von XPATH<\/b>-Ausdrücken und Methoden wie SelectSingleNode <\/b>oder SelectNodes <\/b>nach bestimmten Elementen im Dokumentbaum suchen. <\/p>\n
Sie können damit im Dokumentbaum vor- und zurückspringen oder die enthaltenen Elemente hierarchisch durchlaufen.<\/p>\n
DOM: Vor- und Nachteile<\/b><\/p>\n
Der Nachteil liegt auf der Hand: Da der komplette Baum im Speicher liegt und mitunter verschachtelt ist, kann der Zugriff auf die Inhalte recht schnell zu Lasten der Performance gehen.<\/p>\n
Ein weiterer Nachteil ist, dass sehr große XML-Dateien möglicherweise nicht in den Speicher passen und somit nicht geladen werden können. Dafür können Sie mit DOM aber nicht nur gezielt auf einzelne Elemente zugreifen, sondern den Dokumentbaum und die Inhalte auch bearbeiten.<\/p>\n
SAX: Schnell, aber unflexibel<\/b><\/p>\n
Anders sieht es bei SAX aus. Der SAX-Parser liest das Dokument Zeile für Zeile ein und bietet die Möglichkeit, auf die jeweilige Zeile zuzugreifen. Dabei ist der SAX-Parser rasend schnell! Allerdings liest er auch nur in einer Richtung, ein Hin- und Herspringen oder gar das gezielte Einlesen eines einzelnen Elements ohne Durchlaufen des XML-Dokuments bis zu diesem Punkt ist nicht möglich.<\/p>\n
Außerdem können Sie mit dem SAX-Parser keine änderungen am XML-Dokument vornehmen.<\/p>\n
Vorbereitungen<\/b><\/p>\n
Um den SAX-Parser nutzen zu können, benötigen Sie einen Verweis auf die Objektbibliothek Microsoft XML v6.0 <\/b>(s. Bild 1).<\/p>\n
![\"Setzen](\"..\/fileadmin\/_temp_\/2015_01\/pic_969_001.png\")
<\/p>\n
Bild 1: Setzen eines Verweises auf die Bibliothek Microsoft XML, v6.0<\/span><\/b><\/p>\n Funktionsweise des SAX-Parsers<\/b><\/p>\n Wie aber greift der SAX-Parser nun auf das XML-Dokument zu öffnet er es wie ein Textdokument und liest dann etwa in einer Schleife die einzelnen Zeilen in eine Variable ein, auf deren Inhalt wir dann per VBA zugreifen können<\/p>\n Mitnichten: Der SAX-Parser basiert auf Ereignissen. Das heißt, dass es verschiedene Ereignisse gibt:<\/p>\n Die übrigen Ereignisse benötigen wir für die Beispiele dieses Beitrags nicht.<\/p>\n Ereignisse implementieren<\/b><\/p>\n Wie implementieren wir diese Ereignisse nun Als Erstes erstellen Sie ein neues Klassenmodul namens clsSAX<\/b>. Normalerweise würde man diesem nun eine entsprechende Objektvariable hinzufügen, die mit dem Schlüsselwort WithEvents <\/b>deklariert wird und so die enthaltenen Ereignisprozeduren verfügbar macht.<\/p>\n In diesem Fall ist dies anders: Wir deklarieren keine Objektvariable, sondern legen mit der Implements<\/b>-Anweisung fest, dass die Klasse alle Ereignisprozeduren eines speziellen Interfaces implementiert – in diesem Falle für das Interface MSXML2.IVBSAXContentHandler<\/b> (s. Bild 2).<\/p>\n Bild 2: Implementieren der Klasse IVBSAXContentHandler<\/span><\/b><\/p>\n Dessen Ereignisse können Sie dann jedoch genau wie bei mit WithEvents<\/b> deklarierten Objekten mit den beiden Kombinationsfeldern im oberen Bereich des Codefensters festlegen. Als Erstes fügen wir so das Ereignis startDocument <\/b>hinzu (s. Bild 3).<\/p>\n Bild 3: Implementieren eines Ereignisses der Klasse IVBSAXContentHandler<\/span><\/b><\/p>\n Im Gegensatz zu mit Objekten, die Ereignisse auslösen, müssen Sie jedoch bei der Implementierung eines Interfaces alle Elemente anlegen. Anderenfalls löst das Debuggen des VBA-Projekts den Fehler aus Bild 4 aus. Wenn Sie alle Ereignisprozeduren hinzugefügt haben, ist der erste Teil erledigt.<\/p>\n Bild 4: Die Implementierung der Klasse IVBSAXContentHandler ist noch nicht vollständig.<\/span><\/b><\/p>\n Nun liegt uns allerdings zunächst einmal eine Klasse vor, die allein noch nichts ausrichtet. Wir müssen zunächst ein Objekt auf Basis dieser Klasse deklarieren und instanzieren sowie der Klasse mitteilen, dass sie in Aktion treten soll.<\/p>\n Dies erledigen wir gleich einmal in einem Formular, das auch die Steuerelemente zum Auswählen der zu untersuchenden XML-Datei sowie eine Schaltfläche zum Starten des Vorgangs enthalten soll. Dieses Formular sieht im ersten Entwurf wie in Bild 5 aus. Die Schaltfläche Einlesen <\/b>soll das angegebene XML-Dokument mithilfe der Klasse clsSAX <\/b>einlesen.<\/p>\n Bild 5: Das Formular frmSAX<\/span><\/b><\/p>\n Dazu legen Sie die Ereignisprozedur aus Listing 1 an. Die Prozedur deklariert gleich zwei Objektvariablen: objSax <\/b>soll ein Objekt auf Basis der soeben erstellten Klasse clsSAX <\/b>aufnehmen. objReader <\/b>nimmt ein Objekt des Typs SAXXMLReader60 <\/b>auf, das Teil der Objektbibliothek Microsoft XML, v6.0 <\/b>ist.<\/p>\n <\/p>\n Listing 1: Diese Prozedur startet den Einlesevorgang.<\/span><\/b><\/p>\n Nun weisen Sie der Eigenschaft contentHandler <\/b>der Klasse objReader <\/b>den Verweis auf das Objekt objSax <\/b>zu und rufen dann die Methode parseURL <\/b>der Klasse objReader <\/b>mit der einzulesenden Datei als Parameter auf. Das war der Rahmen – mit einem Klick auf die Schaltfläche cmdEinlesen <\/b>starten Sie nun den Einlesevorgang, der die Ereignisse der Klasse clsSAX <\/b>auslöst.<\/p>\n Dabei geschieht aber offensichtlich noch gar nichts – was aber auch kein Wunder ist: Immerhin haben wir den Ereignisprozeduren ja auch noch keine einzige Zeile Code hinzugefügt.<\/p>\n Einlesevorgang programmieren<\/b><\/p>\n Dies gehen wir im folgenden Schritt an. Wir wollen zunächst einmal erfahren, welche Informationen der Parser zu den einzelnen Elementen liefert – und zwar am Beispiel einer einfachen XML-Datei wie der aus Listing 2.<\/p>\n Listing 2: Einfache Beispiel-XML-Datei<\/span><\/b><\/p>\n Dazu fügen wir den Ereignisprozeduren der Klasse clsSAX <\/b>einige Debug.Print<\/b>-Anweisungen hinzu, die erstens den Namen des jeweiligen Ereignisses enthalten und zweitens die mit den Parametern gelieferten Informationen. Die vollständige Klasse sieht danach wie in Listing 3 aus.<\/p>\n Listing 3: Die Klasse clsSAX mit einigen Anweisungen zum Ausprobieren der Funktion des Parsers<\/span><\/b><\/p>\n Einlesevorgang testen<\/b><\/p>\n Nun lösen wir den Einlesevorgang anhand der weiter oben vorgestellten kleinen Beispieldatei aus. Die Ausgabe im Direktbereich des VBA-Editors sieht anschließend wie in Bild 6 aus.<\/p>\n Bild 6: Ausgabe des SAX-Parsers für ein XML-Dokument<\/span><\/b><\/p>\n Eigentlich sind alle Ausgaben logisch: documentLocator <\/b>liefert den Pfad des Dokuments, startDocument<\/b>, startElement<\/b>, endElement <\/b>und endDocument <\/b>feuern an den entsprechenden Stellen.<\/p>\n Nur das Ereignis characters <\/b>liefert auf den ersten Blick Informationen, die nicht direkt zu interpretieren sind. Wenn man sich allerdings den Aufbau des XML-Dokuments mit seinen Zeilenumbrüchen und Einschüben ansieht, wird schnell deutlich, dass der SAX-Parser auch diese interpretiert.<\/p>\n Dem können Sie entgegenwirken, indem Sie Leerzeichen und Umbrüche aus dem XML-Dokument entfernen. Besteht das komplette Dokument nur noch aus einer einzigen Zeile, sieht die Ausgabe wie in Bild 7 aus – das ist doch schon wesentlich geordneter.<\/p>\n Bild 7: Ausgabe für ein einfaches XML-Dokument ohne Einschübe und Umbrüche<\/span><\/b><\/p>\n Attribute einlesen<\/b><\/p>\n Neben den eigentlichen Elementinhalten fehlen noch die Attribute der einzelnen Elemente. Diese werden beispielsweise wie folgt angegeben:<\/p>\n Auf diese Attribute greifen Sie in der Prozedur IVBSAXContentHandler_startElement <\/b>zu, und zwar mithilfe des Parameters oAttributes<\/b>. Dieses Attribut bietet folgende Eigenschaften, die für uns interessant sind:<\/p>\n Mit diesen Eigenschaften können wir, wenn wir das XML-Dokument noch nicht kennen, einfach auf die enthaltenen Attribute und deren Werte zugreifen. Dazu verwenden wir eine For…Next<\/b>-Schleife über alle Werte von 0 <\/b>bis zur mit der Eigenschaft length <\/b>ermittelten Anzahl minus eins. In dieser Schleife lassen wir uns alle Attribute samt Wert und Typ ausgeben. Dazu erweitern wir die Ereignisprozedur IVBSAXContentHandler_startElement<\/b> wie in Listing 4.<\/p>\n Listing 4: Zugriff auf die Attribute eines XML-Elements<\/span><\/b><\/p>\n Wenn Sie das XML-Dokument und seinen Aufbau kennen, können Sie natürlich auch direkt auf die enthaltenen Attribute eines Elements mit einem bestimmten Namen zugreifen.<\/p>\n Dies lässt sich beispielsweise mit der folgenden Select Case<\/b>-Bedingung prüfen:<\/p>\n Diese bauen Sie ebenfalls in die Ereignisprozedur IVBSAXContentHandler_startElement <\/b>ein. Sollte nun ein Element namens Kunde <\/b>auftauchen, liest die Prozedur den Wert des Attributs KundeID <\/b>ein.<\/p>\n Debuggen nicht in den Ereignissen möglich<\/b><\/p>\n Beim Programmieren der SAX-Schnittstelle wird es früher oder später mal zu einem Fehler kommen. Access meldet den Fehler dann zwar mit einer entsprechenden Meldung, aber wenn Sie dann debuggen wollen, um sich die verantwortliche Anweisung anzusehen, landen Sie immer in der Zeile mit dem Aufruf der Methode parseURL<\/b>.<\/p>\n Sollten Sie also genauer wissen wollen, wo ein solcher Fehler aufgetreten ist, müssen Sie entweder schrittweise durch die Ereignisprozeduren der Klasse clsSAX <\/b>laufen (sehr aufwändig!), entsprechende Haltepunkte an den vermuteten Stellen anbringen und diese per F5 <\/b>nacheinander ansteuern oder die Fehlerbehandlung in den betroffenen Ereignisprozeduren deaktivieren und im Falle eines Fehlers eine benutzerdefinierte Fehlermeldung platzieren:<\/p>\n Wenn Sie es direkt genauer wissen möchten, fügen Sie den Zeilen noch Zeilennummern hinzu (etwa mit MZ-Tools) und lassen die fehlerhafte Zeile mit der nicht dokumentierten Funktion Erl <\/b>ausgeben.<\/p>\n Probleme mit Umlauten et cetera<\/b><\/p>\n Während der Entwicklung trat ein interessantes Problem auf, das ich Ihnen – samt Lösung – nicht vorenthalten möchte. Es geht dabei um das Einlesen von Umlauten und anderen Sonderzeichen.<\/p>\n Bei einer Testdatei, die ich einfach über den Windows Explorer als Textdatei erstellt und dann als .xml<\/b>-Datei gespeichert habe, meldete der SAX-Parser immer wieder den Fehler Ungültiges XML-Zeichen<\/b>. Interessanterweise geschah das nicht mit einer anderen Datei, die ich im Rahmen eines Webservice-Projekts aus dem Internet geladen hatte. Auch diese enthielt Umlaute sowie andere Sonderzeichen.<\/p>\n Um das Problem einzukreisen, habe ich den kompletten Inhalt der fehlerbehafteten XML-Datei in diejenige eingefügt, die keine Probleme verursachte. Das Verrückte war, dass die Webservice-Datei immer noch problemlos eingelesen werden konnte, meine selbst erstellte jedoch nicht.<\/p>\n Schließlich kam ich auf die Idee, die Funktion zum Vergleichen von Dateien des Text-Editors Textpad zu nutzen. Diese offenbarte dann den Unterschied, der wie folgt aussah:<\/p>\n Der Text-Editor zeigte zwar für beide Dateien das Zeichen é <\/b>an, aber in einem Fall war es offensichtlich in einer anderen Codierung gespeichert. Der Datei speichern<\/b>-Dialog von Textpad lieferte schließlich die Lösung: Die Datei, die der Webservice geliefert hat, lag im Zeichensatz UTF-8 <\/b>vor, die unter Windows selbst erstellte im Zeichensatz ANSI<\/b>. Das Speichern der selbst erstellten Datei im Format UTF-8 <\/b>sorgte schließlich dafür, dass ich die Datei fehlerfrei einlesen konnte.<\/p>\n Zusammenfassung und Ausblick<\/b><\/p>\n Dieser Beitrag hat die Grundlagen für die Verwendung des SAX-Parsers zum Einlesen von XML-Dokumenten erläutert. Sie können damit nun nacheinander auf alle Elemente und Attribute sowie deren Inhalte zugreifen und diese weiterverarbeiten. In diesem Fall haben wir die Daten einfach in das Direktfenster des VBA-Editors geschrieben.<\/p>\n In der Praxis werden Sie den SAX-Parser statt des DOM-Parsers verwenden, wenn die zu untersuchenden Dateien sehr groß sind – so groß, dass das Einlesen mit DOM entweder sehr lange dauern würde oder die Datei erst gar nicht geöffnet werden kann, weil sie zu groß ist, um sie in den Arbeitsspeicher zu laden und zu verarbeiten. Bedenken Sie, dass dazu weit mehr Speicherplatz erforderlich ist als die XML-Datei allein einnimmt.<\/p>\n In einem weiteren Beitrag schauen wir uns den Einsatz des SAX-Parsers an konkreten Beispielen an. Das bedeutet, dass wir die Daten aus XML-Dateien auslesen und direkt in entsprechende Access-Tabellen schreiben werden. Der Beitrag heißt SAX: XML-Dokumente einlesen in der Praxis <\/b>(www.access-im-unternehmen.de\/970<\/b>).<\/p>\n Enthaltene Beispieldateien:<\/p>\n SAX.mdb<\/p>\n Kunde.xml<\/p>\n\n
![\"Implementieren](\"..\/fileadmin\/_temp_\/2015_01\/pic_969_002.png\")
<\/p>\n![\"Implementieren](\"..\/fileadmin\/_temp_\/2015_01\/pic_969_003.png\")
<\/p>\n![\"Die](\"..\/fileadmin\/_temp_\/2015_01\/pic_969_004.png\")
<\/p>\n![\"Das](\"..\/fileadmin\/_temp_\/2015_01\/pic_969_005.png\")
<\/p>\nPrivate Sub <\/span>cmdEinlesen_Click()\r\n Dim <\/span>objReader As <\/span>SAXXMLReader60\r\n Dim <\/span>objSax As <\/span>clsSAX\r\n Set<\/span> objReader = New<\/span> SAXXMLReader60\r\n Set<\/span> objSax = New<\/span> clsSAX\r\n Set<\/span> objReader.contentHandler = objSax\r\n objReader.parseURL Me!txtDatei\r\n Set<\/span> objReader = Nothing\r\nEnd Sub<\/span><\/pre>\n<xml version=\"1.0\" encoding=\"utf-8\">\r\n<Kunden xmlns:xsi=\"http:\/\/www.w3.org\/2001\/XMLSchema-instance\" \r\n xmlns:xsd=\"http:\/\/www.w3.org\/2001\/XMLSchema\">\r\n <Kunde KundeID=\"123\">\r\n <Vorname>André<\/Vorname>\r\n <Nachname>Minhorst<\/Nachname>\r\n <\/Kunde>\r\n<\/Kunden><\/pre>\n
Implements MSXML2.IVBSAXContentHandler\r\nPrivate Sub <\/span>IVBSAXContentHandler_characters(strChars As String<\/span>)\r\n On Error Resume Next<\/span>\r\n Debug.Print<\/span> \"characters: \" & strChars\r\n On Error GoTo<\/span> 0\r\nEnd Sub<\/span>\r\nPrivate Property Set<\/span> <\/span>IVBSAXContentHandler_documentLocator(ByVal RHS As <\/span>MSXML2.IVBSAXLocator)\r\n Debug.Print<\/span> \"documentLocator: \" & RHS.columnNumber, RHS.lineNumber, RHS.publicId, _\r\n RHS.systemId\r\nEnd Property<\/span>\r\nPrivate Sub <\/span>IVBSAXContentHandler_endDocument()\r\n Debug.Print<\/span> \"endDocument\"\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>IVBSAXContentHandler_endElement(strNamespaceURI As String<\/span>, _\r\n strLocalName As String<\/span>, strQName As String<\/span>)\r\n Debug.Print<\/span> \"endElement: \" & strNamespaceURI, strLocalName, strQName\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>IVBSAXContentHandler_endPrefixMapping(strPrefix As String<\/span>)\r\n Debug.Print<\/span> \"endPrefixMapping: \" & strPrefix\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>IVBSAXContentHandler_ignorableWhitespace(strChars As String<\/span>)\r\n Debug.Print<\/span> \"ignorableWhitespace: \" & strChars\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>IVBSAXContentHandler_processingInstruction(strTarget As String<\/span>, strData As String<\/span>)\r\n Debug.Print<\/span> \"processingInstruction: \" & strTarget, strData\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>IVBSAXContentHandler_skippedEntity(strName As String<\/span>)\r\n Debug.Print<\/span> \"skippedEntity: \" & strName\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>IVBSAXContentHandler_startDocument()\r\n Debug.Print<\/span> \"startDocument\"\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>IVBSAXContentHandler_startElement(strNamespaceURI As String<\/span>, _\r\n strLocalName As String<\/span>, strQName As String<\/span>, _\r\n ByVal oAttributes As <\/span>MSXML2.IVBSAXAttributes)\r\n Debug.Print<\/span> \"startElement:\" & strNamespaceURI, strLocalName, strQName \r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>IVBSAXContentHandler_startPrefixMapping(strPrefix As String<\/span>, strURI As String<\/span>)\r\n Debug.Print<\/span> \"startPrefixMapping: \" & strPrefix, strURI\r\nEnd Sub<\/span><\/pre>\n![\"Ausgabe](\"..\/fileadmin\/_temp_\/2015_01\/pic_969_006.png\")
<\/p>\n![\"Ausgabe](\"..\/fileadmin\/_temp_\/2015_01\/pic_969_007.png\")
<\/p>\n<Kunde KundeID=\"123\">...<\/Kunde><\/pre>\n
\n
Private Sub <\/span>IVBSAXContentHandler_startElement(strNamespaceURI As String<\/span>, _\r\n strLocalName As String<\/span>, strQName As String<\/span>, _\r\n ByVal oAttributes As <\/span>MSXML2.IVBSAXAttributes)\r\n Dim <\/span>i As Integer<\/span>\r\n Debug.Print<\/span> \"startElement:\" & strNamespaceURI, strLocalName, strQName\r\n For i = 0 To oAttributes.length - 1\r\n With<\/span> oAttributes\r\n Debug.Print<\/span> \"startElement - Attribut: \" & .getLocalName(i) & \"=\" _\r\n & .getValue(i) & \" Type: \" & .getType(i)\r\n End With<\/span>\r\n Next<\/span> i\r\nEnd Sub<\/span><\/pre>\nSelect Case strLocalName\r\n Case <\/span>\"Kunde\"\r\n Debug.Print<\/span> \"ID: \" _\r\n & oAttributes. _\r\n getValueFromName(\"\", \"KundeID\")\r\nEnd Select<\/span><\/pre>\nOn Error Resume Next<\/span>\r\n...\r\nMsgBox<\/span> Err.Number & \" \" & Err.Description\r\nOn Error Goto 0<\/pre>\n4,5c4,5\r\n< <Vorname>André<\/Vorname>\r\n---\r\n> <Vorname>André<\/Vorname><\/pre>\n
Downloads zu diesem Beitrag<\/h3>\n