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.

# AWS Flow Framework pour Java Replay Behavior
<a name="programming-replay"></a>

Cette rubrique présente des exemples de comportements de reproduction, grâce aux exemples de la section [Qu'est-ce que le AWS Flow Framework pour Java ?](welcome.md). Les scénarios [synchrones](#programming-replay-synchronous) et [asynchrones](#programming-replay-asynchronous) sont présentés.

## Exemple 1 : Reproduction synchrone
<a name="programming-replay-synchronous"></a>

Pour un exemple du fonctionnement du replay dans un flux de travail synchrone, modifiez les implémentations du [HelloWorldWorkflow](getting-started-example-helloworldworkflow.md)flux de travail et des activités en ajoutant des `println` appels dans leurs implémentations respectives, comme suit :

```
public class GreeterWorkflowImpl implements GreeterWorkflow {
...
   public void greet() {
      System.out.println("greet executes");
      Promise<String> name = operations.getName();
      System.out.println("client.getName returns");
      Promise<String> greeting = operations.getGreeting(name);
      System.out.println("client.greeting returns");
      operations.say(greeting);
      System.out.println("client.say returns");
   }
}
**************
public class GreeterActivitiesImpl implements GreeterActivities {
   public String getName() {
      System.out.println("activity.getName completes");
      return "World";
   }

   public String getGreeting(String name) {
      System.out.println("activity.getGreeting completes");
      return "Hello " + name + "!";
   }

   public void say(String what) {
      System.out.println(what);
   }
}
```

Pour plus de détails sur le code, consultez [HelloWorldWorkflow Demande](getting-started-example-helloworldworkflow.md). Voici une version modifiée du résultat, avec des commentaires qui indiquent le début de chaque épisode de reproduction.

```
//Episode 1
greet executes
client.getName returns
client.greeting returns
client.say returns

activity.getName completes
//Episode 2
greet executes
client.getName returns
client.greeting returns
client.say returns

activity.getGreeting completes
//Episode 3
greet executes
client.getName returns
client.greeting returns
client.say returns

Hello World! //say completes
//Episode 4
greet executes
client.getName returns
client.greeting returns
client.say returns
```

Le processus de reproduction pour cet exemple fonctionne comme suit :
+ Le premier épisode planifie la tâche d'activité `getName` qui ne possède aucune dépendance.
+ Le deuxième épisode planifie la tâche d'activité `getGreeting` qui dépend de `getName`.
+ Le troisième épisode planifie la tâche d'activité `say` qui dépend de `getGreeting`.
+ Le dernier épisode ne planifie aucune tâche supplémentaire et ne trouve aucune activité inachevée, ce qui termine l'exécution de flux de travail. 

**Note**  
Les trois méthodes de client d'activité sont appelées une fois pour chaque épisode. Pourtant, seul un de ces appels se traduit par une tâche d'activité, ainsi chaque tâche n'est exécutée qu'une fois.

## Exemple 2 : Reproduction asynchrone
<a name="programming-replay-asynchronous"></a>

De même que pour l'[exemple de reproduction synchrone](#programming-replay-synchronous), vous pouvez modifier la [HelloWorldWorkflowAsync Demande](getting-started-example-helloworldworkflowasync.md) pour observer le fonctionnement d'une reproduction asynchrone. Cela produit le résultat suivant :

```
//Episode 1
greet executes
client.name returns
workflow.getGreeting returns
client.say returns

activity.getName completes
//Episode 2
greet executes
client.name returns
workflow.getGreeting returns
client.say returns
workflow.getGreeting completes

Hello World! //say completes
//Episode 3
greet executes
client.name returns
workflow.getGreeting returns
client.say returns
workflow.getGreeting completes
```

HelloWorldAsync utilise trois épisodes en replay car il n'y a que deux activités. L'activité `getGreeting` a été remplacée par la méthode de flux de travail asynchrone *getGreeting* qui ne lance pas un épisode de reproduction lorsqu'elle est terminée.

Le premier épisode n'appelle pas `getGreeting`, car il dépend de la fin de l'activité *name*. Pourtant, après la fin de *getName*, la reproduction appelle *getGreeting* une fois pour chaque épisode suivant.

## consultez aussi
<a name="see-also"></a>
+ [AWS Flow Framework Concepts de base : exécution distribuée](awsflow-basics-distributed-execution.md)