{"id":55001048,"date":"2016-08-01T00:00:00","date_gmt":"2020-05-22T15:29:12","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=1048"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"Dateien_aus_XMLDokumenten_speichern_und_lesen","status":"publish","type":"post","link":"https:\/\/access-im-unternehmen.de\/Dateien_aus_XMLDokumenten_speichern_und_lesen\/","title":{"rendered":"Dateien aus XML-Dokumenten speichern und lesen"},"content":{"rendered":"

\"\"<\/p>\n

Webservices können nicht nur Texte und Zahlen liefern oder entgegennehmen, sondern auch etwa mit Bildern oder PDF-Dateien arbeiten. So könnten Sie einen Webservice nutzen, der Bilder bearbeitet oder umwandelt, oder mit einem, der ein PDF für eine bestimmte Dienstleistung liefert und dazu in einen XML-Response verpackt – zum Beispiel eine Versandmarke et cetera. Für solche Fälle kann es hilfreich sein zu wissen, wie Sie die endlosen Zahlenkombinationen aus dem XML-Dokument in eine Datei umwandeln – und umgekehrt.<\/b><\/p>\n

Dateien aus XML-Dokumenten exportieren<\/h2>\n

Wenn Sie gelegentlich Dateien im XML-Format verarbeiten, kommt dort sicher auch mal eine Base64-kodierte Datei vor. Eine einfache XML-Datei mit dem Root-Element file<\/b>, das zwei weitere Elemente namens filename <\/b>(zum Speichern des Dateinamens) und data<\/b> (mit dem kodierten Inhalt einer PDF-Datei) enthält, sieht beispielsweise wie folgt aus – nur je nach Dateigröße viel länger:<\/p>\n

<xml version=\"1.0\">\r\n<file>\r\n   <filename>Beispieldatei.pdf<\/filename>\r\n   <data>JVBERi0xLjQNJeLjz9MNCjk3NCAwIG9iag08PC9MaW5lYXJpeIIFsgMTA5OCA3MjddPj4NZW5kb2JqDSAgICAg...<\/data>\r\n<\/file><\/pre>\n
Einen besseren Eindruck vom Umfang einer solchen Datei erhalten Sie durch einen Blick auf Bild 1. Die hier abgeschnittene Darstellung besteht tatsächlich aus über 17.000 Zeilen!<\/p>\n
\"Beispiel<\/p>\n
Bild 1: Beispiel für eine in einem XML-Dokument gespeicherte Datei<\/span><\/b><\/p>\n
Und dieses Durcheinander wollen wir nun in eine Datei umwandeln Aber natürlich! Mehr dazu gleich.<\/p>\n
Voraussetzungen<\/h2>\n
Für die Beispiele aus diesem Beitrag (und auch, wenn Sie diese in Ihrer eigenen Datenbank nutzen möchten) benötigen Sie zwei zusätzliche Verweise, nämlich auf die Bibliothek Microsoft XML, v6.0 <\/b>und Microsoft ActiveX Data Objects 6.1 Library <\/b>(s. Bild 2).<\/p>\n
\"Verweise<\/p>\n
Bild 2: Verweise der Beispieldatenbank<\/span><\/b><\/p>\n
Datei auslesen<\/h2>\n
Die Steuerung übernimmt die Prozedur aus Listing 1, in der Sie auch festlegen, welche XML-Datei als Quelle dient, aus welchem Element der Name der zu erzeugenden Datei und aus welchem Element der kodierte Dateiinhalt kommt. Die  Prozedur erstellt ein neues DOMDocument<\/b>-Objekt und lädt den Inhalt der Datei ArtikelInXML.xml<\/b>, deren Inhalt Sie oben bereits kennen gelernt haben, in dieses Objekt. Die nächste Anweisung trägt das Verzeichnis der aktuellen Datenbank gefolgt von einem Backslash (\\<\/b>) und dem aus dem Element filename <\/b>ermittelten Dateinamen, hier Beispieldatei.pdf<\/b>, in die Variable strZieldatei <\/b>ein.<\/p>\n
Public Sub <\/span>XMLElementInDatei()\r\n     Dim <\/span>objDocument As <\/span>MSXML2.DOMDocument60\r\n     Dim <\/span>strXMLDatei As String<\/span>\r\n     Dim <\/span>strZieldatei As String<\/span>\r\n     Dim <\/span>objData As <\/span>MSXML2.IXMLDOMElement\r\n     Set<\/span> objDocument = New<\/span> MSXML2.DOMDocument60\r\n     strXMLDatei = CurrentProject.Path & \"\\ArtikelInXML.xml\"\r\n     objDocument.Load strXMLDatei\r\n     strZieldatei = CurrentProject.Path & \"\\\" & objDocument.selectSingleNode(\"\/\/filename\").nodeTypedValue\r\n     Set<\/span> objData = objDocument.selectSingleNode(\"\/\/data\")\r\n     WriteFileFromBytes strZieldatei, DecodeBase64(objData.nodeTypedValue)\r\nEnd Sub<\/span><\/pre>\n
Listing 1: Auslesen einer Datei aus einem XML-Dokument in das Filesystem<\/span><\/b><\/p>\n
Mit der IXMLDOMElement<\/b>-Variablen objBild <\/b>referenzieren wir den Inhalt des Elements data <\/b>unserer Zieldatei. Schließlich rufen wir gleich zwei Hilfsfunktionen in einer Zeile auf: Die Funktion WriteFileFromBytes <\/b>erwartet den Namen der zu erstellenden Datei sowie ein Byte-Array mit dem zu schreibenden Dateiinhalt als Parameter und soll die Datei in das Datei-sytem schreiben. Das Byte-Array steuert mit dem zweiten Parameter die Funktion DecodeBase64<\/b> bei, welche mit dem Inhalt des Elements Data <\/b>aus der Variablen objData <\/b>versorgt wird.<\/p>\n
Data-Element dekodieren<\/h2>\n
Schauen wir uns als Erstes die Funktion DecodeBase64 <\/b>an. Diese erwartet einen String als Parameter, in diesem Fall den Inhalt des data<\/b>-Elements unserer XML-Datei. Und jetzt kommt der Clou: Wir nutzen keinen selbst programmierten Algorithmus, um die Dekodierung vorzunehmen, sondern wir erstellen ein XML-Dokument, fügen diesem ein neues Element namens tmp <\/b>hinzu, stellen den Datentyp auf bin.base64 <\/b>ein und füllen es über seine Text<\/b>-Eigenschaft mit dem Wert aus dem Parameter strBase64<\/b>. Die XML-Bibliothek erledigt die Umwandlung dann automatisch für uns, sodass wir über die Eigenschaft nodeTypedValue <\/b>des Elements auf das resultierende Byte-Array zugreifen können. Diesen Wert weisen wir dem Rückgabewert DecodeBase64 <\/b>der Funktion zu, der als Byte() <\/b>deklariert ist (s. Listing 2).<\/p>\n
Private Function <\/span>DecodeBase64(strBase64 As String<\/span>) As Byte<\/span>()\r\n     Dim <\/span>objDocument As <\/span>MSXML2.DOMDocument60\r\n     Dim <\/span>objElement As <\/span>MSXML2.IXMLDOMElement\r\n     Set<\/span> objDocument = New<\/span> MSXML2.DOMDocument60\r\n     Set<\/span> objElement = objDocument.createElement(\"tmp\")\r\n     objElement.DataType = \"bin.base64\"\r\n     objElement.Text = strBase64\r\n     DecodeBase64 = objElement.nodeTypedValue\r\nEnd Function<\/span><\/pre>\n
Listing 2: Dekodieren von Base64 in ein Byte-Array<\/span><\/b><\/p>\n
Byte-Array in Datei schreiben<\/h2>\n
<\/p>\n
Damit erhalten wir den zweiten Parameter für die Funktion WriteFileFromBytes<\/b> (s. Listing 3). Der erste Parameter erwartet den Pfad für die zu erstellende Datei, der zweite das soeben mit der Funktion DecodeBase64 <\/b>erstellte Byte-Array. Die Prozedur nutzt wieder eine externe Bibliothek, und zwar Microsoft ActiveX Data Objects 6.1 Library<\/b>. Davon deklariert sie zunächst ein ADODB.Stream<\/b>-Objekt und erstellt eine neue Instanz dieses Objekts. Den Typ des Objekts stellt die Funktion auf adTypeBinary <\/b>ein. Sie öffnet das Objekt mit der Open<\/b>-Methode und schreibt dann das mit dem zweiten Parameter byt() <\/b>übergebene Byte-Array hinein. Das Stream-Objekt bietet direkt eine SaveToFile<\/b>-Methode an, mit der wir den Inhalt in die mit dem ersten Parameter übergebene Datei schreiben können. Mit dem Wert des zweiten Parameters legen wir fest, dass die Datei neu erstellt werden oder eine bestehende Datei überschreiben soll.<\/p>\n
Private Sub <\/span>WriteFileFromBytes(strFile As String<\/span>, byt() As Byte<\/span>)\r\n     Dim <\/span>objStream As <\/span>ADODB.Stream\r\n     Set<\/span> objStream = New<\/span> ADODB.Stream\r\n     objStream.Type = adTypeBinary\r\n     objStream.Open\r\n     objStream.Write byt()\r\n     objStream.SaveToFile strFile, adSaveCreateOverWrite\r\nEnd Sub<\/span><\/pre>\n
Listing 3: Schreiben eines Byte-Arrays in eine Datei<\/span><\/b><\/p>\n
Es hat funktioniert – die Daten aus dem XML-Dokument ergeben tatsächlich eine lesbare Datei, hier im PDF-Format (s. Bild 3).<\/p>\n
\"Es<\/p>\n
Bild 3: Es klappt – die exportierten XML-Daten ergeben tatsächlich eine lesbare Datei.<\/span><\/b><\/p>\n
Datei in ein XML-Dokument schreiben<\/h2>\n
Natürlich wollen wir uns auch den umgekehrten Fall ansehen. Dabei soll eine auf der Festplatte liegende Datei, beispielsweise eine PDF-Datei, in das data<\/b>-Element eines XML-Dokuments geschrieben werden, sodass es mit diesem etwa an einen Webservice geschickt oder anderweitig weitergenutzt werden kann.<\/p>\n
Die Ausgangsmethode für unser Beispiel sieht wie in Listing 4 aus. Sie erstellt ein neues DOMDocument<\/b>-Objekt und definiert zwei Dateipfade: strDatei <\/b>nimmt den Pfad der XML-Datei auf, in welche die Datei geschrieben werden soll, strQuelle <\/b>nimmt den Pfad zu der Datei auf, die in das XML-Dokument geschrieben werden soll.<\/p>\n
Public Sub <\/span>DateiInXMLElement()\r\n     Dim <\/span>objDocument As <\/span>MSXML2.DOMDocument60\r\n     Dim <\/span>objRoot As <\/span>MSXML2.IXMLDOMElement\r\n     Dim <\/span>strDatei As String<\/span>\r\n     Dim <\/span>strData As String<\/span>\r\n     Dim <\/span>strQuelle As String<\/span>\r\n     Dim <\/span>objElement As <\/span>MSXML2.IXMLDOMElement\r\n     Set<\/span> objDocument = New<\/span> MSXML2.DOMDocument60\r\n     strDatei = CurrentProject.Path & \"\\XMLMitPDFDatei.xml\"\r\n     strQuelle = CurrentProject.Path & \"\\Artikel.pdf\"\r\n     Set<\/span> objRoot = objDocument.createElement(\"file\")\r\n     objDocument.appendChild objRoot\r\n     Set<\/span> objElement = objDocument.createElement(\"filename\")\r\n     objElement.nodeTypedValue = Mid<\/span>(strQuelle, _\r\n         InStrRev<\/span>(strQuelle, \"\\\") + 1)\r\n     objRoot.appendChild objElement\r\n     Set<\/span> objElement = objDocument.createElement(\"data\")\r\n     objRoot.appendChild objElement\r\n     strData = EncodeBase64(ReadBytesFromFile(strQuelle))\r\n     objElement.nodeTypedValue = strData\r\n     objDocument.Save CurrentProject.Path & \"\\ArtikelInXML.xml\"\r\nEnd Sub<\/span><\/pre>\n
Listing 4: übertragen einer Datei in ein Element eines XML-Dokuments<\/span><\/b><\/p>\n
Im XML-Dokument erstellt die Prozedur zunächst ein neues Root-Element namens file <\/b>und speichert dieses in der Variablen objRoot<\/b>. Dann hängt es dieses Element mit der appendChild<\/b>-Methode an das Dokument aus objDocument <\/b>an. Das erste Unterelement heißt filename<\/b>. Es soll unterhalb des Elements file <\/b>angehängt werden. Also erstellt die Prozedur zunächst ein neues Element mit der createElement<\/b>-Methode. über die Eigenschaft nodeTypedValue <\/b>weisen wir dem Element filename <\/b>den reinen Dateinamen der zu importierenden Datei ohne Verzeichnisangabe zu. Diesen Wert ermitteln wir, indem wir mit der InStrRev<\/b>-Funktion die Position des letzten Backslash-Zeichens von hinten ermitteln und mit der Mid<\/b>-Funktion den ab dieser Position (plus eins) befindlichen Dateinamen auslesen. Danach hängt die Prozedur das Element mit der Methode appendChild<\/b> an objRoot <\/b>an.<\/p>\n
Dann folgt das Element mit den Daten der zu integrierenden Datei. Dieses legt die Prozedur ebenfalls mit der createElement<\/b>-Methode an, diesmal unter dem Namen data<\/b>. Nach dem Anhängen des Elements unter das Root-Element file <\/b>ermitteln wir die Zeichenkette, welche die Datei repräsentiert, und schreiben diese in die Variable strData<\/b>. Ihr Inhalt landet dann direkt in der Eigenschaft nodeTypedValue <\/b>des Elements file<\/b>. Die Save<\/b>-Methode des DOMDocument<\/b>-Objekts schreibt das XML-Dokument schließlich in die angegebene Datei.<\/p>\n
Nun haben wir den Teil, wo wir aus der Datei die Zeichenkette zum Einfügen in das Element file <\/b>ermitteln, ausgelassen, aber diesen holen wir gleich nach. Auch hier verwenden wir wieder zwei verschachtelte Funktionsaufrufe:<\/p>\n
strData = EncodeBase64(ReadBytesFromFile(strQuelle))<\/pre>\n
Wir lesen also erst mit ReadBytesFromFile <\/b>den Inhalt der Datei in ein Byte-Array ein und kodieren dieses dann mit der Funktion EncodeBase64 <\/b>in Base64.<\/p>\n
Datei in Byte-Array einlesen<\/h2>\n
Die erste Funktion heißt ReadBytesFromFile <\/b>und erwartet den Pfad zur einzulesenden Datei als Parameter. Der Rückgabewert ist ein Byte-Array (s. Listing 5). Die Funktion erstellt wieder ein ADODB-Stream-Objekt. Sie öffnet es mit der Open<\/b>-Methode, legt den Typ mit der Eigenschaft Type <\/b>auf adTypeBinary <\/b>fest und nutzt die LoadFromFile<\/b>-Methode, um die mit dem Parameter strFile <\/b>angegebene Datei in das Stream<\/b>-Objekt zu laden. Schließlich liefert die Read<\/b>-Funktion ein Byte-Array auf Basis der enthaltenen Daten, welche wir mit dem Funktionswert ReadBytesFromFile <\/b>an die aufrufende Routine weitergeben.<\/p>\n
Private Function <\/span>ReadBytesFromFile(strFile As String<\/span>) As Byte<\/span>()\r\n     Dim <\/span>objStream As <\/span>ADODB.Stream\r\n     Set<\/span> objStream = New<\/span> ADODB.Stream\r\n     objStream.Open\r\n     objStream.Type = adTypeBinary\r\n     objStream.LoadFromFile strFile\r\n     ReadBytesFromFile = objStream.Read()\r\nEnd Function<\/span><\/pre>\n
Listing 5: Einlesen einer Datei in ein Byte-Array<\/span><\/b><\/p>\n
Byte-Array in Base64 umwandeln<\/h2>\n
Nun müssen wir das Byte-Array noch in Base64 umwandeln, damit wir es im gängigen Format im XML-Dokument speichern können. Diese Aufgabe nimmt uns die Funktion EncodeBase64 <\/b>ab (s. Listing 6). Sie nutzt dazu wieder Elemente der Bibliothek Microsoft XML, v6.0<\/b>. Sie erstellt zunächst ein DOMDocument<\/b>-Objekt und legt in diesem Kontext ein Objekt des Typs IXMLDOMElement <\/b>an. Für dieses Element legt sie mit der Eigenschaft DataType <\/b>den Datentyp bin.base64 <\/b>fest und weist den Inhalt des per Parameter übergebenen Byte-Arrays der Eigenschaft nodeTypedValue <\/b>zu.<\/p>\n
Private Function <\/span>EncodeBase64(byt() As Byte<\/span>) As String<\/span>\r\n     Dim <\/span>objDocument As <\/span>MSXML2.DOMDocument60\r\n     Dim <\/span>objElement As <\/span>MSXML2.IXMLDOMElement\r\n     Set<\/span> objDocument = New<\/span> MSXML2.DOMDocument60\r\n     Set<\/span> objElement = objDocument.createElement(\"tmp\")\r\n     objElement.DataType = \"bin.base64\"\r\n     objElement.nodeTypedValue = byt\r\n     EncodeBase64 = objElement.Text\r\nEnd Function<\/span><\/pre>\n
Listing 6: Umwandeln eines Byte-Arrays in Base64<\/span><\/b><\/p>\n
Die Zeichenkette im Base64-Format erhalten Sie dann, indem Sie die Text<\/b>-Eigenschaft dieses Elements auslesen, der schließlich als Rückgabewert der Funktion dient.<\/p>\n
Funktion parametrisieren<\/h2>\n
Nun stellt sich die Frage, was wir mit den hier gewonnenen Hilfsfunktionen anstellen. Jedes Mal eine neue Prozedur für den aktuellen Anwendungsfall zu schreiben, wenn wir diese Funktionen ansteuern wollen, ist uns als Access-Entwickler doch zu mühsam. Viel schöner wäre es doch, wenn wir noch eine Wrapper-Funktion hätten, der wir Informationen übergeben wie die folgenden – hier zunächst für den Import:<\/p>\n