As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

Tentar novamente atividades com falha

As atividades falham às vezes por motivos efêmeros, como uma perda temporária de conectividade. Em outro momento, a atividade pode funcionar, assim a forma apropriada de lidar com falhas de atividade geralmente é repetir a atividade, talvez algumas vezes.

Existe uma variedade de estratégias para repetir atividades. A melhor depende dos detalhes do fluxo de trabalho. As estratégias são divididas em três categorias básicas:

As seções a seguir descrevem como implementar essas estratégias. Todos os operadores de fluxo de trabalho de exemplo utilizam uma única atividade, unreliableActivity, que realiza de forma aleatória um dos seguintes:

Estratégia de repetir até o sucesso

A estratégia mais simples de repetição é continuar repetindo a atividade até que eventualmente seja concluída. O padrão básico é:

O fluxo de trabalho a seguir implementa a estratégia de repetir até o sucesso. A interface do fluxo de trabalho é implementada no RetryActivityRecipeWorkflow e possui um método, runUnreliableActivityTillSuccess, que é o ponto de entrada do fluxo de trabalho. O operador do fluxo de trabalho é implementado em RetryActivityRecipeWorkflowImpl, da seguinte maneira:

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();
        }
    }
}

O fluxo de trabalho funciona da seguinte forma:

Estratégia de repetição exponencial

Com a estratégia de repetição exponencial, a estrutura executa uma atividade falha novamente após um período especificado, N segundos. Se essa tentativa falhar, a estrutura executa a atividade novamente após 2N segundos e, em seguida, 4N segundos e assim por diante. Como o tempo de espera pode se tornar grande, normalmente você interrompe as tentativas de repetição em algum momento em vez de continuar indefinidamente.

A estrutura oferece três maneiras para implementar uma estratégia de repetição exponencial:

Todas as abordagens oferecem suporte para as seguintes opções de configuração, onde os valores de tempo estão em segundos:

As seções a seguir descrevem as diversas formas para implementar uma estratégia de repetição exponencial.

Repetição exponencial com @ExponentialRetry

A forma mais simples de implementar uma estratégia de repetição exponencial para uma atividade é aplicar uma anotação @ExponentialRetry à atividade na definição da interface. Se a atividade falhar, a estrutura gerencia o processo de repetição automaticamente, com base nos valores da opção especificada. O padrão básico é:

O operador de fluxo de trabalho ExponentialRetryAnnotationWorkflow implementa a estratégia de repetição exponencial usando uma anotação @ExponentialRetry. Ele usa uma atividade unreliableActivity, cuja definição de interface é implementada nas ExponentialRetryAnnotationActivities, da seguinte forma:

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

As opções @ExponentialRetry especificam a seguinte estratégia:

A interface do fluxo de trabalho é implementada no RetryWorkflow e possui um método, process, que é o ponto de entrada do fluxo de trabalho. O operador do fluxo de trabalho é implementado em ExponentialRetryAnnotationWorkflowImpl, da seguinte maneira:

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

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

O fluxo de trabalho funciona da seguinte forma:

Se a atividade falhar ao lançar uma IllegalStateException, a estrutura executa automaticamente a estratégia de repetição especificada nas ExponentialRetryAnnotationActivities.

Repetição exponencial com a classe RetryDecorator

O uso do @ExponentialRetry é simples. No entanto, a configuração é estática e definida durante a compilação, portanto a estrutura usa a mesma estratégia de repetição sempre que a atividade falhar. É possível implementar uma estratégia de repetição exponencial mais flexível usando a classe RetryDecorator, que permite especificar a configuração durante o tempo de execução e alterá-la conforme necessário. O padrão básico é:

Se a atividade falhar, a estrutura repete a atividade de acordo com a configuração do objeto ExponentialRetryPolicy. Altere a configuração de repetição conforme necessário modificando esse objeto.

A implementação de fluxo de trabalho a seguir mostra como usar a classe RetryDecorator para implementar uma estratégia de repetição exponencial. Ela usa uma atividade unreliableActivity que não possui uma anotação @ExponentialRetry. A interface do fluxo de trabalho é implementada no RetryWorkflow e possui um método, process, que é o ponto de entrada do fluxo de trabalho. O operador do fluxo de trabalho é implementado em DecoratorRetryWorkflowImpl, da seguinte maneira:

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();
  }
}

O fluxo de trabalho funciona da seguinte forma:

Se a atividade falhar, a estrutura repete-a de acordo com a configuração especificada na Etapa 1.

Repetição exponencial com a classe AsyncRetryingExecutor

A classe RetryDecorator oferece mais flexibilidade ao configurar o processo de repetição que a @ExponentialRetry, mas a estrutura ainda executa as tentativas de repetição automaticamente, com base na configuração atual do objeto ExponentialRetryPolicy. Uma abordagem mais flexível é usar a classe AsyncRetryingExecutor. Além de permitir que você configure o processo de repetição durante o tempo de execução, a estrutura chama um método AsyncRunnable.run implementado pelo usuário para executar cada tentativa de repetição em vez de simplesmente executar a atividade.

O padrão básico é:

O fluxo de trabalho a seguir mostra como usar a classe AsyncRetryingExecutor para implementar uma estratégia de repetição exponencial. Ele usa a mesma atividade unreliableActivity que o fluxo de trabalho DecoratorRetryWorkflow discutido anteriormente. A interface do fluxo de trabalho é implementada no RetryWorkflow e possui um método, process, que é o ponto de entrada do fluxo de trabalho. O operador do fluxo de trabalho é implementado em AsyncExecutorRetryWorkflowImpl, da seguinte maneira:

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 {
          }
      };
  }
}

O fluxo de trabalho funciona da seguinte forma:

Para obter mais discussões sobre como usar a classe TryCatch para gerenciar erros, consulte AWS Flow Framework para exceções de Java.

Estratégia de repetição personalizada

A abordagem mais flexível para repetir atividades com falha é uma estratégia personalizada, que chama recursivamente um método assíncrono que executa a tentativa de repetição, de forma bem semelhante à estratégia repetir até o sucesso. No entanto, em vez de simplesmente executar a atividade novamente, implemente a lógica personalizada que decide se e como executar cada tentativa sucessiva de repetição. O padrão básico é:

O fluxo de trabalho a seguir mostra como implementar uma estratégia de repetição personalizada. Ele usa a mesma atividade unreliableActivity que os fluxos de trabalho DecoratorRetryWorkflow e AsyncExecutorRetryWorkflow. A interface do fluxo de trabalho é implementada no RetryWorkflow e possui um método, process, que é o ponto de entrada do fluxo de trabalho. O operador do fluxo de trabalho é implementado em CustomLogicRetryWorkflowImpl, da seguinte maneira:

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;
  }
}

O fluxo de trabalho funciona da seguinte forma: