{"id":55001403,"date":"2023-02-01T00:00:00","date_gmt":"2023-06-17T09:32:01","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=1403"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"JSONDaten_auslesen","status":"publish","type":"post","link":"https:\/\/access-im-unternehmen.de\/JSONDaten_auslesen\/","title":{"rendered":"JSON-Daten auslesen"},"content":{"rendered":"

\"\"<\/p>\n

Für XML gibt es eine eigene Bibliothek zum Lesen und Schreiben der Inhalte eines XML-Dokuments. Bei JSON sieht das anders aus: Microsoft hat bisher keine Bibliothek bereitgestellt, mit der man komfortabel auf ein JSON-Dokument zugreifen kann. Wir wollen diesen Missstand zumindest ein wenig lindern. Es gibt bereits ein Modul, welches den Inhalt einer JSON-Datei in eine Art Objektmodell einliest, das von VBA aus wesentlich einfacher zu lesen ist. Dieses greifen wir in diesem Beitrag auf und zeigen, wie wir die Struktur der enthaltenen Daten erfassen und damit besser und systematisch auswerten können.<\/b><\/p>\n

Fertiges JSON-Modul <\/h2>\n

Das in der Einleitung angesprochene JSON-Modul finden Sie unter dem folgenden Link zum Download vor:<\/p>\n

https:\/\/github.com\/VBA-tools\/VBA-JSON<\/pre>\n
Es ist aber auch in der Beispieldatenbank zu diesem Beitrag enthalten. Dieses Modul stellt eine für uns interessante Funktion namens ParseJSON<\/b> zur Verfügung. Dieser übergibt man den Inhalt des JSON-Dokuments und erhält als Ergebnis ein Objekt des Typs Dictionary <\/b>zurück. Damit wir dieses unter Verwendung von IntelliSense nutzen können, fügen wir dem VBA-Projekt einen Verweis auf die Bibliothek Microsoft Scripting Runtime <\/b>hinzu (siehe Bild 1).<\/p>\n
\"Verweis<\/p>\n
Bild 1: Verweis auf die Bibliothek Microsoft Scripting Runtime<\/span><\/b><\/p>\n
Beispieldokument<\/h2>\n
Als Beispieldokument verwenden wir eines, das wir bei SelfHTML <\/b>unter folgender Adresse gefunden haben:<\/p>\n
https:\/\/wiki.selfhtml.org\/wiki\/JSON<\/pre>\n
Dieses Dokument sieht wie in Bild 2 aus. Dieses Beispiel ist übrigens bereits so formatiert, dass es relativ gut lesbar ist und man seine Struktur erkennen kann. Die JSON-Daten, welche die meisten Webservice-APIs zurückliefern, kommen meist ohne Einrückungen und Zeilenumbrüche. Unser Beispiel würde dann etwa wie folgt aussehen:<\/p>\n
\"Beispiel<\/p>\n
Bild 2: Beispiel für ein JSON-Dokument<\/span><\/b><\/p>\n
{\"name\":\"Georg\",\"alter\":47,\"verheiratet\":false,\"beruf\":null,\"kinder\":[{\"name\":\"Lukas\",\"alter\":19,\"schulabschluss\":\"Gymnasium\"},{\"name\":\"Lisa\",\"alter\":14,\"schulabschluss\":null}]}<\/pre>\n
Bereits diese kleine Datenmenge im JSON-Format ist für das menschliche Auge nicht gut lesbar.<\/p>\n
JSON in ein Objektmodell überführen<\/h2>\n
Nun haben wir weiter oben bereits die Funktion ParseJSON <\/b>erwähnt, welche den Inhalt einer JSON-Datei in ein übergeordnetes Dictionary<\/b>-Objekt überführt. Dieses enthält einfache Eigenschaften, also Name-Wert-Paare, weitere Dictionary<\/b>-Objekte sowie Collection<\/b>-Objekte.<\/p>\n
Das allein reicht eigentlich aus, um auf die Inhalte zuzugreifen. Das setzt allerdings voraus, dass man die Struktur kennt und wie man den Zugriff auf einzelne Elemente in der Struktur – oder auch auf mehrere Elemente unterhalb einer Dictionary<\/b>– oder Collection<\/b>-Auflistung – realisiert. Auf die einzelnen Werte des JSON-Beispiels können wir nach dem Eintragen in objJSON <\/b>nämlich über die folgenden Ausdrücke zugreifen:<\/p>\n
objJSON.Item(\"name\")\r\nobjJSON.Item(\"alter\")\r\nobjJSON.Item(\"verheiratet\")\r\nobjJSON.Item(\"beruf\")\r\nobjJson.Item(\"kinder\").Item(1).Item(\"name\")\r\nobjJson.Item(\"kinder\").Item(1).Item(\"alter\")\r\nobjJson.Item(\"kinder\").Item(1).Item(\"schulabschluss\")\r\nobjJson.Item(\"kinder\").Item(2).Item(\"name\")\r\nobjJson.Item(\"kinder\").Item(2).Item(\"alter\")\r\nobjJson.Item(\"kinder\").Item(2).Item(\"schulabschluss\")<\/pre>\n
Wie wir systematisch auf die Elemente eines JSON-Dokuments zugreifen können, schauen wir uns am Ende des Beitrags an.<\/p>\n
Zur Erläuterung: Die Elemente in geschweiften Klammern werden von ParseJSON <\/b>in Dictionary<\/b>-Objekte umgewandelt. Diejenigen in eckigen Klammern werden zu Collection<\/b>-Objekten. Und die Name-Wert-Paare wie „name“: „Georg“ <\/b>werden einfach zu Elementen im Dictionary<\/b>-Objekt, denen wir Name und Wert entnehmen können.<\/p>\n
Hier erhalten wir also ein Dictionary<\/b>-Objekt, das einige Unterelemente mit String<\/b>-Werten enthält sowie eines, das als Element ein Collection<\/b>-Element aufnimmt (Kinder<\/b>). Dieses enthält wiederum zwei Dictionary<\/b>-Objekte, eines für jedes Kind.<\/p>\n
{\r\n   \"name\": \"Georg\",\r\n   \"alter\": 47,\r\n   \"verheiratet\": false,\r\n   \"beruf\": null,\r\n   \"kinder\": [\r\n     {\r\n       \"name\": \"Lukas\",\r\n       \"alter\": 19,\r\n       \"schulabschluss\": \"Gymnasium\"\r\n     },\r\n     {\r\n       \"name\": \"Lisa\",\r\n       \"alter\": 14,\r\n       \"schulabschluss\": null\r\n     }\r\n   ]\r\n}<\/pre>\n
Wenn man die Grundregeln einmal verinnerlicht hat und das JSON-Dokument ordentlich formatiert vorliegen hat, kann man die für den Zugriff notwendigen Ausdrücke gegebenenfalls aus dem Kopf formulieren. Falls nicht, haben wir drei Routinen definiert, welche genau die Ausdrücke ausgeben, die für den Zugriff auf die im JSON-Dokument enthaltenen Elemente nötig sind.<\/p>\n
Wir gehen davon aus, dass wir das JSON-Dokument auf irgendeine Weise als Zeichenkette erhalten. In der folgenden Beispielprozedur lesen wir dazu den Inhalt der Datei Beispiel.json <\/b>aus dem gleichen Verzeichnis wie die Datenbank in die Variable strJSON <\/b>ein.<\/p>\n
Danach rufen wir die Prozedur GetJSONDOM<\/b> auf, um die für den Zugriff auf das Document Object Model des JSON-Dokuments nötigen Ausdrücke zu ermitteln:<\/p>\n
Public Sub <\/span>JSONBeispiel()\r\n     Dim <\/span>strJSON As String<\/span>\r\n     Open CurrentProject.Path & \"\\Beispiel.json\"  For Input As <\/span>#1\r\n     strJSON = Input$(LOF(1), #1)\r\n     Close #1\r\n     GetJSONDOM strJSON, True<\/span>\r\nEnd Sub<\/span><\/pre>\n
JSON-Dictionary auswerten<\/h2>\n
Die Funktion GetJSONDOM <\/b>erwartet ein JSON-Dokument in Form einer String<\/b>-Variablen als Parameter (siehe Listing 1). Außerdem können wir zwei weitere Parameter übergeben:<\/p>\n
Public Function <\/span>GetJSONDOM(strJSON As String<\/span>, Optional<\/span> bolValues As Boolean<\/span>, Optional<\/span> bolDebug As Boolean<\/span>) As String<\/span>\r\n     Dim <\/span>objJSON As <\/span>Dictionary\r\n     Dim <\/span>dic As <\/span>Dictionary\r\n     Dim <\/span>col As <\/span>Collection\r\n     Dim <\/span>strKey As String<\/span>\r\n     Dim <\/span>i As Integer<\/span>\r\n     Dim <\/span>strJSONDOM As String<\/span>\r\n     Set<\/span> objJSON = mdlJSON.ParseJson(strJSON)\r\n     For i = 0 To objJSON.Count - 1\r\n         Select Case TypeName(objJSON.Items(i))\r\n             Case <\/span>\"Dictionary\"\r\n                 Set<\/span> dic = objJSON.Items(i)\r\n                 JSONDictionary dic, \"objJSON\", strJSONDOM, bolValues, bolDebug\r\n             Case <\/span>\"Collection\"\r\n                 Set<\/span> col = objJSON.Items(i)\r\n                 strKey = \".Item(\"\"\" & objJSON.Keys(i) & \"\"\")\"\r\n                 JSONCollection col, \"objJson\" & strKey, strJSONDOM, bolValues, bolDebug\r\n             Case Else<\/span>\r\n                 If <\/span>Not<\/span> bolValues Then<\/span>\r\n                     If bolDebug Then Debug.Print<\/span> \"objJSON.Item(\"\"\" & objJSON.Keys(i) & \"\"\")\"\r\n                     strJSONDOM = strJSONDOM & \"objJSON.Item(\"\"\" & objJSON.Keys(i) & \"\"\")\" & vbCrLf<\/span>\r\n                 Else<\/span>\r\n                     If <\/span>bolDebug Then<\/span> Debug.Print<\/span> \"objJSON.Item(\"\"\" & objJSON.Keys(i) & \"\"\"):\" & objJSON.Items(i)\r\n                     strJSONDOM = strJSONDOM & \"objJSON.Item(\"\"\" & objJSON.Keys(i) & \"\"\"):\" & objJSON.Items(i) & vbCrLf<\/span>\r\n                 End If<\/span>\r\n         End Select<\/span>\r\n     Next<\/span> i\r\n     GetJSONDOM = strJSONDOM\r\nEnd Function<\/span><\/pre>\n
[<\/p>\n
Listing 1: Ausgabe des DOM eines JSON-Dokuments<\/span><\/b><\/p>\n