Bibliotecas cliente de la API de Routes

En esta página, se muestra cómo comenzar a usar las bibliotecas cliente para la API de Routes.

Obtén más información sobre las bibliotecas cliente en Explicación de bibliotecas cliente.

Cómo instalar la biblioteca cliente

Java

Para obtener más información, consulta Configura un entorno de desarrollo de Java.

Consulta Cliente de la API de Google Routes para Java para obtener las instrucciones de instalación.

Go

go get cloud.google.com/go/maps
Para obtener más información, consulta Configura un entorno de desarrollo de Go.

Consulta Cliente de la API de Google Routes para Go si quieres obtener las instrucciones de instalación.

Node.js

npm install @googlemaps/routing
Para obtener más información, consulta Configura un entorno de desarrollo de Node.js.

Para obtener las instrucciones de instalación completas, consulta Cliente de la API de Google Routes para Node.js

Python

Para obtener más información, consulta Configura un entorno de desarrollo de Python.

Para obtener las instrucciones de instalación completas, consulta Cliente de la API de Google Routes para Python

.Net

Para obtener más información, consulta Configura un entorno de desarrollo de .NET.

Para obtener las instrucciones de instalación completas, consulta Cliente de la API de Google Routes para .NET.

Configura la autenticación

Cuando usas bibliotecas cliente, debes usar las credenciales predeterminadas de la aplicación (ADC) para autenticarte. A fin de obtener información sobre la configuración de ADC, consulta Proporciona credenciales para credenciales predeterminadas de la aplicación. Para obtener más información sobre el uso de ADC con bibliotecas cliente, consulta Autentica mediante bibliotecas cliente.

Usa la biblioteca cliente

Java

Ejemplo de rutas de procesamiento:

import com.google.maps.routing.v2.*;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
   
public class Main {
  public static void main(String[] arguments) throws IOException {
      RoutesSettings routesSettings = RoutesSettings.newBuilder()
              .setHeaderProvider(() -> {
                  Map<String, String> headers = new HashMap<>();
                  headers.put("X-Goog-FieldMask", "*");
                  return headers;
              }).build();
      RoutesClient routesClient = RoutesClient.create(routesSettings);
       
      ComputeRoutesResponse response = routesClient.computeRoutes(ComputeRoutesRequest.newBuilder()
              .setOrigin(Waypoint.newBuilder().setPlaceId("ChIJeRpOeF67j4AR9ydy_PIzPuM").build())
              .setDestination(Waypoint.newBuilder().setPlaceId("ChIJG3kh4hq6j4AR_XuFQnV0_t8").build())
              .setRoutingPreference(RoutingPreference.TRAFFIC_AWARE)
              .setTravelMode(RouteTravelMode.DRIVE).build());
      System.out.println("Response: " + response.toString());
  }
}

Ejemplo de Route Matrix:

import com.google.api.gax.rpc.ServerStream;
import com.google.api.gax.rpc.ServerStreamingCallable;
import com.google.maps.routing.v2.*;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
   
public class Main {
  public static void main(String[] arguments) throws IOException {
      RoutesSettings routesSettings = RoutesSettings.newBuilder()
              .setHeaderProvider(() -> {
                  Map<String, String> headers = new HashMap<>();
                  headers.put("X-Goog-FieldMask", "*");
                  return headers;
              }).build();
      RoutesClient routesClient = RoutesClient.create(routesSettings);
       
      ServerStreamingCallable<ComputeRouteMatrixRequest, RouteMatrixElement> computeRouteMatrix = routesClient.computeRouteMatrixCallable();
      ServerStream<RouteMatrixElement> stream = computeRouteMatrix.call(ComputeRouteMatrixRequest.newBuilder()
              .addOrigins(RouteMatrixOrigin.newBuilder()
                      .setWaypoint(Waypoint.newBuilder().
                              setPlaceId("ChIJeRpOeF67j4AR9ydy_PIzPuM").build()))
              .addDestinations(RouteMatrixDestination.newBuilder()
                      .setWaypoint(Waypoint.newBuilder().setPlaceId("ChIJG3kh4hq6j4AR_XuFQnV0_t8").build())
                      .build()).setTravelMode(RouteTravelMode.DRIVE)
              .build());
      for (RouteMatrixElement element : stream) {
          System.out.println("Response : " + element.toString());
      }
  }
}

Go

Ejemplo de rutas de procesamiento:

import (
  "context"
  "fmt"
  "io"
  "os"
     
  routing "cloud.google.com/go/maps/routing/apiv2"
  "cloud.google.com/go/maps/routing/apiv2/routingpb"
  "google.golang.org/grpc/metadata"
)
   
func main() {
  ctx := context.Background()
  client, err := routing.NewRoutesClient(ctx)
  if err != nil {
    fmt.Fprintf(os.Stderr, "error: %v\n", err)
    os.Exit(1)
  }
     
  computeRoutesReq := routingpb.ComputeRoutesRequest{
    Origin: &routingpb.Waypoint{
      LocationType: &routingpb.Waypoint_PlaceId{
        PlaceId: "ChIJeRpOeF67j4AR9ydy_PIzPuM",
      },
    },
    Destination: &routingpb.Waypoint{
      LocationType: &routingpb.Waypoint_PlaceId{
        PlaceId: "ChIJG3kh4hq6j4AR_XuFQnV0_t8",
      },
    },
    RoutingPreference: routingpb.RoutingPreference_TRAFFIC_AWARE,
    TravelMode:        routingpb.RouteTravelMode_DRIVE,
  }
  ctx = metadata.AppendToOutgoingContext(ctx, "X-Goog-FieldMask", "*")
  computeRoutesResponse, err := client.ComputeRoutes(ctx, &computeRoutesReq)
  if err != nil {
    fmt.Fprintf(os.Stderr, "error: %v\n", err)
    os.Exit(1)
  }
  fmt.Fprintf(os.Stdout, "response: %v\n", computeRoutesResponse)
}

Ejemplo de Route Matrix:

import (
  "context"
  "fmt"
  "io"
  "os"
     
  routing "cloud.google.com/go/maps/routing/apiv2"
  "cloud.google.com/go/maps/routing/apiv2/routingpb"
  "google.golang.org/grpc/metadata"
)
   
func main() {
  ctx := context.Background()
  client, err := routing.NewRoutesClient(ctx)
  if err != nil {
    fmt.Printf("error: %v\n", err)
    os.Exit(1)
  }
     
  computeRouteMatrixReq := routingpb.ComputeRouteMatrixRequest{
    Origins: []*routingpb.RouteMatrixOrigin{
      {
        Waypoint: &routingpb.Waypoint{
          LocationType: &routingpb.Waypoint_PlaceId{
            PlaceId: "ChIJeRpOeF67j4AR9ydy_PIzPuM",
          },
        },
      },
    },
    Destinations: []*routingpb.RouteMatrixDestination{
      {
        Waypoint: &routingpb.Waypoint{
          LocationType: &routingpb.Waypoint_PlaceId{
            PlaceId: "ChIJG3kh4hq6j4AR_XuFQnV0_t8",
          },
        },
      },
    },
    TravelMode: routingpb.RouteTravelMode_DRIVE,
  }
  ctx = metadata.AppendToOutgoingContext(ctx, "X-Goog-FieldMask", "*")
  stream, err := client.ComputeRouteMatrix(ctx, &computeRouteMatrixReq)
  if err != nil {
    fmt.Fprintf(os.Stderr, "error: %v\n", err)
    os.Exit(1)
  }
  for {
    element, err := stream.Recv()
    if err == io.EOF {
      break
    }
    if err != nil {
      fmt.Fprintf(os.Stderr, "error: %v\n", err)
      os.Exit(1)
    }
    fmt.Fprintf(os.Stdout, "element: %v\n", element)
  }
}

Node.js

Ejemplo de rutas de procesamiento:

// Imports the Routing library
const {RoutesClient} = require('@googlemaps/routing').v2;
 
const origin = {
  "location": {
      "latLng": {
          "latitude": 37.419734,
          "longitude": -122.0827784
      }
  }
};
const destination = {
  "location": {
      "latLng": {
          "latitude": 37.417670,
          "longitude": -122.079595
      }
  }
};
// Instantiates a client
const routingClient = new RoutesClient();
async function callComputeRoutes() {
  const request = {
    origin,
    destination
  }
  // Run request
  const response = await routingClient.computeRoutes(request, {
    otherArgs: {
        headers:{
          'X-Goog-FieldMask':'routes.duration,routes.distanceMeters,routes.polyline.encodedPolyline'
        }
    }
  });
  console.log(response);
}
callComputeRoutes();

Ejemplo de Compute Route Matrix:

 
// Imports the Routing library
const {RoutesClient} = require('@googlemaps/routing').v2;
const origins = [
  {
      "waypoint": {
          "location": {
              "latLng": {
                  "latitude": 37.420761,
                  "longitude": -122.081356
              }
          }
      }
  },
  {
      "waypoint": {
          "location": {
              "latLng": {
                  "latitude": 37.403184,
                  "longitude": -122.097371
              }
          }
      }
  }
];
const destinations = [
  {
      "waypoint": {
          "location": {
              "latLng": {
                  "latitude": 37.420999,
                  "longitude": -122.086894
              }
          }
      }
  },
  {
      "waypoint": {
          "location": {
              "latLng": {
                  "latitude": 37.383047,
                  "longitude": -122.044651
              }
          }
      }
  }
]
// Instantiates a client
const routingClient = new RoutesClient();
async function callComputeRouteMatrix() {
  // Construct request
  const request = {
    origins,
    destinations
  };
  // Run request
  const stream = await routingClient.computeRouteMatrix(request, {
    otherArgs: {
        headers:{
            'X-Goog-FieldMask':'*'
        }
    }
  });
  stream.on('data', (response) => { console.log(response) });
  stream.on('error', (err) => { throw(err) });
  stream.on('end', () => { /* API call completed */ });
}
callComputeRouteMatrix();

Python

# This snippet has been automatically generated and should be regarded as a
# code template only.
# It will require modifications to work:
# - It may require correct/in-range values for request initialization.
# - It may require specifying regional endpoints when creating the service
#   client as shown in:
#   https://googleapis.dev/python/google-api-core/latest/client_options.html
from google.maps import routing_v2


async def sample_compute_routes():
    # Create a client
    client = routing_v2.RoutesAsyncClient()

    # Initialize request argument(s)
    request = routing_v2.ComputeRoutesRequest(
    )

    # Make the request
    response = await client.compute_routes(request=request)

    # Handle the response
    print(response)

.Net

using Google.Maps.Routing.V2;
using Google.Protobuf.WellKnownTypes;
using System.Threading.Tasks;

public sealed partial class GeneratedRoutesClientSnippets
{
    /// <summary>Snippet for ComputeRoutesAsync</summary>
    /// <remarks>
    /// This snippet has been automatically generated and should be regarded as a code template only.
    /// It will require modifications to work:
    /// - It may require correct/in-range values for request initialization.
    /// - It may require specifying regional endpoints when creating the service client as shown in
    ///   https://cloud.google.com/dotnet/docs/reference/help/client-configuration#endpoint.
    /// </remarks>
    public async Task ComputeRoutesRequestObjectAsync()
    {
        // Create client
        RoutesClient routesClient = await RoutesClient.CreateAsync();
        // Initialize request argument(s)
        ComputeRoutesRequest request = new ComputeRoutesRequest
        {
            Origin = new Waypoint(),
            Destination = new Waypoint(),
            Intermediates = { new Waypoint(), },
            TravelMode = RouteTravelMode.TravelModeUnspecified,
            RoutingPreference = RoutingPreference.Unspecified,
            PolylineQuality = PolylineQuality.Unspecified,
            DepartureTime = new Timestamp(),
            ComputeAlternativeRoutes = false,
            RouteModifiers = new RouteModifiers(),
            LanguageCode = "",
            Units = Units.Unspecified,
            PolylineEncoding = PolylineEncoding.Unspecified,
            OptimizeWaypointOrder = false,
            RequestedReferenceRoutes =
            {
                ComputeRoutesRequest.Types.ReferenceRoute.Unspecified,
            },
            ExtraComputations =
            {
                ComputeRoutesRequest.Types.ExtraComputation.Unspecified,
            },
            RegionCode = "",
            TrafficModel = TrafficModel.Unspecified,
            ArrivalTime = new Timestamp(),
            TransitPreferences = new TransitPreferences(),
        };
        // Make the request
        ComputeRoutesResponse response = await routesClient.ComputeRoutesAsync(request);
    }
}

Recursos adicionales