本文為英文版的機器翻譯版本，如內容有任何歧義或不一致之處，概以英文版為準。

重試失敗的活動

活動有時會因暫時性原因失敗，例如暫時失去連線。有時活動可能成功，所以處理活動錯誤的適當方法，通常是重試活動，或許要多試幾次。

重試這些活動有各種策略，最好的策略是根據您的工作流程詳細資訊。這些策略分為三大基本分類：

以下各節會說明如何實作這些策略。範例工作流程工作者全都使用單一活動 unreliableActivity，隨機執行下列作業之一：

重試到成功為止策略

最簡單的重試策略是每次活動失敗就一直重試，直到最後成功。基本模式是：

以下工作流程會實作重試到成功為止策略。工作流程界面在 RetryActivityRecipeWorkflow 中實作，且有一個方法 runUnreliableActivityTillSuccess，這是工作流程的進入點。工作流程工作者在 RetryActivityRecipeWorkflowImpl 中實作，如下所示：

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

工作流程運作方式如下：

指數重試策略

使用指數重試策略，框架會在指定期間後 (N 秒) 再次執行失敗的活動。如果該嘗試失敗，框架就會在 2N 秒後、4N 秒後、以此類推，再次執行活動。因為等待時間會變得相當長，您一般會在某個時間點停止重試嘗試，而不是無止境地繼續下去。

框架提供三種方式實作指數重試策略：

所有方法都支援下列組態選項，它們的時間值都是以秒計：

以下各節說明您可實作指數重試策略的各種方式。

使用 @ExponentialRetry 的指數重試

為活動實作指數重試策略最簡單的方式，是在界面定義中將 @ExponentialRetry 註釋套用到活動。如果活動失敗，框架會根據指定的選項值，自動處理重試程序。基本模式是：

ExponentialRetryAnnotationWorkflow 工作流程工作者使用 @ExponentialRetry 註釋實作指數重試策略。它使用 unreliableActivity 活動，它的界面定義是以 ExponentialRetryAnnotationActivities 實作，如下所示：

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

@ExponentialRetry 選項指定以下策略：

工作流程界面在 RetryWorkflow 中實作，且有一個方法 process，這是工作流程的進入點。工作流程工作者在 ExponentialRetryAnnotationWorkflowImpl 中實作，如下所示：

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

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

工作流程運作方式如下：

如果活動因拋出 IllegalStateException 而失敗，框架會自動執行 ExponentialRetryAnnotationActivities 指定的重試策略。

使用 RetryDecorator 類別的指數重試

@ExponentialRetry 簡單好用。不過，組態是靜態的且於編譯階段設定，所以每次活動失敗，框架都會使用相同的重試策略。您可以使用 RetryDecorator 類別，實作更有彈性的指數重試策略，這可讓您在執行時間指定組態，並視需要予以變更。基本模式是：

如果活動失敗，框架會根據 ExponentialRetryPolicy 物件的組態，重試活動。您可以修改此物件，視需要變更重試組態。

以下工作流程實作示範如何使用 RetryDecorator 類別來實作指數重試策略。它使用沒有 @ExponentialRetry 註釋的 unreliableActivity 活動。工作流程界面在 RetryWorkflow 中實作，且有一個方法 process，這是工作流程的進入點。工作流程工作者在 DecoratorRetryWorkflowImpl 中實作，如下所示：

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

工作流程運作方式如下：

如果活動失敗，框架會根據步驟 1 指定的組態，重試活動。

使用 AsyncRetryingExecutor 類別的指數重試

RetryDecorator 類別設定重試程序比 @ExponentialRetry 更有彈性，但是框架仍會根據 ExponentialRetryPolicy 物件目前的組態自動執行重試嘗試。更彈性的方法是使用 AsyncRetryingExecutor 類別。除在執行時間讓您設定重試程序之外，框架還會呼叫使用者實作的 AsyncRunnable.run 方法來執行每次的重試嘗試，不只是執行活動。

基本模式是：

以下工作流程示範如何使用 AsyncRetryingExecutor 類別來實作指數重試策略。它會和前文討論的 DecoratorRetryWorkflow 工作流程使用相同的 unreliableActivity 活動。工作流程界面在 RetryWorkflow 中實作，且有一個方法 process，這是工作流程的進入點。工作流程工作者在 AsyncExecutorRetryWorkflowImpl 中實作，如下所示：

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

工作流程運作方式如下：

如需深入討論如何使用 TryCatch 類別處理錯誤，請參閱「AWS Flow Frameworkin Java 例外狀況」。

自訂重試策略

重試失敗活動最有彈性的方法是自訂策略，遞迴呼叫執行重試嘗試的非同步方法，非常類似重試到成功為止策略。但您不僅僅可以再次執行活動，還可實作自訂邏輯來決定是否及如何執行每次接續的重試嘗試。基本模式是：

以下工作流程示範如何實作自訂的重試策略。它會和 DecoratorRetryWorkflow 與 AsyncExecutorRetryWorkflow 工作流程使用相同的 unreliableActivity 活動。工作流程界面在 RetryWorkflow 中實作，且有一個方法 process，這是工作流程的進入點。工作流程工作者在 CustomLogicRetryWorkflowImpl 中實作，如下所示：

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

工作流程運作方式如下：