<\/p>\n
Der Amazon Associates Web Service bietet den Zugriff auf die in Amazon gespeicherten Produktdaten an. Dazu gehören längst nicht mehr nur Bücher, CDs und DVDs, sondern auch Elektrogeräte, Kleidung und vieles mehr. Der Zugriff darauf ist nicht nur interessant, wenn man Amazon-Partner ist und die Artikel gegen Provision auf seiner eigenen Webseite feilbietet, sondern auch zum reinen automatischen Einlesen von Produktdaten – zum Beispiel für die ebenfalls in dieser Ausgabe vorgestellte Bücherverwaltung.<\/b><\/p>\n
Webservices<\/p>\n
Webservices sind Anwendungen, die man über eine URL ansprechen kann und über die man eine Anfrage schickt, um eine bestimmte Information zu erhalten. Prinzipiell kann man diese mit einer Internetseite im Browser vergleichen: Sie tragen die URL in das entsprechende Textfeld ein und erhalten als Antwort eine Internetseite. Webservices sind nun noch eine Stufe einfacher geschnitzt, denn ihre Antwort kommt nicht in Form einer formatierten Webseite, sondern als XML-Dokument, das man noch auswerten muss. Auch ist die Anfrage keine einfache URL, sondern sie enthält noch weitere Parameter, welche die eigentliche Anfrage ausmachen. Auch für das Zusammenstellen und Versenden der Anfrage sowie das Empfangen und Auswerten der Antwort muss man selbst durch geeigneten Code Sorge tragen.<\/p>\n
Es gibt verschiedene Möglichkeiten, eine Anfrage zu formulieren; im Falle des Amazon Associates Web Services in Kombination mit Access\/VBA geschieht dies am einfachsten über eine sogenannte REST-Anfrage (Representational State Transfer). Dies bedeutet, dass die Parameter einfach an die URL des Webservice angehängt werden. Die Antwort erhält man von Amazon dann in Form eines XML-Dokuments.<\/p>\n
Amazon Web Services<\/b><\/p>\n
Den einfachsten Einstieg in die Amazon Webservices finden Sie über das deutsche Internetangebot unter http:\/\/www.amazon.de<\/b>, wo Sie links im Bereich Entdecken <\/b>einen Eintrag Für Entwickler|Amazon Web Services <\/b>finden. Der deutschsprachige Segen findet hier allerdings ein abruptes Ende, denn bereits der Verweis zum Web Services Software Developer€s Kit (http:\/\/www.amazon.com\/webservices<\/b>) führt zu einer englischsprachigen Seite, die einen überdies nicht gerade mit der Nase auf den Download stößt.<\/p>\n
Das ist aber auch nicht schlimm, denn wenn man einmal dort ist, besorgt man sich am besten direkt einen Amazon Web Services account<\/b>. Dafür brauchen Sie eine E-Mail-Adresse und einige Daten wie Ihre Adresse et cetera. Amazon sendet Ihnen eine Bestätigung des neuen Accounts, der unter anderem einen Link zu einer Seite mit einer Access Key ID enthält. Auf dieser Seite finden Sie das wichtigste Element für Ihren Zugang zu den Amazon Web Services (siehe Bild 1).<\/p>\n
![\"pic001.tif\"](\"..\/fileadmin\/_temp_\/2008_04\/Amazon-web-images\/pic001_opt.jpeg\")
<\/p>\n
Bild 1: Für den Zugriff auf die Amazon Web Services benötigen Sie eine Access Key ID.<\/span><\/b><\/p>\n Wenn Sie die Beispieldatenbank mit dem Amazon Associates Web Service ausprobieren möchten, müssen Sie sich übrigens zwangsläufig einen eigenen Account besorgen – die Beispieldatenbanken enthalten keinen gültigen Schlüssel.<\/p>\n Beispieldatenbank<\/b><\/p>\n Mit dieser ID bewaffnet können Sie eine erste Beispieldatenbank erstellen. Die Access Key ID speichern Sie der Einfachheit halber in einer global zugänglichen Konstanten in einem Standardmodul namens mdlGlobal<\/b>:<\/p>\n Bedingungen<\/b><\/p>\n Die Benutzung der Amazon Webservices ist nur unter bestimmten Bedingungen erlaubt und kostenlos. Dazu gehört, dass der Zugriff hauptsächlich dazu gedacht sein muss, Kunden auf die Webseiten von Amazon zu lenken, und dass man die von Amazon gewonnenen Daten nicht ohne schriftliche Genehmigung weiterveräußert oder verteilt oder diese für mobile Endgeräte aufbereitet. Außerdem ist nur eine Anfrage pro Sekunde pro Access Key ID möglich.<\/p>\n Die genauen Nutzungsrechte müssen Sie aber ohnehin bei der Anmeldung an den Amazon Associates Web Service absegnen. Die ebenfalls in dieser Ausgabe von Access im Unternehmen <\/b>vorgestellte Bücherverwaltung kann daher also nur ein Beispiel für den Zugriff auf den Amazon Associates Web Service sein.<\/p>\n Anfragen senden mit REST<\/b><\/p>\n Wenn man eine Anfrage mit REST versenden und das Antwort-XML-Dokument entgegennehmen möchte, braucht man nur wenige Zeilen Code. Ein einfacher Test sieht beispielsweise wie folgt aus:<\/p>\n Dieser Aufruf enthält zunächst die URL des Webservices und dahinter eine ganze Reihe Parameter. Der erste Parameter namens Service <\/b>besitzt immer den Wert AWSECommerceService<\/b>. Danach folgt die Access Key ID, die für jeden Benutzer eindeutig sein muss. Wenn Sie am Partnerprogramm von Amazon teilnehmen, sollten Sie auch diese in die URL einfließen lassen – auf diese Weise erhalten Sie im Falle eines Verkaufs die entsprechende Provision. Der passende Parameter lautet AssociateTag<\/b>.<\/p>\n Operation <\/b>gibt die gewünschte Aktion an, in diesem Falle mit ItemSearch <\/b>die Suche nach einem Artikel. SearchIndex<\/b> legt fest, nach welcher Art von Artikel der Service suchen soll. Hier sind die Bücher, also Books<\/b>, das Ziel der Anfrage. Title <\/b>markiert nur einen von mehreren möglichen Suchparametern und steht für den Titel eines Buchs. Unter Version <\/b>geben Sie die Version des Amazon Associates Web Services an.<\/p>\n Eine REST-Anfrage können Sie bequem über den Webbrowser absetzen. Dieser liefert das Antwort-XML-Dokument als neue Seite zurück (siehe Bild 2).<\/p>\n Bild 3: Anlegen eines Verweises auf die Microsoft XML-Bibliothek<\/span><\/b><\/p>\n Neben den hier sichtbaren XML-Elementen folgen einige weitere mit den eigentlichen Informationen zu den gefundenen Artikeln.<\/p>\n Ergebnis beeinflussen mit Response Groups<\/b><\/p>\n Amazon liefert dabei die wichtigsten Informationen wie den Titel, den oder die Autoren oder den Hersteller, aber auch eine Reihe von Links zu verschiedenen produktbezogenen Seiten auf Amazon – nicht nur zur Produktseite selbst, sondern auch zu Seiten, auf denen Sie das Produkt zu Wunschlisten hinzufügen oder seine Bewertung durch andere Käufer einsehen können.<\/p>\n Diese Informationen können Sie erheblich erweitern. Dazu verwenden Sie den ResponseGroup-Parameter mit einer der unter [1] angegebenen Response-Groups.<\/p>\n Wenn die Produktliste beispielsweise Links zu den Produktbildern enthalten soll, fügen Sie folgenden Parameter zum REST-Aufruf hinzu:<\/p>\n Weitere Response Groups geben Sie durch Komma getrennt wie folgt an:<\/p>\n Diese Variante würde nicht nur die Links zu Bildern, sondern auch noch die Bewertungstexte anderer Käufer zurückliefern. Weitere Parameter und ihre Bedeutung finden Sie unter obigem Link.<\/p>\n REST-Anfrage per VBA<\/b><\/p>\n Für den VBA-Entwickler ist es natürlich viel interessanter, eine REST-Abfrage per VBA abzusetzen und das Ergebnis in verarbeitbarer Form zurückzuerhalten. Die Amazon-Dokumentation liefert leider überwiegend Material für andere Programmiersprachen wie die .NET-Sprachen, PHP, Perl oder Java – Sprachen, denen man gegenüber VBA eine weit höhere Web-Affinität einräumt.<\/p>\n Die Routine aus Listing 1 zeigt beispielhaft, wie das Verwenden einer REST-Anfrage und die Auswertung der Antwort erfolgt. Dabei setzen die ersten Zeilen zunächst die URL mit den Parametern für die Anfrage zusammen. Hier kommen zunächst nur die oben angegebenen Parameter zum Einsatz, später kümmern wir uns um weitere Parameter wie etwa zusätzliche Suchkriterien.<\/p>\n Listing 1: Ein einfacher Amazon-Request<\/p>\n Nach dem Erstellen des URL-Strings erzeugt die Routine ein DOMDocument<\/b>-Objekt (MSXML-Bibliothek, Verweis siehe Bild 3) und stellt einige Eigenschaften ein. Die Load<\/b>-Methode dieses Objekts liefert beim Aufruf mit der Anfrage entweder den Wert True <\/b>für eine erfolgreiche Anfrage oder den Wert False <\/b>zurück. Letzterer Fall wird mit einer entsprechenden Meldung inklusive Fehlermeldung quittiert, dies sollte jedoch in der Regel nicht passieren. Eher kann es sein, dass ein fehlerhafter Aufruf ein valides XML-Dokument zurückliefert, das selbst die Fehlerbeschreibung enthält. Dies deckt die If…Then<\/b>-Bedingung ab, welche prüft, ob beim Zugriff auf das Element, das üblicherweise Fehlerinformationen enthält (siehe markierter Bereich in Bild 4), ein Fehler aufgetreten ist. Das Auslesen erfolgt dabei mithilfe eines XPath-Ausdrucks (XPath ist die Abfragesprache für XML-Dokumente). Die übergeordnete Errors<\/b>-Auflistung ist nur in einer XML-Response enthalten, wenn der Aufruf fehlerhaft ist, sonst fällt sie komplett weg. Liefert das Dokument Fehlerinformationen, gibt ein Meldungsfenster die Informationen aus.<\/p>\n Bild 2: Ergebnis einer REST-Anfrage im Internet Explorer<\/span><\/b><\/p>\n Bild 4: Ein XML-Dokument mit einer Fehlermeldung weist meist auf eine fehlerhafte Anfrage hin.<\/span><\/b><\/p>\n Liegt kein Fehler vor, enthält dieser Teil des XML-Dokuments die Informationen über die gefundenen Produkte. Diese fallen meist wesentlich umfangreicher als Fehlerinformationen aus, dementsprechend haben wir auch deren Verarbeitung zunächst aus Listing 1 ausgeklammert und nur einen Kommentar platziert, der anzeigt, wo die Verarbeitung stattfindet.<\/p>\n Inhalt der XML-Antwort<\/b><\/p>\n Der wesentliche Teil einer fehlerlosen Antwort sieht etwa wie in Listing 2 aus und enthält die Items<\/b>-Auflistung als Unterelement des Root-Elements ItemSearchResponse<\/b>. <\/p>\n Listing 2: Aussehen der Beschreibung eines Buchs<\/p>\n Diese Auflistung wiederum besteht aus einigen allgemeinen Informationen wie der Wiederholung der in der REST-Anfrage gemachten Angaben sowie der Angabe der Anzahl der Ergebnisse und der Seiten, auf welche die Ergebnisse aufgeteilt sind.<\/p>\n Schließlich folgen einige Item<\/b>-Elemente (standardmäßig sind es zehn Stück je Seite). Diese enthalten einen Link zur Detailseite bei Amazon, weitere Links zum Hinzufügen des Items zu den verschiedenen Listen und unter ItemAttributes <\/b>die eigentlichen Eigenschaften des Item<\/b>-Elements.<\/p>\n Im Rahmen der Bücherverwaltung aus Beitrag Bücherverwaltung <\/b>(s. Shortlink 633) soll der WebService Bücher liefern, die einem oder mehreren Kriterien entsprechen. Dafür brauchen Sie eine spezielle Art der ItemSearch<\/b>-Operation, die nur für Bücher funktioniert und die den Suchparameter Search <\/b>erwartet. Diesen füllt man wiederum mit einem Ausdruck, der die gewünschten Suchkriterien enthält. Ausgiebige Informationen zu diesem Parameter liefert [2].<\/p>\n Zu Beispielzwecken beschränken wir uns hier auf die folgenden Kriterien:<\/p>\n Sowohl die einzelnen Kriterien als auch die für ein Kriterium angegebenen Schlüsselbegriffe können durch and <\/b>und or <\/b>verknüpft werden; auch der Einsatz von Klammern ist möglich. Wichtig ist, dass eventuell auftretende Leerzeichen durch den Ausdruck %20 <\/b>ersetzt werden. Dies entspricht dem hexadezimalen Wert für 32<\/b>, dem ASCII-Wert des Leerzeichens.<\/p>\n <\/p>\n Mehrere Ergebnisseiten<\/b><\/p>\n Die Anzahl der Bücher überschreitet gelegentlich die in einem Zug vom Webservice zurückgelieferten zehn Bücher. In diesem Fall muss man den gleichen Aufruf mehrere Male durchführen, um Informationen zu allen Büchern zu erhalten – mit einer kleinen Ausnahme: Der Aufruf soll jeweils die nächsten zehn Bücher zurückliefern.<\/p>\n Dies erledigt der Parameter ItemPage<\/b>, den man per VBA auf die jeweilige Seite einstellt:<\/p>\n Wie viele Seiten und wie viele Einträge es gibt, erfährt man aus zwei Elementen, die sich unterhalb des Items<\/b>-Knotens befinden und etwa wie folgt aussehen:<\/p>\n Um alle, auch über mehrere Seiten verteilte Bücher einzulesen, braucht man also nur eine Schleife von 2 (den ersten Aufruf braucht man, um überhaupt die Seitenzahl zu erfahren) bis zur Anzahl der Seiten laufen zu lassen und die enthaltenen Einträge zu verarbeiten.<\/p>\n Mehr Eigenschaften<\/b><\/p>\n Im obigen Beispiel liefert das XML-Dokument nur wenige Informationen zu den jeweiligen Büchern zurück. Viel mehr Informationen erhält man, wenn man eine oder mehrere der unter [1] angegebenen Response Groups angibt. Dies geschieht zum Beispiel mit dem folgenden Parameter:<\/p>\n Medium <\/b>repräsentiert bereits eine Zusammenfassung mehrerer anderer Response Groups. Wenn Sie eine andere, individuelle Zusammenstellung von Response Groups wünschen, können Sie diese durch Kommata getrennt angeben. Die folgenden Elemente entsprechen beispielsweise denen, welche die Response Group Medium <\/b>zusammenfasst:<\/p>\n Für unsere Zwecke reicht die Response Group Medium <\/b>voll aus. Sie liefert diese Informationen:<\/p>\n Abfrage und Verarbeitung der Daten<\/b><\/p>\n Eine interessante Frage ist die nach den Möglichkeiten der Weiterverarbeitung der Daten nach dem Einlesen des XML-Dokuments beziehungsweise der XML-Dokumente.<\/p>\n Da laut Amazon ohnehin nur ein Zugriff pro Access Key ID und Sekunde möglich ist, macht es durchaus Sinn, jeweils nur die zehn Einträge des aktuellen Suchergebnisses in einer Liste anzuzeigen und Schaltflächen anzubieten, mit denen der Benutzer zwischen den Seiten blättern, einen bestimmten Eintrag in der Detailansicht anzeigen oder diesen zur Bücherverwaltung hinzufügen kann.<\/p>\n Die Vorgehensweise sieht also etwa so aus: Zunächst gibt der Benutzer in einem Formular seine Suchbegriffe ein und startet die Abfrage des XML-Dokuments mit den ersten zehn Ergebnissen sowie der Seitenanzahl. Die zehn Ergebnisse werden temporär in einer Tabelle gespeichert, deren Inhalt in einem geeigneten Steuerelement – einem Listenfeld oder einem Unterformular in der Datenblattansicht – angezeigt wird.<\/p>\n Springt der Benutzer über eine entsprechende Schaltfläche zur nächsten Seite, wird auch diese in der temporären Tabelle gespeichert – freilich ohne die ersten Einträge dieser Suche zu löschen. Nun soll das Formular die neuen zehn Einträge anzeigen. Will der Benutzer weitere Einträge sehen, lädt die Anwendung das XML-Dokument mit den nächsten zehn Einträgen. Will er die vorherigen zehn Einträge sehen, erfolgt keine erneute Abfrage, sondern einfach die Anzeige der bereits gespeicherten Bücher.<\/p>\n Die folgenden Abschnitte beschreiben nun die folgenden notwendigen Elemente:<\/p>\n Datenmodell<\/b><\/p>\n Das kleine Datenmodell zum Speichern der Suchergebnisse umfasst drei Tabellen, wobei die Tabelle tblSearchresults <\/b>die wesentlichen Informationen aufnimmt. Es gibt nur eine Information, die dort nicht so recht reinpasst, und das sind die Autoren. Da es je Buch mehrere Autoren geben und jeder Autor auch mehrere Bücher geschrieben haben kann, gibt es eine eigene Autorentabelle, die per m:n-Beziehung mit der Tabelle der Suchergebnisse verknüft ist (siehe Bild 5).<\/p>\n Bild 5: Datenmodell zum Speichern der Suchergebnisse von Amazon-Abfragen<\/span><\/b><\/p>\n Formular zur Eingabe von Suchkriterien und Ausgabe der Ergebnisse<\/b><\/p>\n Das Aussehen des Formulars zur Suche nach Büchern bei Amazon finden Sie in Bild 6. Es enthält einige Felder für die Eingabe von Suchkriterien, ein Feld zur Ausgabe des Suchausdrucks, einige Schaltflächen sowie ein Unterformular, welches das Suchergebnis anzeigt.<\/p>\n Bild 6: Formular zur Suche nach Büchern bei Amazon<\/span><\/b><\/p>\n Nach der Eingabe von Text für eines der Suchkriterien soll der Suchausdruck direkt aktualisiert werden. Das heißt, dass dieser beim Öffnen des Formulars leer ist und mit jedem in eines der Textfelder eingegebenen Buchstaben aktualisiert wird. Dabei ergänzt das Formular automatisch die für die Abfrage des Amazon-Webservices nötigen Ausdrücke. Gibt man also unter Autor den Buchstaben M <\/b>ein, soll das Suchfeld direkt den Inhalt Author:M <\/b>anzeigen. Dieser Ausdruck wird dann mit der Eingabe weiterer Zeichen ständig aktualisiert.<\/p>\n Damit dies reibungslos funktioniert, gibt es zu jedem Suchfeld ein weiteres unsichtbares Suchfeld (erkennbar in Bild 7), das zunächst mit dem im sichtbaren Suchfeld eingegebenen Text gefüllt wird. Außerdem ruft die für jedes der sichtbaren Textfelder vorhandene Ereignisprozedur Bei änderung<\/b> die Routine CreateSearchString<\/b> auf, welche die Inhalte der Suchfelder zu dem gewünschten Ausdruck zusammenstellt:<\/p>\n Bild 7: Entwurfsansicht des Formulars frmSearchAmazon<\/span><\/b><\/p>\n Die Routine CreateSearchString<\/b> sieht wie in Listing 3 aus. Sie durchläuft die fünf Suchfelder und stellt daraus einen Ausdruck wie Title:Access and Author:Minhorst <\/b>zusammen.<\/p>\n Listing 3: Zusammenstellen des Suchausdrucks<\/p>\n Warum der Aufwand mit den zusätzlichen Textfeldern Die Routine CreateSearchString <\/b>könnte doch auch direkt auf die Text<\/b>-Eigenschaft der Textfelder zugreifen Nein, das kann Sie eben nicht: Die Text-Eigenschaft ist nur verfügbar, solange ein Steuerelement den Fokus hat. Nun könnte man sicher in der Routine CreateSearchString <\/b>prüfen, ob ein Textfeld gerade den Fokus hat und davon abhängig entweder die Text<\/b>– oder, implizit, die Value<\/b>-Eigenschaft auslesen. Aber die Lösung mit den zusätzlichen Textfeldern scheint sauberer.<\/p>\n Wie oben erwähnt, kann man auch mehrere durch And <\/b>oder Or <\/b>verknüpfte Ausdrücke verwenden. Der Aufwand für das Erstellen einer Eingabemaske, die dies unterstützt, schien uns nicht angemessen.<\/p>\n Daher kann der Benutzer den halbautomatisch erzeugten Suchausdruck nachträglich bearbeiten, indem er weitere Ausdrücke, And<\/b>– und Or<\/b>-Operatoren oder Klammern hinzufügt. Aber Vorsicht: Eingaben in die oberen Kriterienfelder setzen manuelle änderungen im Suchausdruck wieder zurück.<\/p>\n Suchformular zurücksetzen<\/b><\/p>\n Die Schaltfläche Suchfelder leeren <\/b>hat die einfachste Aufgabe im Formular: Sie setzt die Suchfelder zurück, löscht das angezeigte Suchergebnis und deaktiviert alle anderen Schaltflächen im oberen Bereich.<\/p>\n Suche starten<\/b><\/p>\n Die wichtigste Aufgabe hat die Schaltfläche cmdSearchAmazon<\/b>: Sie wertet den eingegebenen Suchausdruck aus, sendet ihn an den Amazon-Webservice, speichert im Erfolgsfall das Suchergebnis in den oben beschriebenen Tabellen und zeigt ihren Inhalt im Unterformular an. Wenn man sich Listing 4 anschaut, sieht das recht einfach aus. Hinter den dortigen Aufrufen verbergen sich jedoch noch einige weitere Routinen.<\/p>\n Listing 4: Diese Zeilen sind für die Büchersuche verantwortlich.<\/p>\n Beginnen wir mit der Routine GetPageCount <\/b>aus Listing 5. Diese soll lediglich ermitteln, aus wie vielen Seiten das Suchergebnis besteht.<\/p>\n Listing 5: Anzahl der Ergebnisseiten einlesen<\/p>\n Sie ruft zunächst die Funktion GetRequest <\/b>auf, die aus dem Suchausdruck und den übrigen, weitgehend feststehenden Parametern einen Request zusammensetzt und diesen über die Variable strRequest <\/b>zurückliefert.<\/p>\n Der nächste Aufruf auf die Routine SendRequest <\/b>sendet eben diesen Request an den Amazon-Webservice und liefert im Erfolgsfall in objXML <\/b>das XML-Dokument mit dem Ergebnis zurück.<\/p>\n Dieses XML-Dokument wird anschließend von der Routine ResponseError <\/b>dahingehend geprüft, ob ein formeller Fehler, beispielsweise durch einen ungültigen Parameter, aufgetreten ist und im XML-Dokument verzeichnet wurde. Falls ja, erscheint eine entsprechende Fehlermeldung. Sie können dies provozieren, indem Sie eine ungültige Access Key ID angeben.<\/p>\n Ist auch diese Hürde überwunden, ermittelt die Routine mittels XPath den Wert des Knotens ItemSearchResponse\/Items\/TotalPages <\/b>und schreibt diesen in die Variable intPages<\/b>. intPages<\/b> ist dabei eine modulweit gültige Variable, die im Folgenden vor allem der Aktivierung und Deaktivierung der beiden Schaltflächen zum Vor- und Zurückblättern dient.<\/p>\n Request zusammensetzen<\/b><\/p>\n Die oben erwähnte Routine GetRequest <\/b>finden Sie in Listing 6.<\/p>\n Listing 6: Zusammensetzen des Webservice-Requests<\/p>\n Die Routine erwartet den Suchausdruck strSearch <\/b>sowie die Angabe der Seitenzahl, die ermittelt werden soll, und liefert mit strRequest <\/b>die Request<\/b>-Zeichenfolge zurück.<\/p>\n In diese wird unter anderem die Access Key ID aus der Konstanten cDeveloperToken <\/b>eingearbeitet.<\/p>\n Request senden<\/p>\n Die Routine SendRequest <\/b>übernimmt das Senden des Requests an den Amazon-Webservice (s. Listing 7). Scheitert der Request, weil er beispielsweise eine falsche URL enthält, liefert die Routine den Wert False <\/b>zurück, anderenfalls True<\/b>. In letzterem Fall kann die aufrufende Routine das in objXML <\/b>gespeicherte XML-Dokument weiterverwenden.<\/p>\n Listing 7: Anfrage an den Amazon-Webservice senden<\/p>\n Interne Fehler suchen<\/b><\/p>\n Wenn der Request erfolgreich war und ein XML-Dokument zurückgeliefert hat, kann dieses immer noch eine interne Fehlermeldung enthalten. Diese resultiert, wie bereits oben erwähnt, beispielsweise aus falschen Parametern (siehe Bild 4). Die Routine ResponseError <\/b>aus Listing 8 kümmert sich um solche Fälle. Dabei versucht die Routine zunächst, den Wert des Knotens ItemSearchResponse\/OperationRequest\/Errors\/Error\/Code <\/b>aus dem Dokument auszulesen, der im Falle eines Fehlers vorhanden ist. Tritt dabei kein Fehler auf, bedeutet dies, dass der Fehlerknoten vorhanden ist und der Request fehlerhafte Parameter enthält. In diesem Fall liest die Routine auch noch den Wert von ItemSearchResponse\/OperationRequest\/Errors\/Error\/Message <\/b>aus und liefert die beiden Informationen über die Parameter strErrorCode <\/b>und strErrorDescription <\/b>an die aufrufende Routine zurück.<\/p>\n Listing 8: Diese Funktion untersucht das Response-Objekt auf Fehlermeldungen.<\/p>\n Tritt beim Auslesen von ItemSearchResponse\/OperationRequest\/Errors\/Error\/Code<\/b> hingegen ein Fehler auf, ist an dieser Stelle auch keine Fehlermeldung vorhanden. Die Routine forscht dann noch an einer anderen Stelle nach einer Fehlermeldung, und zwar im Element Errors\/Error\/Code<\/b>. Gibt es einen solchen Fehler, liefert Errors\/Error\/Message <\/b>weitere Informationen und die beiden Fehlertexte werden auf dem oben bereits beschriebenen Weg an die aufrufende Prozedur übergeben.<\/p>\n XML-Dokument auslesen<\/b><\/p>\n Wenn die Anwendung auf diese Art ein fehlerfreies XML-Dokument erhalten und aus diesem die Anzahl der Antwortseiten ausgelesen hat, kann sie endlich die eigentlichen Informationen einlesen.<\/p>\n Dies erledigt die Routine GetPage<\/b>, die prinzipiell wie die Routine GetPageCount <\/b>arbeitet, aber nicht die Anzahl der Seiten liefert, sondern auf Basis der übergebenen Seitennummer das passende XML-Dokument mit den Suchergebnissen liefert.<\/p>\n XML-Dokument verarbeiten<\/b><\/p>\n Die eigentliche Verarbeitung des so gewonnenen XML-Dokuments erledigt die Routine SaveSearchResults<\/b> (s. Listing 9). Diese durchläuft alle Item<\/b>-Elemente des Knotens ItemSearchResponse\/Items <\/b>des XML-Dokuments und bedient sich dabei einiger Hilfsfunktionen, die mithilfe von XPath-Abfragen den Wert der in den Item-Elementen enthaltenen Buchinformationen auslesen. Die einzelnen Informationen zu jedem gefundenen Buch werden zunächst in Variablen wie strISBN <\/b>oder lngSalesRank <\/b>gespeichert und von dort mit einer INSERT INTO<\/b>-Aktionsabfrage als neuer Datensatz zur Tabelle tblSearchresults <\/b>hinzugefügt.<\/p>\n Listing 9: Informationen aus XML-Dokument lesen und in Tabellen schreiben<\/p>\n Die Autoren, von denen jedes Item<\/b>-Element unter ItemAttributes\/Author <\/b>keinen, einen oder mehrere enthalten kann, erfahren eine Sonderbehandlung: Sie werden zunächst einzeln in die Tabelle tblAutoren <\/b>geschrieben, wobei Dubletten durch einen eindeutigen Index auf das Feld Autor <\/b>der Tabelle vermieden werden (eine On Error Resume Next<\/b>-Anweisung beugt hieraus resultierenden Fehlermeldungen vor).<\/p>\n Die Routine ermittelt dann die ID der neuen Datensätze in tblSearchresults <\/b>und tblAutoren <\/b>und legt einen neuen Datensatz in der Verknüpfungstabelle tblSearchresultsAutoren <\/b>an, der die beiden verknüpft. Auf diese Weise landen alle benötigten Daten in diesen drei Tabellen.<\/p>\n Ergebnisse anzeigen<\/p>\n Weiter oben in Listing 4 finden Sie die Routine, die durch die Schaltfläche cmdSearchAmazon <\/b>ausgelöst wurde und die beschriebenen Routinen aufruft. Nach dem Speichern der Buchinformationen und dem Aktualisieren der Variablen intCurrentPage <\/b>mit der aktuellen Seite bleibt dieser Prozedur nur noch die Aufgabe, die Anzeige im Formular zu aktualisieren, was sie mithilfe der Routine RequeryControls <\/b>erledigt (s. Listing 10).<\/p>\n Listing 10: Diese Routine aktualisiert die Steurelemente.<\/p>\n Diese stellt vor allem den Filter des Unterformulars, das die beiden Felder ISBN <\/b>und Titel <\/b>der gefundenen Bücher anzeigt, auf die aktuelle und in intCurrentPage <\/b>gespeicherte Antwortseite des Amazon-Webservice ein.<\/p>\n Außerdem prüft sie die Variable intCurrentPage <\/b>und weitere Informationen, um die Schaltflächen cmdNextPage <\/b>und cmdPreviousPage <\/b>aktivieren beziehungsweise deaktivieren zu können – die Schaltfläche cmdNextPage <\/b>soll etwa deaktiviert sein, wenn das Formular bereits die letzte Seite des Suchergebnisses anzeigt.<\/p>\n Außerdem sorgt die Routine dafür, dass der Benutzer eine Information über die aktuelle und die gesamte Seitenzahl erhält.<\/p>\n Vorherige und nächste Seite<\/b><\/p>\n Die Schaltfläche cmdNextPage <\/b>addiert beim Anklicken (s. Listing 11) zunächst zur Variablen intCurrentPage <\/b>den Wert 1 <\/b>hinzu, weil sie ja die nächste Seite anzeigen soll. Dann prüft sie, ob intCurrentPage <\/b>größer als intMaxPage <\/b>ist. intMaxPage <\/b>speichert die größte bisher eingelesene Seitenzahl. Wenn intCurrentPage <\/b>größer als intMaxPage <\/b>ist, liegt die anzuzeigende Ergebnisseite noch nicht in der Tabelle tblSearchresults <\/b>vor und sie muss durch einen Aufruf von GetPage <\/b>zunächst ermittelt und ihr Inhalt mit SaveSearchResults <\/b>in der Tabelle tblSearchResults <\/b>gespeichert werden. Falls die Seite schon vorhanden, intCurrentPage <\/b>also kleiner oder gleich intMaxPage <\/b>ist, braucht die Anwendung keine Daten vom Amazon-Webservice einzulesen, sondern nur den Filter des Unterformulars auf die Datensätze für die aktuelle Seite einzustellen.<\/p>\n Listing 11: Aufrufen der nächsten Seite<\/p>\n Zusammenfassung und Ausblick<\/b><\/p>\n Der Beitrag zeigt, wie Sie Buchdaten über den Webservice von Amazon einlesen und in den Tabellen einer Datenbank speichern können. Hat man die grundsätzliche Vorgehensweise einmal verstanden, kann man prinzipiell auch jeden anderen Webservice von Access aus abfragen und die gewonnen Daten weiterverwenden.<\/p>\n Offen lässt dieser Beitrag die weitere Verwendung der ermittelten Buchinformationen. Wir lassen Sie aber nicht im Regen stehen: Sie können damit beispielsweise eine Bücherverwaltung füttern. So können Sie Ihre Bücher ganz einfach durch die Angabe einer Eigenschaft wie der ISBN in der Amazon-Datenbank suchen und die dort vorhandenen Informationen zu Ihrer eigenen Datenbank hinzufügen. Wie das geht, zeigt der Beitrag Bücherverwaltung (Shortlink 633).<\/p>\n Wir weisen an dieser Stelle allerdings nochmals darauf hin, dass der Amazon-Webservice nicht primär für solche Zwecke genutzt werden darf! Der Haupteinsatz sollte darin bestehen, Kunden auf die Amazon-Webseiten zu schicken.<\/p>\n Literatur<\/p>\n [1] Request-Parameter: http:\/\/docs.amazonwebservices.com\/AWSECommerceService\/2008-08-19\/DG\/index.htmlCHAP_ResponseGroupsList.html<\/p>\n [2] Search-Paremter: http:\/\/docs.amazonwebservices.com\/AWSECommerceService\/2008-08-19\/DG\/index.htmlCHAP_MakingRequestsandUnderstandingResponses.html<\/p>\n [3] Amazon Webservices Startseite: http:\/\/www.amazon.com\/gp\/browse.htmlnode=3435361<\/p>\n [4] Amazon Associates Web Service Developer Guide: http:\/\/docs.amazonwebservices.com\/AWSECommerceService\/2008-08-19\/DG\/<\/p>\n Enthaltene Beispieldateien:<\/p>\n Buecherverwaltung.mdb<\/p>\nPublic Const cDeveloperToken As String = _\r\n\"ABCDEFGHIJ0123456789\"<\/pre>\n
http:\/\/ecs.amazonaws.de\/onca\/xml\r\nService=AWSECommerceService\r\n&AWSAccessKeyId=ABCDEFGHIJ0123456789\r\n&Operation=ItemSearch\r\n&SearchIndex=Books\r\n&Title=Access\r\n&Version=2008-08-19<\/pre>\n
![\"pic002.tif\"](\"..\/fileadmin\/_temp_\/2008_04\/Amazon-web-images\/pic002_opt.jpeg\")
<\/p>\n&ResponseGroup=Images<\/pre>\n
&ResponseGroup=Images,Reviews<\/pre>\n
Public Sub AmazonRequest()\r\nDim objXML As MSXML2.DOMDocument\r\nDim strRequest As String\r\nDim strDeveloperToken As String\r\nDim strErrorCode As String\r\nDim strErrorDescription As String\r\nDim bolSuccess As Boolean\r\nstrDeveloperToken = cDeveloperToken\r\nstrRequest = \"http:\/\/ecs.amazonaws.de\/onca\/xml€\r\nstrRequest = strRequest & \"Service=AWSECommerceService€\r\nstrRequest = strRequest & \"&AWSAccessKeyId=€ & strDeveloperToken\r\nstrRequest = strRequest & \"&Operation=ItemSearch€\r\nstrRequest = strRequest & \"&SearchIndex=Books€\r\nstrRequest = strRequest & \"&Title=Access€\r\nstrRequest = strRequest & \"&Version=2008-08-19€\r\nSet objXML = New MSXML2.DOMDocument\r\nWith objXML\r\n.async = False\r\n.preserveWhiteSpace = False\r\n.validateOnParse = True\r\n.resolveExternals = False\r\nEnd With\r\nbolSuccess = objXML.Load(strRequest)\r\nIf bolSuccess = True Then\r\n On Error Resume Next\r\n strErrorCode = objXML. _\r\n selectSingleNode(\"ItemSearchResponse\/OperationRequest\/Errors\/Error\/Code€).Text\r\n If Err.Number = 0 Then\r\n strErrorDescription = objXML. _\r\n selectSingleNode(\"ItemSearchResponse\/OperationRequest\/Errors\/Error\/Message€).Text\r\n MsgBox strErrorDescription, vbOKOnly + vbCritical, strErrorCode\r\n Else\r\n Debug.Print objXML.XML\r\n End If\r\nElse\r\n MsgBox \"Error!€ & vbCrLf & objXML.parseError.reason\r\nEnd If\r\nEnd Sub<\/pre>\n
![\"pic003.tif\"](\"..\/fileadmin\/_temp_\/2008_04\/Amazon-web-images\/pic003_opt.jpeg\")
<\/p>\n![\"pic004.tif\"](\"..\/fileadmin\/_temp_\/2008_04\/Amazon-web-images\/pic004_opt.jpeg\")
<\/p>\n...\r\n<Items>\r\n<Request>\r\n<IsValid>True<\/IsValid>\r\n<ItemSearchRequest>\r\n<SearchIndex>Books<\/SearchIndex>\r\n<Title>Access<\/Title>\r\n<\/ItemSearchRequest>\r\n<\/Request>\r\n<TotalResults>1051<\/TotalResults>\r\n<TotalPages>106<\/TotalPages>\r\n<Item>\r\n<ASIN>3827322650<\/ASIN>\r\n<DetailPageURL>http:\/\/www.amazon.de\/...<\/DetailPageURL>\r\n<ItemLinks>\r\n<ItemLink>\r\n<Description>Add To Wishlist<\/Description>\r\n<URL>http:\/\/www.amazon.de\/...<\/URL>\r\n<\/ItemLink>\r\n... more <ItemLink>-Elements\r\n<\/ItemLinks>\r\n<ItemAttributes>\r\n<Author>Andre Minhorst<\/Author>\r\n<Creator Role=\"Autor\">Andre Minhorst<\/Creator>\r\n<Manufacturer>Addison-Wesley, München<\/Manufacturer>\r\n<ProductGroup>Book<\/ProductGroup>\r\n<Title>Das Access 2003-Entwicklerbuch<\/Title>\r\n<\/ItemAttributes>\r\n<\/Item>\r\n... more <Item>-Elements\r\n<\/Items>\r\n...<\/pre>\n
\n
strRequest = strRequest & \"&ItemPage=\" & intPage<\/pre>\n
<TotalResults>12<\/TotalResults>\r\n<TotalPages>2<\/TotalPages><\/pre>\n
&ResponseGroup=Medium<\/pre>\n
&ResponseGroup=EditorialReview,Images,ItemAttributes,OfferSummary,Request,SalesRank,Small<\/pre>\n
\n
\n
![\"pic006.tif\"](\"..\/fileadmin\/_temp_\/2008_04\/Amazon-web-images\/pic006_opt.jpeg\")
<\/p>\n![\"pic005.tif\"](\"..\/fileadmin\/_temp_\/2008_04\/Amazon-web-images\/pic005_opt.jpeg\")
<\/p>\n![\"pic007.tif\"](\"..\/fileadmin\/_temp_\/2008_04\/Amazon-web-images\/pic007_opt.jpeg\")
<\/p>\nPrivate Sub txtISBN_Change()\r\n Me!txtISBNTemp = Me!txtISBN.Text\r\n CreateSearchString\r\n End Sub<\/pre>\n
Private Sub CreateSearchString()\r\n Dim strSearch As String\r\n If Len(Me!txtISBNTemp) > 0 Then\r\n If Len(strSearch) > 0 Then\r\n strSearch = strSearch & \" and \"\r\n End If\r\n strSearch = strSearch & \"ASIN:€ & Me!txtISBNTemp\r\n End If\r\n If Len(Me!txtTitleTemp) > 0 Then\r\n If Len(strSearch) > 0 Then\r\n strSearch = strSearch & \" and \"\r\n End If\r\n strSearch = strSearch & \"Title:€ & Me!txtTitleTemp\r\n End If\r\n ... weitere Kriterien\r\n If Left(strSearch, 5) = \" and \" Then _\r\n strSearch = Mid(strSearch, 6)\r\n Me!txtSearch = strSearch\r\n Me!cmdSearchAmazon.Enabled = Len(strSearch) > 0\r\n End Sub<\/pre>\n
Private Sub cmdSearchAmazon_Click()\r\n Dim strSearch As String\r\n Dim objXML As MSXML2.DOMDocument\r\n strSearch = Replace(Me.txtSearch, \" \", \"%20€)\r\n If GetPageCount(strSearch, intPages) = True Then\r\n CurrentDb.Execute \"DELETE FROM tblSearchresults€, _\r\n dbFailOnError\r\n If intPages > 0 Then\r\n intCurrentPage = 1\r\n intMaxPage = 1\r\n If GetPage(strSearch, 1, objXML) = True Then\r\n SaveSearchResults objXML, intCurrentPage\r\n End If\r\n End If\r\n End If\r\n RequeryControls\r\n End Sub<\/pre>\n
Public Function GetPageCount(strSearch As String, intPages As Integer) As Boolean\r\n ... Deklaration ...\r\n If GetRequest(strSearch, 1, strRequest) = True Then\r\n If SendRequest(strRequest, objXML) = True Then\r\n If ResponseError(objXML, strErrorCode, strErrorDescription) = True Then\r\n MsgBox strErrorDescription, vbOKOnly + vbCritical, strErrorCode\r\n Else\r\n intPages = objXML.selectSingleNode(\"ItemSearchResponse\/Items\/TotalPages\").Text\r\n bolSuccess = True\r\n End If\r\n Else\r\n MsgBox \"Error!\" & vbCrLf & objXML.parseError.reason\r\n End If\r\n End If\r\n GetPageCount = bolSuccess\r\n ... Fehlerbehandlung ...\r\nEnd Function<\/pre>\n
Public Function GetRequest(strSearch As String, _\r\n intPage As Integer, strRequest As String) As Boolean\r\n Dim strDeveloperToken As String\r\n strDeveloperToken = cDeveloperToken\r\n strRequest = \"http:\/\/ecs.amazonaws.de\/onca\/xml€\r\n strRequest = strRequest & \"Service=AWSECommerceService€\r\n strRequest = strRequest & \"&AWSAccessKeyId=€ & strDeveloperToken\r\n strRequest = strRequest & \"&Operation=ItemSearch€\r\n strRequest = strRequest & \"&SearchIndex=Books€\r\n If intPage > 1 Then\r\n strRequest = strRequest & \"&ItemPage=€ & intPage\r\n End If\r\n strRequest = strRequest & \"&Power=€ & strSearch\r\n strRequest = strRequest & \"&ResponseGroup=Medium€\r\n strRequest = strRequest & \"&Version=2008-08-19€\r\n GetRequest = True\r\n ... Fehlerbehandlung ...\r\nEnd Function<\/pre>\n
Public Function SendRequest(strRequest As String, _\r\n objXML As MSXML2.DOMDocument) As Boolean\r\n Set objXML = New MSXML2.DOMDocument\r\n With objXML\r\n .async = False\r\n .preserveWhiteSpace = False\r\n .validateOnParse = True\r\n .resolveExternals = False\r\n End With\r\n SendRequest = objXML.Load(strRequest)\r\nEnd Function<\/pre>\n
Public Function ResponseError(objXML As MSXML2.DOMDocument, strErrorCode As String, _\r\n strErrorDescription As String) As Boolean\r\n Dim bolError As Boolean\r\n ...\r\n On Error Resume Next\r\n strErrorCode = objXML.selectSingleNode _\r\n (\"ItemSearchResponse\/OperationRequest\/Errors\/Error\/Code\").Text\r\n If Err.Number = 0 Then\r\n strErrorDescription = objXML.selectSingleNode _\r\n (\"ItemSearchResponse\/OperationRequest\/Errors\/Error\/Message\").Text\r\n bolError = True\r\n Else\r\n On Error Resume Next\r\n strErrorCode = objXML.selectSingleNode(\"Errors\/Error\/Code\").Text\r\n If Err.Number = 0 Then\r\n strErrorDescription = objXML.selectSingleNode(\"Errors\/Error\/Message\").Text\r\n bolError = True\r\n End If\r\n End If\r\n ResponseError = bolError\r\n ...\r\nEnd Function<\/pre>\n
Public Function SaveSearchResults(objXML As MSXML2.DOMDocument, intPage As Integer) As Boolean\r\n ... Deklaration ...\r\n Set db = CurrentDb\r\n Set objItems = objXML.selectNodes(\"ItemSearchResponse\/Items\/Item\")\r\n For i = 0 To objItems.length - 1\r\n strISBN = GetStringFromXML(objItems.Item(i), \"ASIN\")\r\n ...\r\n lngSalesRank = GetNumberFromXML(objItems.Item(i), \"SalesRank\")\r\n ...\r\n datPublicationDate = GetStringFromXML(objItems.Item(i), \"ItemAttributes\/PublicationDate\")\r\n ...\r\n strSQL = \"INSERT INTO tblSearchresults(ISBN, Title, ...) VALUES(€\" _\r\n & strISBN & \"€, €\" & Replace(strTitle, \"€\", \"€€\") & \"€, ...)\"\r\n db.Execute strSQL, dbFailOnError\r\n lngSearchresultID = db.OpenRecordset(\"SELECT @@IDENTITY\").Fields(0)\r\n Set objAuthors = objItems.Item(i).selectNodes(\"ItemAttributes\/Author\")\r\n For j = 0 To objAuthors.length\r\n On Error Resume Next\r\n db.Execute \"INSERT INTO tblAutoren(Autor) VALUES(€\" & objAuthors.Item(j).Text & \"€)\"\r\n If Err.Number = 0 And db.RecordsAffected = 1 Then\r\n lngAuthorID = db.OpenRecordset(\"SELECT @@IDENTITY\").Fields(0)\r\n Else\r\n lngAuthorID = db.OpenRecordset(\"SELECT ID FROM tblAutoren WHERE Autor = €\" _\r\n & objAuthors.Item(j).Text & \"€\", dbOpenDynaset).Fields(0)\r\n End If\r\n Next j\r\n Next i\r\nEnd Function<\/pre>\n
Private Sub RequeryControls()\r\n Me!sfmSearchAmazon.Form.Filter = \"Resultpage=\" & intCurrentPage\r\n Me!sfmSearchAmazon.Form.FilterOn = True\r\n If intCurrentPage > 1 Then\r\n Me!cmdPreviousPage.Enabled = True\r\n Else\r\n Me!cmdSuchfelderLeeren.SetFocus\r\n Me!cmdPreviousPage.Enabled = False\r\n End If\r\n If intCurrentPage < intPages And Not intPages = 0 Then\r\n Me!cmdNextPage.Enabled = True\r\n Else\r\n Me!cmdSuchfelderLeeren.SetFocus\r\n Me!cmdNextPage.Enabled = False\r\n End If\r\n Me!cmdSearchAmazon.Enabled = Len(Me!txtSearch) > 0\r\n Me!lblSeite.Caption = Seite " & intCurrentPage & "\/" & intPages\r\n End Sub<\/pre>\n
Private Sub cmdNextPage_Click()\r\n Dim strSearch As String\r\n Dim objXML As MSXML2.DOMDocument\r\n strSearch = Replace(Me.txtSearch, " ", "%20")\r\n intCurrentPage = intCurrentPage + 1\r\n If intCurrentPage > intMaxPage Then\r\n intMaxPage = intCurrentPage\r\n If GetPage(strSearch, intCurrentPage, objXML) = True Then\r\n SaveSearchResults objXML, intCurrentPage\r\n End If\r\n End If\r\n RequeryControls\r\n End Sub<\/pre>\n
Downloads zu diesem Beitrag<\/h3>\n