<\/p>\n
Christoph Spielmann, Düsseldorf<\/b><\/p>\n
Die Kommunikation zwischen Anwendungen spielt bei modernen Datenbanken eine wesentliche Rolle. Häufig ist es beispielsweise notwendig, dass eine Anwendung auf eine Datenbank zugreifen soll, hierbei jedoch keinen direkten Zugriff auf die Tabellen haben darf. Zudem kann der Fall eintreten, dass die Datenbank nicht auf dem lokalen PC oder im lokalen Netzwerk, sondern irgendwo im Internet untergebracht ist. Um hier eine Kommunikation zu ermöglichen, bietet sich der Einsatz von Web-Services an. Dieser Artikel zeigt Ihnen, wie Sie mit Access auf den Web-Service der Suchmaschine „Google“ zugreifen und die abgefragten Suchergebnisse in einer Datenbank speichern.<\/b><\/p>\n
Bei Web-Services handelt es sich um Anwendungen, die ihre Dienste über ein standardisiertes Protokoll zur Verfügung stellen. Hinter diesem Protokoll verbirgt sich nichts anderes als eine Textdatei im XML-Format.<\/p>\n
Der Hintergrund ist, dass XML-Dateien von modernen Browsern wie herkömmlicher HTML-Code interpretiert werden können. Dementsprechend gelangen XML-Dateien z. B. problemlos durch Firewalls, sofern diese für den normalen Transfer von Web-Seiten freigeschaltet sind. Die Kommunikation findet über den Port 80 statt, der für Web-Server reserviert ist.<\/p>\n
Nun genügt es nicht zu definieren, dass die Daten per XML übertragen werden. Wichtig ist außerdem noch, dass eine spezielle XML-Struktur zum Einsatz kommt. Diese Strukturdefinition trägt den Namen SOAP (Simple Object Access Protocol). Bei der Entwicklung von SOAP war das Ziel, die Kommunikation für den Benutzer möglichst einfach zu gestalten. Zudem sollte SOAP alle möglichen Programmier-Werkzeuge und Plattformen (z. B. Windows, Linux oder Macintosh) unterstützen.<\/p>\n
Herausgekommen ist ein standardisiertes Protokoll zum Abruf von Objektmethoden über das Internet. Sie kennen dies bereits von VBA und Access: Wenn Sie ein Klassenmodul namens clsDienst in Ihrer Anwendung haben, können Sie die darin enthaltene Methode Start über die folgende Syntax aufrufen:<\/p>\n
Dim MeinDienst as new clsDienst\r\nMeinDienst.Start<\/pre>\nähnlich einfach ist der Aufruf mit Hilfe von SOAP, wenn sich die Klasse Dienst auf einem Rechner im Internet befindet.<\/p>\n
Da Web-Services eine relativ neue Technologie sind, stellt Access noch keine eingebauten Funktionen zum Aufruf von Web-Services zur Verfügung. Sie benötigen dafür ein spezielles Toolkit namens Microsoft Office XP Web Services Toolkit 2.0. Um die hier vorgestellte Lösung nachvollziehen zu können, müssen Sie dieses Toolkit unter der folgenden Adresse herunterladen:<\/p>\n
<\/p>\n
<\/b><\/p>\n
Bild 1: Registrierung bei Google<\/span><\/b><\/p>\n
http:\/\/download.microsoft.com\/download\/OfficeXPDev\/Install\/2.0\/W982KMeXP\/DE\/setup.exe<\/pre>\nAchten Sie darauf, dass Sie nicht versehentlich die Version 1.0 herunterladen, auf die Microsoft noch von den Office-Startseiten verlinkt.<\/p>\n
Hinweis<\/h3>\n
Von dem Zusatz XP sollten Sie sich übrigens nicht verwirren lassen: Das Toolkit funktioniert sowohl mit Access 2000 als auch mit Access XP. ältere Versionen wie z. B. Access 97 werden allerdings nicht unterstützt. <\/p>\n
Nach dem Download starten Sie die EXE-Datei und installieren das Toolkit.<\/p>\n
Wie bereits erwähnt, greift das hier vorgestellte Beispiel auf die Suchmaschine Google zu. Die Google-Betreiber möchten hierbei sicherstellen, dass der Zugriff nicht missbraucht wird.<\/p>\n
Schließlich wäre es denkbar, eine eigene Suchmaschine im Internet zu veröffentlichen, die in Wirklichkeit per Web-Service auf Google zugreift. Aus diesem Grund ist eine vorhergehende Registrierung bei Google erforderlich, bei der Sie einen Schlüssel erhalten. Dieser Schlüssel berechtigt Sie, täglich maximal 1000 Suchergebnisse abzufragen, was in der Praxis mehr als genug sein dürfte.<\/p>\n
Zur Durchführung der Registrierung gehen Sie wie folgt vor:<\/p>\n
Rufen Sie den Internet-Explorer auf und wechseln Sie zu der Seite http:\/\/www.google.de\/apis\/.<\/li>\n Klicken Sie auf create a google account.<\/li>\n Geben Sie Ihre E-Mail-Adresse und ein beliebiges Passwort ein.<\/li>\n Erzeugen Sie Ihr Konto über die entsprechende Schaltfläche.<\/li>\n Warten Sie auf die Bestätigungs-E-Mail, die Google automatisch an die angegebene Adresse sendet.<\/li>\n Klicken Sie den in der Bestätigungs-E-Mail enthaltenen Link an. Hierdurch teilen Sie Google mit, dass Sie eine korrekte E-Mail-Adresse angegeben haben.<\/li>\n Wechseln Sie wieder zu der Seite http:\/\/www.google.de\/apis\/ und klicken Sie erneut auf create a google account.<\/li>\n Klicken Sie anschließend auf Sign in here und geben Sie Ihre E-Mail-Adresse und das Passwort an. Bestätigen Sie mit Sign in (siehe Bild 1). (<\/li>\n Nach dem letzten Schritt erhalten Sie von Google eine erneute E-Mail, die Ihren Schlüssel zum Zugriff auf den Web-Service enthält. Bewahren Sie diesen gut auf.<\/p>\n
<\/p>\n
<\/b><\/p>\n
Bild 2: Der Startbildschirm des Web-Service-Toolkits<\/span><\/b><\/p>\n
<\/p>\n
<\/b><\/p>\n
Bild 3: Die Suche nach Web-Services zum Thema Wetter.<\/span><\/b><\/p>\n
Um nun eine Verbindung zu Google herzustellen, legen Sie zunächst eine neue Access-Datenbank an. Klicken Sie anschließend auf Module und danach auf Neu, um ein neues Modul anzulegen. Dieser Schritt ist erforderlich, da die Funktionen des Web-Service-Toolkits nur vom VBA-Editor aus zur Verfügung stehen.<\/p>\n
Nachdem Sie nun den VBA-Editor auf dem Bildschirm haben, wählen Sie den Menüpunkt Extras\/Webdienstverweise aus. Dieser Menüpunkt startet das Toolkit (siehe Bild 2).<\/p>\n
Auf der linken Seite des Startfensters haben Sie die Möglichkeit, nach Web-Services zu suchen. Hierbei kommen spezielle Suchmaschinen zum Einsatz. Wenn Sie beispielsweise unter Schlüsselwörter den Text weather eingeben und anschließend auf Suchen klicken, erscheint einige Zeit später eine Liste aller Web-Services zum Thema Wetter (siehe Bild 3). Voraussetzung für die erfolgreiche Suche ist natürlich, dass Sie mit dem Internet verbunden sind.<\/p>\n
Anhand der Liste können Sie bereits die Struktur der einzelnen Dienste erkennen. Der Dienst WeatherRetriever unterstützt beispielsweise zwei Methoden namens GetTemperature und GetWeather. Um den Web-Service auszuprobieren, markieren Sie diesen in der Liste und klicken auf Testen.<\/p>\n
Das Toolkit öffnet nun den Internet-Explorer und ruft eine spezielle Seite auf, die der Anbieter zum Test des Web-Services zur Verfügung stellt. Auf dieser Seite werden auch die beiden Methoden GetTemperature und GetWeather aufgeführt (siehe Bild 4).<\/p>\n
Hinweis<\/h3>\n
Dieser Web-Service wurde mit Hilfe der Microsoft .NET-Technologie entwickelt. Wenn Sie einen mit einem anderen Werkzeug entwickelten Web-Service aufrufen, hat die Testseite einen anderen Aufbau. <\/p>\n
<\/p>\n
<\/b><\/p>\n
Bild 4: Die Hauptseite zum Test eines Web-Service<\/span><\/b><\/p>\n
<\/p>\n
<\/b><\/p>\n
Bild 5: Auswahl des Ortes zur Ermittlung der Temperatur<\/span><\/b><\/p>\n
<\/p>\n
<\/b><\/p>\n
Bild 6: Das Ergebnis der Temperatur-Abfrage<\/span><\/b><\/p>\n
<\/p>\n
<\/b><\/p>\n
Bild 7: Die URL des Google Web-Service<\/span><\/b><\/p>\n
Klicken Sie auf der Testseite auf GetTemperature. Sie gelangen hierdurch auf eine zweite Seite, in der Sie den US-ZIP-Code des Ortes eingeben können, von dem Sie die aktuelle Temperatur wissen möchten. Geben Sie hier 20000 ein und bestätigen Sie mit Invoke (siehe Bild 5).<\/p>\n
Es erscheint eine weitere Web-Seite, die das Ergebnis in Form einer XML-Datei anzeigt (siehe Bild 6).<\/p>\n
Das Ergebnis wird in Fahrenheit ausgegeben.<\/p>\n
Nachdem Sie nun den ersten Test mit einem Web-Service durchgeführt haben, soll nun eine Verbindung zu Google hergestellt werden. Zu diesem Zweck klicken Sie in dem Startbildschirm des Web-Service-Toolkits auf Webdienst-URL und geben folgende URL ein (siehe Bild 7). Beachten Sie dabei Groß- und Kleinschreibung:<\/p>\n
http:\/\/api.google.com\/GoogleSearch.wsdl<\/pre>\nDieser Link zeigt auf eine WSDL-Datei (Web Service Definition Language), die den Aufbau und die Struktur des Web-Services beschreibt. Hier ist beispielsweise hinterlegt, welche Parameter zur Suche in Google erforderlich sind und wie das Suchergebnis strukturiert ist.<\/p>\n
<\/p>\n
Klicken Sie nach der Eingabe auf Suchen und warten Sie, bis der Web-Service in der rechten oberen Liste erscheint. Hier kreuzen Sie den Web-Service an und klicken anschließend auf Hinzufügen (siehe Bild 8).<\/p>\n
Access liest nun die WSDL-Datei ein und erstellt daraus automatisch eine Reihe von Klassen-modulen in Ihrer Datenbank, welche die Kommunikation mit dem Web-Service übernehmen. Diese Klassen werden auch als Proxies bezeichnet. Sie erzeugen unter Access das Objektmodell, das dem des Web-Service von Google entspricht und ermöglichen so eine einfache Nutzung von Access aus.<\/p>\n
<\/p>\n
<\/b><\/p>\n
Bild 8: Auswahl des Google Web-Service<\/span><\/b><\/p>\n
Hinweis<\/h3>\n
Nach der Anlage sollten Sie alle Proxy-Klassen speichern. übernehmen Sie hierbei die von dem Web-Service-Toolkit vorgegebenen Namen. <\/p>\n
Um nun sicherzustellen, dass der Web-Service korrekt aufgerufen werden kann, legen Sie in dem neuen Modul die folgende Testprozedur an:<\/p>\n
Sub Test()\r\n Const c_Key = \"GOOGLEKEY\"\r\n Dim GoogleService As New _ clsws_GoogleSearchService\r\n GoogleService.wsm_doGoogleSearch _ c_Key, \"Access\", 1, 10, False, _ \"\", True, \"\", \"\", \"\"\r\nEnd Sub<\/pre>\nBeachten Sie hierbei, dass Sie anstelle von GOOGLEKEY den Schlüssel angeben, den Sie von Google erhalten haben. Danach starten Sie die Prozedur, indem Sie beispielsweise im Direktfenster den Ausdruck Test eingeben.<\/p>\n
Direkt nach dem Start legt die Prozedur eine neue Instanz des Objekts clsws_GoogleSearchService an. Hierbei handelt es sich um das Haupt-Objekt des Web-Services, das vom Web-Service-Toolkit automatisch angelegt wurde. Anschließend erfolgt der Start des Suchvorgangs. In diesem Beispiel wird nach dem Stichwort Access gesucht. Die Bedeutungen der einzelnen Parameter entnehmen Sie der Tabelle 1. Eine vollständige Beschreibung der Parameter finden Sie in der Referenz des Google SDKs, das Sie ebenfalls auf der Google-Seite herunterladen können.<\/p>\n
\n
\n \n Parameter<\/b><\/p>\n<\/td>\n
\n Funktion<\/b><\/p>\n<\/td>\n<\/tr>\n
\n \n Key<\/p>\n<\/td>\n
\n Ihr Schlüssel<\/p>\n<\/td>\n<\/tr>\n
\n \n Q<\/p>\n<\/td>\n
\n Der Suchbegriff. Hierbei können Sie die von Google her bekannten Suchausdrücke mit AND, OR, „+“ und „-“ verwenden.<\/p>\n<\/td>\n<\/tr>\n
\n \n Start<\/p>\n<\/td>\n
\n Index des ersten Ergebnisses<\/p>\n<\/td>\n<\/tr>\n
\n \n maxResults<\/p>\n<\/td>\n
\n Maximale Anzahl der Ergebnisse. Diese ist auf 10 begrenzt. Indem der Service jedoch mehrmals hintereinander mit anderen Start-Indizes aufgerufen wird, können jedoch bis maximal 1000 Suchergebnisse pro Tag abgerufen werden.<\/p>\n<\/td>\n<\/tr>\n
\n \n Filter<\/p>\n<\/td>\n
\n Er bestimmt, ob ähnliche Seiten des gleichen Hosts ausgeblendet werden sollen.<\/p>\n<\/td>\n<\/tr>\n
\n \n Restrict<\/p>\n<\/td>\n
\n Hiermit kann das Suchergebnis beispielsweise auf bestimmte Länder eingeschränkt werden.<\/p>\n<\/td>\n<\/tr>\n
\n \n safeSearch<\/p>\n<\/td>\n
\n Filtert Inhalte für Erwachsene aus dem Suchergebnis.<\/p>\n<\/td>\n<\/tr>\n
\n \n Lr<\/p>\n<\/td>\n
\n Limitiert das Suchergebnis auf eine bestimmte Sprache.<\/p>\n<\/td>\n<\/tr>\n
\n \n Ie<\/p>\n<\/td>\n
\n Dieser Parameter ist für spätere Zwecke reserviert. Er hat momentan noch keine Funktion.<\/p>\n<\/td>\n<\/tr>\n
\n \n oe<\/p>\n<\/td>\n
\n Dieser Parameter ist ebenfalls reserviert.<\/p>\n<\/td>\n<\/tr>\n<\/table>\n
Tab. 1: Suchparameter<\/b><\/p>\n
Tritt während der Abarbeitung der Prozedur kein Fehler auf, war der Aufruf des Web-Service erfolgreich.<\/p>\n
Zur Anzeige des Suchergebnisses bietet es sich natürlich an, dieses vorher in eine Access-Tabelle einzulesen und dann innerhalb eines Formulars anzuzeigen. Die Beispieldatenbank zu diesem Artikel enthält zu diesem Zweck zwei Tabellen.<\/p>\n
Die Tabelle tblQueries<\/b><\/p>\n
Die Tabelle tblQueries speichert komplette Suchanfragen. Die Tabelle enthält dafür eine QueryID sowie den gewünschten Suchausdruck. Zusätzlich wird die maximale Anzahl der Suchergebnisse gespeichert. Es können also mehrere Suchanfragen vorbereitend in der Tabelle hinterlegt werden, die dann beispielsweise in der Mittagspause als Batch abgearbeitet werden.<\/p>\n
Nach Abschluss einer einzelnen Suchanfrage werden pro Datensatz das Ausführungsdatum, die Anzahl der gefundenen Sucheinträge sowie die Anzahl der verfügbaren Sucheinträge ergänzt. Letzteres ist beispielsweise bei der Suche nach Access sinnvoll, bei der Google ca. 58.400.000 Web-Seiten findet, aber von Access eventuell nur die ersten 100 Ergebnisse abgerufen wurden.<\/p>\n
Eine vollständige Beschreibung der Felder finden Sie in Tabelle 2.<\/p>\n
\n
\n \n Feld<\/b><\/p>\n<\/td>\n
\n Beschreibung<\/b><\/p>\n<\/td>\n<\/tr>\n
\n \n QueryID<\/p>\n<\/td>\n
\n Primärschlüssel<\/p>\n<\/td>\n<\/tr>\n
\n \n QueryString<\/p>\n<\/td>\n
\n Suchtext<\/p>\n<\/td>\n<\/tr>\n
\n \n ExecutedOn<\/p>\n<\/td>\n
\n Zeitpunkt der Suche<\/p>\n<\/td>\n<\/tr>\n
\n \n MaxResults<\/p>\n<\/td>\n
\n maximal gewünschte Anzahl der Suchergebnisse<\/p>\n<\/td>\n<\/tr>\n
\n \n Found<\/p>\n<\/td>\n
\n Anzahl der tatsächlich zurückgelieferten Suchergebnisse<\/p>\n<\/td>\n<\/tr>\n
\n \n Stimated<\/p>\n<\/td>\n
\n Von Google geschätzte Anzahl aller Seiten mit dem angegebenen Suchwort<\/p>\n<\/td>\n<\/tr>\n<\/table>\n
Tab. 2: Aufbau der Tabelle tblQueries<\/b><\/p>\n
Die Tabelle tblQueryResults<\/b><\/p>\n
Die Tabelle tblQueryResults nimmt die einzelnen Suchergebnisse auf. Pro Suchergebnis werden hierbei ein Titel, eine Zusammenfassung sowie eine URL gespeichert.<\/p>\n
über das Feld QueryID steht diese Tabelle in einer 1:n-Beziehung mit der Tabelle tblQueries, sodass pro Suchanfrage mehrere Ergebnisse gespeichert werden können.<\/p>\n
Bild 9 zeigt die beiden Tabellen im Beziehungen-Fenster. Den Aufbau der Tabelle entnehmen Sie Tabelle 3.<\/p>\n
<\/p>\n
<\/b><\/p>\n
Bild 9: Das Datenmodell der Beispieldatenbank<\/span><\/b><\/p>\n
\n
\n \n Feld<\/b><\/p>\n<\/td>\n
\n Beschreibung<\/b><\/p>\n<\/td>\n<\/tr>\n
\n \n QueryResultID<\/p>\n<\/td>\n
\n Primärschlüssel<\/p>\n<\/td>\n<\/tr>\n
\n \n QueryID<\/p>\n<\/td>\n
\n Fremdschlüssel auf die Tabelle tblQueries<\/p>\n<\/td>\n<\/tr>\n
\n \n Title<\/p>\n<\/td>\n
\n Titel der gefundenen Seite<\/p>\n<\/td>\n<\/tr>\n
\n \n Summary<\/p>\n<\/td>\n
\n Zusammenfassung der Teststelle, an der der Suchbegriff aufgetaucht ist<\/p>\n<\/td>\n<\/tr>\n
\n \n URL<\/p>\n<\/td>\n
\n URL der gefundenen Seite<\/p>\n<\/td>\n<\/tr>\n<\/table>\n
Tab. 3: Aufbau der Tabelle tblQueries<\/b><\/p>\n
Das Einlesen des Suchergebnisses in die Tabellen wird von dem Klassenmodul clsQuery bewerkstelligt. Diese Klasse enthält die Methode PerformAllOpenQueries (s. Quellcode 1).<\/p>\n
Public Sub PerformAllOpenQueries()\r\n Dim QueryData As New ADODB.Recordset\r\n With QueryData\r\n Set .ActiveConnection = _ CurrentProject.Connection\r\n .LockType = adLockOptimistic\r\n .CursorLocation = adUseClient\r\n .CursorType = adOpenDynamic\r\n .Source = \"SELECT * FROM tblQueries \" _ & \"WHERE ExecutedOn IS NULL\"\r\n .Open\r\n While Not .EOF\r\n Me.PerformQuery .Fields(\"QueryID\")\r\n .MoveNext\r\n Wend\r\n End With\r\nEnd Sub<\/pre>\nQuellcode 1<\/b><\/p>\n
Public Sub PerformQuery(QueryID As Long)\r\n Dim QueryData As New ADODB.Recordset\r\n With QueryData\r\n Set .ActiveConnection = _ CurrentProject.Connection\r\n .LockType = adLockOptimistic\r\n .CursorLocation = adUseClient\r\n .CursorType = adOpenDynamic\r\n .Source = \"SELECT * FROM tblQueries \" _ & \"WHERE QueryID=\" & QueryID\r\n .Open\r\n End With\r\n Dim ResultData As New ADODB.Recordset\r\n With ResultData\r\n Set .ActiveConnection = _ CurrentProject.Connection\r\n .LockType = adLockOptimistic\r\n .CursorLocation = adUseClient\r\n .CursorType = adOpenDynamic\r\n .MaxRecords = 1\r\n .Source = \"SELECT * FROM tblQueryResults \" _ & \"WHERE False\"\r\n .Open\r\n End With<\/pre>\nQuellcode 2 (erster Teil)<\/b><\/p>\n
Durchführen einer einzelnen Suche<\/b><\/p>\n
Die Methode macht nichts anderes, als alle noch nicht durchgeführten Suchvorgänge abzufragen und diese zu starten.<\/p>\n
Der Start der Suche erfolgt durch Aufruf der Methode PerformQuery, wobei hierbei die ID des Suchvorgangs übergeben werden muss. Den Aufbau der Methode PerformQuery finden Sie in Quellcode 2.<\/p>\n
Zunächst einmal öffnet die Prozedur die betreffende Suchanfrage aus der Tabelle tblQueries , um auf die Suchparameter – also z. B. den Suchausdruck – zugreifen zu können. Hinterlegt werden die Daten in dem Recordset QueryData.<\/p>\n
Danach wird auf der Basis der Tabelle tblQueryResults ein leeres Recordset namens ResultData geöffnet. Hier wird später das Suchergebnis abgelegt.<\/p>\n
Nach der Definition der beiden Recordsets ist eine Schleife positioniert, die den Web-Service unter Umständen pro Suchanfrage mehrmals ausführt.<\/p>\n
Dies ist erforderlich, da Google pro Anfrage maximal 10 Suchergebnisse zurückliefert. Wenn Sie dagegen beispielsweise 100 Einträge als Ergebnis zurückgeliefert haben möchten, müssen Sie den Service zehnmal starten und bei jedem Aufruf den Startindex um 10 erhöhen. Der erste Start würde also mit dem Startindex 0 erfolgen und die Ergebnisse 0 bis 9 zurückliefern. Der zweite Start erfolgt dann mit dem Startindex 10 und liefert die Ergebnisse 10 bis 19 zurück. Auf diese Weise können Sie beliebig große Ergebnismengen abrufen, solange Sie sich an die Beschränkung von 1000 Abrufen pro Tag halten.<\/p>\n
Dim Index As Long\r\n Dim FoundCount As Long\r\n Dim GoogleService As New clsws_GoogleSearchService\r\n Dim Result As struct_GoogleSearchResult\r\n Dim ResultElement As struct_ResultElement\r\n Dim ResultIndex As Long\r\n For Index = 0 To QueryData.Fields(\"MaxResults\") \\ 10 - 1\r\n RaiseEvent OnStatusChange(\"Suche nach ''\" & QueryData.Fields(\"QueryString\") _ & \"'' (\" & CStr(FoundCount) & \" von \" & QueryData.Fields(\"MaxResults\") _ & \")\")\r\n Set Result = GoogleService.wsm_doGoogleSearch(c_Key, _ QueryData.Fields(\"QueryString\"), _\r\n Index * 10, 10, False, \"\", True, \"\", \"\", \"\")\r\n ResultIndex = 0\r\n For ResultIndex = 0 To Result.endIndex - Result.StartIndex\r\n Set ResultElement = Result.resultElements(ResultIndex)\r\n With ResultElement\r\n ResultData.AddNew\r\n ResultData.Fields(\"QueryID\") = QueryID\r\n ResultData.Fields(\"Title\") = StripHTML(.title)\r\n ResultData.Fields(\"Summary\") = StripHTML(.summary)\r\n ResultData.Fields(\"URL\") = .URL\r\n ResultData.Update\r\n FoundCount = FoundCount + 1\r\n End With\r\n Next\r\n If Result.endIndex - Result.StartIndex < 9 Then Exit For\r\n Next Index\r\n QueryData.Fields(\"ExecutedOn\") = Now\r\n QueryData.Fields(\"Found\") = FoundCount\r\n QueryData.Fields(\"Estimated\") = Result.estimatedTotalResultsCount\r\n QueryData.Update\r\nEnd Sub<\/pre>\nQuellcode 2 (Fortsetzung)<\/b><\/p>\n
Innerhalb der Schleife erfolgt dann der eigentliche Suchaufruf mit der bereits vorgestellten Methode wsm_doGoogleSearch. Das Ergebnis wird in die Variante Result eingelesen, die mit dem Datentyp struct_GoogleSearchResult deklariert ist. Diese wurde ebenfalls in Form einer Klasse vom Web-Service-Toolkit erstellt.<\/p>\n
<\/p>\n
<\/b><\/p>\n
Bild 10: Das Suchergebnis im Formular<\/span><\/b><\/p>\n
Die wichtigste Eigenschaft dieser Klasse lautet resultElements. In diesem Variant-Array sind die einzelnen Suchergebnisse in Form von Objekten des Typs struct_ResultElement hinterlegt.<\/p>\n
Auch diese Klasse wurde vom Web-Service-Toolkit erzeugt. Die Ergebnisse dieses Arrays werden wieder mit Hilfe einer Schleife ausgelesen und in die entsprechenden Felder der Tabelle geschrieben.<\/p>\n
Private Function StripHTML(Text As _ String) As String\r\n Dim res As String\r\n res = Text\r\n res = Replace(res, \"<\/b>\", \"\")\r\n res = Replace(res, \"<b>\", \"\")\r\n res = Replace(res, \"<b>...<\/b>\", \"\")\r\n StripHTML = Trim(res)\r\nEnd Function<\/pre>\nQuellcode 3<\/b><\/p>\n
Da das Suchergebnis primär zur Anzeige innerhalb eines Web-Browsers vorgesehen ist, enthält der Text teilweise HTML-Formatierungs-Tags. Das Tag <b> stellt einen Text beispielsweise fett dar. Diese Tags werden von der Funktion StripHTML entfernt (s. Quellcode 3).<\/p>\n
Nach Abschluss der Suche werden noch die fehlenden Angaben der Tabellen tblQueries ergänzt.<\/p>\n
Hinweis<\/h3>\n
Im Kopf des Moduls wird die Konstante c_Key definiert, die den von Google gelieferten Key enthält. Vor der Ausführung der Prozedur müssen Sie hier Ihren Key eintragen. <\/p>\n
Statusmeldungen<\/b><\/p>\n
Da die Suche unter Umständen längere Zeit in Anspruch nehmen kann, wird jeder Aufruf des Web-Service mit einem Status-Ereignis an die aufrufende Stelle gemeldet. Das Ereignis ist im Kopf der Klasse folgendermaßen deklariert:<\/p>\n
Public Event OnStatusChange(Text _ As String)<\/pre>\nBei jedem Web-Service-Aufruf wird der Status mit dem Suchtext und dem aktuellen Suchindex versehen protokolliert.<\/p>\n
Die Steuerung der Klasse clsQuery erfolgt von dem Formular frmQueries aus (siehe Bild 10), das auf der Tabelle tblQueries basiert. Die Suchergebnisse zu jeder Suchanfrage werden innerhalb eines Unterformulars angezeigt.<\/p>\n
Die Abarbeitung aller noch offenen Suchanfragen wird mit Hilfe einer Schaltfläche gestartet, die den Namen btnStartFind trägt.<\/p>\n
Diese Schaltfläche ist mit der folgenden Ereignisprozedur verknüpft:<\/p>\n
Private Sub btnStartFind_Click()\r\n Set m_Query = New clsQuery\r\n m_Query.PerformAllOpenQueries\r\n Me.Caption = \"Fertig!\"\r\n Me.Requery\r\nEnd Sub<\/pre>\nDiese Ereignisprozedur erzeugt eine neue Instanz der Klasse clsQuery und ruft anschließend die Methode PerformAllOpenQueries auf. Nach Abschluss der Arbeiten schreibt die Prozedur den Text Fertig! in den Fenstertitel und aktualisiert die Daten des Formulars.<\/p>\n
Die Deklaration der Variablen m_Query erfolgt im Kopf des Formulars unter Zuhilfenahme des WithEvents-Attributs:<\/p>\n
Private WithEvents m_Query As clsQuery<\/pre>\nHierdurch kann das Formular auf das Status-Ereignis der Klasse reagieren und den Status-Text in der Titelleiste des Feldes anzeigen:<\/p>\n
Private Sub m_Query_OnStatusChange(Text _ As String)\r\n Me.Caption = Text\r\n DoEvents\r\nEnd Sub<\/pre>\nSobald Sie nun die Suche starten, können Sie über die Texte der Titelleiste den aktuellen Fortschritt verfolgen.<\/p>\n
Das hier vorgestellte Beispiel stellt nur die grundlegenden Funktionen zur Verwaltung des Suchergebnisses zur Verfügung. Denkbar ist beispielsweise, die Datenbank zu einem Recherche-System mit folgenden Funktionen auszubauen:<\/p>\n
Prüfung der vorhandenen URLs auf Duplikate<\/li>\n Direktes öffnen der URL aus der Access-Anwendung heraus<\/li>\n Suchen innerhalb des Suchergebnisses<\/li>\n Bewerten und Kategorisieren der Suchergebnisse<\/li>\n Aufbereiten des Suchergebnisses als Report<\/li>\n Denkbar wäre auch die Entwicklung eines Tools, welches die Web-Seiten der eigenen Firma regelmäßig auf die Platzierung in Google hin prüft und beim Abrutschen auf einen der niedrigeren Ränge eine Warnung ausgibt.<\/p>\n
Anhand des Beispiels mit Google wird deutlich, welchen Stellenwert Web-Services in Zukunft einnehmen werden. Viele Firmen entwickeln momentan Dienste, die kostenpflichtig über das Internet zur Verfügung gestellt werden. So wird es wohl nicht lange dauern, bis die ersten Firmen z. B. das Suchen in Telefonbüchern oder das Prüfen von Adressen über das Internet anbieten. Der Kauf einer Telefonbuch-CD, deren Datenbestand schnell an Aktualität verliert, wird damit überflüssig.<\/p>\n
Dank des Web-Service-Toolkits ist die Nutzung solcher Dienste nun auch mit Access möglich. Ein kleiner Wermutstropfen bleibt jedoch: Mit Access können Sie zwar Web-Services nutzen, jedoch keine Web-Services anbieten. Dies bleibt leider auch mittelfristig Entwicklungsumgebungen wie .NET vorbehalten.<\/p>\n
Downloads zu diesem Beitrag<\/h3>\n
Enthaltene Beispieldateien:<\/p>\n
Google00.mdb<\/p>\n