HelloWorldWorkflow Demande

Bien que l'HelloWorldexemple de base soit structuré comme un flux de travail, il diffère d'un flux de travail Amazon SWF à plusieurs égards essentiels :

Applications de flux de travail classiques et Amazon SWF
HelloWorld	Flux de travail Amazon SWF
S'exécute localement sous la forme d'un processus unique.	S'exécute sous la forme de plusieurs processus qui peuvent être répartis sur plusieurs systèmes, notamment les instances Amazon EC2, les centres de données privés, les ordinateurs clients, etc. Ces derniers n'ont pas besoin d'être exécutés sur le même système d'exploitation.
Les activités sont des méthodes synchrones, qui sont bloquées tant qu'elles ne sont pas terminées.	Les activités sont représentées par des méthodes asynchrones, qui renvoient des données immédiatement et qui permettent au flux de travail d'exécuter d'autres tâches en attendant la fin de l'exécution de l'activité.
L'exécuteur de flux de travail interagit avec un exécuteur d'activités en appelant la méthode appropriée.	Les travailleurs du flux de travail interagissent avec les travailleurs des activités à l'aide de requêtes HTTP, Amazon SWF jouant le rôle d'intermédiaire.
Le démarreur de flux de travail interagit avec un objet exécuteur de flux de travail en appelant la méthode appropriée.	Les initiateurs de flux de travail interagissent avec les travailleurs de flux de travail à l'aide de requêtes HTTP, Amazon SWF jouant le rôle d'intermédiaire.

Vous pouvez implémenter une application de flux de travail asynchrone réparti à partir de rien, par exemple, en faisant en sorte que votre objet exécuteur de flux de travail interagisse avec un objet de travail d'activités directement via des appels de services web. Toutefois, vous devez alors implémenter tout le code compliqué nécessaire à la gestion de l'exécution asynchrone de plusieurs activités, gérer le flux de données, etc. AWS Flow Framework for Java et Amazon SWF s'occupent de tous ces détails, ce qui vous permet de vous concentrer sur la mise en œuvre de la logique métier.

HelloWorldWorkflow est une version modifiée de HelloWorld qui s'exécute en tant que flux de travail Amazon SWF. Le schéma suivant résume le fonctionnement des deux applications.

HelloWorld s'exécute comme un processus unique et le démarreur, le responsable du flux de travail et le responsable des activités interagissent à l'aide d'appels de méthode conventionnels. AvecHelloWorldWorkflow, le démarreur, le gestionnaire de flux de travail et le gestionnaire d'activités sont des composants distribués qui interagissent via Amazon SWF à l'aide de requêtes HTTP. Amazon SWF gère l'interaction en tenant à jour des listes de tâches de flux de travail et d'activités, qu'il distribue aux composants respectifs. Cette section décrit le fonctionnement du framework HelloWorldWorkflow.

HelloWorldWorkflow est implémenté à l'aide de l'API AWS Flow Framework for Java, qui gère les détails parfois complexes liés à l'interaction avec Amazon SWF en arrière-plan et simplifie considérablement le processus de développement. Vous pouvez utiliser le même projet que celui pour lequel vous l'avez fait HelloWorld, qui est déjà configuré AWS Flow Framework pour les applications Java. Toutefois, pour exécuter l'application, vous devez configurer un compte Amazon SWF, comme suit :

• Ouvrez un AWS compte, si vous n'en avez pas déjà un, sur Amazon Web Services.

• Affectez respectivement l'ID d'accès et l'ID de code secret de votre compte aux variables d'environnement AWS_ACCESS_KEY_ID et AWS_SECRET_KEY. Il est conseillé de ne pas afficher les valeurs de clé littérale dans votre code. Le stockage de ces clés dans les variables d'environnement vous permet de respecter cette pratique.

• Ouvrez un compte Amazon SWF sur Amazon Simple Workflow Service.

• Connectez-vous au service Amazon SWF AWS Management Console et sélectionnez-le.

• Choisissez Gérer les domaines dans le coin supérieur droit et enregistrez un nouveau domaine Amazon SWF. Un domaine est un conteneur logique pour vos ressources d'application, comme les types de flux de travail et d'activité, et les exécutions de flux de travail. Vous pouvez utiliser n'importe quel nom de domaine pratique, mais les procédures pas à pas utilisent « »helloWorldWalkthrough.

Pour implémenter le HelloWorldWorkflow, créez une copie de HelloWorld. HelloWorld placez le package dans le répertoire de votre projet et nommez-le HelloWorld. HelloWorldWorkflow. Les sections suivantes décrivent comment modifier le HelloWorld code d'origine afin d'utiliser le AWS Flow Framework pour Java et de l'exécuter en tant qu'application de flux de travail Amazon SWF.

HelloWorldWorkflow Travailleur des activités

HelloWorld a mis en œuvre ses activités de travailleur en tant que classe unique. Un outil AWS Flow Framework de travail pour les activités Java comporte trois composants de base :

• Les méthodes d'activité, qui exécutent les tâches réelles, sont définies dans une interface et implémentées dans une classe associée.

• Une ActivityWorkerclasse gère l'interaction entre les méthodes d'activité et Amazon SWF.

• Une application hôte d'activités enregistre et démarre l'exécuteur d'activités, et gère les nettoyages.

Cette section présente les méthodes d'activité ; les deux autres classes seront présentées ultérieurement.

HelloWorldWorkflow définit l'interface des activités dansGreeterActivities, comme suit :

import com.amazonaws.services.simpleworkflow.flow.annotations.Activities;
import com.amazonaws.services.simpleworkflow.flow.annotations.ActivityRegistrationOptions;

@ActivityRegistrationOptions(defaultTaskScheduleToStartTimeoutSeconds = 300,
                             defaultTaskStartToCloseTimeoutSeconds = 10)
@Activities(version="1.0")

public interface GreeterActivities {
   public String getName();
   public String getGreeting(String name);
   public void say(String what);
}

Cette interface n'était pas strictement nécessaire pour HelloWorld, mais elle l'est AWS Flow Framework pour une application Java. Notez que la définition de l'interface elle-même n'a pas changé. Cependant, vous devez en appliquer deux AWS Flow Framework pour les annotations Java @ActivityRegistrationOptions et @Activités pour la définition de l'interface. Les annotations fournissent des informations de configuration et indiquent au processeur d'annotations AWS Flow Framework pour Java d'utiliser la définition de l'interface pour générer une classe de clients d'activités, dont il sera question plus loin.

@ActivityRegistrationOptionspossède plusieurs valeurs nommées qui sont utilisées pour configurer le comportement des activités. HelloWorldWorkflow spécifie deux délais d'expiration :

• defaultTaskScheduleToStartTimeoutSeconds indique combien de temps les tâches peuvent rester dans la liste des tâches d'activités ; ce délai est défini sur 300 secondes (5 minutes).

• defaultTaskStartToCloseTimeoutSeconds indique le temps maximal dont une activité peut disposer pour exécuter la tâche ; ce délai est défini sur 10 secondes.

Ces délais d'attente permettent de s'assurer que l'activité exécute sa tâche dans un délai raisonnable. Si l'un de ces délais est dépassé, la structure génère une erreur et l'objet exécuteur de flux de travail doit décider de la façon dont le problème sera résolu. Pour obtenir des informations sur la façon de gérer ces erreurs, consultez Gestion des erreurs.

@Activities comporte plusieurs valeurs, mais généralement cet élément définit simplement le numéro de version des activités, ce qui vous permet de conserver une trace des différentes générations d'implémentations d'activité. Si vous modifiez une interface d'activité après l'avoir enregistrée auprès d'Amazon SWF, notamment en modifiant les @ActivityRegistrationOptions valeurs, vous devez utiliser un nouveau numéro de version.

HelloWorldWorkflow implémente les méthodes GreeterActivitiesImpl d'activité comme suit :

public class GreeterActivitiesImpl implements GreeterActivities {
   @Override
   public String getName() {
      return "World";
   }
   @Override
   public String getGreeting(String name) {
      return "Hello " + name;
   }
   @Override
   public void say(String what) {
      System.out.println(what);
   }
}

Notez que le code est identique à l' HelloWorld implémentation. À la base, une AWS Flow Framework activité n'est qu'une méthode qui exécute du code et renvoie peut-être un résultat. La différence entre une application standard et une application de flux de travail Amazon SWF réside dans la manière dont le flux de travail exécute les activités, dans quel endroit les activités s'exécutent et dans la manière dont les résultats sont renvoyés au gestionnaire du flux de travail.

HelloWorldWorkflow Travailleur du workflow

Un gestionnaire de flux de travail Amazon SWF comporte trois composants de base.

• Une implémentation de flux de travail, qui est une classe exécutant des tâches liés aux flux de travail.

• Une classe client d'activités, qui est à la base un proxy destiné à la classe d'activités et qui est utilisé par une implémentation de flux de travail pour exécuter les méthodes d'activité de façon asynchrone.

• Une WorkflowWorkerclasse qui gère l'interaction entre le flux de travail et Amazon SWF.

Cette section présente l'implémentation de flux de travail et le client d'activités ; la classe WorkflowWorker sera présentée ultérieurement.

HelloWorldWorkflow définit l'interface du flux GreeterWorkflow 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 = "1.0")
   public void greet();
}

Cette interface n'est pas non plus strictement nécessaire HelloWorld mais essentielle AWS Flow Framework pour une application Java. Vous devez en appliquer deux AWS Flow Framework pour les annotations Java @Flux de travail et @WorkflowRegistrationOptions pour la définition de l'interface du flux de travail. Les annotations fournissent des informations de configuration et indiquent également au processeur d'annotations AWS Flow Framework pour Java de générer une classe client de flux de travail basée sur l'interface, comme indiqué plus loin.

@Workflowpossède un paramètre facultatif, DataConverter, qui est souvent utilisé avec sa valeur par défaut, qui indique qu' NullDataConverteril doit être utilisé. JsonDataConverter

@WorkflowRegistrationOptions comporte aussi un certain nombre de paramètres facultatifs qui peuvent être utilisés pour configurer l'objet exécuteur de flux de travail. Ici, nous avons défini la durée pendant defaultExecutionStartToCloseTimeoutSeconds laquelle le flux de travail peut s'exécuter à 3 600 secondes (1 heure).

La définition de GreeterWorkflow l'interface diffère HelloWorld de l'@Executeannotation sur un point important. Les interfaces de flux de travail définissent les méthodes pouvant être appelées par les applications telles que le démarreur de flux de travail, et sont limitées à une poignée de méthodes , chacune avec un rôle particulier. Le framework ne spécifie pas de nom ou de liste de paramètres pour les méthodes d'interface de flux de travail ; vous utilisez une liste de noms et de paramètres adaptée à votre flux de travail et vous appliquez une annotation AWS Flow Framework pour Java pour identifier le rôle de la méthode.

@Execute a deux objectifs :

• Il identifie greet comme le point d'entrée du flux de travail, c'est-à-dire la méthode que le démarreur de flux de travail appelle pour démarrer le flux de travail. En général, un point d'entrée peut être associé à un ou plusieurs paramètres, ce qui permet au démarreur d'initialiser le flux de travail, mais cet exemple ne requiert pas d'initialisation.

• Il définit le numéro de version du flux de travail, ce qui vous permet de conserver une trace des différentes générations d'implémentations de flux de travail. Pour modifier une interface de flux de travail après l'avoir enregistrée auprès d'Amazon SWF, notamment pour modifier les valeurs de délai d'expiration, vous devez utiliser un nouveau numéro de version.

Pour obtenir des informations sur les autres méthodes pouvant être incluses dans une interface de flux de travail, consultez Contrats de flux de travail et d'activité.

HelloWorldWorkflow implémente le flux GreeterWorkflowImpl de travail comme suit :

import com.amazonaws.services.simpleworkflow.flow.core.Promise;

public class GreeterWorkflowImpl implements GreeterWorkflow {
   private GreeterActivitiesClient operations = new GreeterActivitiesClientImpl();

   public void greet() {
     Promise<String> name = operations.getName();
     Promise<String> greeting = operations.getGreeting(name);
     operations.say(greeting);
   }
}

Le code est similaire HelloWorld, mais avec deux différences importantes.

• GreeterWorkflowImpl crée une instance de GreeterActivitiesClientImpl, le client d'activité, au lieu de GreeterActivitiesImpl, et exécute les activités en appelant des méthodes sur l'objet client.

• Les activités de nom et de salutation renvoient des objets Promise<String> au lieu d'objets String.

HelloWorld est une application Java standard qui s'exécute localement en tant que processus unique. Elle GreeterWorkflowImpl peut donc implémenter la topologie du flux de travail en créant simplement une instance deGreeterActivitiesImpl, en appelant les méthodes dans l'ordre et en transmettant les valeurs de retour d'une activité à l'autre. Avec un flux de travail Amazon SWF, la tâche d'une activité est toujours exécutée par une méthode d'activité provenant de. GreeterActivitiesImpl Toutefois, la méthode ne s'exécute pas forcément dans le même processus que le flux de travail (elle peut même ne pas s'exécuter sur le même système) et le flux de travail a besoin d'exécuter l'activité de façon asynchrone. Ces conditions requises posent les problèmes suivants :

• Comment exécuter une méthode d'activité qui peut être exécutée dans un processus différent, voire même sur un système différent ?

• Comment exécuter une méthode d'activité de façon asynchrone ?

• Comment gérer les valeurs d'entrée et les valeurs de retour des activités ? Par exemple, si la valeur renvoyée par l'activité A est une valeur d'entrée de l'activité B, vous devez vous assurer que l'activité B ne s'exécute pas tant que l'activité A n'est pas terminée.

Vous pouvez implémenter diverses topologies de flux de travail via le flux de contrôle de l'application en utilisant le contrôle de flux Java courant avec le client d'activités et l'élément Promise<T>.

Client d'activités

GreeterActivitiesClientImpl est à la base un proxy destiné à GreeterActivitiesImpl qui permet à une implémentation de flux de travail d'exécuter les méthodes GreeterActivitiesImpl de façon asynchrone.

Les classes GreeterActivitiesClient et GreeterActivitiesClientImpl sont générées automatiquement à partir des informations fournies dans les annotations appliquées à votre classe GreeterActivities. Vous n'avez pas besoin de les implémenter vous-même.

Note

Eclipse génère ces classes lorsque vous sauvegardez votre projet. Vous pouvez afficher le code généré dans le sous-répertoire .apt_generated de votre répertoire de projet.

Afin d'éviter les erreurs de compilation dans votre classe GreeterWorkflowImpl, il est conseillé de déplacer le répertoire .apt_generated vers le haut de l'onglet Order and Export (Ordonner et exporter) dans la boîte de dialogue Java Build Path (Chemin de génération Java).

Un objet exécuteur de flux de travail exécute une activité en appelant la méthode de client correspondante. Cette méthode est asynchrone et renvoie immédiatement un objet Promise<T>, où T représente le type de retour de l'activité. L'objet Promise<T> renvoyé est à la base un espace réservé pour la valeur finalement renvoyée par la méthode d'activité.

• Lorsque la méthode du client d'activités renvoie des données, l'objet Promise<T> est initialement à l'état non prêt, ce qui indique que l'objet ne représente pas pour l'instant un valeur de retour valide.

• Lorsque la méthode d'activité correspondante a terminé et renvoyé sa tâche, l'infrastructure affecte la valeur de retour à l'objet Promise<T> et le place dans l'état prêt.

Promets- <T> Type

Le premier objectif des objets Promise<T> est de gérer le flux de données entre les composants asynchrones et le contrôle lorsqu'ils s'exécutent. Il évitent à votre application de devoir gérer de façon explicite la synchronisation ou de dépendre de mécanismes tels que les temporisateurs pour s'assurer que les composants asynchrones ne s'exécutent pas prématurément. Lorsque vous appelez une méthode de client d'activités, elle renvoie immédiatement des données mais l'infrastructure diffère l'exécution de la méthode d'activité correspondante jusqu'à ce qu'un objet d'entrée Promise<T> soit prêt et représente des données valides.

À partir de la perspective GreeterWorkflowImpl, les trois méthodes de client d'activités renvoient des données immédiatement. À partir de la perspective GreeterActivitiesImpl, l'infrastructure n'appelle pas getGreeting tan que name n'a pas terminé son exécution et n'appelle pas say tant que getGreeting n'a pas non plus terminé son exécution.

L'utilisation de Promise<T> pour transmettre des données d'une activité à la suivante permet à HelloWorldWorkflow de s'assurer que les méthodes d'activité ne tentent pas d'utiliser des données non valides, mais aussi de contrôler le moment auquel les activités s'exécutent et, implicitement, de définir la topologie du flux de travail. La transmission de la valeur de retour Promise<T> de chaque activité à l'activité suivante nécessite que l'activité suivante s'exécute séquentiellement, en définissant la topologie linéaire présentée préalablement. Avec AWS Flow Framework for Java, vous n'avez pas besoin d'utiliser de code de modélisation spécial pour définir des topologies, même complexes, il suffit d'utiliser un contrôle de flux Java standard etPromise<T>. Pour obtenir un exemple d'implémentation d'une topologie parallèle simple, consultez Exécuteur d'activité HelloWorldWorkflowParallel.

Note

Lorsqu'une méthode d'activité telle que say ne renvoie pas de valeur, la méthode du client correspondante renvoie un objet Promise<Void>. Cet objet ne représente pas des données, mais il est initialement à l'état non prêt et il devient prêt lorsque l'exécution d'une activité se termine. Vous pouvez donc transmettre un objet Promise<Void> aux autres méthodes de client d'activités afin de vous assurer qu'elles diffèrent l'exécution jusqu'à ce que l'activité initiale soit terminée.

Promise<T> permet à une implémentation de flux de travail d'utiliser les méthodes de client d'activités et leurs valeurs de retour de la même manière que les méthodes synchrones. Toutefois, vous devez être prudent lors de l'accès à la valeur d'un objet Promise<T>. Contrairement au type Java Future<T>, l'infrastructure gère la synchronisation pour Promise<T>, pas l'application. Si vous appelez Promise<T>.get et que l'objet n'est pas prêt, get émet une exception. Notez que HelloWorldWorkflow n'accède jamais directement à un objet Promise<T> ; il transmet simplement les objets d'une activité à la suivante. Lorsqu'un objet devient prêt, l'infrastructure extrait la valeur et la transmet à la méthode d'activité sous la forme d'un type standard.

Les objets Promise<T> doivent être accessibles uniquement par le code asynchrone, où l'infrastructure garantit que l'objet est prêt et représente une valeur valide. HelloWorldWorkflow traite ce problème en transmettant les objets Promise<T> uniquement aux activités des méthodes client. Vous pouvez accéder à la valeur d'un objet Promise<T> dans l'implémentation du flux de travail en transmettant l'objet à une méthode de flux de travail asynchrone, qui se comporte de façon similaire à une activité. Pour obtenir un exemple, consultez Application HelloWorldWorkflowAsync.

HelloWorldWorkflow Mise en œuvre des flux de travail et activités

Les implémentations du flux de travail et des activités ont des classes de travail associées, ActivityWorkeret WorkflowWorker. Ils gèrent la communication entre Amazon SWF et les activités et implémentations de flux de travail en interrogeant la liste de tâches Amazon SWF appropriée pour les tâches, en exécutant la méthode appropriée pour chaque tâche et en gérant le flux de données. Pour plus d’informations, consultez AWS Flow FrameworkConcepts de base : structure de l'application.

Pour associer les implémentations de flux de travail et d'activités aux objets exécuteurs correspondants, vous implémentez une ou plusieurs applications de travail qui effectuent les tâches suivantes :

• Enregistrez des flux de travail ou des activités avec Amazon SWF.

• Création d'objets exécuteur et association de ces derniers avec les implémentations de travail d'activité ou de flux de travail

• Demandez aux objets de travail de commencer à communiquer avec Amazon SWF.

Si vous souhaitez exécuter le flux de travail et les activités sous forme de processus distincts, vous devez implémenter des hôtes d'exécuteur de flux de travail et d'activités distincts. Pour obtenir un exemple, consultez Application HelloWorldWorkflowDistributed. Pour des raisons de simplicité, HelloWorldWorkflow implémente un hôte de travail unique qui exécute les activités et les travailleurs du flux de travail dans le même processus, comme suit :

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 = "HelloWorldList";

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

GreeterWorkern'a pas d' HelloWorld équivalent, vous devez donc ajouter une classe Java nommée GreeterWorker au projet et copier l'exemple de code dans ce fichier.

La première étape consiste à créer et à configurer un AmazonSimpleWorkflowClientobjet qui invoque les méthodes de service Amazon SWF sous-jacentes. Pour ce faire, GreeterWorker :

1. Crée un ClientConfigurationobjet et spécifie un délai d'expiration du socket de 70 secondes. Cette valeur définit combien de temps le système attend que les données soient transférées via une connexion ouverte établie avant de fermer le socket.

2. Crée un AWSCredentials objet Basic pour identifier le AWS compte et transmet les clés du compte au constructeur. Pour plus de commodité et afin d'éviter de les afficher en texte brut dans le code, les clés sont stockées sous forme de variables d'environnement.

3. Crée un AmazonSimpleWorkflowClientobjet pour représenter le flux de travail et transmet les ClientConfiguration objets BasicAWSCredentials et au constructeur.

4. Définit l'URL du point de terminaison de service de l'objet client. Amazon SWF est actuellement disponible dans toutes les AWS régions.

Pour plus de commodité, GreeterWorker définit deux constantes de chaîne :

• domainest le nom de domaine Amazon SWF du flux de travail, que vous avez créé lors de la configuration de votre compte Amazon SWF. HelloWorldWorkflowsuppose que vous exécutez le flux de travail dans le domaine helloWorldWalkthrough « ».

• taskListToPollest le nom des listes de tâches qu'Amazon SWF utilise pour gérer la communication entre les travailleurs du flux de travail et des activités. Vous pouvez utiliser n'importe quelle chaîne. HelloWorldWorkflow utilise « HelloWorldList » pour les listes de tâches liées aux flux de travail et aux activités. En arrière-plan, les noms se terminent par des espaces de noms différents ; les listes de tâches sont donc distinctes.

GreeterWorkerutilise les constantes de chaîne et l'AmazonSimpleWorkflowClientobjet pour créer des objets de travail, qui gèrent l'interaction entre les activités et les implémentations de travail et Amazon SWF. Les objets exécuteur gèrent en particulier la tâche de recherche de tâches dans la liste des tâches appropriée.

GreeterWorker crée un objet ActivityWorker et le configure pour gérer GreeterActivitiesImpl en ajoutant une nouvelle instance de classe. GreeterWorker appelle ensuite la méthode start de l'objet ActivityWorker, qui indique à l'objet de commencer à interroger la liste des tâches des activités spécifiées.

GreeterWorker crée un objet WorkflowWorker et le configure pour gérer GreeterWorkflowImpl en ajoutant le nom de fichier de classe GreeterWorkflowImpl.class. IL appelle ensuite dans l'objet WorkflowWorker la méthode start qui indique à l'objet qu'il doit lancer la recherche des tâches dans la liste de tâches de flux de travail spécifiée.

Vous pouvez exécuter GreeterWorker avec succès à partir de ce moment. Il enregistre le flux de travail et les activités dans Amazon SWF et lance les objets de travail à interroger leurs listes de tâches respectives. Pour vérifier cela, exécutez GreeterWorker et accédez à la console Amazon SWF, puis sélectionnez un helloWorldWalkthrough domaine dans la liste des domaines. Si vous choisissez Workflow Types (Types de flux de travail) dans le volet Navigation, vous devez voir GreeterWorkflow.greet:

Si vous choisissez Activity Types (Types d'activités), les méthodes GreeterActivities s'affichent :

Toutefois, si vous choisissez Workflow Executions (Exécutions de flux de travail), vous ne verrez aucune exécution active. Bien que les exécuteurs d'activités et de flux de travail soient en train de rechercher les tâches, nous n'avons pas encore démarré une exécution du flux de travail.

HelloWorldWorkflow Démarreur

La dernière pièce du puzzle consiste à implémenter le démarreur de flux de travail, qui est une application lançant l'exécution du flux de travail. L'état d'exécution est stocké par Amazon SWF, afin que vous puissiez consulter son historique et son état d'exécution. HelloWorldWorkflow implémente un démarreur de flux de travail en modifiant la GreeterMain classe, comme suit :

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;

public class GreeterMain {

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

     GreeterWorkflowClientExternalFactory factory = new GreeterWorkflowClientExternalFactoryImpl(service, domain);
     GreeterWorkflowClientExternal greeter = factory.getClient("someID");
     greeter.greet();
   }
}

GreeterMain crée un objet AmazonSimpleWorkflowClient en utilisant le même code que GreeterWorker. Il crée ensuite un objet GreeterWorkflowClientExternal qui agit comme un proxy pour le flux de travail, de la même manière que le client d'activités créé dans GreeterWorkflowClientImpl agit comme un proxy pour les méthodes d'activité. Au lieu de créer un objet de client de flux de travail en utilisant new, vous devez :

1. Créez un objet d'usine client externe et transmettez l'AmazonSimpleWorkflowClientobjet et le nom de domaine Amazon SWF au constructeur. L'objet client factory est créé par le processeur d'annotation du framework, qui crée le nom de l'objet en ajoutant simplement « ClientExternalFactoryImpl » au nom de l'interface du flux de travail.

2. Créez un objet client externe en appelant la getClient méthode de l'objet d'usine, qui crée le nom de l'objet en ajoutant « ClientExternal » au nom de l'interface du flux de travail. Vous pouvez éventuellement transmettre getClient une chaîne qu'Amazon SWF utilisera pour identifier cette instance du flux de travail. Sinon, Amazon SWF représente une instance de flux de travail à l'aide d'un GUID généré.

Le client renvoyé par l'usine créera uniquement des flux de travail nommés à l'aide de la chaîne transmise à la méthode GetClient (le client renvoyé par l'usine possède déjà un état dans Amazon SWF). Pour exécuter un flux de travail avec un ID différent, vous devez revenir à la fabrique et créer un nouveau client avec l'ID différent spécifié.

Le client du flux de travail affiche une méthode greet qui est appelée par GreeterMain pour commencer l'exécution du flux de travail, car greet() est la méthode qui a été spécifiée avec l'annotation @Execute.

Note

Le processeur d'annotations crée aussi un objet de fabrique de clients interne qui est utilisé pour créer des flux de travail enfants. Pour plus de détails, consultez Exécutions de flux de travail enfant.

Arrêtez GreeterWorker pour le moment s'il est toujours en cours d'exécution, et exécutez GreeterMain. Vous devriez maintenant voir SomeID dans la liste des exécutions de flux de travail actives de la console Amazon SWF :.

Si vous choisissez someID et que vous choisissez l'onglet Events (Événements), les événements suivants s'affichent :

Note

Si vous avez déjà démarré GreeterWorker et qu'il est toujours en cours d'exécution, vous verrez une liste d'événements plus longue pour des raisons que nous évoquerons plus loin. Arrêtez GreeterWorker et essayez d'exécuter à nouveau GreaterMain.

L'onglet Events (Événements) affiche seulement deux événements :

• WorkflowExecutionStarted indique que le flux de travail a commencé son exécution.

• DecisionTaskScheduledindique qu'Amazon SWF a mis en file d'attente la première tâche de décision.

La raison pour laquelle le flux de travail est bloqué sur la première tâche de décision est que le flux de travail est réparti entre deux applications, GreeterMain et GreeterWorker. GreeterMain a démarré l'exécution du flux de travail, mais GreeterWorker n'est pas en cours d'exécution, de telle sorte que les applications de travail n'interrogent pas les listes et n'exécutent pas les tâches. Vous pouvez exécuter l'une ou l'autre des applications de façon indépendante, mais vous avez besoin des deux pour que l'exécution du flux de travail aille au-delà de la première tâche de décision. Si vous exécutez à présent GreeterWorker, les objets exécuteur de flux de travail et d'activité vont commencer à interroger les listes et les diverses tâches seront rapidement exécutées. Si vous consultez à présent l'onglet Events, le premier lot d'événements s'affiche.

Vous pouvez choisir des événements individuels pour obtenir plus d'informations. Lorsque vous aurez fini de chercher, le flux de travail devrait avoir imprimé « Hello World ! » sur votre console.

Une fois que le flux de travail est terminé, il ne s'affiche plus dans la liste des exécutions actives. Toutefois, si vous souhaitez le passer en revue, choisissez le bouton de statut d'exécution Closed (Fermé), puis choisissez List Executions (Liste des exécutions). Vous affichez ainsi la totalité des instances de flux de travail terminées dans le domaine spécifié (helloWorldWalkthrough) et qui n'ont pas dépassé leur durée de conservation maximale (durée que vous avez définie lors de la création du domaine).

Notez que chaque instance de flux de travail possède une valeur Run ID (ID d'exécution) unique. Vous pouvez utiliser le même ID d'exécution pour différentes instances de flux de travail, mais pour une seule exécution active à la fois.