Sie können eine Route mithilfe der Routes API abrufen. Dazu senden Sie eine HTTP-POST-Anfrage an die Methode computeRoutes (REST) oder rufen die Methode ComputeRoutes (gRPC) auf.
Das folgende Beispiel zeigt die URL einer REST-Anfrage an die Methode computeRoutes
:
https://routes.googleapis.com/directions/v2:computeRoutes
Fügen Sie Ihre Anfrageoptionen in den JSON-Anfragetext ein. Der Anfragetext enthält die Quell- und Zielorte sowie alle Optionen, die Sie für die Route festlegen möchten. Weitere Informationen finden Sie unter Standorte festlegen und Verfügbare Routenoptionen.
Die Antwort enthält die Felder, die Sie in der Antwortfeldmaske mit dem URL-Parameter $fields
oder mit field
mit dem HTTP-gRPC-Header X-Goog-FieldMask
angegeben haben. Weitere Informationen finden Sie unter Auswählen, welche Informationen zurückgegeben werden sollen.
Ein Beispiel für eine Routenanfrage für öffentliche Verkehrsmittel finden Sie unter Beispiel: Route für öffentliche Verkehrsmittel abrufen.
Beispiel: HTTP-Routenanfrage
Der folgende Code zeigt, wie Sie einen Anfragetext für eine computeRoutes-Anfrage erstellen. In diesem Beispiel legen Sie den Quell- und den Zielort fest und geben außerdem Folgendes an:
Ein
travelMode
vonDRIVE
und eine Route, bei der die Verkehrslage berücksichtigt wird.Eine festgelegte Abfahrtszeit.
Die Sprache
en-US
mitimperial
Entfernungseinheiten.Eine Antwortfeldmaske im
X-Goog-FieldMask
-Header, die angibt, dass in der Antwort die folgenden Felder zurückgegeben werden:routes.duration
routes.distanceMeters
routes.polyline.encodedPolyline
curl -X POST -d '{ "origin":{ "location":{ "latLng":{ "latitude": 37.419734, "longitude": -122.0827784 } } }, "destination":{ "location":{ "latLng":{ "latitude": 37.417670, "longitude": -122.079595 } } }, "travelMode": "DRIVE", "routingPreference": "TRAFFIC_AWARE", "departureTime": "2023-10-15T15:01:23.045123456Z", "computeAlternativeRoutes": false, "routeModifiers": { "avoidTolls": false, "avoidHighways": false, "avoidFerries": false }, "languageCode": "en-US", "units": "IMPERIAL" }' \ -H 'Content-Type: application/json' -H 'X-Goog-Api-Key: YOUR_API_KEY' \ -H 'X-Goog-FieldMask: routes.duration,routes.distanceMeters,routes.polyline.encodedPolyline' \ 'https://routes.googleapis.com/directions/v2:computeRoutes'
Beispiel: Antworttext der HTTP-Route
Der obige Aufruf generiert die folgende JSON-Antwort:
{ "routes": [ { "distanceMeters": 772, "duration": "165s", "polyline": { "encodedPolyline": "ipkcFfichVnP@j@BLoFVwM{E?" } } ] }
Beispiel: gRPC-Anfrage
gRPC ist ein von Google entwickeltes leistungsstarkes, universelles Open-Source-RPC-Framework. In gRPC kann eine Clientanwendung direkt Methoden in einer Serveranwendung auf einem anderen Computer aufrufen, als wäre sie ein lokales Objekt.
Im Folgenden sehen Sie eine Beispiel-gRPC-Anfrage.
Ok
package main import ( "context" "crypto/tls" "fmt" "log" "time" routespb "google.golang.org/genproto/googleapis/maps/routing/v2" "google.golang.org/genproto/googleapis/type/latlng" "google.golang.org/grpc" "google.golang.org/grpc/credentials" "google.golang.org/grpc/metadata" ) const ( fieldMask = "*" apiKey = "INSERT_API_KEY_HERE" serverAddr = "routes.googleapis.com:443" ) func main() { config := tls.Config{} conn, err := grpc.Dial(serverAddr, grpc.WithTransportCredentials(credentials.NewTLS(&config))) if err != nil { log.Fatalf("Failed to connect: %v", err) } defer conn.Close() client := routespb.NewRoutesClient(conn) ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second) ctx = metadata.AppendToOutgoingContext(ctx, "X-Goog-Api-Key", apiKey) ctx = metadata.AppendToOutgoingContext(ctx, "X-Goog-Fieldmask", fieldMask) defer cancel() // create the origin using a latitude and longitude origin := &routespb.Waypoint{ LocationType: &routespb.Waypoint_Location{ Location: &routespb.Location{ LatLng: &latlng.LatLng{ Latitude: 37.417670, Longitude: -122.0827784, }, }, }, } // create the destination using a latitude and longitude destination := &routespb.Waypoint{ LocationType: &routespb.Waypoint_Location{ Location: &routespb.Location{ LatLng: &latlng.LatLng{ Latitude: 37.417670, Longitude: -122.079595, }, }, }, } req := &routespb.ComputeRoutesRequest{ Origin: origin, Destination: destination, TravelMode: routespb.RouteTravelMode_DRIVE, RoutingPreference: routespb.RoutingPreference_TRAFFIC_AWARE, ComputeAlternativeRoutes: true, Units: routespb.Units_METRIC, RouteModifiers: &routespb.RouteModifiers{ AvoidTolls: false, AvoidHighways: true, AvoidFerries: true, }, PolylineQuality: routespb.PolylineQuality_OVERVIEW, } // execute rpc resp, err := client.ComputeRoutes(ctx, req) if err != nil { // "rpc error: code = InvalidArgument desc = Request contains an invalid // argument" may indicate that your project lacks access to Routes log.Fatal(err) } fmt.Printf("Response: %v", resp) }
Java
package com.example; import com.google.maps.routing.v2.*; import com.google.type.LatLng; import io.grpc.CallOptions; import io.grpc.Channel; import io.grpc.ClientCall; import io.grpc.ClientInterceptor; import io.grpc.ClientInterceptors; import io.grpc.ForwardingClientCall; import io.grpc.Metadata; import io.grpc.MethodDescriptor; import io.grpc.StatusRuntimeException; import io.grpc.netty.NettyChannelBuilder; import java.util.Iterator; import java.util.concurrent.TimeUnit; import java.util.logging.Level; import java.util.logging.Logger; public class RoutesClient { // For more detail on inserting API keys, see: // https://cloud.google.com/endpoints/docs/grpc/restricting-api-access-with-api-keys#java // For more detail on system parameters (such as FieldMask), see: // https://cloud.google.com/apis/docs/system-parameters private static final class RoutesInterceptor implements ClientInterceptor { private final String apiKey; private static final Logger logger = Logger.getLogger(RoutesInterceptor.class.getName()); private static Metadata.KeyAPI_KEY_HEADER = Metadata.Key.of("x-goog-api-key", Metadata.ASCII_STRING_MARSHALLER); private static Metadata.Key FIELD_MASK_HEADER = Metadata.Key.of("x-goog-fieldmask", Metadata.ASCII_STRING_MARSHALLER); public RoutesInterceptor(String apiKey) { this.apiKey = apiKey; } @Override public ClientCall interceptCall(MethodDescriptor method, CallOptions callOptions, Channel next) { logger.info("Intercepted " + method.getFullMethodName()); ClientCall call = next.newCall(method, callOptions); call = new ForwardingClientCall.SimpleForwardingClientCall (call) { @Override public void start(Listener responseListener, Metadata headers) { headers.put(API_KEY_HEADER, apiKey); // Note that setting the field mask to * is OK for testing, but discouraged in // production. // For example, for ComputeRoutes, set the field mask to // "routes.distanceMeters,routes.duration,routes.polyline.encodedPolyline" // in order to get the route distances, durations, and encoded polylines. headers.put(FIELD_MASK_HEADER, "*"); super.start(responseListener, headers); } }; return call; } } private static final Logger logger = Logger.getLogger(RoutesClient.class.getName()); private final RoutesGrpc.RoutesBlockingStub blockingStub; public RoutesClient(Channel channel) { blockingStub = RoutesGrpc.newBlockingStub(channel); } public static Waypoint createWaypointForLatLng(double lat, double lng) { return Waypoint.newBuilder() .setLocation(Location.newBuilder().setLatLng(LatLng.newBuilder().setLatitude(lat).setLongitude(lng))) .build(); } public void computeRoutes() { ComputeRoutesRequest request = ComputeRoutesRequest.newBuilder() .setOrigin(createWaypointForLatLng(37.420761, -122.081356)) .setDestination(createWaypointForLatLng(37.420999, -122.086894)).setTravelMode(RouteTravelMode.DRIVE) .setRoutingPreference(RoutingPreference.TRAFFIC_AWARE).setComputeAlternativeRoutes(true) .setRouteModifiers( RouteModifiers.newBuilder().setAvoidTolls(false).setAvoidHighways(true).setAvoidFerries(true)) .setPolylineQuality(PolylineQuality.OVERVIEW).build(); ComputeRoutesResponse response; try { logger.info("About to send request: " + request.toString()); response = blockingStub.withDeadlineAfter(2000, TimeUnit.MILLISECONDS).computeRoutes(request); } catch (StatusRuntimeException e) { logger.log(Level.WARNING, "RPC failed: {0}", e.getStatus()); return; } logger.info("Response: " + response.toString()); } public void computeRouteMatrix() { ComputeRouteMatrixRequest request = ComputeRouteMatrixRequest.newBuilder() .addOrigins(RouteMatrixOrigin.newBuilder().setWaypoint(createWaypointForLatLng(37.420761, -122.081356)) .setRouteModifiers(RouteModifiers.newBuilder().setAvoidTolls(false).setAvoidHighways(true) .setAvoidFerries(true))) .addOrigins(RouteMatrixOrigin.newBuilder().setWaypoint(createWaypointForLatLng(37.403184, -122.097371))) .addDestinations(RouteMatrixDestination.newBuilder() .setWaypoint(createWaypointForLatLng(37.420999, -122.086894))) .addDestinations(RouteMatrixDestination.newBuilder() .setWaypoint(createWaypointForLatLng(37.383047, -122.044651))) .setTravelMode(RouteTravelMode.DRIVE).setRoutingPreference(RoutingPreference.TRAFFIC_AWARE).build(); Iterator elements; try { logger.info("About to send request: " + request.toString()); elements = blockingStub.withDeadlineAfter(2000, TimeUnit.MILLISECONDS).computeRouteMatrix(request); } catch (StatusRuntimeException e) { logger.log(Level.WARNING, "RPC failed: {0}", e.getStatus()); return; } while (elements.hasNext()) { logger.info("Element response: " + elements.next().toString()); } } public static void main(String[] args) throws Exception { String apiKey = System.getenv("INSERT_API_KEY_HERE"); // The standard TLS port is 443 Channel channel = NettyChannelBuilder.forAddress("routes.googleapis.com", 443).build(); channel = ClientInterceptors.intercept(channel, new RoutesInterceptor(apiKey)); RoutesClient client = new RoutesClient(channel); client.computeRoutes(); client.computeRouteMatrix(); } }
C#
Ein Beispiel für C# finden Sie unter Google.Maps.Routing.V2.
Node.js
const protoPath = "YOUR_PROTO_PATH"; const grpc = require("@grpc/grpc-js"); const protoLoader = require("@grpc/proto-loader"); const packageDefinition = protoLoader.loadSync(protoPath, { keepCase: true, longs: String, enums: String, defaults: true, oneofs: true, }); const protoDescriptor = grpc.loadPackageDefinition(packageDefinition).google.maps.routing.v2; const metadata = new grpc.Metadata(); const host = "routes.googleapis.com:443"; const apiKey = "YOUR_API_KEY"; const fieldMask = "*"; let ComputeRoutesRequest = { origin: { location: { lat_lng: { latitude: -37.816, longitude: 144.964, }, }, }, destination: { location: { lat_lng: { latitude: -37.815, longitude: 144.966, }, }, }, routing_preference: "TRAFFIC_AWARE", travel_mode: "DRIVE", }; const ssl_creds = grpc.credentials.createSsl(); const call_creds = grpc.credentials.createFromMetadataGenerator( function (args, callback) { metadata.set("X-Goog-Api-Key", apiKey); metadata.set("X-Goog-Fieldmask", fieldMask); metadata.set("Content-Type", "application/json"); callback(null, metadata); }, ); const credentials = grpc.credentials.combineChannelCredentials( ssl_creds, call_creds, ); const client = new protoDescriptor.Routes(host, credentials); client.ComputeRoutes(ComputeRoutesRequest, (error, response) => { if (error) { console.log(error); return; } else if (response) { console.log(response); } });