<\/p>\n
Fast jede Datenbankanwendung speichert Adressen in irgendeiner Form – seien es Kunden-, Mitarbeiter-, Privat- oder Firmenadressen. Diese gelangen über irgendeine Schnittstelle in die Datenbank, beispielsweise über den Import von Daten aus externen Dateien oder auch durch manuelle Eingabe. Aber prüfen Sie diese Adressen auch Oder lassen Sie es darauf ankommen, bis die Post einen Brief zu Ihnen zurückschickt, weil sie mit der Adresse nichts anfangen kann. In diesem Beitrag zeigen wir Ihnen, wie Sie fehlerhafte und unvollständige Adressen aufspüren und sie gegebenenfalls sogar automatisch korrigieren und ergänzen.<\/b><\/p>\n
Damit Sie später nicht enttäuscht sind: Die hier vorgestellte Lösung kümmert sich tatsächlich nur um Adressen, also um Straßen, Postleitzahlen, Orte, Bundesländer und Länder. Sie prüft nicht, ob eine bestimmte Person einer Adresse zugeordnet werden kann oder nicht – für einen Datenbestand, der dies erledigt, müssten Sie mit Sicherheit eine Menge Geld hinblättern.<\/p>\n
Unsere Lösung ist kostenlos und erledigt immerhin die Kontrolle und gegebenenfalls die Ergänzung von Adressen wie etwa Borkhofer Str. 17, Duisburg<\/b>.<\/p>\n
Wenn sie eine passende Adresse findet, liefert sie eine eventuell korrigierte Version zurück (Str. <\/b>wird beispielsweise zu Straße<\/b>) und ergänzt die Adresse um fehlende Elemente, hier etwa Postleitzahl, Land und Bundesland. Und falls Sie Bedarf haben, erhalten Sie gleichzeitig noch die Geodaten der angegebenen Adresse.<\/p>\n
Wenn tatsächlich keine passende Adresse zu finden ist, soll die Lösung dies melden – so können Sie sich, soweit vorhanden, via E-Mail oder Telefon an den Adressaten wenden und die korrekte Adresse ermitteln. Vielleicht stellt sich ja dabei heraus, dass es die angegebene Adresse tatsächlich nicht gibt und sich jemand einen schlechten Scherz erlaubt hat.<\/p>\n
Google als Datenlieferant<\/b><\/p>\n
Der Kern dieser Anwendung ist ein Dienst von Google, nämlich die Google Geocoding API<\/b> (http:\/\/code.google.com\/intl\/de\/apis\/maps\/documentation\/geocoding\/<\/b>).<\/p>\n
Wenn Sie diesem unter einer bestimmten Adresse die richtigen Parameter unterjubeln, liefert er ein XML-Dokument mit den gewünschten Informationen zurück. Um beim Beispiel Borkhofer Str. 17, Duisburg <\/b>zu bleiben, das immerhin die Postleitzahl vermissen lässt, geben Sie einfach einmal die folgende URL im Webbrowser Ihrer Wahl ein:<\/p>\n Die Bestandteile sind schnell erklärt: http:\/\/maps.google.com\/maps\/api\/geocode\/ <\/b>ist die eigentliche Webadresse des Services. xml <\/b>gibt an, dass Google das Ergebnis im XML-Format liefern soll – alternativ können Sie hier json <\/b>für die JavaScript Object Notation <\/b>angeben. Schließlich folgen noch weitere Parameter, die durch ein Fragezeichen eingeleitet werden: address<\/b> erwartet den eigentlichen Adress-Ausdruck.<\/p>\n Dessen Elemente trennen Sie durch Kommata voneinander. Leerzeichen ersetzen Sie durch das Plus-Zeichen:<\/p>\n Weitere Parameter werden durch das Kaufmanns-Und eingeleitet. Der folgende Ausdruck gibt an, dass die Anfrage von einem Gerät ohne Positionsermittlung kommt:<\/p>\n Der letzte Ausdruck gibt schließlich die Sprache an, in der Google die Antwort liefern soll:<\/p>\n Beim Absetzen der Abfrage im Browser kann dieser Parameter wegfallen, da er normalerweise automatisch die Länderkennung auswirft, später beim Aufruf per VBA müssen Sie die Länderkennung jedoch mitschicken.<\/p>\n Als Antwort erhalten Sie eine XML-Datei wie in Bild 1.<\/p>\n Bild 1: Diese Antwort liefert eine Adress-Anfrage via Browser.<\/span><\/b><\/p>\n XML-Adressdaten per Code holen<\/b><\/p>\n Natürlich sollen Sie Ihre Adressdaten nicht alle per Webbrowser abfragen, sondern dies automatisiert mit einer geeigneten VBA-Prozedur erledigen. Die einfachste Variante dieser Prozedur finden Sie in Bild 2 einen Verweis auf die Bibliothek Microsoft XML 3.0<\/b> oder höher hinzu.<\/p>\n Listing 1: Einfache Funktion zum Aufrufen des Webservices und zum Ausgeben des Ergebnisses<\/p>\n Bild 2: Hinzufügen eines Verweises auf die XML-Bibliothek von Microsoft<\/span><\/b><\/p>\n Die Prozedur AdressePruefen <\/b>deklariert zunächst das Objekt objDocument<\/b>, das nach einem Aufruf des Google-Webservices mit dessen Antwort gefüllt werden soll.<\/p>\n Die Variable strRequest <\/b>nimmt die URL mit der Anfrage auf. Nach dem Einstellen einiger Eigenschaften von objDocument<\/b>, auf die wir hier nicht im Detail eingehen, wird die Anfrage als Parameter der Load<\/b>-Funktion von objDocument <\/b>ausgewertet. Die Load<\/b>-Funktion liefert, je nachdem, ob der Aufruf erfolgreich war oder nicht, entweder den Wert True<\/b> oder False <\/b>zurück. War der Aufruf erfolgreich, können Sie anschließend über die Eigenschaft XML <\/b>des Objekts objDocument <\/b>den Inhalt der Antwort im XML-Format betrachten – diese wird in dieser ersten Version im Direktfenster ausgegeben (s. Bild 3).<\/p>\n Bild 3: Das Ergebnis einer Adress-Abfrage im Direktfenster des VBA-Editors<\/span><\/b><\/p>\n Einsatzmöglichkeiten<\/b><\/p>\n Sie wissen nun, wie Sie eine Anfrage an den Google-Webservice zum Prüfen von Adressen formulieren müssen, und erhalten die Antwort im XML-Format. Nun machen wir uns um die weitere Vorgehensweise Gedanken, was vor allem drei Fragen betrifft:<\/p>\n Zusammenstellen der HTTP-Anfrage an Google<\/b><\/p>\n Der Aufbau der Anfrage an Google ist bis auf den Wert des Parameters address <\/b>immer gleich. Wir müssen lediglich die zu prüfenden Adressdaten in eine geeignete Form bringen. Das bedeutet, dass die einzelnen Bestandteile (Straße und Hausnummer, PLZ und Ort sowie gegebenenfalls Land und Bundesland) durch Kommata voneinander getrennt aneinandergereiht werden. Leerzeichen innerhalb dieser Einträge ersetzen wir durch Plus-Zeichen.<\/p>\n XML-Antwort auswerten<\/b><\/p>\n Nachdem wir die Anfrage etwa wie in der Prozedur aus Listing 1<\/a> abgeschickt haben, erhalten wir ein XML-Dokument zurück. Dieses enthält entweder einen Hinweis darauf, dass die Adresse nicht gefunden oder der Aufruf aus irgendeinem anderen Grund gescheitert ist, oder es liefert die auf Basis der übermittelten Informationen ermittelten Adressdaten. In beiden Fällen müssen wir den Inhalt des XML-Dokuments untersuchen, was wir mit den Mitteln der Microsoft XML 3.0<\/b>-Bibliothek erledigen.<\/p>\n Adressinformationen weiterverarbeiten<\/b><\/p>\n Schließlich müssen wir die so ermittelten Informationen weiterverarbeiten – beispielsweise, indem wir diese über die zuvor ermittelten Adressdaten schreiben und eventuell noch nicht ausgefüllte Felder des Adressbestandes mit den gewonnenen Daten füllen.<\/p>\n Adressen prüfen per Klasse<\/b><\/p>\n Da diese Funktionen recht umfangreich sind und möglicherweise in mehr als nur einer Anwendung zum Einsatz kommen könnten, lagern wir diese in eine eigene Klasse aus. Die Beschreibung dieser Klasse folgt im Anschluss, zunächst schauen wir uns ihren praktischen Einsatz an.<\/p>\n Um die Klasse einzusetzen, benötigen Sie zuerst eine Objektvariable zum Speichern der Referenz auf die Klasse:<\/p>\n Anschließend erstellen Sie ein Objekt auf Basis der Klasse:<\/p>\n Dann weisen Sie einigen Eigenschaften der Klasse die Werte der zu untersuchenden Adresse zu:<\/p>\n Schließlich rufen Sie die Funktion CheckAddress<\/b> auf, die entweder den Wert True <\/b>oder False <\/b>zurückliefert. Im Falle des Wertes True <\/b>möchten wir die gefundenen Informationen im Direktfenster betrachten:<\/p>\n Anderenfalls soll das Direktfenster einfach eine Meldung mit einer Erklärung liefern, warum die Adressprüfung nicht funktioniert hat:<\/p>\n Dies alles können Sie leicht in eine Do While<\/b>-Schleife packen, die alle Datensätze einer Adressdatenbank durchläuft. Sie müssen dann statt der hier konkret zugewiesenen Zeichenketten die Inhalte der entsprechenden Felder der Adresstabelle übergeben, damit die Adressen geprüft werden können. Sollte die Methode CheckAddress <\/b>eine passende Adresse gefunden haben, können Sie die vorhandene Adresse gleich durch die geprüfte und gegebenenfalls ergänzte Adresse ersetzen.<\/p>\n Erstellen der Klasse clsAddressChecker<\/b><\/p>\n Wechseln Sie zum VBA-Editor und legen Sie eine neue Klasse namens clsAddressChecker <\/b>an (Menüeintrag Einfügen|Klassenmodul<\/b>).<\/p>\n Dieser Klasse wollen wir sowohl unsere bestehenden Adressdaten übergeben als auch die geprüften und überarbeiteten Daten entnehmen. Wir benötigen also in jedem Falle einige private Variablen zum Zwischenspeichern dieser Informationen. Diese Variablen sehen wie folgt aus und speichern Informationen wie Straße, Hausnummer et cetera:<\/p>\n Damit Sie dem Objekt die Daten der zu prüfenden Adressen nach dem Instanzieren übermitteln können, legen Sie eine Reihe von Property Let<\/b>-Prozeduren an. Jede dieser Prozeduren tritt nach außen als Eigenschaft der Klasse clsAddressChecker <\/b>in Erscheinung. Im laufenden Betrieb nehmen diese die Werte entgegen, die den Eigenschaften des Objekts zugewiesen werden, und speichern diese in den entsprechenden privaten Variablen:<\/p>\n <\/p>\n Um eines vorwegzunehmen: Die Klasse soll, wenn die Methode CheckAddress<\/b> erfolgreich war, die gefundenen und gegebenenfalls korrigierten Werte genau in die Variablen schreiben, in denen auch die von der aufrufenden Instanz übergebenen Ausgangswerte landeten. Damit diese Instanz auf diese in den einzelnen Variablen gespeicherten Werte zugreifen kann, brauchen Sie eine Reihe von Property Get<\/b>-Prozeduren, die das Gegenteil von dem tun, was die Property Let<\/b>-Prozeduren erledigen: Sie stellen die Werte der privaten Variablen nach außen als Eigenschaften des Objekts auf Basis der Klasse clsAddressChecker <\/b>zur Verfügung.<\/p>\n Die jeweils einzige Anweisung weist dabei dem Funktionswert dieser Prozeduren den jeweiligen Variableninhalt zu:<\/p>\n Zusätzlich zu den bekannten Eigenschaften können Sie mit den folgenden beiden die geografische Position der betroffenen Adresse ermitteln:<\/p>\n Die letzte der verwendeten Property Get<\/b>-Prozeduren liefert schließlich einen Erklärungstext für ein eventuelles Scheitern des Aufrufs von CheckAddress<\/b>:<\/p>\n Die Funktion CheckAddress<\/b> finden Sie in Listing 2<\/a>. Sie erwartet keine Parameter und liefert einen Boolean<\/b>-Wert zurück. Wie aber soll eine gefundene Adresse zurückgeliefert werden, wenn nicht als Parameter der Prüffunktion<\/p>\n Listing 2: Diese Funktion initiiert die Prüfung einer Adresse.<\/p>\n Wer bereits einmal Klassen programmiert hat, weiß es: Die gefundenen Daten landen in den oben beschriebenen Variablen und können nach erfolgreicher Prüfung genau so ausgelesen werden, wie die zu prüfenden Daten zugewiesen wurden.<\/p>\n Die Funktion CheckAddress <\/b>verwendet zunächst die Funktion GetAddress<\/b>, um den Adress-Ausdruck für die Übergabe an den Google-Webservice zusammenzusetzen. Danach sendet die Funktion GetXML <\/b>die Anfrage ab und nimmt das Ergebnis in Form eines XML-Dokuments entgegen, welches im Objekt objDocument <\/b>gespeichert wird.<\/p>\n Das darin enthaltene XML-Dokument enthält ein Element namens Status<\/b>, welches als Ergebnis der Anfrage den Ausdruck OK <\/b>oder, im Fehlerfall, einen Wert wie ZERO_RESULTS <\/b>zurückliefert (s. Bild 4). Diesen Wert erhalten wir über eine SelectSingleNode<\/b>-Anweisung, welche Elemente des XML-Dokuments entsprechend einer bestimmten Syntax ermittelt (mehr zu diesem Thema erfahren Sie im Beitrag XML-Dokumente mit VBA erstellen und lesen <\/b>unter www.access-im-unternehmen.de\/522<\/b>).<\/p>\n Bild 4: Die XML-Antwort enthält gleich zu Beginn Informationen über Erfolg oder Misserfolg.<\/span><\/b><\/p>\n Eine besondere Rolle kommt der For…Next<\/b>-Schleife zu, die viermal durchlaufen wird und prüft, ob das XML-Dokument als Status <\/b>den Wert OVER QUERY LIMIT <\/b>zurückliefert. Dies kann geschen, wenn zuviele Abfragen in kurzer Zeit erfolgen oder wenn Sie tatsächlich die bei Drucklegung dieses Beitrags gültige Grenze von 2.500 Zugriffen überschritten haben. Im ersten Fall wartet die Prozedur jeweils eine halbe Sekunde, bevor sie einen erneuten Zugriff versucht. Sollte dies viermal schiefgehen, ist davon auszugehen, dass tatsächlich das Tageslimit erreicht wurde, anderenfalls arbeitet die Prozedur mit dem nun ermittelten XML-Dokument weiter.<\/p>\n Nach erfolgreichem Einlesen nimmt sich die Funktion ExtractAddress <\/b>das XML-Dokument vor und schreibt die relevanten Informationen in die privaten Variablen der Klasse. Außerdem wird der Rückgabewert der Funktion CheckAddress <\/b>im Erfolgsfall auf den Wert True <\/b>eingestellt.<\/p>\n Adressausdruck zusammenstellen<\/b><\/p>\n Kommen wir nun zu den oben bereits erwähnten Funktionen, die von CheckAddress <\/b>aufgerufen werden. Die erste heißt GetAddress <\/b>und soll aus den von der aufrufenden Instanz übergebenen Werten für die einzelnen Adress-Bestandteile einen Ausdruck machen, den Google auswerten und in eine vollständige, geprüfte Adresse umwandeln kann (s. Listing 3<\/a>). Die Funktion fügt den benötigten Ausdruck in der Variablen strAddress <\/b>zusammen. Zuerst werden der um führende oder folgende Leerzeichen gekürzte Straßenname sowie die Hausnummer zu strAddress <\/b>hinzugefügt (Leerzeichen vorne und hinten werden generell auch bei den folgenden Ausdrücken abgeschnitten).<\/p>\n Listing 3: Zusammensetzen des Adress-Ausdrucks<\/p>\n Gleiches geschieht mit PLZ und Ort sowie Bundesland und Land. Zwischendurch ersetzt die Funktion Leerzeichen durch Plus-Zeichen. Eventuell durch überzählige Leerzeichen auftretende doppelte Plus-Zeichen werden durch einfache Plus-Zeichen ersetzt, Gleiches geschieht mit doppelten Kommata.<\/p>\n Der resultierende Ausdruck wird an die Funktion GetXML<\/b> übergeben (s. Listing 4). Diese setzt den Adressausdruck mit dem Rest der HTTP-Anfrage zusammen und schickt diese an den Google-Webservice.<\/p>\n Listing 4: Prüfanfrage an Google<\/p>\n Wenn Google eine Antwort zurückgeschickt hat, erhält GetXML <\/b>als Rückgabewert den Wert True<\/b>, anderenfalls False<\/b>. Im letzteren Fall wird auch die Variable m_Message<\/b>, die beim Scheitern der Adressprüfung eine entsprechende Erläuterung liefern soll, mit einem passenden Text gefüllt.<\/p>\n Das Extrahieren der Adresse aus dem XML-Dokument übernehmen die beiden Prozeduren ExtractAddress<\/b> und ExtractAddressPart<\/b>. Erstere ruft zunächst für jeden Adressteil die Funktion ExtractAddressPart <\/b>auf und übergibt neben einem Verweis auf das XML-Dokument die Eigenschaft, nach der die Prozedur suchen soll.<\/p>\n Listing 5: Extrahieren der Adresse aus der XML-Antwort<\/p>\n Hintergrund ist, dass die Adressbestandteile jeweils in einem eigenen Element mit mehreren Unterelementen untergebracht sind. Für die Hausnummer sieht dies etwa so aus:<\/p>\n Die Aufgabe lautet hier, das address_component<\/b>-Element zu finden, dessen Unterelement type <\/b>den entsprechenden Wert aufweist, hier zum Beispiel street_number<\/b>, und aus diesem Element den Inhalt des Unterelements long_name <\/b>auszulesen.<\/p>\n Dies erledigt jeweils die Funktion ExtractAddressPart <\/b>und liefert den gefundenen Wert zurück – und dies nacheinander für die Elemente mit dem Wert route<\/b>, street_number<\/b>, postal_code<\/b>, locality<\/b>, administrative_area_level_1 <\/b>und country<\/b>.<\/p>\n Die übrigen beiden Zeilen der Funktion ExtractAddress <\/b>lesen schließlich noch die geografischen Koordinaten ein, die schematisch etwas anders als die übrigen Adressinformationen untergebracht und leichter zu erreichen sind – deshalb reicht ein einfacher selectSingleNode<\/b>-Aufruf, um ihren Wert zu ermitteln.<\/p>\n Um zu prüfen, ob die Funktion alle Elemente der Adresse geliefert hat, erstellt eine weitere Anweisung eine Art Prüfzahl: Sie ermittelt mit der Len<\/b>-Funktion die Längen der ermittelten Adressbestandteile und multipliziert diese miteinander.<\/p>\n Sollte mindestens ein Teil die Länge 0 <\/b>haben, liefert der gesamte Ausdruck den Wert 0<\/b>. In diesem Fall liefert die Funktion den Wert False <\/b>zurück, anderenfalls den Wert True<\/b>.<\/p>\n Praxisbeispiel<\/p>\n Schauen wir uns die Lösung noch in einem kleinen Praxisbeispiel an, bei dem wir die Datensätze einer Tabelle durchlaufen, und versuchen, alle enthaltenen Adressen zu prüfen und gegebenenfalls zu korrigieren und zu ergänzen.<\/p>\n Als Beispiel können Sie eine beliebige Tabelle mit Adressen verwenden. Am besten importieren Sie diese in die Beispieldatenbank zu diesem Beitrag, damit Sie nicht versehentlich änderungen am Originaldatenbestand durchführen – Sie sollten Ihre Vorgehensweise vorab sorgfältig testen.<\/p>\n Das folgende Beispiel verwendet eine Adresstabelle, welche die Felder Strasse<\/b>, PLZ<\/b>, Ort <\/b>und Land <\/b>verwendet. Wir wollen erstens die Adressen prüfen und zweitens einige Daten umstrukturieren: Der Inhalt des Feldes Strasse<\/b> soll auf die Felder Strasse <\/b>und Hausnummer <\/b>aufgeteilt werden. Außerdem soll ein neues Feld Bundesland <\/b>das zur Adresse passende Bundesland aufnehmen.<\/p>\n Schließlich haben wir ein weiteres Feld namens AdresseGeprueft<\/b> hinzugefügt. Dieses erhält den Wert Ja<\/b>, wenn die Adresse erfolgreich geprüft wurde – das bedeutet, dass Google für alle sechs abgefragten Felder Ergebnisse zurückgeliefert hat.<\/p>\n In vielen Fällen geht dies schief, weil die Hausnummer nicht identifiziert werden kann – beispielsweise bei Werten wie 24\/7 oder 13a. Sie können dann nach dem Prüfen per Abfrage alle Einträge anzeigen lassen, deren Prüfung fehlgeschlagen ist.<\/p>\n Desweiteren kann es sein, dass der Webservice empfindlich auf zu schnell aufeinanderfolgende Abfragen reagiert und den Wert OVER_QUERY_LIMIT <\/b>als Antwort für den Parameter Result <\/b>liefert. Die aktuelle Version des AddressCheckers<\/b> gibt die Anfragen und die Resultate im Direktfenster aus. Dort können Sie sehen, ob eine Adressprüfung erfolgreich war.<\/p>\n Unsere Beispielprozedur KundenadressenPruefen<\/b> aus Listing 6<\/a> arbeitet wie folgt: Zunächst deklariert sie die benötigten Elemente wie das Database<\/b>-Objekt, ein Recordset <\/b>zum Durchlaufen der Datensätze sowie das AddressChecker<\/b>-Objekt.<\/p>\n Danach füllt sie die Variable CurrentDb <\/b>mit einem Verweis auf die aktuelle Datenbank und erzeugt ein Recordset<\/b>-Objekt mit allen Datensätzen einer Tabelle namens tblKunden<\/b>. Diese durchläuft die folgende Do While<\/b>-Schleife. Dabei erzeugt die erste Anweisung ein neues Objekt auf Basis der Klasse clsAddressChecker <\/b>und füllt dessen Eigenschaften City<\/b>, Country<\/b>, PostalCode <\/b>und Street <\/b>mit den Daten, die bereits in der Tabelle tblKunden<\/b> enthalten sind.<\/p>\n Mit diesen Daten im Gepäck geht es zur Funktion CheckAddress<\/b>, welche den eigentlichen Aufruf durchführt und, sofern dieser erfolgreich ist, die Eigenschaften des Objekts objAddressChecker <\/b>mit den gelieferten Werten füllt.<\/p>\n Hier sei nochmals angemerkt, dass der Aufruf nur den Wert True <\/b>zurückliefert, wenn alle sechs Eigenschaften ermittelt werden können. In diesem Fall bereitet die Prozedur das Recordset<\/b>-Objekt rst <\/b>mit der Edit<\/b>-Methode zum Bearbeiten der Feldinhalte vor. Die folgenden sechs Anweisungen tragen die ermittelten Adressdaten ein, bevor die Update<\/b>-Methode die änderungen in die zugrunde liegende Tabelle überträgt. Diesen Vorgang wiederholt die Prozedur für jeden in der Datensatzgruppe enthaltenen Datensatz.<\/p>\n Nach dem Durchlaufen aller Datensätze, was je nach Menge der zu prüfenden Adressen einige Zeit in Anspruch nehmen kann, finden Sie die geänderten Adressen in der entsprechenden Tabelle vor.<\/p>\n Gegebenenfalls wäre es sinnvoll, temporär noch ein Feld namens Message <\/b>zur Tabelle hinzuzufügen, um gleich nachlesen zu können, warum eine Adresse nicht erfolgreich geprüft werden konnte. Eine Beispieltabelle könnte etwa wie in Bild 5 aussehen.<\/p>\n Bild 5: Beispiel für eine Tabelle mit den Feldern zum Speichern des Prüfergebnisses<\/span><\/b><\/p>\n Zusammenfassung und Ausblick<\/b><\/p>\n Der AddressChecker<\/b> verwendet einen Google-Webservice zum Prüfen bestehender Adressen. Dieser Service ist kostenlos und erfordert keinerlei Registrierung – allein die Anzahl der Zugriffe ist auf 2.500 pro Tag beschränkt.<\/p>\n Dank einiger spezieller Techniken können wir diesen Service auch von Access aus ansprechen und für einen gegebenen Adress-Ausdruck ein XML-Dokument mit den validierten und ergänzten Adress-Daten ermitteln, welches wir im Anschluss per VBA auswerten.<\/p>\nhttp:\/\/maps.google.com\/maps\/api\/geocode\/xmladdress=Borkhofer+Str.,Duisburg&sensor=false&language=de<\/pre>\n
adress=Borkhofer+Str.,Duisburg<\/pre>\n
&sensor=false<\/pre>\n
&language=de<\/pre>\n
![\"pic001.png\"](\"..\/fileadmin\/_temp_\/2010_05\/Adresspruefer-web-images\/pic001.png\")
<\/p>\nPublic Function AdressePruefen()\r\n Dim objDocument As New MSXML2.DOMDocument\r\n Dim strRequest As String\r\n strRequest = "http:\/\/maps.google.com\/maps\/api\/geocode\/xmladdress=Borkhofer+Str.,Duisburg&sensor=false"\r\n With objDocument\r\n .async = False\r\n .preserveWhiteSpace = False\r\n .validateOnParse = True\r\n .resolveExternals = False\r\n End With\r\n If objDocument.Load(strRequest) = True Then\r\n Debug.Print objDocument.XML\r\n Else\r\n Debug.Print "#Fehler beim Aufruf"\r\n End If\r\nEnd Function<\/pre>\n
![\"pic002.png\"](\"..\/fileadmin\/_temp_\/2010_05\/Adresspruefer-web-images\/pic002.png\")
<\/p>\n![\"pic003.png\"](\"..\/fileadmin\/_temp_\/2010_05\/Adresspruefer-web-images\/pic003.png\")
<\/p>\n\n
Dim objAddressChecker As clsAddressChecker<\/pre>\n
Set objAddressChecker = New clsAddressChecker<\/pre>\n
With objAddressChecker\r\n .Street = "Borkhofer Str."\r\n .Streetnumber = "17"\r\n .PostalCode = "47137"\r\n .City = "Duisburg"<\/pre>\n
If .CheckAddress = True Then\r\n Debug.Print .Street, .Streetnumber, .PostalCode, .City, .Country, .State, .Latitude, .Longitude<\/pre>\n
Else\r\n Debug.Print .Message\r\n End If\r\nEnd With<\/pre>\n
Private m_Street As String\r\nPrivate m_Streetnumber As String\r\nPrivate m_PostalCode As String\r\nPrivate m_Country As String\r\nPrivate m_City As String\r\nPrivate m_State As String\r\nPrivate m_Message As String\r\nPrivate m_Latitude As String\r\nPrivate m_Longitude As String<\/pre>\n
Public Property Let Street(str As String)\r\n m_Street = str\r\nEnd Property\r\nPublic Property Let Streetnumber(str As String)\r\n m_Streetnumber = str\r\nEnd Property\r\nPublic Property Let PostalCode(str As String)\r\n m_PostalCode = str\r\nEnd Property\r\nPublic Property Let Country(str As String)\r\n m_Country = str\r\nEnd Property\r\nPublic Property Let City(str As String)\r\n m_City = str\r\nEnd Property\r\nPublic Property Let State(str As String)\r\n m_State = str\r\nEnd Property<\/pre>\n
Public Property Get Street() As String\r\n Street = m_Street\r\nEnd Property\r\nPublic Property Get Streetnumber() As String\r\n Streetnumber = m_Streetnumber\r\nEnd Property\r\n...<\/pre>\n
Public Property Get Latitude() As String\r\n Latitude = m_Latitude\r\nEnd Property\r\nPublic Property Get Longitude() As String\r\n Longitude = m_Longitude\r\nEnd Property<\/pre>\n
Public Property Get Message() As String\r\n Message = m_Message\r\nEnd Property<\/pre>\n
Public Function CheckAddress() As Boolean\r\n Dim strAddress As String\r\n Dim strStatus As String\r\n Dim objDocument As MSXML2.DOMDocument\r\n Dim i As Integer\r\n strAddress = GetAddress\r\n If GetXML(strAddress, objDocument) = True Then\r\n strStatus = objDocument.selectSingleNode("\/GeocodeResponse\/status").nodeTypedValue\r\n If strStatus = "OVER_QUERY_LIMIT" Then\r\n For i = 1 To 4\r\n Sleep 500\r\n GetXML strAddress, objDocument\r\n strStatus = objDocument.selectSingleNode("\/GeocodeResponse\/status").nodeTypedValue\r\n If strStatus = "OVER QUERY LIMIT" Then\r\n Exit For\r\n End If\r\n Next i\r\n End If\r\n Select Case strStatus\r\n Case "OK"\r\n If ExtractAddress(objDocument) Then\r\n CheckAddress = True\r\n m_Message = "Adresse vollständig."\r\n Else\r\n m_Message = "Adresse unvollständig."\r\n End If\r\n Case "OVER_QUERY_LIMIT"\r\n m_Message = "OVER_QUERY_LIMIT"\r\n Case Else\r\n m_Message = strStatus\r\n End Select\r\n End If\r\nEnd Function<\/pre>\n![\"pic004.png\"](\"..\/fileadmin\/_temp_\/2010_05\/Adresspruefer-web-images\/pic004.png\")
<\/p>\nPrivate Function GetAddress() As String\r\n Dim strAddress As String\r\n strAddress = Trim(m_Street) & "+" & Trim(m_Streetnumber) & ","\r\n If Right(strAddress, 2) = "+," Then strAddress = Left(strAddress, Len(strAddress) - 2) & ","\r\n strAddress = strAddress & Trim(m_PostalCode) & "+" & Trim(m_City) & ","\r\n strAddress = strAddress & Trim(m_State) & ","\r\n strAddress = strAddress & Trim(m_Country)\r\n strAddress = Replace(strAddress, " ", "+")\r\n Do While InStr(1, strAddress, "++")\r\n strAddress = Replace(strAddress, "++", "+")\r\n Loop\r\n Do While InStr(1, strAddress, ",,")\r\n strAddress = Replace(strAddress, ",,", ",")\r\n Loop\r\n If Right(strAddress, 1) = "," Then\r\n strAddress = Left(strAddress, Len(strAddress) - 1)\r\n End If\r\n strAddress = Replace(strAddress, "ß", "ss")\r\n strAddress = Replace(strAddress, "ä", "ae")\r\n strAddress = Replace(strAddress, "ö", "oe")\r\n ''... weitere Sonderzeichen ersetzen\r\n GetAddress = strAddress\r\nEnd Function<\/pre>\n
Private Function GetXML(strAddress, objDocument As MSXML2.DOMDocument) As Boolean\r\n Dim strRequest As String\r\n strRequest = "http:\/\/maps.google.com\/maps\/api\/geocode\/xmladdress=" & strAddress _\r\n & "&sensor=false&language=de"\r\n Set objDocument = New MSXML2.DOMDocument\r\n With objDocument\r\n .async = False\r\n .preserveWhiteSpace = False\r\n .validateOnParse = True\r\n .resolveExternals = False\r\n End With\r\n If objDocument.Load(strRequest) = True Then\r\n GetXML = True\r\n Else\r\n m_Message = "Die Anfrage wurde nicht beantwortet."\r\n GetXML = False\r\n End If\r\nEnd Function<\/pre>\n
Private Function ExtractAddress(objDocument As MSXML2.DOMDocument) As Boolean\r\n Dim lngResult As Long\r\n m_Street = ExtractAddresspart(objDocument, "route")\r\n m_Streetnumber = ExtractAddresspart(objDocument, "street_number")\r\n m_PostalCode = ExtractAddresspart(objDocument, "postal_code")\r\n m_City = ExtractAddresspart(objDocument, "locality")\r\n m_State = ExtractAddresspart(objDocument, "administrative_area_level_1")\r\n m_Country = ExtractAddresspart(objDocument, "country")\r\n m_Latitude = objDocument.selectSingleNode("\/GeocodeResponse\/result\/geometry\/location\/lat").nodeTypedValue\r\n m_Longitude = objDocument.selectSingleNode("\/GeocodeResponse\/result\/geometry\/location\/lng").nodeTypedValue\r\n lngResult = Len(m_Street) * Len(m_Streetnumber) * Len(m_PostalCode) * Len(m_City) _\r\n * Len(m_State) * Len(m_Country) * Len(m_Latitude) * Len(m_Longitude)\r\n If lngResult > 0 Then\r\n ExtractAddress = True\r\n Else\r\n ExtractAddress = False\r\n End If\r\nEnd Function\r\nPublic Function ExtractAddresspart(objDocument As MSXML2.DOMDocument, strPart As String) As String\r\n Dim objNode As MSXML2.IXMLDOMNode\r\n Set objNode = objDocument.selectSingleNode("\/GeocodeResponse\/result\/address_component[type=''" _\r\n & strPart & "']")\r\n If Not objNode Is Nothing Then\r\n ExtractAddresspart = objNode.selectSingleNode("long_name").nodeTypedValue\r\n End If\r\nEnd Function<\/pre>\n<address_component>\r\n <long_name>17<\/long_name>\r\n <short_name>17<\/short_name>\r\n <type>street_number<\/type>\r\n<\/address_component><\/pre>\n
![\"pic005.png\"](\"..\/fileadmin\/_temp_\/2010_05\/Adresspruefer-web-images\/pic005.png\")
<\/p>\n