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.
# HelloWorld Demande
Pour présenter la structure des applications Amazon SWF, nous allons créer une application Java qui se comporte comme un flux de travail, mais qui s'exécute localement dans le cadre d'un seul processus. Aucune connexion à Amazon Web Services n'est requise.
**Note**
L'[HelloWorldWorkflow](getting-started-example-helloworldworkflow.md)exemple s'appuie sur celui-ci, en se connectant à Amazon SWF pour gérer le flux de travail.
Une application de flux de travail consiste en trois composants de base :
+ Un *exécuteur d'activité* prend en charge un ensemble d'*activités*, dont chacune est une méthode qui s'exécute indépendamment pour effectuer une tâche particulière.
+ Un *exécuteur d'activité* orchestre l'exécution des activités et gère le flux de données. Il s'agit de la réalisation par programmation d'une *topologie de flux de travail*, qui est essentiellement un diagramme de flux qui définit le moment où les différentes activités s'exécutent, qu'elles s'exécutent dans l'ordre ou simultanément, etc.
+ Un *démarreur de flux de travail* lance une instance de flux de travail, appelée *exécution*, et peut interagir avec elle pendant l'opération.
HelloWorld est implémenté sous la forme de trois classes et de deux interfaces associées, décrites dans les sections suivantes. Avant de commencer, vous devez configurer votre environnement de développement et créer un nouveau projet AWS Java comme décrit dans[Configuration du AWS Flow Framework pour Java](setup.md). Les packages utilisés pour les procédures suivantes sont tous nommés `helloWorld.XYZ`. Pour utiliser ces noms, définissez l'attribut `within` dans aop.xml comme suit :
```
...
```
Pour l'implémenter HelloWorld, créez un nouveau package Java dans votre projet AWS SDK nommé `helloWorld.HelloWorld` et ajoutez les fichiers suivants :
+ Un fichier d'interface nommé `GreeterActivities.java`
+ Un fichier de classe nommé `GreeterActivitiesImpl.java` qui implémente l'exécuteur d'activité.
+ Un fichier d'interface nommé `GreeterWorkflow.java`.
+ Un fichier de classe nommé `GreeterWorkflowImpl.java` qui implémente l'exécuteur de flux de travail.
+ Un fichier de classe nommé `GreeterMain.java` qui implémente le démarreur de flux de travail.
Les détails sont présentés dans les sections suivantes et incluent le code complet de chaque composant, que vous pouvez ajouter au fichier approprié.
## HelloWorld Mise en œuvre des activités
HelloWorld divise la tâche globale d'impression d'un `"Hello World!"` message d'accueil sur la console en trois tâches, chacune étant exécutée par une *méthode d'activité*. Les méthode d'activité sont définies dans l'interface `GreeterActivities`, comme suit.
```
public interface GreeterActivities {
public String getName();
public String getGreeting(String name);
public void say(String what);
}
```
HelloWorld a une implémentation d'activité`GreeterActivitiesImpl`, qui fournit les `GreeterActivities` méthodes indiquées :
```
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);
}
}
```
Les activités sont indépendantes les unes des autres et peuvent être souvent utilisées par différents flux de travail. Par exemple, n'importe quel flux de travail peut utiliser l'activité `say` pour imprimer une chaîne dans la console. Les flux de travail peuvent également plusieurs implémentations d'activité, chacune exécutant un ensemble différent de tâches.
## HelloWorld Travailleur du workflow
Pour imprimer « Hello World \$1 » sur la console, les tâches d'activité doivent être exécutées en séquence dans le bon ordre avec les données correctes. Le travailleur du HelloWorld flux de travail orchestre l'exécution des activités sur la base d'une *topologie de flux de travail linéaire* simple, illustrée dans la figure suivante.
![\[Topologie de flux de travail linéaire\]](http://docs.aws.amazon.com/fr_fr/amazonswf/latest/awsflowguide/images/helloworld_topology.png)
Les trois activités s'exécutent séquentiellement, et les flux de données depuis une activité vers la suivante.
Le HelloWorld gestionnaire de flux de travail utilise une seule méthode, le point d'entrée du flux de travail, qui est définie dans l'`GreeterWorkflow`interface, comme suit :
```
public interface GreeterWorkflow {
public void greet();
}
```
La classe `GreeterWorkflowImpl` implémente cette interface, comme suit :
```
public class GreeterWorkflowImpl implements GreeterWorkflow{
private GreeterActivities operations = new GreeterActivitiesImpl();
public void greet() {
String name = operations.getName();
String greeting = operations.getGreeting(name);
operations.say(greeting);
}
}
```
La `greet` méthode implémente la HelloWorld topologie en créant une instance de`GreeterActivitiesImpl`, en appelant chaque méthode d'activité dans le bon ordre et en transmettant les données appropriées à chaque méthode.
## HelloWorld Démarreur de workflow
Un *démarreur du flux de travail* est une application qui lance une exécution de flux de travail, et peut également communiquer avec le flux de travail pendant qu'il s'exécute. La `GreeterMain` classe implémente le démarreur HelloWorld de flux de travail, comme suit :
```
public class GreeterMain {
public static void main(String[] args) {
GreeterWorkflow greeter = new GreeterWorkflowImpl();
greeter.greet();
}
}
```
`GreeterMain` crée une instance de `GreeterWorkflowImpl` et appelle `greet` pour lancer l'exécuteur de flux de travail. Exécutez `GreeterMain` en tant qu'application Java et vous devriez voir « Hello World \$1 » dans la sortie de la console.