Uso avanzado

En esta guía, se describe cómo personalizar varios de los aspectos más avanzados de la biblioteca cliente de Java. Un patrón común es que muchas de estas funciones se basan en el Callable subyacente en lugar de los métodos de conveniencia estándar. Por lo general, el objeto invocable es un buen lugar para buscar otras funciones por RPC que no se documentan aquí.

Tiempo de espera

La biblioteca de Java proporciona una superficie para establecer tiempos de espera a nivel de cada llamada. El valor predeterminado se establece según el parámetro de configuración method_config/timeout en googleads_grpc_service_config.json. Establece un valor más bajo si necesitas aplicar un límite más corto en el tiempo máximo para una llamada a la API.

Para usar esta función, llama al objeto Callable directamente. Por ejemplo, cuando llames a GoogleAdsService.searchStream(), establece el tiempo de espera de la siguiente manera:

try (GoogleAdsServiceClient googleAdsServiceClient =
    googleAdsClient.getLatestVersion().createGoogleAdsServiceClient()) {
  // Constructs the SearchGoogleAdsStreamRequest.
  SearchGoogleAdsStreamRequest request =
      SearchGoogleAdsStreamRequest.newBuilder()
          .setCustomerId(Long.toString(customerId))
          .setQuery("SELECT campaign.id, campaign.name FROM campaign")
          .build();

  // Executes the API call with a timeout of 5 minutes.
  ServerStream<SearchGoogleAdsStreamResponse> stream =
      googleAdsServiceClient
          .searchStreamCallable()
          .call(
              request,
              GrpcCallContext.createDefault()
                  .withTimeout(Duration.of(5, ChronoUnit.MINUTES)));
  for (SearchGoogleAdsStreamResponse response : stream) {
    // Processes the response rows.
  }
}

Puedes establecer el tiempo de espera en 2 horas o más, pero es posible que la API aún agote el tiempo de espera de las solicitudes de ejecución extremadamente prolongada y muestre un error DEADLINE_EXCEEDED. Si esto se convierte en un problema, lo mejor suele ser dividir la consulta y ejecutar los fragmentos en paralelo. Esto evita la situación en la que falla una solicitud de larga duración y la única forma de recuperarse es volver a activar la solicitud desde el principio.

Configuración de reintentos

La biblioteca de Java también proporciona una interfaz para configurar los parámetros de configuración de reintentos a nivel de cada llamada. Para usar esta función, llama al objeto Callable directamente. Por ejemplo, cuando llames a GoogleAdsService.searchStream(), configura los parámetros de configuración de reintento de la siguiente manera:

try (GoogleAdsServiceClient googleAdsServiceClient =
    googleAdsClient.getLatestVersion().createGoogleAdsServiceClient()) {
  SearchGoogleAdsStreamRequest request =
      SearchGoogleAdsStreamRequest.newBuilder()
          .setCustomerId(Long.toString(customerId))
          .setQuery("SELECT campaign.id, campaign.name FROM campaign")
          .build();

  // Creates a context object with the custom retry settings.
  GrpcCallContext context =
      GrpcCallContext.createDefault()
          .withRetrySettings(
              RetrySettings.newBuilder()
                  .setInitialRetryDelay(Duration.ofMillis(10L))
                  .setMaxRetryDelay(Duration.ofSeconds(10L))
                  .setRetryDelayMultiplier(1.4)
                  .setMaxAttempts(10)
                  .setLogicalTimeout(Duration.ofSeconds(30L))
                  .build());

  // Issues the streaming search request.
  ServerStream<SearchGoogleAdsStreamResponse> stream =
      googleAdsServiceClient.searchStreamCallable().call(request, context);
  for (SearchGoogleAdsStreamResponse response : stream) {
    // Processes the response rows.
  }
}

Optimización del rendimiento del tiempo de inicio

Es posible que observes un pequeño retraso la primera vez que se crea una instancia de GoogleAdsClient. Esto se debe a la interfaz fluida para los servicios (GoogleAdsClient.getLatestVersion()), que carga las clases de servicio de la API a la vez para proporcionar un mecanismo conveniente para construir clientes de servicio.

Si el rendimiento de la primera solicitud se encuentra en la ruta crítica de tu aplicación, sigue estos pasos:

  1. Crea el GoogleAdsClient durante el inicio, antes de atender las solicitudes de los usuarios.

  2. Envía algunas solicitudes de calentamiento a la API de Google Ads cuando se inicie el proceso. Por ejemplo:

    // Runs some warm-up requests.
try (GoogleAdsServiceClient googleAdsServiceClient =
    googleAdsClient.getLatestVersion().createGoogleAdsServiceClient()) {
  // Runs 5 warm-up requests. In our profiling we see that 90% of
  // performance loss is only experienced on the first API call. After 3
  // subsequent calls we saw a negligible improvement in performance.
  for (int i = 0; i < 5; ++i) {
    // Warm-up queries are run with a nonexistent CID so the calls will
    // fail. If you have a CID that you know will be accessible with the
    // OAuth credentials provided you may want to provide that instead and
    // avoid the try-catch.
    try {
      googleAdsServiceClient.search("-1", "Warm-up query");
    } catch (ApiException ex) {
      // Do nothing, we're expecting this to fail.
    }
  }
}

Las solicitudes de calentamiento solo deben ejecutarse una vez por proceso. Cada creación posterior de un cliente de servicio reutiliza automáticamente las clases precargadas.

Reutilización del cliente de servicio

Debes reutilizar las instancias del cliente de servicio cuando sea práctico, ya que cada llamada a GoogleAdsClient.getLatestVersion().createYYYServiceClient() (o a un descriptor de acceso específico de la versión, como getVersion25()) crea una nueva conexión subyacente y recursos asociados.

Asegúrate de cerrar el cliente de servicio cuando ya no sea necesario. Puedes hacerlo en un bloque try-with-resources o llamando a close() en el cliente del servicio.

Si intentas usar un cliente de servicio cerrado para realizar solicitudes a la API, el método del cliente de servicio arroja un java.util.concurrent.RejectedExecutionException.

App Engine no puede realizar la implementación si el archivo JAR es mayor que 32 MB

App Engine tiene una cuota de 32 MB para cada archivo subido. El archivo JAR para google-ads es considerablemente más grande que este, en especial cuando se usan implementaciones de archivos JAR sombreados o de sombra. Si implementas archivos JAR de forma manual, es posible que recibas errores como los siguientes:

ERROR: (gcloud.app.deploy) Cannot upload file [<your-app>/WEB-INF/lib/google-ads-46.1.0.jar],
which has size [66095767] (greater than maximum allowed size of [33554432])

En su lugar, realiza la implementación con el complemento de Gradle o el complemento de Maven de App Engine. Cada complemento proporciona una opción de enableJarSplitting que divide cada archivo JAR en fragmentos de 10 MB y, luego, sube esos fragmentos.

Dependencias ocultas

Si tu proyecto tiene dependencias que entran en conflicto con las de la biblioteca, inspecciona la jerarquía de dependencias del proyecto con uno de los siguientes comandos y, luego, modifica las dependencias del proyecto según sea necesario (o usa la lista de materiales):

Maven

mvn dependency:tree

Gradle

./gradlew dependencies

Si no es posible resolver los conflictos de dependencias, puedes depender de la versión sombreada de la biblioteca:

Maven

<dependency>
  <groupId>com.google.api-ads</groupId>
  <artifactId>google-ads-shadowjar</artifactId>
  <version>46.1.0</version>
</dependency>

Gradle

implementation 'com.google.api-ads:google-ads-shadowjar:46.1.0'