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.

Exécution de programmes écrits avecAWS Flow Frameworkpour Java

Le cadre fournitclasses de travailpour initialiser laAWS Flow Frameworkpour Java Runtime et communiquez avec Amazon SWF. Pour implémenter un objet exécuteur de flux de travail ou d'activité, vous devez créer et démarrer une instance de classe d'exécuteur. Ces classes de travail sont chargées de la gestion des opérations asynchrones en cours, de l'appel aux méthodes asynchrones qui se débloquent et de la communication avec Amazon SWF. Elles peuvent être configurées avec des implémentations de flux de travail et d'activité, le nombre de threads, la liste des tâches à interroger, etc.

L'infrastructure est livrée avec deux classes d'exécuteur, une pour les activités et une pour les flux de travail. Pour exécuter la logique de flux de travail, utilisez la classe WorkflowWorker. De même, la classe ActivityWorker est utilisée pour les activités. Ces classes interrogent automatiquement sur Amazon SWF pour détecter les tâches d'activité et invoquent les méthodes appropriées dans votre implémentation.

L'exemple suivant montre comment instancier une classe WorkflowWorker et lancer l'interrogation pour la recherche de tâches :

AmazonSimpleWorkflow swfClient = new AmazonSimpleWorkflowClient(awsCredentials);
WorkflowWorker worker = new WorkflowWorker(swfClient, "domain1", "tasklist1");
// Add workflow implementation types
worker.addWorkflowImplementationType(MyWorkflowImpl.class);

// Start worker
worker.start();

Les étapes de base pour créer une instance de la classe ActivityWorker et lancer l'interrogation pour la recherche de tâches sont les suivantes :

AmazonSimpleWorkflow swfClient
      = new AmazonSimpleWorkflowClient(awsCredentials);
ActivityWorker worker = new ActivityWorker(swfClient,
                                           "domain1",
                                           "tasklist1");
worker.addActivitiesImplementation(new MyActivitiesImpl());

// Start worker
worker.start();  

Lorsque vous souhaitez arrêter une activité ou un décideur, votre application doit arrêter les instances des classes de travail utilisées, ainsi que l'instance du client Java Amazon SWF. Cela permet de s'assurer que toutes les ressources utilisées par les classes d'exécuteur sont correctement libérées.

worker.shutdown();
worker.awaitTermination(1, TimeUnit.MINUTES);
  

Pour démarrer une exécution, créez simplement une instance du client externe généré et appelez la méthode @Execute.

MyWorkflowClientExternalFactory factory = new MyWorkflowClientExternalFactoryImpl();
MyWorkflowClientExternal client = factory.getClient();
client.start();

WorkflowWorker

Comme son nom l'indique, cette classe d'exécuteur est destinée à être utilisée par l'implémentation de flux de travail. Elle est configurée avec une liste de tâches et le type d'implémentation du flux de travail. La classe d'exécuteur exécute une boucle pour rechercher les tâches de décision dans la liste des tâches spécifiée. Lors de la réception d'une tâche de décision, elle crée une instance de l'implémentation du flux de travail et appelle la méthode @Execute pour traiter la tâche.

ActivityWorker

Pour implémenter des exécuteurs d'activité, vous pouvez utiliser la classe ActivityWorker pour rechercher facilement des tâches d'activité dans une liste de tâches. Vous configurez l'exécuteur d'activité avec les objets d'implémentation d'activité. Cette classe d'exécuteur exécute une boucle pour rechercher les tâches d'activité dans la liste des tâches spécifiée. Lors de la réception d'une tâche d'activité, elle recherche l'implémentation appropriée que vous avez fournie et appelle la méthode d'activité pour traiter la tâche. Contrairement à WorkflowWorker, qui appelle la fabrique à créer une nouvelle instance pour chaque tâche de décision, ActivityWorker utilise simplement l'objet que vous avez fourni.

LeActivityWorkerutilise la classeAWS Flow Frameworkpour les annotations Java afin de déterminer les options d'enregistrement et d'exécution.

Modèle de thread d'exécuteur

DansAWS Flow FrameworkPour Java, l'incarnation d'une activité ou d'un décideur est une instance de la classe de travail. Votre application est responsable de la configuration et de l'instanciation de l'objet exécuteur sur chaque machine, ainsi que du processus agissant en tant qu'exécuteur. L'objet exécuteur reçoit ensuite automatiquement les tâches d'Amazon SWF, les répartie sur votre implémentation d'activité ou de flux de travail, et renvoie les résultats à Amazon SWF. Une instance de flux de travail peut couvrir de nombreux exécuteurs. Lorsqu'Amazon SWF a une ou plusieurs tâches d'activité en attente, il affecte une tâche au premier travail disponible, puis une autre au suivant, etc. Ainsi, des tâches appartenant à la même instance de flux de travail peuvent être traitées simultanément sur des exécuteurs différents.

De plus, chaque exécuteur peut être configuré pour traiter des tâches sur plusieurs threads. Cela signifie que les tâches d'activité d'une instance de flux de travail peuvent être exécutées simultanément même s'il n'y a qu'un exécuteur.

Les tâches de décision se comportent de la même manière, à ceci près qu'Amazon SWF garantit que, pour une exécution de flux de travail donnée, une seule décision peut être exécutée à la fois. Généralement, une exécution de flux de travail requiert plusieurs tâches de décision ; cela peut donc entraîner l'exécution sur plusieurs processus et threads. Le décideur est configuré avec le type d'implémentation du flux de travail. Lors de la réception d'une tâche de décision par le décideur, une instance (objet) de l'implémentation du flux de travail est créée. L'infrastructure fournit un schéma de fabrique extensible pour la création de ces instances. La fabrique de flux de travail par défaut crée à chaque fois un nouvel objet. Vous pouvez fournir des fabriques personnalisées pour remplacer ce comportement.

Contrairement aux décideurs, qui sont configurés avec des types d'implémentation de flux de travail, les exécuteurs d'activité sont configurés avec des instances (objets) d'implémentation d'activité. Lorsqu'une tâche d'activité est reçue par l'exécuteur d'activité , elle est envoyée vers l'objet d'implémentation d'activité approprié.

L'exécuteur du flux de travail gère un pool de threads unique et exécute le flux de travail sur le même thread que celui utilisé pour interroger Amazon SWF pour la tâche. Les activités étant de longue durée (tout du moins en comparaison avec la logique du flux de travail), la classe de travail de l'activité gère deux pools de threads distincts : un pour interroger Amazon SWF pour traiter les tâches d'activité, et un autre pour traiter les tâches en exécutant l'implémentation d'activité. Cela vous permet de configurer le nombre de threads dans lequel rechercher des tâches indépendamment du nombre de threads pour les exécuter. Par exemple, vous pouvez avoir un petit nombre de threads pour la recherche et un grand nombre de threads pour l'exécution des tâches. La classe de l'exécuteur d'activité recherche une tâche dans Amazon SWF uniquement lorsqu'elle a un thread de recherche libre et un thread libre pour traiter la tâche.

Ce comportement de thread et d'instanciation implique que :

Extensibilité de l'exécuteur

LeAWS Flow Frameworkcontient également deux classes de travail de bas niveau qui vous offrent une extensibilité et un contrôle plus approfondi. Leur utilisation vous permet de personnaliser complètement l'enregistrement du type de flux de travail et d'activité, et de définir des fabriques pour la création d'objets d'implémentation. Ces exécuteurs sont GenericWorkflowWorker et GenericActivityWorker.

GenericWorkflowWorker peut être configuré avec une fabrique pour la création de fabriques de définition de flux de travail. La fabrique de définition de flux de travail est responsable de la création d'instances d'implémentation de flux de travail et de la fourniture des paramètres de configuration tels que les options d'enregistrement. Dans des circonstance normales, vous devez utiliser la classe WorkflowWorker directement. Celle-ci crée et configure automatiquement l'implémentation des fabriques fournies dans l'infrastructure, POJOWorkflowDefinitionFactoryFactory et POJOWorkflowDefinitionFactory. La fabrique nécessite que la classe d'implémentation de flux de travail ait un constructeur sans argument. Ce constructeur est utilisé pour créer des instances de l'objet de flux de travail lors de l'exécution. La fabrique regarde les annotations que vous avez utilisées sur l'interface et l'implémentation de flux de travail pour créer les options d'enregistrement et d'exécution appropriées.

Vous pouvez fournir votre propre implémentation des fabriques via WorkflowDefinitionFactory, WorkflowDefinitionFactoryFactory et WorkflowDefinition. La classe WorkflowDefinition est utilisée par la classe de l'exécuteur pour répartir les tâches et les signaux de décision. En implémentant ces classes de base, vous pouvez personnaliser complètement la fabrique et la répartition des demandes transmises à l'implémentation du flux de travail. Par exemple, vous pouvez utiliser ces points d'extensibilité pour fournir un modèle de programmation personnalisé pour écrire des flux de travail, par exemple, basés sur vos propres annotations, ou en générer un à partir de WSDL au lieu de l'approche de code utilisée par l'infrastructure. Pour utiliser vos fabriques personnalisées, vous devrez utiliser la classe GenericWorkflowWorker. Pour plus de détails sur ces classes, consultez la documentation AWS SDK for Java.

De même, GenericActivityWorker vous permet de fournir une fabrique d'implémentation d'activité personnalisée. En implémentant les classes ActivityImplementationFactory et ActivityImplementation, vous pouvez contrôler complètement l'instanciation d'activité et personnaliser les options d'enregistrement et d'exécution. Pour plus de détails sur ces classes, consultez la documentation AWS SDK for Java.