Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Ripetere le attività non andate a buon fine

A volte le attività non vanno a buon fine per ragioni effimere, ad esempio una perdita temporanea della connessione. In altri casi l'attività va a buon fine, quindi il modo corretto di gestire l'errore è spesso quello di ripetere l'attività, anche più volte.

Esiste una serie di strategie per ripetere le attività; la migliore dipende dai dettagli del flusso di lavoro. Tali strategie rientrano in tre categorie di base:

Le sezioni seguenti descrivono come implementare queste strategie. I lavoratori del flusso di lavoro di esempio utilizzano tutti una singola attività, unreliableActivity, che esegue casualmente una delle seguenti operazioni:

Retry-Until-Success Strategia

La strategia più semplice è quella di ripetere l'attività ogni volta che ha esito negativo fino al buon esito. Il modello di base è:

Il seguente flusso di lavoro implementa la retry-until-success strategia. L'interfaccia del flusso di lavoro è implementata in RetryActivityRecipeWorkflow e ha un metodo, runUnreliableActivityTillSuccess, che è il punto di ingresso del flusso di lavoro. Il lavoratore del flusso di lavoro viene implementato in RetryActivityRecipeWorkflowImpl, nel seguente modo:

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

Il flusso di lavoro funziona come segue:

Strategia di ripetizione esponenziale

Con la strategia di ripetizione esponenziale, il framework esegue nuovamente un'attività non andata a buon fine dopo un periodo di tempo specifico, N secondi. Se il tentativo ha esito negativo, il framework esegue nuovamente l'attività dopo 2N secondi, 4N secondi e così via. Poiché il tempo di attesa può essere lungo, in genere i tentativi si arrestano a un certo punto invece che proseguire all'infinito.

Il framework prevede tre modi per implementare una strategia di ripetizione esponenziale:

Tutti gli approcci supportano le seguenti opzioni di configurazione, in cui i valori di tempo sono espressi in secondi:

Le sezioni seguenti descrivono i vari modi in cui è possibile implementare una strategia di ripetizione esponenziale.

Riprova esponenziale con @ ExponentialRetry

Il modo più semplice per implementare una strategia di ripetizione esponenziale per un'attività è applicare un'annotazione @ExponentialRetry all'attività nella definizione dell'interfaccia. Se l'attività non va a buon fine, il framework gestisce automaticamente il processo di ripetizione in base ai valori opzionali specificati. Il modello di base è:

Il lavoratore del flusso di lavoro ExponentialRetryAnnotationWorkflow implementa la strategia di ripetizione esponenziale utilizzando un'annotazione @ExponentialRetry. Utilizza un'attività unreliableActivity la cui definizione dell'interfaccia è implementata in ExponentialRetryAnnotationActivities, nel modo seguente:

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

Le opzioni di @ExponentialRetry specificano la seguente strategia:

L'interfaccia del flusso di lavoro è implementata in RetryWorkflow e ha un metodo, process, che è il punto di ingresso del flusso di lavoro. Il lavoratore del flusso di lavoro viene implementato in ExponentialRetryAnnotationWorkflowImpl, nel seguente modo:

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

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

Il flusso di lavoro funziona come segue:

Se l'attività non va a buon fine generando IllegalStateException, il framework esegue automaticamente la strategia di ripetizione specificata in ExponentialRetryAnnotationActivities.

Riprova esponenziale con la classe RetryDecorator

@ExponentialRetry è semplice da usare. Tuttavia, la configurazione è statica e impostata al momento della compilazione, in modo che il framework utilizzi la stessa strategia di ripetizione ogni volta che l'attività non va a buon fine. Puoi implementare una strategia di ripetizione esponenziale più flessibile utilizzando la classe RetryDecorator, che ti permette di specificare la configurazione in fase di runtime e di modificarla in base alle necessità. Il modello di base è:

Se l'attività non va a buon fine, il framework la ripete secondo la configurazione dell'oggetto ExponentialRetryPolicy. Puoi modificare la configurazione della ripetizione in base alla necessità cambiando l'oggetto.

La seguente implementazione del flusso di lavoro mostra come utilizzare la classe RetryDecorator per implementare una strategia di ripetizione esponenziale. Utilizza un'attività unreliableActivity priva dell'annotazione @ExponentialRetry. L'interfaccia del flusso di lavoro è implementata in RetryWorkflow e ha un metodo, process, che è il punto di ingresso del flusso di lavoro. Il lavoratore del flusso di lavoro viene implementato in DecoratorRetryWorkflowImpl, nel seguente modo:

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

Il flusso di lavoro funziona come segue:

Se l'attività non va a buon fine, il framework la ripete secondo la configurazione specificata nella Fase 1.

Riprova esponenziale con la classe AsyncRetryingExecutor

La classe RetryDecorator offre più flessibilità nella configurazione del processo di ripetizione rispetto a @ExponentialRetry, ma il framework esegue comunque automaticamente i tentativi di ripetizione, in base alla attuale configurazione dell'oggetto ExponentialRetryPolicy. Un approccio più flessibile prevede l'utilizzo della classe AsyncRetryingExecutor. Oltre a permetterti di configurare il processo di ripetizione in fase di runtime, il framework chiama un metodo AsyncRunnable.run implementato dall'utente per eseguire ogni tentativo di ripetizione invece che eseguire semplicemente l'attività.

Il modello di base è:

Il flusso di lavoro seguente mostra come utilizzare la classe AsyncRetryingExecutor per implementare una strategia di ripetizione esponenziale. Utilizza la stessa attività unreliableActivity del flusso di lavoro DecoratorRetryWorkflow discusso in precedenza. L'interfaccia del flusso di lavoro è implementata in RetryWorkflow e ha un metodo, process, che è il punto di ingresso del flusso di lavoro. Il lavoratore del flusso di lavoro viene implementato in AsyncExecutorRetryWorkflowImpl, nel seguente modo:

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

Il flusso di lavoro funziona come segue:

Per ulteriori discussioni su come utilizzare la classe TryCatch per gestire gli errori, consulta AWS Flow Framework per le eccezioni Java.

Strategia di ripetizione personalizzata

L'approccio più flessibile per riprovare le attività non riuscite è una strategia personalizzata, che richiama ricorsivamente un metodo asincrono che esegue il tentativo di nuovo tentativo, proprio come la strategia. retry-until-success Tuttavia, invece che rieseguire semplicemente l'attività, implementi una logica personalizzata che decide se e come eseguire i successivi tentativi di ripetizione. Il modello di base è:

Il flusso di lavoro seguente mostra come implementare una strategia di ripetizione personalizzata. Utilizza la stessa attività unreliableActivity dei flussi di lavoro DecoratorRetryWorkflow e AsyncExecutorRetryWorkflow. L'interfaccia del flusso di lavoro è implementata in RetryWorkflow e ha un metodo, process, che è il punto di ingresso del flusso di lavoro. Il lavoratore del flusso di lavoro viene implementato in CustomLogicRetryWorkflowImpl, nel seguente modo:

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

Il flusso di lavoro funziona come segue: