Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Contexte d'exécution
**Topics**
+ [Contexte décisionnel](#executioncontext.decision)
+ [Contexte d'exécution d'une activité](#activitycontext)
L'infrastructure fournit un contexte ambiant aux implémentations de flux de travail et d'activité. Ce contexte est propre à la tâche en cours de traitement et fournit certains utilitaires que vous pouvez utiliser dans votre implémentation. Un objet de contexte est créé chaque fois qu'une nouvelle tâche est traitée par l'exécuteur.
## Contexte décisionnel
Lorsqu'une tâche de décision est exécutée, elle fournit le contexte de la mise en œuvre du flux de travail grâce à la classe `DecisionContext`. `DecisionContext` fournit des informations contextuelles telles que les ID d'exécution de flux de travail, et les fonctionnalités d'horloge et de minuteur.
### Accès lors de DecisionContext l'implémentation du flux de travail
Vous pouvez accéder à la classe `DecisionContext` dans l'implémentation de votre flux de travail à l'aide de la classe `DecisionContextProviderImpl`. Vous pouvez également injecter le contexte dans un champ ou une propriété de l'implémentation de votre flux de travail à l'aide de Spring comme illustré dans la section Injection de la testabilité et de la dépendance.
```
DecisionContextProvider contextProvider
= new DecisionContextProviderImpl();
DecisionContext context = contextProvider.getDecisionContext();
```
### Création d'une horloge et d'un minuteur
La classe `DecisionContext` contient une propriété de type `WorkflowClock` qui fournit une fonction de minuteur et d'horloge. La logique du flux de travail devant être déterministe, vous ne devez pas utiliser directement l'horloge système dans l'implémentation de votre flux de travail. La méthode `currentTimeMills` sur la classe `WorkflowClock` renvoie l'heure de l'événement de début de la décision en cours de traitement. Cela veille à ce que vous obteniez la même valeur temporelle pendant la reproduction, d'où l'importance d'une logique de flux de travail déterministe.
La classe `WorkflowClock` possède également une méthode `createTimer` qui renvoie un objet `Promise` qui sera prêt après l'intervalle spécifié. Vous pouvez utiliser cette valeur en tant que paramètre pour les autres méthodes asynchrones afin de retarder leur exécution de la durée spécifiée. De cette manière, vous pouvez efficacement planifier une méthode ou une activité asynchrone en vue d'une exécution ultérieure.
L'exemple de la liste suivante montre comment utiliser appeler une activité périodiquement.
```
@Workflow
@WorkflowRegistrationOptions(defaultExecutionStartToCloseTimeoutSeconds = 60,
defaultTaskStartToCloseTimeoutSeconds = 10)
public interface PeriodicWorkflow {
@Execute(version = "1.0")
void periodicWorkflow();
}
@Activities(version = "1.0")
@ActivityRegistrationOptions(defaultTaskScheduleToStartTimeoutSeconds = 300,
defaultTaskStartToCloseTimeoutSeconds = 3600)
public interface PeriodicActivity {
void activity1();
}
public class PeriodicWorkflowImpl implements PeriodicWorkflow {
private DecisionContextProvider contextProvider
= new DecisionContextProviderImpl();
private WorkflowClock clock
= contextProvider.getDecisionContext().getWorkflowClock();
@Override
public void periodicWorkflow() {
callPeriodicActivity(0);
}
@Asynchronous
private void callPeriodicActivity(int count,
Promise... waitFor) {
if (count == 100) {
return;
}
PeriodicActivityClient client = new PeriodicActivityClientImpl();
// call activity
Promise activityCompletion = client.activity1();
Promise timer = clock.createTimer(3600);
// Repeat the activity either after 1 hour or after previous activity run
// if it takes longer than 1 hour
callPeriodicActivity(count + 1, timer, activityCompletion);
}
}
public class PeriodicActivityImpl implements PeriodicActivity
{
@Override
public void activity1() {
...
}
}
```
Dans la liste ci-dessus, la méthode asynchrone `callPeriodicActivity` appelle un objet `activity1`, puis crée un minuteur à l'aide de la classe `AsyncDecisionContext` actuelle. Elle transmet l'objet `Promise` renvoyé en tant qu'argument à un appel récursif à elle-même. Cet appel récursif patiente jusqu'à ce que le minuteur se déclenche (1 heure dans cet exemple) avant l'exécution.
## Contexte d'exécution d'une activité
De la même manière que la classe `DecisionContext` fournit des informations contextuelles lorsqu'une tâche de décision est traitée, la classe `ActivityExecutionContext` fournit des informations contextuelles similaires lorsqu'une tâche d'activité est en cours de traitement. Ce contexte est disponible depuis votre code d'activité via la classe `ActivityExecutionContextProviderImpl`.
```
ActivityExecutionContextProvider provider
= new ActivityExecutionContextProviderImpl();
ActivityExecutionContext aec = provider.getActivityExecutionContext();
```
À l'aide la classe `ActivityExecutionContext`, vous pouvez exécuter les activités suivantes :
### Vérification des pulsations d'une activité de longue durée
Si l'activité dure longtemps, elle doit régulièrement signaler sa progression à Amazon SWF pour lui indiquer que la tâche progresse toujours. En cas d'absence de pulsations, le délai d'attente de la tâche peut être dépassé si un délai de pulsation de la tâche a été défini lors de l'enregistrement du type d'activité ou de la planification de l'activité. Afin d'envoyer une pulsation, vous pouvez utiliser la méthode `recordActivityHeartbeat` sur la classe `ActivityExecutionContext`. Heartbeat fournit également un mécanisme pour annuler les activités en cours. Consultez la section [Gestion des erreurs](errorhandling.md) pour en savoir plus et obtenir un exemple.
### Obtention des détails de la tâche d'activité
Si vous le souhaitez, vous pouvez obtenir tous les détails de la tâche d'activité transmise par Amazon SWF lorsque l'exécuteur a reçu la tâche. Cela comprend les informations concernant les entrées de la tâche, son type, son jeton, etc. Si vous souhaitez implémenter une activité exécutée manuellement, par exemple par une action humaine, vous devez utiliser le pour récupérer le jeton de tâche et le transmettre `ActivityExecutionContext` au processus qui finira par terminer la tâche d'activité. Pour en savoir plus, consultez la section sur [Finalisation manuelle des activités](activityimpl.md#activityimpl.complete).
### Obtenez l'objet client Amazon SWF utilisé par l'exécuteur
L'objet client Amazon SWF utilisé par l'exécuteur peut être récupéré en appelant `getService` method on. `ActivityExecutionContext` Cela est utile si vous souhaitez appeler directement le service Amazon SWF.