{"id":55000801,"date":"2011-10-01T00:00:00","date_gmt":"2020-05-22T21:58:30","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=801"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"XMLCodeBuilder_","status":"publish","type":"post","link":"https:\/\/access-im-unternehmen.de\/XMLCodeBuilder_\/","title":{"rendered":"XML-Code-Builder"},"content":{"rendered":"

\"\"<\/p>\n

Ein XML-Code-Builder – was soll das denn sein Nun: Stellen Sie sich einfach vor, Ihr Kunde liefert Ihnen eine Datenbank und ein XML-Dokument und möchte, dass Sie ihm den Code liefern, mit dem er ein so aufgebautes XML-Dokument mit Daten aus der Datenbank füllen kann. Kein Problem, sagen Sie – es ist zwar etwas Fleißarbeit, aber das bekommen Sie schon hin. Ach: Ist Fleißarbeit nicht das erklärte Feindbild eines Access-Entwicklers Genau! Und deshalb liefert dieser Beitrag Ihnen die Werkzeuge, um das Grundgerüst des zu erstellenden Codes aufzubauen.<\/b><\/p>\n

Mir ist das schon einige Male untergekommen: Ein Kunde möchte Daten aus seiner Datenbank in das XML-Format übertragen, weil dies die einzige Möglichkeit ist, die Daten an eine weitere Anwendung, einen Webservice und so weiter zu übergeben. Bereits nach dem Zusammenstellen der ersten paar Zeilen Code war klar: Das lässt sich automatisieren, zumindest für das Grundgerüst. Dass da noch ein wenig Handarbeit nötig ist, war klar, aber zumindest das Kopieren und Einfügen bestehender Codesegmente und das Anpassen an die jeweils zu schreibenden XML-Elemente auf Basis der Tabellenfelder ist erstens zu mühsam und zweitens zu fehleranfällig.<\/p>\n

Also toben wir uns lieber an ein paar schicken VBA-Routinen aus, die uns den Großteil der Arbeit abnehmen. Was ist das Ziel der Lösung, die wir in diesem Beitrag vorstellen Stellen Sie sich vor, Sie sollten aus der Südsturm-Datenbank heraus einen Export fahren, der etwa in einen Onlineshop importiert werden soll. Das XML-Dokument zum Übertragen der Artikeldaten zum Onlineshop soll dann beispielsweise so aussehen, wie ein Beispieldokument verrät:<\/p>\n

<xml version="1.0">\r\n<Katalog>\r\n    <Datum>11.07.2011<\/Datum>\r\n    <Zeit>12:29:49<\/Zeit>\r\n    <Artikelliste>\r\n        <Artikel ID="1">\r\n            <Artikelname>Artikel 1<\/Artikelname>\r\n            <Waehrung>EUR<\/Waehrung>\r\n            <Einzelpreis>10,00<\/Einzelpreis>\r\n        <\/Artikel>\r\n        <Artikel ID="2">\r\n            <Artikelname>Artikel 2<\/Artikelname>\r\n            <Waehrung>EUR<\/Waehrung>\r\n            <Einzelpreis>20,00<\/Einzelpreis>\r\n        <\/Artikel>\r\n        ...\r\n    <\/Artikelliste>\r\n<\/Katalog><\/pre>\n
Sie müssen nun Code schreiben, der erstens die Basiselemente wie die XML-Auszeichnung und die Elemente Katalog<\/b>, Datum<\/b>, Zeit <\/b>und Artikelliste<\/b> erzeugt. Danach folgt eine Schleife über alle Einträge der Tabelle tblArtikel<\/b>, in der für jeden Artikel ein Artikel<\/b>-Element sowie die darunter befindlichen Elemente angelegt werden.<\/p>\n
Im Detail würde bereits zum Erstellen dieses einfachen XML-Dokuments die Prozedur aus Listing 1<\/a><\/span> nötig sein. Die Prozedur erstellt zunächst die Kopfdaten, danach folgen die Elemente Katalog <\/b>und Artikelliste <\/b>sowie in einer Do While<\/b>-Schleife über alle Artikel die Elemente Artikel <\/b>(mit dem Attribut ID<\/b>), Artikelname<\/b>, Waehrung <\/b>und Einzelpreis<\/b>. Um die Struktur abzubilden, legt die Prozedur jeweils die übergeordneten Elemente an, speichert einen Verweis auf diese Elemente in einer entsprechenden Objektvariablen und verwendet diese dann, um weitere Elemente unterzuordnen. Das bedeutet, dass Sie prinzipiell für jeden Elementtyp eine Objektvariable erzeugen müssen, in deren Kontext dann die untergeordneten Elemente erstellt werden können.<\/p>\n
Listing 1: Zusammenstellen eines XML-Dokuments mit Artikeldaten<\/p>\n
Public Sub Katalog()\r\n    Dim db As DAO.Database\r\n    Dim rst As DAO.Recordset\r\n    Dim objXML As MSXML2.DOMDocument\r\n    Dim objPI As MSXML2.IXMLDOMProcessingInstruction\r\n    Dim objKatalog As MSXML2.IXMLDOMElement\r\n    Dim objDatum As MSXML2.IXMLDOMElement\r\n    Dim objZeit As MSXML2.IXMLDOMElement\r\n    Dim objArtikelliste As MSXML2.IXMLDOMElement\r\n    Dim objArtikel As MSXML2.IXMLDOMElement\r\n    Dim objArtikelname As MSXML2.IXMLDOMElement\r\n    Dim objWaehrung As MSXML2.IXMLDOMElement\r\n    Dim objEinzelpreis As MSXML2.IXMLDOMElement\r\n    Set db = CurrentDb\r\n    Set rst = db.OpenRecordset("SELECT * FROM tblArtikel", dbOpenDynaset)\r\n    Set objXML = New MSXML2.DOMDocument\r\n    Set objPI = objXML.createProcessingInstruction("xml", "version=""1.0"" encoding=""utf-8""")\r\n    objXML.appendChild objPI\r\n    Set objKatalog = objXML.createElement("Katalog")\r\n    objXML.appendChild objKatalog\r\n    Set objDatum = objXML.createElement("Datum")\r\n    objKatalog.appendChild objDatum\r\n    objDatum.Text = Date\r\n    Set objZeit = objXML.createElement("Zeit")\r\n    objKatalog.appendChild objZeit\r\n    objZeit.Text = Time\r\n    Set objArtikelliste = objXML.createElement("Artikelliste")\r\n    objKatalog.appendChild objArtikelliste\r\n    Do While Not rst.EOF\r\n         Set objArtikel = objXML.createElement("Artikel")\r\n        objArtikelliste.appendChild objArtikel\r\n        objArtikel.setAttribute "ID", rst!ArtikelID\r\n        Set objArtikelname = objXML.createElement("Artikelname")\r\n        objArtikel.appendChild objArtikelname\r\n        objArtikelname.Text = rst!Artikelname\r\n        Set objWaehrung = objXML.createElement("Waehrung")\r\n        objArtikel.appendChild objWaehrung\r\n        objWaehrung.Text = "EUR"\r\n        Set objEinzelpreis = objXML.createElement("Einzelpreis")\r\n        objArtikel.appendChild objEinzelpreis\r\n        objEinzelpreis.Text = rst!Einzelpreis\r\n        rst.MoveNext\r\n    Loop\r\n    Debug.Print FormatXML(objXML.XML)\r\nEnd Sub<\/pre>\n
Verweis auf die XML-Bibliothek<\/b><\/p>\n
Damit Sie die notwendigen Routinen zum Erstellen und Auslesen der XML-Dokumente unter Zuhilfenahme von IntelliSense erstellen können, brauchen Sie einen Verweis auf die Bibliothek Microsoft XML, vx.0<\/b>. Diesen fügen Sie über den Verweise<\/b>-Dialog hinzu, den Sie mit dem Menüeintrag Extras|Verweise <\/b>öffnen.<\/p>\n
Vereinfachung der Code-Erstellung<\/b><\/p>\n
Der erste Schritt auf dem Weg zu einer massiven Vereinfachung der Erstellung von Code zum Produzieren von XML-Dokumenten sind Routinen, welche die immer wiederkehrenden Befehle kapseln.<\/p>\n
Verarbeitungsanweisung hinzufügen<\/b><\/p>\n
Ein XML-Dokument enthält in der Regel die folgende Zeile:<\/p>\n
<xml version="1.0"><\/pre>\n
Um diese Zeile zu einem jungfräulichen XML-Dokument hinzuzufügen, das mit einer entsprechenden DOMDocument<\/b>-Variablen referenziert wird, verwenden Sie die Prozedur aus Listing 2<\/a><\/span>. Die Prozedur fügt der mit dem als Parameter übergebenen XML-Dokument die gewünschte Zeile hinzu. Um ein Dokument nur mit der Verarbeitungsanweisung auszustatten, benötigen Sie nun nur noch die folgende kleine Prozedur:<\/p>\n
Listing 2: Erstellen der Verarbeitungsanweisung eines XML-Dokuments<\/p>\n
Public Sub AddPI(objXML As MSXML2.DOMDocument)\r\n    Dim objPI As MSXML2.IXMLDOMProcessingInstruction\r\n    Set objPI = objXML.createProcessingInstruction("xml", "version=""1.0"" encoding=""utf-8""")\r\n    objXML.appendChild objPI\r\nEnd Sub\r\nPublic Sub DokumentMitPI()\r\n    Dim objXML As MSXML2.DOMDocument\r\n    Set objXML = New MSXML2.DOMDocument\r\n    AddPI objXML\r\n    Debug.Print objXML.XML\r\nEnd Sub<\/pre>\n
Diese Prozedur erstellt das XML-Dokument, fügt die Verarbeitungsanweisung hinzu und gibt das Dokument im Direktfenster aus.<\/p>\n
Elemente hinzufügen<\/b><\/p>\n
Nun folgen die eigentlichen Elemente des XML-Dokuments. Zum Hinzufügen eines einfachen Elements benötigen Sie eigentlich die folgenden beiden Anweisungen:<\/p>\n
Set objKatalog = objXML.createElement("Katalog")\r\nobjXML.appendChild objKatalog<\/pre>\n
Damit fügen Sie ein Element mit dem Namen Katalog <\/b>als Root-Element hinzu, das jedoch noch keinen Inhalt besitzt:<\/p>\n
<xml version="1.0">\r\n<Katalog\/><\/pre>\n
Um diesem Element das Element Artikelliste <\/b>unterzuordnen, legen Sie das Element im Kontext von objXML <\/b>an, hängen es aber mit appendChild <\/b>an das Element objKatalog <\/b>an:<\/p>\n
Set objArtikelliste = objXML.\r\ncreateElement("Artikelliste")\r\nobjKatalog.appendChild objArtikelliste<\/pre>\n
Das Result sieht dann so aus:<\/p>\n
<xml version="1.0">\r\n<Katalog><Artikelliste\/><\/Katalog><\/pre>\n
Das Anhängen der Artikel<\/b>-Elemente geschieht genau so, beim Element Artikelname <\/b>kommt jedoch noch ein Inhalt hinzu – genau genommen ein Text:<\/p>\n
Set objArtikelname = objXML. createElement("Artikelname")\r\nobjArtikel.appendChild objArtikelname\r\nobjArtikelname.Text = rst!Artikelname<\/pre>\n
Dazu speichern Sie wiederum den Verweis auf das Element und verwenden dann dessen Text<\/b>-Eigenschaft, um den Inhalt hinzuzufügen. Wie wäre es, diese Objekte – egal, ob mit oder ohne Text – sämtlich mit Einzeilern anzulegen Schauen Sie sich einmal die Prozedur aus Listing 3<\/a><\/span> an. Diese erwartet drei Parameter:<\/p>\n
Listing 3: Erstellung der Elemente des XML-Dokuments<\/p>\n
Public Function CreateSubElement(objElement As Object, strElementname As String, Optional strText As String) As MSXML2.IXMLDOMElement\r\n    Dim strTypename As String\r\n    Dim objDocument As MSXML2.DOMDocument\r\n    Dim objXMLElement As MSXML2.IXMLDOMElement\r\n    strTypename = TypeName(objElement)\r\n    Select Case strTypename\r\n        Case "DOMDocument"\r\n            Set objXMLElement = objElement.createElement(strElementname)\r\n            objElement.appendChild objXMLElement\r\n        Case "IXMLDOMElement"\r\n            Set objDocument = objElement.ownerDocument\r\n            Set objXMLElement = objDocument.createElement(strElementname)\r\n            objElement.appendChild objXMLElement\r\n    End Select\r\n    If Len(strText) > 0 Then\r\n        objXMLElement.Text = strText\r\n    End If\r\n    Set CreateSubElement = objXMLElement\r\nEnd Function<\/pre>\n