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. # HelloWorldWorkflowAsync Demande Il est parfois préférable de faire exécuter certaines tâches en local par un flux de travail au lieu d'utiliser une activité. Cependant, les tâches de flux de travail impliquent souvent le traitement des valeurs représentées par des objets `Promise`. Si vous transmettez un objet `Promise` à une méthode de flux de travail synchrone, la méthode s'exécute immédiatement mais elle ne peut pas accéder à la valeur de l'objet `Promise` tant que l'objet n'est pas prêt. Vous pouvez interroger l'objet `Promise.isReady` jusqu'à ce qu'il renvoie `true`, mais cela s'avère inefficace et la méthode peut se bloquer pendant longtemps. Une meilleure approche consiste à utiliser une *méthode asynchrone*. Une méthode asynchrone est implémentée de la même manière qu'une méthode standard, souvent en tant que membre de la classe d'implémentation du flux de travail, et s'exécute dans le contexte de l'implémentation du flux de travail. Vous la désignez en tant que méthode asynchrone en appliquant une annotation `@Asynchronous` qui demande à l'infrastructure de la traiter comme une activité. + Quand une implémentation de flux de travail appelle une méthode asynchrone, elle renvoie immédiatement un résultat. Les méthodes asynchrones renvoient généralement un objet `Promise` qui devient prêt quand la méthode se termine. + Si vous transmettez à une méthode asynchrone un ou plusieurs objets `Promise`, cela diffère l'exécution jusqu'à ce que tous les objets d'entrée soient prêts. Une méthode asynchrone peut donc accéder à ses valeurs `Promise` d'entrée sans risquer une exception. **Note** En raison de la façon dont AWS Flow Framework for Java exécute le flux de travail, les méthodes asynchrones s'exécutent généralement plusieurs fois. Vous ne devez donc les utiliser que pour des tâches rapides et peu coûteuses. Il est conseillée d'utiliser des activités pour effectuer des tâches de longue durée comme des calculs volumineux. Pour en savoir plus, consultez [AWS Flow Framework Concepts de base : exécution distribuée](awsflow-basics-distributed-execution.md). Cette rubrique est une présentation détaillée d' HelloWorldWorkflowAsyncune version modifiée HelloWorldWorkflow qui remplace l'une des activités par une méthode asynchrone. Pour implémenter l'application, créez une copie de HelloWorld. HelloWorldWorkflow placez le package dans le répertoire de votre projet et nommez-le HelloWorld. HelloWorldWorkflowAsync. **Note** Cette rubrique s'appuie sur les concepts et les fichiers présentés dans les rubriques [HelloWorld Demande](getting-started-example-helloworld.md) et [HelloWorldWorkflow Demande](getting-started-example-helloworldworkflow.md). Familiarisez-vous avec les fichiers et les concepts présentés dans ces rubriques avant de continuer. Les sections suivantes décrivent comment modifier le HelloWorldWorkflow code d'origine pour utiliser une méthode asynchrone. ## HelloWorldWorkflowAsync Mise en œuvre des activités HelloWorldWorkflowAsync implémente son interface de travail des activités`GreeterActivities`, comme suit : ``` import com.amazonaws.services.simpleworkflow.flow.annotations.Activities; import com.amazonaws.services.simpleworkflow.flow.annotations.ActivityRegistrationOptions; @Activities(version="2.0") @ActivityRegistrationOptions(defaultTaskScheduleToStartTimeoutSeconds = 300, defaultTaskStartToCloseTimeoutSeconds = 10) public interface GreeterActivities { public String getName(); public void say(String what); } ``` Cette interface est similaire à celle utilisée par HelloWorldWorkflow, avec les exceptions suivantes : + Elle omet l'activité `getGreeting` ; cette tâche est maintenant traitée par une méthode asynchrone. + Le numéro de version est défini sur 2.0. Une fois que vous avez enregistré une interface d'activités auprès d'Amazon SWF, vous ne pouvez pas la modifier à moins de changer le numéro de version. Les implémentations de méthodes d'activité restantes sont identiques à HelloWorldWorkflow. Supprimez juste `getGreeting` de `GreeterActivitiesImpl`. ## HelloWorldWorkflowAsync Mise en œuvre du workflow HelloWorldWorkflowAsync définit l'interface du flux de travail comme suit : ``` import com.amazonaws.services.simpleworkflow.flow.annotations.Execute; import com.amazonaws.services.simpleworkflow.flow.annotations.Workflow; import com.amazonaws.services.simpleworkflow.flow.annotations.WorkflowRegistrationOptions; @Workflow @WorkflowRegistrationOptions(defaultExecutionStartToCloseTimeoutSeconds = 3600) public interface GreeterWorkflow { @Execute(version = "2.0") public void greet(); } ``` L'interface est identique à l' HelloWorldWorkflow exception d'un nouveau numéro de version. Comme avec les activités, si vous souhaitez modifier un flux de travail enregistré, vous devez changer sa version. HelloWorldWorkflowAsync implémente le flux de travail comme suit : ``` import com.amazonaws.services.simpleworkflow.flow.annotations.Asynchronous; import com.amazonaws.services.simpleworkflow.flow.core.Promise; public class GreeterWorkflowImpl implements GreeterWorkflow { private GreeterActivitiesClient operations = new GreeterActivitiesClientImpl(); @Override public void greet() { Promise name = operations.getName(); Promise greeting = getGreeting(name); operations.say(greeting); } @Asynchronous private Promise getGreeting(Promise name) { String returnString = "Hello " + name.get() + "!"; return Promise.asPromise(returnString); } } ``` HelloWorldWorkflowAsync remplace l'`getGreeting`activité par une méthode `getGreeting` asynchrone mais la `greet` méthode fonctionne à peu près de la même manière : 1. Elle exécute l'activité `getName` qui renvoie immédiatement un objet `Promise`, `name`, qui représente le nom. 1. Appelez la méthode asynchrone `getGreeting` et transmettez-lui l'objet `name`. `getGreeting` renvoie immédiatement un objet `Promise`, `greeting`, qui représente la salutation. 1. Elle exécute l'activité `say` et la transmet à l'objet `greeting`. 1. Lorsque `getName` se termine, `name` devient prêt et `getGreeting` utilise sa valeur pour construire la salutation. 1. Lorsque `getGreeting` se termine, `greeting` devient prêt et `say` affiche la chaîne sur la console. La différence est que, au lieu d'appeler le client d'activités pour exécuter une activité `getGreeting`, la salutation appelle la méthode `getGreeting` asynchrone. le résultat est le même, mais la méthode `getGreeting` fonctionne quelque peu différemment de l'activité `getGreeting`. + L'exécuteur de flux de travail utilise une sémantique d'appel de fonction standard pour exécuter `getGreeting`. Toutefois, l'exécution asynchrone de l'activité est assurée par Amazon SWF. + `getGreeting` s'exécute dans le processus d'implémentation de flux de travail. + `getGreeting` renvoie un objet `Promise` au lieu d'un objet `String`. Pour obtenir la valeur de chaîne détenue par `Promise`, vous appelez sa méthode `get()`. Cependant, étant donné que l'activité est exécutée de manière asynchrone, sa valeur de retour peut ne pas être prête immédiatement ; cela `get()` déclenchera une exception jusqu'à ce que la valeur de retour de la méthode asynchrone soit disponible. Pour plus d'informations sur la façon dont `Promise` fonctionne, consultez [AWS Flow Framework Concepts de base : échange de données entre les activités et les flux de travail](awsflow-basics-data-exchange-activities-workflows.md). `getGreeting` crée une valeur de retour en transmettant la chaîne de salutation à la méthode `Promise.asPromise` statique. Cette méthode crée un objet `Promise` du type approprié, définit la valeur et le met à l'état prêt. ## HelloWorldWorkflowAsync Workflow et activités Host and Starter HelloWorldWorkflowAsync implémente en `GreeterWorker` tant que classe hôte pour les implémentations de flux de travail et d'activités. Il est identique à l' HelloWorldWorkflowimplémentation à l'exception du `taskListToPoll` nom, qui est défini sur « `HelloWorldAsyncList` ». ``` import com.amazonaws.ClientConfiguration; import com.amazonaws.auth.AWSCredentials; import com.amazonaws.auth.BasicAWSCredentials; import com.amazonaws.services.simpleworkflow.AmazonSimpleWorkflow; import com.amazonaws.services.simpleworkflow.AmazonSimpleWorkflowClient; import com.amazonaws.services.simpleworkflow.flow.ActivityWorker; import com.amazonaws.services.simpleworkflow.flow.WorkflowWorker; public class GreeterWorker { public static void main(String[] args) throws Exception { ClientConfiguration config = new ClientConfiguration().withSocketTimeout(70*1000); String swfAccessId = System.getenv("AWS_ACCESS_KEY_ID"); String swfSecretKey = System.getenv("AWS_SECRET_KEY"); AWSCredentials awsCredentials = new BasicAWSCredentials(swfAccessId, swfSecretKey); AmazonSimpleWorkflow service = new AmazonSimpleWorkflowClient(awsCredentials, config); service.setEndpoint("https://swf.us-east-1.amazonaws.com"); String domain = "helloWorldWalkthrough"; String taskListToPoll = "HelloWorldAsyncList"; ActivityWorker aw = new ActivityWorker(service, domain, taskListToPoll); aw.addActivitiesImplementation(new GreeterActivitiesImpl()); aw.start(); WorkflowWorker wfw = new WorkflowWorker(service, domain, taskListToPoll); wfw.addWorkflowImplementationType(GreeterWorkflowImpl.class); wfw.start(); } } ``` HelloWorldWorkflowAsync implémente le démarreur du flux de travail dans `GreeterMain` ; il est identique à l' HelloWorldWorkflow implémentation. Pour exécuter le flux de travail, exécutez `GreeterWorker` et`GreeterMain`, comme avec HelloWorldWorkflow.