Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

Coba lagi Aktivitas Gagal

Kegiatan kadang-kadang gagal karena alasan sementara, seperti kehilangan konektivitas sementara. Di lain waktu, aktivitas mungkin berhasil, sehingga cara yang tepat untuk menangani kegagalan aktivitas sering untuk mencoba lagi aktivitas, mungkin beberapa kali.

Ada berbagai strategi untuk mencoba kembali aktivitas; yang terbaik tergantung pada detail alur kerja Anda. Strategi jatuh ke dalam tiga kategori dasar:

Bagian berikut menjelaskan cara menerapkan strategi ini. Contoh pekerja alur kerja semua menggunakan aktivitas tunggal, unreliableActivity, yang secara acak melakukan salah satu dari berikut ini:

Retry-Until-Success Strategi

Strategi coba lagi yang paling sederhana adalah terus mencoba kembali aktivitas setiap kali gagal sampai akhirnya berhasil. Pola dasar adalah:

Alur kerja berikut mengimplementasikan strategi. retry-until-success Antarmuka alur kerja diimplementasikan dalam RetryActivityRecipeWorkflow dan memiliki satu metode, runUnreliableActivityTillSuccess, yang merupakan titik masuk alur kerja. Pekerja alur kerja diimplementasikan dalam RetryActivityRecipeWorkflowImpl, sebagai berikut:

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

Alur kerja bekerja sebagai berikut:

Strategi Coba Kembali Eksponensial

Dengan strategi coba lagi eksponensial, kerangka kerja mengeksekusi aktivitas gagal lagi setelah jangka waktu tertentu, N detik. Jika upaya gagal kerangka kerja mengeksekusi aktivitas lagi setelah 2N detik, dan kemudian 4N detik dan seterusnya. Karena waktu tunggu bisa mendapatkan cukup besar, Anda biasanya menghentikan upaya coba lagi di beberapa titik daripada berlanjut tanpa batas..

Kerangka kerja ini menyediakan tiga cara untuk menerapkan strategi coba lagi eksponensial:

Semua pendekatan mendukung opsi konfigurasi berikut, di mana nilai waktu dalam detik:

Bagian berikut menjelaskan berbagai cara yang Anda dapat menerapkan strategi coba lagi eksponensial.

Coba lagi eksponensial dengan @ ExponentialRetry

Cara termudah untuk menerapkan strategi coba lagi eksponensial untuk suatu kegiatan adalah dengan menerapkan anotasi @ExponentialRetry untuk aktivitas dalam definisi antarmuka. Jika aktivitas gagal, kerangka kerja menangani proses coba lagi secara otomatis, berdasarkan nilai opsi yang ditentukan. Pola dasar adalah:

Pekerja alur kerja ExponentialRetryAnnotationWorkflow mengimplementasikan strategi coba lagi eksponensial dengan menggunakan anotasi @ExponentialRetry. anotasi tersebut menggunakan aktivitas unreliableActivity yang definisi antarmukanya diimplementasikan dalam ExponentialRetryAnnotationActivities sebagai berikut:

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

Opsi @ExponentialRetry menentukan strategi berikut:

Antarmuka alur kerja diimplementasikan dalam RetryWorkflow dan memiliki satu metode, process, yang merupakan titik masuk alur kerja. Pekerja alur kerja diimplementasikan dalam ExponentialRetryAnnotationWorkflowImpl, sebagai berikut:

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

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

Alur kerja bekerja sebagai berikut:

Jika aktivitas gagal dengan melempar IllegalStateException, kerangka kerja secara otomatis menjalankan strategi coba lagi yang ditentukan dalam ExponentialRetryAnnotationActivities.

Coba Ulang Eksponensial dengan Kelas RetryDecorator

@ExponentialRetry mudah digunakan. Namun, konfigurasi statis dan ditetapkan pada waktu kompilasi, sehingga kerangka kerja menggunakan strategi coba lagi yang sama setiap kali aktivitas gagal. Anda dapat menerapkan strategi coba lagi eksponensial yang lebih fleksibel dengan menggunakan kelas RetryDecorator, yang mengizinkan Anda untuk menentukan konfigurasi pada waktu aktif dan mengubahnya sesuai kebutuhan. Pola dasar adalah:

Jika aktivitas gagal, kerangka kerja mencoba ulang aktivitas sesuai dengan konfigurasi objek ExponentialRetryPolicy. Anda dapat mengubah konfigurasi coba lagi yang diperlukan dengan memodifikasi objek ini.

Implementasi alur kerja berikut menunjukkan cara menggunakan kelas RetryDecorator untuk menerapkan strategi coba lagi eksponensial. Implementasi menggunakan aktivitas unreliableActivity yang tidak memiliki anotasi @ExponentialRetry. Antarmuka alur kerja diimplementasikan dalam RetryWorkflow dan memiliki satu metode, process, yang merupakan titik masuk alur kerja. Pekerja alur kerja diimplementasikan dalam DecoratorRetryWorkflowImpl, sebagai berikut:

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

Alur kerja bekerja sebagai berikut:

Jika aktivitas gagal, kerangka kerja coba lagi sesuai dengan konfigurasi yang ditentukan pada Langkah 1.

Coba Ulang Eksponensial dengan Kelas AsyncRetryingExecutor

Kelas RetryDecorator menyediakan lebih banyak fleksibilitas dalam mengkonfigurasi proses coba lagi daripada @ExponentialRetry, namun kerangka kerja masih menjalankan upaya coba lagi secara otomatis, berdasarkan objek konfigurasi ExponentialRetryPolicy saat ini. Pendekatan yang lebih fleksibel adalah dengan menggunakan kelas AsyncRetryingExecutor. Selain mengizinkan Anda untuk mengkonfigurasi proses coba lagi pada waktu aktif, kerangka kerja memanggil metode AsyncRunnable.run yang diimplementasikan pengguna untuk menjalankan setiap upaya coba lagi bukan hanya mengeksekusi aktivitas.

Pola dasar adalah:

Alur kerja berikut menunjukkan cara menggunakan kelas AsyncRetryingExecutor untuk menerapkan strategi coba lagi eksponensial. Alur kerja menggunakan aktivitas unreliableActivity yang sama sebagai alur kerja DecoratorRetryWorkflowyang dibahas sebelumnya. Antarmuka alur kerja diimplementasikan dalam RetryWorkflow dan memiliki satu metode, process, yang merupakan titik masuk alur kerja. Pekerja alur kerja diimplementasikan dalam AsyncExecutorRetryWorkflowImpl, sebagai berikut:

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

Alur kerja bekerja sebagai berikut:

Untuk diskusi lebih lanjut tentang cara menggunakan kelas TryCatch untuk menangani kesalahan, lihat AWS Flow Framework untuk Pengecualian Java.

Strategi Coba Lagi Kustom

Pendekatan yang paling fleksibel untuk mencoba kembali aktivitas yang gagal adalah strategi khusus, yang secara rekursif memanggil metode asinkron yang menjalankan upaya coba lagi, seperti strategi. retry-until-success Namun, bukan hanya menjalankan aktivitas lagi, Anda menerapkan logika kustom yang memutuskan apakah dan cara menjalankan setiap upaya coba lagi berturut-turut. Pola dasar adalah:

Alur kerja berikut menunjukkan cara menerapkan strategi coba lagi kustom. Alur kerja menggunakan aktivitas unreliableActivity yang sama sebagai DecoratorRetryWorkflow dan alur kerja AsyncExecutorRetryWorkflow. Antarmuka alur kerja diimplementasikan dalam RetryWorkflow dan memiliki satu metode, process, yang merupakan titik masuk alur kerja. Pekerja alur kerja diimplementasikan dalam CustomLogicRetryWorkflowImpl, sebagai berikut:

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

Alur kerja bekerja sebagai berikut: