Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

Reintento de actividades con errores

En ocasiones se producen errores en las actividades por motivos efímeros, como por ejemplo la pérdida temporal de conexión. En otras ocasiones, la actividad podría tener éxito, por lo que la manera apropiada de abordar el error en la actividad consiste con frecuencia en reintentar la actividad, quizás varias veces.

Hay diferentes estrategias para reintentar actividades; la mejor depende de los detalles de su flujo de trabajo. Las estrategias se dividen en tres categorías básicas:

Las siguientes secciones describen cómo implementar estas estrategias. Todos los procesos de trabajo de flujo de trabajo de ejemplo utilizan una sola actividad, unreliableActivity, que hace lo siguiente de manera aleatoria:

Estrategia de reintento hasta tener éxito

La estrategia de reintento más sencilla consiste en seguir reintentando la actividad cada vez que se produce un error hasta que finalmente se ejecuta satisfactoriamente. Este es el patrón básico:

El siguiente flujo de trabajo implementa la estrategia de reintento hasta tener éxito. La interfaz de flujo de trabajo se implementa en RetryActivityRecipeWorkflow y tiene un método, runUnreliableActivityTillSuccess, que es el punto de entrada del flujo de trabajo. El proceso de trabajo de flujo de trabajo se implementa en RetryActivityRecipeWorkflowImpl, de la siguiente manera:

public class RetryActivityRecipeWorkflowImpl
    implements RetryActivityRecipeWorkflow {

    @Override
    public void runUnreliableActivityTillSuccess() {
        final Settable<Boolean> retryActivity = new Settable<Boolean>();

        new TryCatch() {
            @Override
            protected void doTry() throws Throwable {
                Promise<Void> activityRanSuccessfully
                    = client.unreliableActivity();
                setRetryActivityToFalse(activityRanSuccessfully, retryActivity);
            }

            @Override
            protected void doCatch(Throwable e) throws Throwable {
                retryActivity.set(true);
            }
        };
        restartRunUnreliableActivityTillSuccess(retryActivity);
    }

    @Asynchronous
    private void setRetryActivityToFalse(
            Promise<Void> activityRanSuccessfully,
            @NoWait Settable<Boolean> retryActivity) {
        retryActivity.set(false);
    }

    @Asynchronous
    private void restartRunUnreliableActivityTillSuccess(
            Settable<Boolean> retryActivity) {
        if (retryActivity.get()) {
            runUnreliableActivityTillSuccess();
        }
    }
}

El flujo de trabajo funciona de la siguiente manera:

Estrategia de reintento exponencial

Con la estrategia de reintento exponencial, el marco de trabajo ejecuta una actividad en la que se ha producido un error de nuevo tras un periodo de tiempo especificado, N segundos. Si se produce un error en ese intento, el marco de trabajo ejecuta de nuevo la actividad después de 2N segundos y luego tras 4N segundos, etc. Debido a que el tiempo de espera puede aumentar bastante, habitualmente interrumpe los reintentos en algún punto en lugar de continuar de manera indefinida.

El marco de trabajo ofrece tres maneras de implementar una estrategia de reintento exponencial:

Todos los enfoques admiten las siguientes opciones de configuración, en las que los valores de tiempo se muestran en segundos:

En las siguientes secciones se describen las distintas maneras de implementar una estrategia de reintento exponencial.

Reintento exponencial con @ExponentialRetry

La manera más sencilla de implementar una estrategia de reintento exponencial para una actividad consiste en aplicar una anotación @ExponentialRetry a la actividad en la definición de interfaz. Si se produce un error en la actividad, el marco de trabajo gestiona el proceso de reintento automáticamente, en función de los valores de opciones especificados. Este es el patrón básico:

El proceso de trabajo del flujo de trabajo ExponentialRetryAnnotationWorkflow implementa la estrategia de reintento exponencial utilizando una anotación @ExponentialRetry. Utiliza una actividad unreliableActivity cuya definición de interfaz se implementa en ExponentialRetryAnnotationActivities, de la siguiente manera:

@Activities(version = "1.0")
@ActivityRegistrationOptions(
    defaultTaskScheduleToStartTimeoutSeconds = 30,
    defaultTaskStartToCloseTimeoutSeconds = 30)
public interface ExponentialRetryAnnotationActivities {
    @ExponentialRetry(
        initialRetryIntervalSeconds = 5,
        maximumAttempts = 5,
        exceptionsToRetry = IllegalStateException.class)
    public void unreliableActivity();
}

Las opciones de @ExponentialRetry especifican la siguiente estrategia:

La interfaz de flujo de trabajo se implementa en RetryWorkflow y tiene un método, process, que es el punto de entrada del flujo de trabajo. El proceso de trabajo de flujo de trabajo se implementa en ExponentialRetryAnnotationWorkflowImpl, de la siguiente manera:

public class ExponentialRetryAnnotationWorkflowImpl implements RetryWorkflow {
    public void process() {
        handleUnreliableActivity();
    }

    public void handleUnreliableActivity() {
        client.unreliableActivity();
    }
}

El flujo de trabajo funciona de la siguiente manera:

Si se produce un error en la actividad y lanza IllegalStateException, el marco de trabajo ejecuta automáticamente la estrategia de reintento especificada en ExponentialRetryAnnotationActivities.

Reintento exponencial con la clase RetryDecorator

@ExponentialRetry es fácil de utilizar. No obstante, la configuración es estática y se establece en el tiempo de compilación, por lo que el marco de trabajo utiliza la misma estrategia de reintento cada vez que se produce un error en la actividad. Puede implementar una estrategia de reintento exponencial más flexible utilizando la clase RetryDecorator que le permite especificar la configuración en el tiempo de ejecución y cambiarla según sea necesario. Este es el patrón básico:

Si se produce un error en la actividad, el marco de trabajo reintenta la actividad en función de la configuración del objeto ExponentialRetryPolicy. Puede cambiar la configuración de los reintentos según sea necesario modificando este objeto.

La siguiente implementación de flujo de trabajo muestra cómo usar la clase RetryDecorator para implementar una estrategia de reintento exponencial. Utiliza una actividad unreliableActivity que no tiene una anotación @ExponentialRetry. La interfaz de flujo de trabajo se implementa en RetryWorkflow y tiene un método, process, que es el punto de entrada del flujo de trabajo. El proceso de trabajo de flujo de trabajo se implementa en DecoratorRetryWorkflowImpl, de la siguiente manera:

public class DecoratorRetryWorkflowImpl implements RetryWorkflow {
   ...
  public void process() {
      long initialRetryIntervalSeconds = 5;
      int maximumAttempts = 5;
      ExponentialRetryPolicy retryPolicy = new ExponentialRetryPolicy(
              initialRetryIntervalSeconds).withMaximumAttempts(maximumAttempts);

      Decorator retryDecorator = new RetryDecorator(retryPolicy);
      client = retryDecorator.decorate(RetryActivitiesClient.class, client);
      handleUnreliableActivity();
  }

  public void handleUnreliableActivity() {
      client.unreliableActivity();
  }
}

El flujo de trabajo funciona de la siguiente manera:

Si se produce un error en la actividad, el marco de trabajo lo reintenta en función de la configuración especificada en el Paso 1.

Reintento exponencial con la clase AsyncRetryingExecutor

La clase RetryDecorator ofrece más flexibilidad en la configuración del proceso de reintento que @ExponentialRetry, pero el marco de trabajo sigue ejecutando los reintentos automáticamente, en función de la configuración actual del objeto ExponentialRetryPolicy. Un enfoque más flexible consiste en usar la clase AsyncRetryingExecutor. Además de permitirle configurar el proceso de reintento en el tiempo de ejecución, el marco de trabajo llama a un método AsyncRunnable.run implementado por el usuario para que ejecute cada reintento en lugar de simplemente ejecutar la actividad.

Este es el patrón básico:

El siguiente flujo de trabajo muestra cómo usar la clase AsyncRetryingExecutor para implementar una estrategia de reintento exponencial. Utiliza la misma actividad unreliableActivity que el flujo de trabajo DecoratorRetryWorkflow sobre el que hemos hablado antes. La interfaz de flujo de trabajo se implementa en RetryWorkflow y tiene un método, process, que es el punto de entrada del flujo de trabajo. El proceso de trabajo de flujo de trabajo se implementa en AsyncExecutorRetryWorkflowImpl, de la siguiente manera:

public class AsyncExecutorRetryWorkflowImpl implements RetryWorkflow {
  private final RetryActivitiesClient client = new RetryActivitiesClientImpl();
  private final DecisionContextProvider contextProvider = new DecisionContextProviderImpl();
  private final WorkflowClock clock = contextProvider.getDecisionContext().getWorkflowClock();

  public void process() {
      long initialRetryIntervalSeconds = 5;
      int maximumAttempts = 5;
      handleUnreliableActivity(initialRetryIntervalSeconds, maximumAttempts);
  }
  public void handleUnreliableActivity(long initialRetryIntervalSeconds, int maximumAttempts) {

      ExponentialRetryPolicy retryPolicy = new ExponentialRetryPolicy(initialRetryIntervalSeconds).withMaximumAttempts(maximumAttempts);
      final AsyncExecutor executor = new AsyncRetryingExecutor(retryPolicy, clock);

      new TryCatch() {
          @Override
          protected void doTry() throws Throwable {
              executor.execute(new AsyncRunnable() {
                  @Override
                  public void run() throws Throwable {
                      client.unreliableActivity();
                  }
              });
          }
          @Override
          protected void doCatch(Throwable e) throws Throwable {
          }
      };
  }
}

El flujo de trabajo funciona de la siguiente manera:

Para obtener más información sobre cómo utilizar la clase TryCatch para gestionar errores, consulte Excepciones del AWS Flow Framework para Java.

Estrategia de reintento personalizada

El enfoque más flexible para el reintento de actividades en las que se ha producido un error es una estrategia personalizada, que llama de forma recursiva a un método asíncrono que ejecuta el reintento, de forma parecida a la estrategia de reintento hasta alcanzar el éxito. No obstante, en lugar de simplemente ejecutar la actividad de nuevo, usted implementa la lógica personalizada que decide si se ejecuta cada reintento sucesivo y cómo hacerlo. Este es el patrón básico:

El siguiente flujo de trabajo muestra cómo implementar una estrategia de reintento personalizada. Utiliza la misma actividad unreliableActivity que los flujos de trabajo DecoratorRetryWorkflow y AsyncExecutorRetryWorkflow. La interfaz de flujo de trabajo se implementa en RetryWorkflow y tiene un método, process, que es el punto de entrada del flujo de trabajo. El proceso de trabajo de flujo de trabajo se implementa en CustomLogicRetryWorkflowImpl, de la siguiente manera:

public class CustomLogicRetryWorkflowImpl implements RetryWorkflow {
  ...
  public void process() {
      callActivityWithRetry();
  }
  @Asynchronous
  public void callActivityWithRetry() {
      final Settable<Throwable> failure = new Settable<Throwable>();
      new TryCatchFinally() {
          protected void doTry() throws Throwable {
              client.unreliableActivity();
          }
          protected void doCatch(Throwable e) {
              failure.set(e);
          }
          protected void doFinally() throws Throwable {
              if (!failure.isReady()) {
                  failure.set(null);
              }
          }
      };
      retryOnFailure(failure);
  }
  @Asynchronous
  private void retryOnFailure(Promise<Throwable> failureP) {
      Throwable failure = failureP.get();
      if (failure != null && shouldRetry(failure)) {
          callActivityWithRetry();
      }
  }
  protected Boolean shouldRetry(Throwable e) {
      //custom logic to decide to retry the activity or not
      return true;
  }
}

El flujo de trabajo funciona de la siguiente manera: