computeRoutes yöntemine (REST) bir HTTP POST isteği göndererek veya ComputeRoutes yöntemini (gRPC) çağırarak Routes API'yi kullanarak bir rota alabilirsiniz.
Aşağıdaki örnekte computeRoutes yöntemine gönderilen bir REST isteğinin URL'si gösterilmektedir:
https://routes.googleapis.com/directions/v2:computeRoutes
İstek seçeneklerinizi JSON istek gövdesine ekleyin. İstek gövdesi, kaynak ve hedef konumların yanı sıra rotada ayarlamak istediğiniz seçenekleri içerir. Daha fazla bilgi için Konumları belirtme ve Mevcut rota seçenekleri konularına bakın.
Yanıt, X-Goog-FieldMask HTTP gRPC başlığı kullanarak $fields veya field URL parametresini kullanarak yanıt alanı maskesinde belirttiğiniz alanları içerir. Ayrıntılar için Döndürülecek bilgileri seçme bölümüne bakın.
Toplu taşıma rotası isteğinin bir örneği için Örnek: Toplu taşımada rota bulma bölümüne bakın.
Örnek: HTTP yönlendirme isteği
Aşağıdaki kod, computeRoutes isteği için bir istek gövdesinin nasıl oluşturulacağını göstermektedir. Bu örnekte, kaynak ve hedef konumlarını ayarlarsınız ve ayrıca şunları belirtirsiniz:
travelMode/DRIVEve trafiğe duyarlı sürüş rotası.Ayarlanmış kalkış saati.
Dil,
en-USveimperialmesafe birimi.X-Goog-FieldMasküstbilgisinde, yanıtta aşağıdaki alanların döndürüleceğini belirten bir yanıt alanı maskesi:routes.durationroutes.distanceMetersroutes.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'
Örnek: HTTP rota yanıtı gövdesi
Yukarıdaki çağrı, aşağıdaki JSON yanıtını oluşturur:
{
"routes": [
{
"distanceMeters": 772,
"duration": "165s",
"polyline": {
"encodedPolyline": "ipkcFfichVnP@j@BLoFVwM{E?"
}
}
]
}
Örnek: gRPC isteği
gRPC, Google tarafından geliştirilen yüksek performanslı ve açık kaynaklı evrensel bir RPC çerçevesidir. gRPC'de bir istemci uygulaması, farklı bir makinedeki bir sunucu uygulamasında yerel bir nesneymiş gibi doğrudan yöntemler çağırabilir.
Aşağıda örnek bir gRPC isteği gösterilmektedir.
Go
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.Key API_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#
C#'nin kullanıldığı bir örnek için bkz. 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);
}
});