Google Maps APIs-Webdienste

Die Google Maps-Webdienste sind eine Sammlung von HTTP-Schnittstellen zu Google-Diensten, die geografische Daten für Ihre Maps-Anwendungen bereitstellen. Dieser Leitfaden bietet lediglich eine Einführung in Webdienste und Informationen, die allen Diensten gemein sind. Über die folgenden Links gelangen Sie zur detaillierten Dokumentation für jeden Dienst:

Die gewünschte API finden

Wenn Sie herausfinden möchten, welche die richtige API für Ihr Projekt ist, verwenden Sie die API-Auswahl.

Weitere Infos über Webdienste

Im verbleibenden Teil dieses Leitfadens werden Techniken zum Einrichten von Webdienstanforderungen und Parsen von Antworten erörtert. Genaue Anleitungen für jeden der Webdienste finden Sie in der entsprechenden Dokumentation.

Was ist ein Webdienst?

Die Google Maps API stellt die folgenden Webdienste als Schnittstellen zur Verfügung, damit Sie Maps API-Daten von externen Diensten anfordern und diese in Ihren Maps-Anwendungen verwenden können. Gemäß den Nutzungsbedingungen und Lizenzbeschränkungen für Maps API sind diese Dienste für die Verwendung in Verbindung mit Karten bestimmt.

Die Webdienste verwenden HTTP-Anforderungen an bestimmte URLs, die URL-Parameter als Argumente an die Dienste übergeben. Im Allgemeinen werden Daten in der HTTP-Anforderung von den Diensten als JSON oder XML zurückgegeben, und können dann von der Anwendung geparst bzw. verarbeitet werden.

Eine typische Webdienstanforderung hat normalerweise folgende Form:

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

wobei service den jeweils angeforderten Dienst und output das Antwortformat (meist json oder xml) angibt.

Die vollständige Dokumentation für jeden Dienst finden Sie in den jeweiligen Entwicklerleitfäden. In diesem Leitfaden werden einige für alle Webdienste übliche Verfahrensweisen beschrieben, die für die Einrichtung von Webdienstanforderungen und Verarbeitung der Webdienstantworten hilfreich sein können.

SSL-Zugriff

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

HTTPS ist für alle Maps API-Webdienstanforderungen erforderlich, die Nutzerdaten oder Entwickler-IDs enthalten. Über HTTP durchgeführte Anforderungen, die vertrauliche Daten enthalten, werden möglicherweise abgelehnt.

Eine gültige URL erstellen

Dass eine URL gültig ist, erscheint selbstverständlich, doch müssen dafür bestimmte Voraussetzungen erfüllt sein. Wird eine URL z. B. in die Adressleiste des Browsers eingegeben, so kann sie Sonderzeichen enthalten (bspw. "上海+中國"). Der Browser muss diese vor der Übertragung intern in eine andere Codierung übersetzen. Ebenso können URLs mit UTF-8-Zeichen durch Code, der UTF-8-Eingaben generiert oder zulässt, als „gültig“ betrachtet werden, während es trotzdem weiterhin erforderlich ist, diese Zeichen zu übersetzen, bevor sie an einen Webserver gesendet werden. Dieser Prozess wird als URL-Codierung bezeichnet.

Sonderzeichen müssen übersetzt werden, da alle URLs die in der URI-Spezifikation des W3 bestimmte Syntax aufweisen müssen. Dies bedeutet, dass URLs nur einen Teil der ASCII-Zeichen enthalten dürfen: die bekannten alphanumerischen Symbole und einige weitere Zeichen, die in den URLs als Steuerzeichen dienen. Die folgende Tabelle bietet eine Übersicht über diese Zeichen:

Gültige URL-Zeichen
ZeichensatzZeichenVerwendung in der URL
Alphanumerisch a b c d e f g h i j k l m n o p q r s t u v w x y z A B C D E F G H I J K L M N O P Q R S T U V W X Y Z 0 1 2 3 4 5 6 7 8 9 Text, Schemas (http), Ports (8080) usw.
Nicht reserviert - _ . ~ Text
Reserviert ! * ' ( ) ; : @ & = + $ , / ? % # [ ] Steuerzeichen und/oder Text

Um eine gültige URL zu erstellen, müssen Sie sicherstellen, dass sie nur die genannten Zeichen enthält. Dabei können Sie auf zwei Probleme stoßen:

  • Die Zeichen, die verarbeitet werden sollen, gehören nicht zu den Zeichen aus obiger Tabelle. So müssen bspw. Zeichen in bestimmten Sprachen wie 上海+中國 mithilfe der genannten Zeichen codiert werden. Leerzeichen sind in URLs nicht erlaubt und werden daher oft mithilfe des Zeichens '+' wiedergegeben.
  • Die Zeichen gehören zu obigen reservierten Zeichen, Sie möchten sie jedoch in ihrer eigentlichen Bedeutung verwenden. So wird ? in URLs für den Beginn einer Abfragezeichenfolge verwendet. Möchten Sie es stattdessen für den Text „? and the Mysterians“ verwenden, müssen Sie das Zeichen '?' codieren.

Alle Zeichen, die als URL codiert werden sollen, werden mithilfe des Zeichens '%' und einem Hexadezimalwert aus zwei Zeichen, der ihrem UTF-8-Zeichen entspricht, codiert. So wird 上海+中國 in UTF-8 folgendermaßen als URL codiert: %E4%B8%8A%E6%B5%B7%2B%E4%B8%AD%E5%9C%8B. Die Zeichenfolge ? and the Mysterians wird wie folgt als URL codiert: %3F+and+the+Mysterians.

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

Unsicheres Zeichen Codierter Wert
Leerzeichen %20
" %22
< %3C
> %3E
# %23
% %25
| %7C

Das Konvertieren von Benutzereingaben in URLs kann schwierig sein. Beispielsweise kann ein Benutzer eine Adresse als „5th&Main St.“ eingeben. Im Allgemeinen sollten Sie die URL aus ihren Teilen erstellen und jede Benutzereingabe wortwörtlich betrachten.

Hinzu kommt, dass URLs für alle Webdienste auf 8192 Zeichen beschränkt sind. Bei den meisten Diensten wird diese Begrenzung selten erreicht. Beachten Sie jedoch, dass einige Dienste verschiedene Parameter aufweisen, 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 Server von Google stärker als notwendig belasten. Dieser Abschnitt enthält einige bewährte Methoden für Kunden der APIs. Mithilfe dieser bewährten Methoden können Sie verhindern, dass Ihre Anwendung aufgrund von unbeabsichtigtem Missbrauch der APIs gesperrt wird.

Exponentieller Backoff

In seltenen Fällen können bei der Verarbeitung Ihrer Anforderung Fehler auftreten. Sie erhalten möglicherweise einen HTTP-Antwortcode vom Typ 4XX oder 5XX oder die TCP-Verbindung zwischen Ihrem Client und einem Google-Server fällt aus. Häufig lohnt es sich, die Anforderung erneut durchzuführen, da die zweite Anforderung möglicherweise erfolgreich ist, wenn die ursprüngliche Anforderung fehlgeschlagen ist. Es ist jedoch wichtig, nicht einfach wiederholt in Form einer Endlosschleife immer wieder Anforderungen an die Google-Server zu senden. Durch dieses Verhalten kann das Netzwerk zwischen Ihrem Client und Google überlastet werden, was zu Problemen für viele Beteiligte führen kann.

Ein besserer Ansatz ist es, wiederholte Versuche in immer größeren Abständen durchzuführen. Die Verzögerung wird in der Regel bei jedem Versuch mithilfe eines multiplikativen Faktors erhöht. Dieser Ansatz wird auch als Exponentieller Backoff bezeichnet.

Angenommen, eine Anwendung möchte die folgende Anforderung bei der Google Maps Time Zone API durchführen:

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
import urllib2

def timezone(lat, lng, timestamp):
    # 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
    maps_key = 'YOUR_KEY_HERE'
    timezone_base_url = 'https://maps.googleapis.com/maps/api/timezone/json'

    # This joins the parts of the URL together into one string.
    url = timezone_base_url + '?' + urllib.urlencode({
        'location': "%s,%s" % (lat, lng),
        'timestamp': timestamp,
        'key': maps_key,
    })

    current_delay = 0.1  # Set the initial retry delay to 100ms.
    max_delay = 3600  # Set the maximum retry delay to 1 hour.

    while True:
        try:
            # Get the API response.
            response = str(urllib2.urlopen(url).read())
        except IOError:
            pass  # Fall through to the retry loop.
        else:
            # If we didn't get an IOError then parse the result.
            result = json.loads(response.replace('\\n', ''))
            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.

tz = timezone(39.6034810, -119.6822510, 1331161200)
print 'Timezone:', tz

Darüber hinaus sollten Sie sorgfältig darauf achten, dass an höherer Stelle in der Aufrufkette der Anwendung kein Wiederholungscode vorhanden ist, der in schneller Abfolge zu wiederholten Anforderungen führt.

Synchronisierte Anforderungen

Eine große Anzahl synchronisierter Anforderungen an die Google-APIs kann den Eindruck erwecken, dass es sich um DDoS-Angriffe (Distributed Denial of Service) auf die Infrastruktur von Google handelt, und wird entsprechend behandelt. Um dies zu verhindern, sollten Sie sicherstellen, dass API-Anforderungen nicht zwischen Clients synchronisiert werden.

Angenommen, eine Anwendung zeigt die Zeit in der aktuellen Zeitzone an. Diese Anwendung richtet wahrscheinlich einen Alarm im Betriebssystem des Clients ein, über den das Betriebssystem zu Beginn der Minute aktiviert wird, sodass die angezeigte Zeit aktualisiert werden kann. Die Anwendung sollte keine API-Aufrufe im Rahmen der Verarbeitungsschritte in Verbindung mit diesem Alarm durchführen.

Die Durchführung von API-Aufrufen als Reaktion auf einen festgelegten Alarm ist nicht sinnvoll, da dies zur Folge hat, dass API-Aufrufe selbst zwischen Geräten zu Beginn der Minute synchronisiert werden, statt gleichmäßig über einen längeren Zeitraum verteilt zu werden. Eine schlecht konzipierte Anwendung, die entsprechend verfährt, produziert zu Beginn jeder Minute eine 60 mal höhere Spitzenlast als üblich.

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 benötigten APIs auf und speichert die Ergebnisse. Wenn die Anzeige der Anwendung zu Beginn der Minute aktualisiert werden soll, werden hierfür zuvor gespeicherte Ergebnisse verwendet, statt die API erneut aufzurufen. Bei dieser Vorgehensweise werden API-Aufrufe gleichmäßig über eine Zeitspanne hinweg verteilt. Darüber hinaus wird die Wiedergabe durch die API-Aufrufe nicht verzögert, wenn die Anzeige aktualisiert wird.

Abgesehen vom Beginn der Minute sollten Sie auch die folgenden üblichen Synchronisierungszeiten möglichst nicht verwenden: den Beginn einer Stunde und den Beginn jedes Tages um Mitternacht.

Antworten verarbeiten

Da das genaue Format der einzelnen Antworten bei Webdienstanforderungen nicht garantiert ist (einige Elemente können fehlen oder sich an mehreren Orten befinden), sollten Sie nicht davon ausgehen, dass das für eine Antwort zurückgegebene Format bei allen Abfragen gleich ist. Daher sollten Sie die Antwort verarbeiten und die jeweiligen Werte mithilfe von Ausdrücken auswählen. In diesem Abschnitt wird gezeigt, wie diese Werte dynamisch aus Webdienstanforderungen extrahiert werden können.

Die Google Maps-Webdienste bieten Antworten, die leicht verständlich, aber nicht unbedingt benutzerfreundlich sind. Wenn Sie eine Abfrage durchführen, möchten Sie möglicherweise bestimmte Werte extrahieren, anstatt einen Satz Daten anzuzeigen. Grundsätzlich sollten Sie Antworten aus dem Webdienst parsen und nur die Werte extrahieren, die Sie interessieren.

Welches Parsingschema Sie verwenden, hängt davon ab, ob die Ausgabe in XML oder JSON erfolgt. JSON-Antworten haben bereits die Form von JavaScript-Objekten und können daher in JavaScript im Client verarbeitet werden. XML-Antworten sollten mit XML-Prozessor und XML-Abfragesprache verarbeitet werden, um Elemente im XML-Format zu adressieren. In den folgenden Beispielen wird XPath verwendet, da dieses in XML verarbeitenden Bibliotheken allgemein unterstützt wird.

XML mit XPath verarbeiten

XML ist ein relativ ausgereiftes Format für strukturierte Informationen, das für den Datenaustausch verwendet wird. Zwar ist es nicht so einfach wie JSON, unterstützt aber mehr Sprachen und bietet robustere Tools. Code zur Verarbeitung von XML in Java ist bspw. in die Pakete javax.xml integriert.

Wenn Sie XML-Antworten verarbeiten, sollten Sie eine geeignete Abfragesprache zur Auswahl von Knoten im XML-Dokument verwenden, anstatt davon auszugehen, dass sich die Elemente an absoluten Positionen im XML-Markup befinden. XPath ist eine Sprachsyntax zur eindeutigen Beschreibung von Knoten und Elementen in einem XML-Dokument. XPath-Ausdrücke ermöglichen es Ihnen, bestimmte Inhalte im XML-Antwortdokument zu identifizieren.

XPath-Ausdrücke

Etwas Kenntnis von XPath genügt, um ein robustes Parsingschema zu entwickeln. In diesem Abschnitt wird betrachtet, wie Elemente in einem XML-Dokument mit XPath adressiert werden, sodass Sie mehrere Elemente bearbeiten und komplexe Abfragen erstellen können.

XPath verwendet zur Auswahl von Elementen in einem XML-Dokument Ausdrücke und verwendet dafür eine Syntax, die der für Verzeichnispfade ähnelt. Diese Ausdrücke identifizieren die Elemente in der XML-Dokumentstruktur, einer hierarchischen Struktur ähnlich wie der eines DOM. XPath-Ausdrücke sind gierig, d. h., es werden alle Knoten gefunden, die die angegebenen Kriterien aufweisen.

Zur Veranschaulichung verwenden wir die folgende abstrakte XML:

<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

Die XPath-Auswahl wählt Knoten aus. Der Stammknoten umfasst das gesamte Dokument. Die Auswahl dieses Knotens erfolgt mithilfe des speziellen Ausdrucks "/". Beachten Sie, dass der Stammknoten nicht der oberste Knoten des XML-Dokuments ist. Er befindet sich eine Ebene über diesem obersten Element und beinhaltet dieses.

Elementknoten stellen die verschiedenen Elemente in der XML-Dokumentstruktur dar. So stellt das Element <WebServiceResponse> bspw. das oberste Element dar, das im obigen Beispieldienst zurückgegeben wird. Die einzelnen Knoten werden über absolute oder relative Pfade ausgewählt, die durch Vorhandensein oder Fehlen eines führenden „/“ angegeben werden.

  • Absoluter Pfad: Der Ausdruck "/WebServiceResponse/result" wählt alle Knoten <result> aus, die dem Knoten <WebServiceResponse> untergeordnet sind. (Beachten Sie, dass beide Elemente vom Stammknoten „/“ abgeleitet sind.)
  • Relativer Pfad im aktuellen Kontext: Der Ausdruck „result“ würde alle Elemente <result> im aktuellen Kontext finden. Über den Kontext müssen Sie sich normalerweise keine Gedanken machen, da Sie Webdienstergebnisse über einen einzigen Ausdruck verarbeiten.

Jeder dieser Ausdrücke kann durch Hinzufügen eines Platzhalterpfads („//“) erweitert werden. Der Platzhalter gibt an, dass null oder mehr Elemente im dazwischenliegenden Pfad übereinstimmen können. So findet der XPath-Ausdruck „//formatted_address“ bspw. alle Knoten mit diesem Namen im aktuellen Dokument. Der Ausdruck //viewport//lat findet alle Elemente <lat> mit dem übergeordneten Element <viewport>.

Standardmäßig finden XPath-Ausdrücke alle übereinstimmenden Elemente. Wenn nur ein bestimmtes Element gefunden werden soll, können Sie den Ausdruck mithilfe eines Prädikats in eckigen Klammern ([]) einschränken. So gibt der XPath-Ausdruck „/GeocodeResponse/result[2]“ stets das zweite Ergebnis zurück.

Ausdruckstyp
Stammknoten
XPath-Ausdruck:  "/"
Auswahl:
    <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>
    
Absoluter Pfad
XPath-Ausdruck:  "/WebServiceResponse/result"
Auswahl:
    <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>
    
Pfad mit Platzhalter
XPath-Ausdruck:  "/WebServiceResponse//location"
Auswahl:
    <location>
     <lat>37.4217550</lat>
     <lng>-122.0846330</lng>
    </location>
    
Pfad mit Prädikat
XPath-Ausdruck:  "/WebServiceResponse/result[2]/message"
Auswahl:
    <message>The secret message</message>
    
Alle direkt untergeordneten Elemente des ersten result
XPath-Ausdruck:  "/WebServiceResponse/result[1]/*"
Auswahl:
     <type>sample</type>
     <name>Sample XML</name>
     <location>
      <lat>37.4217550</lat>
      <lng>-122.0846330</lng>
     </location>
    
Der name eines result mit „sample“ als Text des type.
XPath-Ausdruck:  "/WebServiceResponse/result[type/text()='sample']/name"
Auswahl:
    Sample XML
    

Beachten Sie, dass Sie beim Auswählen von Elementen nicht nur den Text in den Objekten, sondern Knoten auswählen. Grundsätzlich sollten Sie alle gefundenen Knoten durchlaufen und den Text extrahieren. Sie können die Textknoten auch direkt abgleichen. Mehr Informationen dazu enthält der Abschnitt Textknoten weiter unten.

XPath unterstützt auch Attributknoten; die Webdienste von Google Maps verarbeiten jedoch Elemente ohne Attribute, weshalb der Abgleich von Attributen nicht erforderlich ist.

Auswahl von Text in Ausdrücken

Text in einem XML-Dokument wird in XPath-Ausdrücken mithilfe des Textknoten-Operators angegeben. Der Operator „text()“ gibt an, dass Text aus dem angegebenen Knoten extrahiert wird. So gibt bspw. der XPath-Ausdruck „//formatted_address/text()“ den gesamten Text in den Elementen <formatted_address> zurück.

Ausdruckstyp
Alle Textknoten (einschl. Leerzeichen)
XPath-Ausdruck:  "//text()"
Auswahl:
    sample
    Sample XML

    37.4217550
    -122.0846330
    The secret message
    
Textauswahl
XPath-Ausdruck:  "/WebServiceRequest/result[2]/message/text()"
Auswahl:
    The secret message
    
Kontextbezogene Auswahl
XPath-Ausdruck:  "/WebServiceRequest/result[type/text() = 'sample']/name/text()"
Auswahl:
    Sample XML
    

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

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

Auswerten von XPath in Java

Java bietet im Paket javax.xml.xpath.* umfassende Unterstützung für das Parsen von XML und die Verwendung von XPath-Ausdrücken. Daher wird im Beispielcode in diesem Abschnitt Java verwendet, um die Verarbeitung von XML und das Parsen von Daten aus XML-Dienstantworten zu veranschaulichen.

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

Stellen Sie beim Auswerten von XPath-Ausdrücken sicher, dass Sie alle „Knotengruppen“ durchlaufen, die zurückgegeben werden. Da diese Ergebnisse als DOM-Knoten in Java-Code zurückgegeben werden, sollten Sie solche mehrfachen Werte in einem Objekt NodeList erfassen und es durchlaufen, um Text oder Werte aus den Knoten zu extrahieren.

Im nachfolgenden Codebeispiel wird dargestellt, wie Sie das Objekt XPath erstellen, ihm XML und einen XPath-Ausdruck zuweisen und den Ausdruck auswerten, um dann relevante Inhalte 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");
    }
  }
}

Laden Sie den Code von js-v2-samples herunter.

JSON mit JavaScript verarbeiten

Der Vorteil von JSON (Javascript Object Notation) gegenüber XML besteht in den einfachen Antworten. Das Parsen eines solchen Ergebnisses in JavaScript ist ein Kinderspiel, da das Format bereits ein gültiges JavaScript-Objekt ist. Wenn Sie bspw. den Wert der Schlüssel 'formatted_address' in einem JSON-Ergebnisobjekt extrahieren möchten, greifen Sie einfach mithilfe des folgenden Codes auf sie zu:

for (i = 0; i < myJSONResult.results.length; i++) {
  myAddress[i] = myJSONResult.results[i].formatted_address;
}

Beachten Sie, dass JSON mehrere Werte enthalten kann und Sie deshalb das gesamte Array results durchlaufen sollten, um alle Werte zu erfassen. In der Praxis kann es aber empfehlenswert sein, nur das erste Ergebnis (results[0]) zurückzugeben.

Das Parsen von JSON in anderen Sprachen ist nur etwas schwieriger. Im folgenden Beispiel mit Python wird eine Webdienstanforderung zum Geocoding initiiert und dem Nutzer werden alle erhaltenen Werte vom Typ formatted_address in einem Array angezeigt:

import simplejson, urllib

GEOCODE_BASE_URL = 'https://maps.googleapis.com/maps/api/geocode/json'

def geocode(address, **geo_args):
    geo_args.update({
        'address': address
    })

    url = GEOCODE_BASE_URL + '?' + urllib.urlencode(geo_args)
    result = simplejson.load(urllib.urlopen(url))

    print simplejson.dumps([s['formatted_address'] for s in result['results']], indent=2)

if __name__ == '__main__':
    geocode(address="San+Francisco")

Output: [ "San Francisco, CA, USA" ]

Laden Sie den Code von js-v2-samples herunter.

Der Parameter sensor

Bisher war in der Google Maps API die Angabe des Parameters sensor erforderlich. Damit wurde festgelegt, ob seitens der Anwendung ein Sensor zur Ermittlung des Benutzerstandorts verwendet wurde. Dieser Parameter wird nicht mehr benötigt.

Feedback geben zu...

Google Maps Web Service APIs
Google Maps Web Service APIs