Best Practices für die Verwendung von Directions API-Webdiensten

Die Google Maps Platform-Webdienste sind eine Sammlung von HTTP-Schnittstellen zu Google-Diensten, die geografische Daten für Ihre Kartenanwendungen bereitstellen.

In diesem Leitfaden werden einige gängige Vorgehensweisen beschrieben, die beim Einrichten von Webdienstanfragen und Verarbeiten von Dienstantworten hilfreich sind. Im Entwicklerhandbuch finden Sie die vollständige Dokumentation zur Directions API.

Was ist ein Webdienst?

Google Maps Platform-Webdienste sind eine Schnittstelle, über die Sie Maps API-Daten von externen Diensten anfordern und in Ihren Maps-Anwendungen verwenden können. Diese Dienste sind für die Verwendung in Verbindung mit einer Karte vorgesehen, wie in den Lizenzbeschränkungen in den Nutzungsbedingungen der Google Maps Platform beschrieben.

Die Maps APIs-Webdienste verwenden HTTP(S)-Anfragen an bestimmte URLs und übergeben dabei URL-Parameter und/oder POST-Daten im JSON-Format als Argumente an die Dienste. Im Allgemeinen geben diese Dienste Daten im Antworttext entweder im JSON- oder XML-Format zurück, um sie durch Ihre Anwendung zu parsen und/oder zu verarbeiten.

Eine typische Directions API-Anfrage hat im Allgemeinen die folgende Form:

https://maps.googleapis.com/maps/api/directions/output?parameters

Dabei gibt output das Antwortformat an (in der Regel json oder xml).

Hinweis: Alle Directions API-Anwendungen erfordern eine Authentifizierung. Weitere Informationen zu Anmeldedaten für die Authentifizierung

SSL/TLS-Zugriff

HTTPS ist für alle Google Maps Platform-Anfragen erforderlich, die API-Schlüssel verwenden oder Nutzerdaten enthalten. Über HTTP gesendete Anfragen, die sensible Daten enthalten, können abgelehnt werden.

Gültige URL erstellen

Es mag den Anschein haben, dass „gültige“ URLs eine Selbstverständlichkeit sind. Das ist jedoch nicht der Fall. So kann beispielsweise eine URL, die in die Adresszeile eines Browsers eingegeben wird, Sonderzeichen wie "上海+中國" enthalten. Der Browser muss diese Zeichen vor der Übertragung intern in eine andere Codierung umwandeln. Ebenso ist es möglich, dass Code, der UTF-8-Eingaben erzeugt oder akzeptiert, URLs mit UTF-8-Zeichen als „gültig“ behandelt; diese Zeichen müssten jedoch vor dem Senden an einen Webbrowser ebenfalls umgewandelt werden. Dieser Vorgang wird als URL-Codierung oder Prozentcodierung bezeichnet.

Sonderzeichen

Sonderzeichen müssen umgewandelt werden, da alle URLs der Syntax entsprechen müssen, die in der Spezifikation Uniform Resource Identifier (URI) angegeben ist. Das bedeutet, dass URLs nur einen Teil der ASCII-Zeichen enthalten dürfen: die bekannten alphanumerischen Symbole und einige reservierte Zeichen, die in den URLs als Steuerzeichen dienen. Hier eine Übersicht:

Beachten Sie bei der Generierung einer URL, dass diese nur die in der Tabelle aufgeführten Zeichen enthalten darf. Die Anpassung der URL an diesen Zeichensatz führt in der Regel zu zwei Problemen, nämlich dass Zeichen weggelassen oder ersetzt werden müssen:

• Die Zeichen, die Sie verarbeiten möchten, sind nicht im obigen Zeichensatz enthalten. So müssen beispielsweise Zeichen ausländischer Sprachen, wie 上海+中國, mithilfe der oben angegebenen Zeichen codiert werden. Auch werden Leerzeichen, die innerhalb von URLs nicht zulässig sind, entsprechend den geltenden Konventionen oftmals durch das Zeichen '+' dargestellt.
• Die Zeichen sind im obigen Zeichensatz als reservierte Zeichen enthalten, müssen aber im ursprünglichen Sinn des Zeichens verwendet werden. So wird beispielsweise ? in URLs für den Beginn eines Abfragestrings verwendet. Möchten Sie es stattdessen für den Text „? and the Mysterions“ verwenden, müssen Sie das Zeichen '?' codieren.

Alle Zeichen, die als URL codiert werden sollen, werden mithilfe des Zeichens '%' und eines Hexadezimalwerts aus zwei Zeichen codiert, der ihrem UTF-8-Zeichen entspricht. So würde zum Beispiel der UTF-8-String 上海+中國 durch die URL-Codierung in %E4%B8%8A%E6%B5%B7%2B%E4%B8%AD%E5%9C%8B umgewandelt. Und aus ? and the Mysterians würde %3F+and+the+Mysterians oder %3F%20and%20the%20Mysterians werden.

Häufig vorkommende Zeichen, die codiert werden müssen

Folgende häufig vorkommende Zeichen müssen codiert werden:

Die Konvertierung von URLs, die aus Nutzereingaben empfangen werden, kann manchmal Probleme mit sich bringen. Beispielsweise kann ein Nutzer eine Adresse als „5th&Main St.“ eingeben. Im Allgemeinen sollten Sie die URL aus ihren Teilen erstellen und jede Nutzereingabe wortwörtlich betrachten.

Außerdem sind URLs für alle Google Maps Platform-Webdienste und statischen Web-APIs auf 16.384 Zeichen beschränkt. Bei den meisten Diensten wird diese Begrenzung selten erreicht. Beachten Sie jedoch, dass bestimmte Dienste einige Parameter haben, die zu langen URLs führen können.

Respektvolle Nutzung der Google APIs

Schlecht konzipierte API-Clients können sowohl das Internet als auch die Google-Server stärker als nötig belasten. Dieser Abschnitt enthält einige bewährte Methoden für Kunden der APIs. Wenn Sie diese Best Practices befolgen, können Sie verhindern, dass Ihre Anwendung aufgrund eines unbeabsichtigten Missbrauchs der APIs blockiert wird.

Exponentieller Backoff

In seltenen Fällen kann bei der Verarbeitung Ihrer Anfrage ein Fehler auftreten. Sie erhalten möglicherweise einen HTTP-Antwortcode 4XX oder 5XX oder die TCP-Verbindung zwischen Ihrem Client und dem Google-Server schlägt fehl. Oft lohnt es sich, die Anfrage noch einmal zu senden, da die Folgeanfrage möglicherweise erfolgreich ist, wenn die ursprüngliche Anfrage fehlgeschlagen ist. Es ist jedoch wichtig, Anfragen nicht einfach in einer Schleife wiederholt an die Google-Server zu senden. Dieses Verhalten kann zu einer Überlastung des Netzwerks zwischen Ihrem Client und Google führen, was für viele Parteien zu Problemen führt.

Ein besserer Ansatz ist es, wiederholte Versuche in immer größeren Abständen durchzuführen. In der Regel wird die Verzögerung bei jedem Versuch um einen multiplikativen Faktor erhöht. Dieser Ansatz wird als exponentieller Backoff bezeichnet.

Angenommen, Sie haben eine Anwendung, die diese Anfrage an die Time Zone API senden möchte:

https://maps.googleapis.com/maps/api/timezone/json?location=39.6034810,-119.6822510&timestamp=1331161200&key=YOUR_API_KEY

Im folgenden Beispiel mit Python wird gezeigt, wie die Anforderung mit exponentiellem Backoff durchgeführt wird:

import json
import time
import urllib.error
import urllib.parse
import urllib.request

# The maps_key defined below isn't a valid Google Maps API key.
# You need to get your own API key.
# See https://developers.google.com/maps/documentation/timezone/get-api-key
API_KEY = "YOUR_KEY_HERE"
TIMEZONE_BASE_URL = "https://maps.googleapis.com/maps/api/timezone/json"


def timezone(lat, lng, timestamp):

    # Join the parts of the URL together into one string.
    params = urllib.parse.urlencode(
        {"location": f"{lat},{lng}", "timestamp": timestamp, "key": API_KEY,}
    )
    url = f"{TIMEZONE_BASE_URL}?{params}"

    current_delay = 0.1  # Set the initial retry delay to 100ms.
    max_delay = 5  # Set the maximum retry delay to 5 seconds.

    while True:
        try:
            # Get the API response.
            response = urllib.request.urlopen(url)
        except urllib.error.URLError:
            pass  # Fall through to the retry loop.
        else:
            # If we didn't get an IOError then parse the result.
            result = json.load(response)

            if result["status"] == "OK":
                return result["timeZoneId"]
            elif result["status"] != "UNKNOWN_ERROR":
                # Many API errors cannot be fixed by a retry, e.g. INVALID_REQUEST or
                # ZERO_RESULTS. There is no point retrying these requests.
                raise Exception(result["error_message"])

        if current_delay > max_delay:
            raise Exception("Too many retry attempts.")

        print("Waiting", current_delay, "seconds before retrying.")

        time.sleep(current_delay)
        current_delay *= 2  # Increase the delay each time we retry.


if __name__ == "__main__":
    tz = timezone(39.6034810, -119.6822510, 1331161200)
    print(f"Timezone: {tz}")

Sie sollten außerdem darauf achten, dass weiter oben in der Anwendungsaufrufkette kein Wiederholungscode vorhanden ist, der zu wiederholten Anfragen in schneller Abfolge führt.

Synchronisierte Anforderungen

Eine große Anzahl von synchronisierten Anfragen an die APIs von Google kann wie ein DDoS-Angriff (Distributed Denial of Service) auf die Infrastruktur von Google aussehen und entsprechend behandelt werden. Um dies zu vermeiden, sollten Sie darauf achten, dass API-Anfragen nicht zwischen Clients synchronisiert werden.

Angenommen, eine Anwendung zeigt die Zeit in der aktuellen Zeitzone an. Diese Anwendung wird wahrscheinlich im Client-Betriebssystem einen Alarm einrichten, mit dem das System zu Beginn der Minute aktiviert wird, damit die angezeigte Zeit aktualisiert werden kann. Die Anwendung sollte keine API-Aufrufe im Rahmen der Verarbeitung dieses Alarms ausführen.

Wenn API-Aufrufe als Reaktion auf einen festgelegten Alarm ausgeführt werden, ist das nicht hilfreich, da sie dazu führen, dass die API-Aufrufe mit dem Beginn der Minute synchronisiert werden, auch zwischen verschiedenen Geräten, anstatt gleichmäßig über die Zeit verteilt zu werden. Eine schlecht konzipierte Anwendung, die dies tut, erzeugt zu Beginn jeder Minute eine 60-mal höhere Traffic-Spitze.

Stattdessen wird bei einer guten Lösung ein zweiter Alarm für eine zufällig gewählte Zeit festgelegt. Wenn dieser zweite Alarm ausgelöst wird, ruft die Anwendung alle erforderlichen APIs auf und speichert die Ergebnisse. Wenn die Anzeige der Anwendung zu Beginn der Minute aktualisiert werden soll, werden zuvor gespeicherte Ergebnisse verwendet, anstatt die API noch einmal aufzurufen. Bei diesem Ansatz werden API-Aufrufe gleichmäßig über einen Zeitraum verteilt. Außerdem verzögern die API-Aufrufe das Rendering nicht, wenn die Anzeige aktualisiert wird.

Abgesehen vom Beginn der Minute sollten andere häufige Synchronisierungszeiten, die Sie nicht erreichen möchten, der Beginn einer Stunde und der Beginn jedes Tages um Mitternacht sein.

Antworten verarbeiten

In diesem Abschnitt wird gezeigt, wie diese Werte dynamisch aus Webdienstanforderungen extrahiert werden können.

Die Antworten der Google Maps-Webdienste sind leicht verständlich, aber nicht gerade nutzerfreundlich. Wenn Sie eine Abfrage durchführen, empfiehlt es sich, einige bestimmte Werte zu extrahieren, anstatt einen Datensatz anzuzeigen. Im Allgemeinen sollten Sie Antworten aus dem Webdienst parsen und nur die Werte extrahieren, die für Sie von Interesse sind.

Welches Parsing-Schema Sie verwenden, hängt davon ab, ob Sie die Ausgabe in XML oder JSON zurückgeben. JSON-Antworten liegen bereits in Form von JavaScript-Objekten vor und können auf dem Client in JavaScript verarbeitet werden. XML-Antworten sollten mit einem XML-Prozessor und einer XML-Abfragesprache verarbeitet werden, um Elemente im XML-Format zu adressieren. In den folgenden Beispielen wird XPath verwendet, da es in XML-Verarbeitungsbibliotheken häufig unterstützt wird.

XML mit XPath verarbeiten

XML ist ein relativ ausgereiftes Format für strukturierte Informationen, das für den Datenaustausch verwendet wird. XML ist zwar nicht so einfach wie JSON, bietet aber mehr Sprachunterstützung und robustere Tools. Code für die Verarbeitung von XML in Java ist beispielsweise in die javax.xml-Pakete integriert.

Bei der Verarbeitung von XML-Antworten sollten Sie eine geeignete Abfragesprache zur Auswahl von Knoten im XML-Dokument verwenden, anstatt davon auszugehen, dass sich die Elemente an absoluten Positionen innerhalb des XML-Markups befinden. XPath ist eine Sprachsyntax zur eindeutigen Beschreibung von Knoten und Elementen in einem XML-Dokument. Mit XPath-Ausdrücken können Sie bestimmte Inhalte im XML-Antwortdokument identifizieren.

XPath-Ausdrücke

Wenn Sie mit XPath bereits vertraut sind, können Sie schon bald ein robustes Parsing-Schema entwickeln. In diesem Abschnitt geht es darum, wie Elemente in einem XML-Dokument mit XPath angesprochen werden. So können Sie mehrere Elemente adressieren und komplexe Abfragen erstellen.

XPath verwendet Ausdrücke, um Elemente innerhalb eines XML-Dokuments auszuwählen. Dabei wird eine ähnliche Syntax verwendet wie für Verzeichnispfade. Diese Ausdrücke identifizieren Elemente in einer XML-Dokumentstruktur, einer hierarchischen Baumstruktur ähnlich der eines DOM. Im Allgemeinen sind XPath-Ausdrücke „gierig“. Das bedeutet, dass sie mit allen Knoten übereinstimmen, die den angegebenen Kriterien entsprechen.

Zur Veranschaulichung verwenden wir den folgenden abstrakten XML-Code:

<WebServiceResponse>
 <status>OK</status>
 <result>
  <type>sample</type>
  <name>Sample XML</name>
  <location>
   <lat>37.4217550</lat>
   <lng>-122.0846330</lng>
  </location>
 </result>
 <result>
  <message>The secret message</message>
 </result>
</WebServiceResponse>

Auswahl von Knoten in Ausdrücken

Mit der XPath-Auswahl werden Knoten ausgewählt. Der Stammknoten umfasst das gesamte Dokument. Sie wählen diesen Knoten mit dem Spezialausdruck "/" aus. Beachten Sie, dass der Stammknoten nicht der oberste Knoten Ihres XML-Dokuments ist. Tatsächlich befindet er sich eine Ebene über diesem übergeordneten Element und enthält es.

Elementknoten stellen die verschiedenen Elemente in der XML-Dokumentstruktur dar. Ein <WebServiceResponse>-Element steht beispielsweise für das Element der obersten Ebene, das im obigen Beispieldienst zurückgegeben wurde. Sie wählen einzelne Knoten entweder über absolute oder relative Pfade aus, was durch das Vorhandensein oder Fehlen eines vorangestellten „/“-Zeichens angegeben wird.

• Absoluter Pfad: Mit dem Ausdruck „/WebServiceResponse/result“ werden alle <result>-Knoten ausgewählt, die dem Knoten <WebServiceResponse> untergeordnet sind. Beide Elemente stammen vom Stammknoten „/“.
• Relativer Pfad bezogen auf den aktuellen Kontext: Mit dem Ausdruck „result“ werden alle <result>-Elemente im aktuellen Kontext gefunden. Im Allgemeinen sollten Sie sich nicht um den Kontext kümmern müssen, da Sie Webdienstergebnisse normalerweise über einen einzigen Ausdruck verarbeiten.

Jeder dieser Ausdrücke kann durch das Hinzufügen eines Platzhalterpfads erweitert werden, der durch einen doppelten Schrägstrich („//“) gekennzeichnet ist. Dieser Platzhalter gibt an, dass null oder mehr Elemente im dazwischenliegenden Pfad übereinstimmen können. Mit dem XPath-Ausdruck „//formatted_address“ werden beispielsweise alle Knoten mit diesem Namen im aktuellen Dokument abgeglichen. Mit dem Ausdruck //viewport//lat werden alle <lat>-Elemente gefunden, die <viewport> als übergeordnetes Element verfolgen können.

Standardmäßig finden XPath-Ausdrücke alle übereinstimmenden Elemente. Sie können den Ausdruck auf ein bestimmtes Element beschränken, indem Sie ein Prädikat angeben, das in eckige Klammern ([]) eingeschlossen ist. Der XPath-Ausdruck „/GeocodeResponse/result[2]“ gibt beispielsweise immer das zweite Ergebnis zurück.

    <WebServiceResponse>
     <status>OK</status>
     <result>
      <type>sample</type>
      <name>Sample XML</name>
      <location>
       <lat>37.4217550</lat>
       <lng>-122.0846330</lng>
      </location>
     </result>
     <result>
      <message>The secret message</message>
     </result>
    </WebServiceResponse>
    

    <result>
     <type>sample</type>
     <name>Sample XML</name>
     <location>
      <lat>37.4217550</lat>
      <lng>-122.0846330</lng>
     </location>
    </result>
    <result>
     <message>The secret message</message>
    </result>
    

    <location>
     <lat>37.4217550</lat>
     <lng>-122.0846330</lng>
    </location>
    

    <message>The secret message</message>
    

     <type>sample</type>
     <name>Sample XML</name>
     <location>
      <lat>37.4217550</lat>
      <lng>-122.0846330</lng>
     </location>
    

    Sample XML
    

Wichtig: Wenn Sie Elemente auswählen, wählen Sie Knoten aus, nicht nur den Text in diesen Objekten. Im Allgemeinen sollten Sie alle übereinstimmenden Knoten durchlaufen und den Text extrahieren. Sie können Textknoten auch direkt abgleichen. Siehe Textknoten unten.

XPath unterstützt auch Attributknoten. Da jedoch alle Google Maps-Webdienste Elemente ohne Attribute bereitstellen, ist ein Abgleich von Attributen nicht erforderlich.

Auswahl von Text in Ausdrücken

Text innerhalb eines XML-Dokuments wird in XPath-Ausdrücken über einen Textknoten-Operator angegeben. Der Operator „text()“ gibt an, dass Text aus dem angegebenen Knoten extrahiert werden soll. Mit dem XPath-Ausdruck „//formatted_address/text()“ wird beispielsweise der gesamte Text in den <formatted_address>-Elementen zurückgegeben.

    sample
    Sample XML

    37.4217550
    -122.0846330
    The secret message
    

    The secret message
    

    Sample XML
    

Alternativ können Sie einen Ausdruck evaluieren, eine Gruppe von Knoten zurückgeben, diese "Knotengruppe" durchlaufen und dabei den Text aus jedem Knoten extrahieren. Dieser Ansatz wird im folgenden Beispiel dargestellt:

Weitere Informationen zu XPath finden Sie in der XPath-W3C-Spezifikation.

XPath in Java auswerten

Java bietet innerhalb des javax.xml.xpath.*-Pakets umfassende Unterstützung für das Parsen von XML und die Verwendung von XPath-Ausdrücken. Aus diesem Grund wird im Beispielcode in diesem Abschnitt Java verwendet, um zu veranschaulichen, wie XML verarbeitet und Daten aus XML-Dienstantworten geparst werden.

Wenn Sie XPath in Ihrem Java-Code verwenden möchten, müssen Sie zuerst eine Instanz eines XPathFactory instanziieren und in dieser Factory newXPath() aufrufen, um ein XPath -Objekt zu erstellen. Dieses Objekt kann dann übergebene XML- und XPath-Ausdrücke mit der Methode evaluate() verarbeiten.

Achten Sie bei der Auswertung von XPath-Ausdrücken darauf, alle möglichen „Knotengruppen“ zu durchlaufen, die zurückgegeben werden können. Da diese Ergebnisse im Java-Code als DOM-Knoten zurückgegeben werden, sollten Sie mehrere Werte in einem NodeList-Objekt erfassen und über dieses Objekt iterieren, um Text oder Werte aus diesen Knoten zu extrahieren.

Der folgende Code zeigt, wie Sie ein XPath-Objekt erstellen, ihm XML und einen XPath-Ausdruck zuweisen und den Ausdruck evaluieren, um den relevanten Inhalt auszugeben.

import org.xml.sax.InputSource;
import org.w3c.dom.*;
import javax.xml.xpath.*;
import java.io.*;

public class SimpleParser {

  public static void main(String[] args) throws IOException {

	XPathFactory factory = XPathFactory.newInstance();

    XPath xpath = factory.newXPath();

    try {
      System.out.print("Web Service Parser 1.0\n");

      // In practice, you'd retrieve your XML via an HTTP request.
      // Here we simply access an existing file.
      File xmlFile = new File("XML_FILE");

      // The xpath evaluator requires the XML be in the format of an InputSource
	  InputSource inputXml = new InputSource(new FileInputStream(xmlFile));

      // Because the evaluator may return multiple entries, we specify that the expression
      // return a NODESET and place the result in a NodeList.
      NodeList nodes = (NodeList) xpath.evaluate("XPATH_EXPRESSION", inputXml, XPathConstants.NODESET);

      // We can then iterate over the NodeList and extract the content via getTextContent().
      // NOTE: this will only return text for element nodes at the returned context.
      for (int i = 0, n = nodes.getLength(); i < n; i++) {
        String nodeString = nodes.item(i).getTextContent();
        System.out.print(nodeString);
        System.out.print("\n");
      }
    } catch (XPathExpressionException ex) {
	  System.out.print("XPath Error");
    } catch (FileNotFoundException ex) {
      System.out.print("File Error");
    }
  }
}