Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich. # Erste Schritte mit dem AWS Flow Framework für Java In diesem Abschnitt wird das vorgestellt, AWS Flow Framework indem er Sie durch eine Reihe einfacher Beispielanwendungen führt, in denen das grundlegende Programmiermodell und die API vorgestellt werden. Die Beispielanwendungen basieren auf der standardmäßigen Anwendung "Hello World", die häufig für die Einführung von C und verwandter Programmiersprachen verwendet wird. Hier sehen Sie eine typische Java-Implementierung von "Hello World": ``` public class HelloWorld { public static void main(String[] args) { System.out.println("Hello World!"); } } ``` Im Folgenden finden Sie eine kurze Beschreibung der Beispielanwendungen: Der vollständige Quellcode ist angegeben, sodass Sie die Anwendungen selbst implementieren und ausführen können. Bevor Sie beginnen, sollten Sie zunächst Ihre Entwicklungsumgebung konfigurieren und ein AWS Flow Framework Java-Projekt erstellen, wie in[Einrichtung des AWS Flow Framework für Java](setup.md). + [HelloWorld Bewerbung](getting-started-example-helloworld.md) stellt Workflow-Anwendungen vor, indem "Hello World" als standardmäßige Java-Anwendung implementiert, aber wie eine Workflow-Anwendung strukturiert wird. + [HelloWorldWorkflow Bewerbung](getting-started-example-helloworldworkflow.md)verwendet den AWS Flow Framework for Java zur Konvertierung HelloWorld in einen Amazon SWF SWF-Workflow. + [HelloWorldWorkflowAsync Bewerbung](getting-started-example-helloworldworkflowasync.md) ändert `HelloWorldWorkflow`, damit eine *asynchrone Workflow-Methode* verwendet wird. + [HelloWorldWorkflowDistributed Bewerbung](getting-started-example-helloworldworkflowdistributed.md) ändert `HelloWorldWorkflowAsync`, sodass Workflow und Aktivitäts-Worker auf unterschiedlichen System ausgeführt werden. + [HelloWorldWorkflowParallel Bewerbung](getting-started-example-helloworldworkflowparallel.md) ändert `HelloWorldWorkflow`, damit zwei Aktivitäten parallel ausgeführt werden können. # Einrichtung des AWS Flow Framework für Java Das AWS Flow Framework für Java ist im Lieferumfang von enthalten. [AWS SDK für Java](https://aws.amazon.com/sdkforjava/) Falls Sie das noch nicht eingerichtet haben AWS SDK für Java, finden Sie unter [Erste Schritte](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/getting-started.html) im AWS SDK für Java Entwicklerhandbuch Informationen zur Installation und Konfiguration des SDK selbst. ## Fügen Sie das Flow-Framework mit Maven hinzu Die Amazon SWF SWF-Build-Tools sind Open Source. Um den Code anzusehen oder herunterzuladen oder die Tools selbst zu erstellen, besuchen Sie das Repository unter. [https://github.com/aws/aws-swf-build-tools](https://github.com/aws/aws-swf-build-tools) Amazon stellt [Amazon SWF SWF-Build-Tools](https://mvnrepository.com/artifact/com.amazonaws/aws-swf-build-tools) im Maven Central Repository bereit. Um das Flow-Framework für Maven einzurichten, fügen Sie die folgende Abhängigkeit zur `pom.xml`-Datei Ihres Projekts hinzu: ``` com.amazonaws aws-swf-build-tools 2.0.0 ``` # HelloWorld Bewerbung Um die Struktur von Amazon SWF SWF-Anwendungen vorzustellen, erstellen wir eine Java-Anwendung, die sich wie ein Workflow verhält, aber lokal in einem einzigen Prozess ausgeführt wird. Es ist keine Verbindung zu Amazon Web Services erforderlich. **Anmerkung** Das [HelloWorldWorkflow](getting-started-example-helloworldworkflow.md)Beispiel baut auf diesem auf und stellt eine Verbindung zu Amazon SWF her, um die Verwaltung des Workflows zu übernehmen. Eine Workflow-Anwendung besteht aus drei Grundkomponenten: + Ein *Aktivitätsauftragnehmer* unterstützt eine Reihe von *Aktivitäten*, die jeweils eine Methode sind, die unabhängig ausgeführt wird, um eine bestimmte Aufgabe zu erfüllen. + Ein *Workflow-Auftragnehmer* orchestriert die Ausführung der Aktivitäten und verwaltet den Datenfluss. Er ist eine programmgesteuerte Umsetzung einer *Workflow-Topologie*. Dabei handelt es sich im Grunde um ein Flussdiagramm, in dem definiert wird, wann die verschiedenen Aktivitäten ausgeführt werden, ob sie nacheinander oder parallel ausgeführt werden usw. + Ein *Workflow-Starter* startet eine Workflow-Instance, eine sogenannte *Ausführung*, und kann während der Ausführung mit ihr interagieren. HelloWorld ist in drei Klassen und zwei verwandte Schnittstellen implementiert, die in den folgenden Abschnitten beschrieben werden. Bevor Sie beginnen, sollten Sie Ihre Entwicklungsumgebung einrichten und ein neues AWS Java-Projekt erstellen, wie unter beschrieben[Einrichtung des AWS Flow Framework für Java](setup.md). Die für die folgenden Anleitungen verwendeten Pakete heißen `helloWorld.XYZ`. Um diese Namen zu verwenden, legen Sie das `within`-Attribut in aop.xml wie folgt fest: ``` ... ``` Erstellen Sie zur Implementierung HelloWorld ein neues Java-Paket in Ihrem AWS SDK-Projekt mit dem Namen `helloWorld.HelloWorld` und fügen Sie die folgenden Dateien hinzu: + Eine Schnittstellendatei namens `GreeterActivities.java` + Eine Klassendatei namens `GreeterActivitiesImpl.java`, die den Aktivitätenauftragnehmer implementiert + Eine Schnittstellendatei namens `GreeterWorkflow.java` + Eine Klassendatei namens `GreeterWorkflowImpl.java`, die den Workflow-Auftragnehmer implementiert + Eine Klassendatei namens `GreeterMain.java`, die den Workflow-Starter implementiert Die Details werden in den folgenden Abschnitten erläutert und enthalten den vollständigen Code der einzelnen Komponenten, den Sie in die jeweilige Datei einfügen können. ## HelloWorld Implementierung der Aktivitäten HelloWorld unterteilt die allgemeine Aufgabe, eine `"Hello World!"` Begrüßung auf der Konsole zu drucken, in drei Aufgaben, von denen jede mit einer *Aktivitätsmethode* ausgeführt wird. Die Aktivitätsmethoden sind in der Schnittstelle `GreeterActivities` wie folgt definiert. ``` public interface GreeterActivities { public String getName(); public String getGreeting(String name); public void say(String what); } ``` HelloWorld hat eine Aktivitätsimplementierung`GreeterActivitiesImpl`, die die `GreeterActivities` folgenden Methoden bereitstellt: ``` 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); } } ``` Aktivitäten sind unabhängig voneinander und können häufig in unterschiedlichen Workflows verwendet werden. Beispielsweise kann jeder Workflow die Aktivität `say` verwenden, um eine Zeichenfolge auf der Konsole auszugeben. Workflows können auch über mehrere Aktivitätsimplementierungen verfügen, die jeweils unterschiedliche Aufgaben ausführen. ## HelloWorld Workflow-Mitarbeiter Um „Hello World\$1“ zu drucken auf der Konsole müssen die Aktivitätsaufgaben nacheinander in der richtigen Reihenfolge mit den richtigen Daten ausgeführt werden. Der HelloWorld Workflow-Worker orchestriert die Ausführung der Aktivitäten auf der Grundlage einer einfachen *linearen Workflow-Topologie*, die in der folgenden Abbildung dargestellt ist. ![\[Lineare Workflow-Topologie\]](http://docs.aws.amazon.com/de_de/amazonswf/latest/awsflowguide/images/helloworld_topology.png) Die drei Aktivitäten werden nacheinander ausgeführt und die Daten werden von einer Aktivität an die nächste übergeben. Der HelloWorld Workflow-Worker hat eine einzige Methode, den Einstiegspunkt des Workflows, der in der `GreeterWorkflow` Benutzeroberfläche wie folgt definiert ist: ``` public interface GreeterWorkflow { public void greet(); } ``` Die `GreeterWorkflowImpl`-Klasse implementiert diese Schnittstelle wie folgt: ``` 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); } } ``` Die `greet` Methode implementiert die HelloWorld Topologie, indem sie eine Instanz von erstellt`GreeterActivitiesImpl`, jede Aktivitätsmethode in der richtigen Reihenfolge aufruft und die entsprechenden Daten an jede Methode weitergibt. ## HelloWorld Workflow-Starter Ein *Workflow-Starter* ist eine Anwendung, die eine Workflow-Instance startet und während der Ausführung mit dem Workflow kommunizieren kann. Die `GreeterMain` Klasse implementiert den HelloWorld Workflow-Starter wie folgt: ``` public class GreeterMain { public static void main(String[] args) { GreeterWorkflow greeter = new GreeterWorkflowImpl(); greeter.greet(); } } ``` `GreeterMain` erstellt eine Instance von `GreeterWorkflowImpl` und ruft `greet` auf, um den Workflow-Auftragnehmer auszuführen. Führen Sie `GreeterMain` es als Java-Anwendung aus und Sie sollten „Hello World\$1“ sehen in der Konsolenausgabe. # HelloWorldWorkflow Bewerbung Obwohl das grundlegende [HelloWorld](getting-started-example-helloworld.md)Beispiel wie ein Workflow strukturiert ist, unterscheidet es sich in mehreren wichtigen Punkten von einem Amazon SWF SWF-Workflow: **Konventionelle Workflow-Anwendungen und Amazon SWF SWF-Workflow-Anwendungen** | HelloWorld | Amazon SWF SWF-Arbeitsablauf | | --- | --- | | Wird lokal als einzelner Prozess ausgeführt. | Läuft als mehrere Prozesse, die auf mehrere Systeme verteilt werden können, darunter EC2 Amazon-Instances, private Rechenzentren, Client-Computer usw. Es muss nicht einmal das gleiche Betriebssystem verwendet werden. | | Aktivitäten sind synchrone Methoden, die bis zu ihrem Abschluss für eine Blockierung sorgen. | Aktivitäten werden durch asynchrone Methoden abgebildet. Diese geben die Kontrolle sofort zurück. Sie ermöglichen es dem Workflow, während der Wartezeit auf den Abschluss der Aktivität andere Aufgaben auszuführen. | | Der Workflow-Worker interagiert mit einem Aktivitäts-Worker, indem er die entsprechende Methode aufruft. | Workflow-Worker interagieren mit Activity-Workern mithilfe von HTTP-Anfragen, wobei Amazon SWF als Vermittler fungiert. | | Der Workflow-Starter interagiert mit dem Workflow-Worker, indem er die entsprechende Methode aufruft. | Workflow-Starter interagieren mit Workflow-Workern mithilfe von HTTP-Anfragen, wobei Amazon SWF als Vermittler fungiert. | Sie können eine verteilte, asynchrone Workflow-Anwendung von Grund auf neu implementieren, indem Sie beispielsweise Ihren Workflow-Worker direkt über Webservice-Aufrufe mit einem Aktivitäts-Worker interagieren lassen. Allerdings müssen Sie dann den gesamten, komplizierten Code implementieren, der für die asynchrone Ausführung mehrerer Aktivitäten, den Datenfluss usw. erforderlich ist. Die SWF AWS Flow Framework für Java und Amazon kümmern sich um all diese Details, sodass Sie sich auf die Implementierung der Geschäftslogik konzentrieren können. HelloWorldWorkflow ist eine modifizierte Version davon HelloWorld , die als Amazon SWF SWF-Workflow ausgeführt wird. Die folgende Abbildung fasst die Funktionsweise der beiden Anwendungen zusammen. ![\[Herkömmliche und Amazon SWF SWF-Versionen von Hello World!\]](http://docs.aws.amazon.com/de_de/amazonswf/latest/awsflowguide/images/workflow_conceptual_welcome.png) HelloWorld wird als ein einziger Prozess ausgeführt, und der Starter, der Workflow-Worker und der Aktivitäten-Worker interagieren mithilfe herkömmlicher Methodenaufrufe. Bei Starter`HelloWorldWorkflow`, Workflow Worker und Activities Worker handelt es sich um verteilte Komponenten, die über Amazon SWF mithilfe von HTTP-Anfragen interagieren. Amazon SWF verwaltet die Interaktion, indem es Listen mit Workflow- und Aktivitätsaufgaben verwaltet und an die jeweiligen Komponenten weiterleitet. In diesem Abschnitt wird beschrieben, wie das Framework für HelloWorldWorkflow funktioniert. HelloWorldWorkflow wird mithilfe der AWS Flow Framework for Java-API implementiert, die die manchmal komplizierten Details der Interaktion mit Amazon SWF im Hintergrund verarbeitet und den Entwicklungsprozess erheblich vereinfacht. Sie können dasselbe Projekt verwenden HelloWorld, für das Sie bereits AWS Flow Framework für Java-Anwendungen konfiguriert haben. Um die Anwendung auszuführen, müssen Sie jedoch wie folgt ein Amazon SWF SWF-Konto einrichten: + Eröffnen Sie ein AWS Konto bei [Amazon Web Services](https://aws.amazon.com/), falls Sie noch keines haben. + Weisen Sie den AWS\$1SECRET\$1KEY Umgebungsvariablen die Zugriffs-ID AWS\$1ACCESS\$1KEY\$1ID und die geheime ID Ihres Kontos zu. Die Schlüsselwerte selbst sollten nicht in Ihrem Code enthalten sein. Die Speicherung in Umgebungsvariablen ist ein bequemer Weg, um das Problem zu lösen. + Eröffnen Sie ein Amazon SWF SWF-Konto bei [Amazon Simple Workflow Service](https://aws.amazon.com/swf/). + Melden Sie sich beim Amazon SWF-Service an AWS-Managementkonsole und wählen Sie ihn aus. + Wählen Sie oben rechts **Domains verwalten** und registrieren Sie eine neue Amazon SWF-Domain. Ein *Domäne* ist ein logischer Container für Ihre Anwendungsressourcen (z. B. Workflow- und Aktivitätstypen und Workflow-Ausführungen). Sie können jeden beliebigen Domainnamen verwenden, in den exemplarischen Vorgehensweisen wird jedoch "“ helloWorldWalkthrough verwendet. Um das zu implementieren HelloWorldWorkflow, erstellen Sie eine Kopie von HelloWorld. HelloWorld packe es in dein Projektverzeichnis und nenne es HelloWorld. HelloWorldWorkflow. In den folgenden Abschnitten wird beschrieben, wie Sie den HelloWorld Originalcode ändern, um ihn AWS Flow Framework für Java zu verwenden und als Amazon SWF SWF-Workflow-Anwendung auszuführen. ## HelloWorldWorkflow Aktivitäten Arbeiter HelloWorld hat seine Aktivitäten Worker als eine einzige Klasse eingeführt. Ein Worker AWS Flow Framework für Java-Aktivitäten besteht aus drei grundlegenden Komponenten: + Die *Aktivitätsmethoden*, die die eigentlichen Aufgaben ausführen, werden in einer Schnittstelle definiert und in einer verwandten Klasse implementiert. + Eine [ActivityWorker](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/simpleworkflow/flow/ActivityWorker.html)Klasse verwaltet die Interaktion zwischen den Aktivitätsmethoden und Amazon SWF. + Eine *Aktivitäts-Host*-Anwendung, die den Aktivitäts-Worker registriert und startet und die Bereinigung übernimmt. Dieser Abschnitt behandelt die Aktivitätsmethoden. Die beiden anderen Klassen werden später besprochen. HelloWorldWorkflow definiert die Aktivitätsschnittstelle in `GreeterActivities` wie folgt: ``` 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); } ``` Diese Schnittstelle war nicht unbedingt notwendig für HelloWorld, aber sie ist AWS Flow Framework für eine Java-Anwendung notwendig. Beachten Sie, dass sich die Schnittstellendefinition selbst nicht geändert hat. Sie müssen jedoch zwei AWS Flow Framework für Java-Anmerkungen [@ActivityRegistrationOptions](annotations.md#annotations-activityregistration) und [@Aktivität](annotations.md#annotations-activities) für die Schnittstellendefinition anwenden. Die Anmerkungen stellen Konfigurationsinformationen bereit und weisen den Annotationsprozessor AWS Flow Framework für Java an, anhand der Schnittstellendefinition eine *Clientklasse für Aktivitäten* zu generieren, auf die später eingegangen wird. `@ActivityRegistrationOptions`hat mehrere benannte Werte, die verwendet werden, um das Verhalten der Aktivitäten zu konfigurieren. HelloWorldWorkflow gibt zwei Timeouts an: + `defaultTaskScheduleToStartTimeoutSeconds` definiert, wie lange sich die Aufgaben in der Aktivitätsaufgabenliste in der Warteschlange befinden können. Der Wert ist auf 300 Sekunden (5 Minuten) festgelegt. + `defaultTaskStartToCloseTimeoutSeconds` definiert die maximale Zeit, die die Aktivität zur Ausführung der Aufgabe nutzen kann. Der Wert ist auf 10 Sekunden festgelegt. Diese Timeouts stellen sicher, dass die Aktivität ihre Aufgabe in angemessener Zeit abschließt. Wird ein Timeout überschritten, generiert das Framework einen Fehler und der Workflow-Worker muss entscheiden, wie das Problem behandelt werden soll. Wie man mit solchen Fehlern umgeht, erfahren Sie unter [Fehlerbehandlung](errorhandling.md). `@Activities` hat mehrere Werte. In der Regel wird jedoch nur die Versionsnummer der Aktivität definiert. So können Sie verschiedene Generationen der Aktivitätsimplementierungen nachverfolgen. Wenn Sie eine Aktivitätsschnittstelle ändern, nachdem Sie sie bei Amazon SWF registriert haben, einschließlich der Änderung der `@ActivityRegistrationOptions` Werte, müssen Sie eine neue Versionsnummer verwenden. HelloWorldWorkflow implementiert die Aktivitätsmethoden wie folgt: `GreeterActivitiesImpl` ``` 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); } } ``` Beachten Sie, dass der Code mit der HelloWorld Implementierung identisch ist. Im Kern ist eine AWS Flow Framework Aktivität nur eine Methode, die Code ausführt und möglicherweise ein Ergebnis zurückgibt. Der Unterschied zwischen einer Standardanwendung und einer Amazon SWF SWF-Workflow-Anwendung besteht darin, wie der Workflow die Aktivitäten ausführt, wo die Aktivitäten ausgeführt werden und wie die Ergebnisse an den Workflow-Worker zurückgegeben werden. ## HelloWorldWorkflow Workflow-Worker Ein Amazon SWF SWF-Workflow-Worker besteht aus drei grundlegenden Komponenten. + Eine *Workflow-Implementierung*. Dies ist eine Klasse, die die Workflow-bezogenen Aufgaben ausführt. + Eine *Activities-Client*. Diese ist im Wesentlichen ein Proxy für die Aktivitätsklasse und wird von einer Workflow-Implementierung verwendet, um Aktivitätsmethoden asynchron auszuführen. + Eine [WorkflowWorker](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/simpleworkflow/flow/WorkflowWorker.html)Klasse, die die Interaktion zwischen dem Workflow und Amazon SWF verwaltet. Dieser Abschnitt beschreibt die Workflow-Implementierung und den Activities-Client. Die `WorkflowWorker`-Klasse wird später besprochen. HelloWorldWorkflow definiert die Workflow-Schnittstelle in `GreeterWorkflow` wie folgt: ``` 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(); } ``` Diese Schnittstelle ist auch für eine Java-Anwendung nicht unbedingt erforderlich, AWS Flow Framework für eine Java-Anwendung HelloWorld jedoch unerlässlich. Sie müssen zwei AWS Flow Framework für Java-Anmerkungen [@Workflow](annotations.md#annotations-workflow) und [@WorkflowRegistrationOptions](annotations.md#annotations-workflowregistrationoptions) für die Definition der Workflow-Schnittstelle anwenden. Die Anmerkungen stellen Konfigurationsinformationen bereit und weisen den Annotationsprozessor AWS Flow Framework für Java an, auf der Grundlage der Schnittstelle eine Workflow-Client-Klasse zu generieren, wie später beschrieben wird. `@Workflow`hat einen optionalen Parameter, *DataConverter*, der häufig mit seinem Standardwert verwendet wird, der angibt NullDataConverter, dass er verwendet werden JsonDataConverter sollte. `@WorkflowRegistrationOptions` hat außerdem eine Reihe von optionalen Parametern, die zur Konfiguration des Workflow-Workers verwendet werden können. Hier legen wir `defaultExecutionStartToCloseTimeoutSeconds` — was angibt, wie lange der Workflow ausgeführt werden kann — auf 3600 Sekunden (1 Stunde) fest. Die `GreeterWorkflow` Schnittstellendefinition unterscheidet sich HelloWorld in einem wichtigen Punkt von der Anmerkung. [@Execute](annotations.md#annotations-execute) Workflow-Schnittstellen legen die Methoden fest, die von Anwendungen wie dem Workflow-Starter aufgerufen werden können. Sie sind auf eine Handvoll Methoden mit jeweils einer bestimmten Rolle beschränkt. Das Framework spezifiziert keinen Namen oder keine Parameterliste für Workflow-Schnittstellenmethoden. Sie verwenden eine Namens- und Parameterliste, die für Ihren Workflow geeignet ist, und fügen eine AWS Flow Framework For-Java-Anmerkung hinzu, um die Rolle der Methode zu identifizieren. `@Execute` hat zwei Aufgaben: + Es legt `greet` als Einstiegspunkt des Workflows fest (die Methode, die der Workflow-Starter aufruft, um den Workflow zu starten). Im Allgemeinen kann ein Einstiegspunkt einen oder mehrere Parameter entgegennehmen. Diese ermöglichen es dem Starter, den Workflow zu initialisieren. Das aktuelle Beispiel erfordert jedoch keine Initialisierung. + Es legt die Versionsnummer des Workflows fest, über die Sie verschiedene Generationen von Workflow-Implementierungen nachverfolgen können. Um eine Workflow-Oberfläche zu ändern, nachdem Sie sie bei Amazon SWF registriert haben, einschließlich der Änderung der Timeout-Werte, müssen Sie eine neue Versionsnummer verwenden. Informationen zu den anderen Methoden, die in eine Workflow-Schnittstelle eingebunden werden können, finden Sie unter [Workflow- und Aktivitäts-Verträge](features.workflow.md). HelloWorldWorkflow implementiert den Workflow wie folgt: `GreeterWorkflowImpl` ``` import com.amazonaws.services.simpleworkflow.flow.core.Promise; public class GreeterWorkflowImpl implements GreeterWorkflow { private GreeterActivitiesClient operations = new GreeterActivitiesClientImpl(); public void greet() { Promise name = operations.getName(); Promise greeting = operations.getGreeting(name); operations.say(greeting); } } ``` Der Code ähnelt dem HelloWorld, weist jedoch zwei wichtige Unterschiede auf. + `GreeterWorkflowImpl` erzeugt eine Instanz von `GreeterActivitiesClientImpl` (dem Activities-Client) statt von `GreeterActivitiesImpl`, und führt Aktivitäten durch den Aufruf von Methoden für das Client-Objekt aus. + Der Name und Greeting-Aktivitäten geben `Promise`-Objekte statt `String`-Objekte zurück. HelloWorld ist eine Java-Standardanwendung, die lokal als ein einziger Prozess ausgeführt wird. `GreeterWorkflowImpl` Sie kann also die Workflow-Topologie implementieren, indem sie einfach eine Instanz von erstellt`GreeterActivitiesImpl`, die Methoden der Reihe nach aufruft und die Rückgabewerte von einer Aktivität an die nächste weitergibt. Bei einem Amazon SWF SWF-Workflow wird die Aufgabe einer Aktivität immer noch von einer Aktivitätsmethode von ausgeführt`GreeterActivitiesImpl`. Die Methode wird jedoch nicht notwendigerweise im selben Prozess wie der Workflow ausgeführt. Sie wird möglicherweise nicht einmal auf demselben System ausgeführt. Der Workflow muss die Aktivität außerdem asynchron ausführen. Diese Anforderungen werfen folgende Probleme auf: + Wie kann man eine Aktivitätsmethode ausführen, die in einem anderen Prozess oder sogar auf einem anderen System ausgeführt wird? + Wie kann man eine Aktivitätsmethode asynchron ausführen? + Wie kann man die Übergabe- und Rückgabewerte von Aktivitäten verwaltet? Wenn der Rückgabewert von Aktivität A beispielsweise an Aktivität B übergeben wird, müssen Sie sicherstellen, dass Aktivität B nicht ausgeführt wird, bis Aktivität A abgeschlossen ist. Sie können mit der vertrauten Java-Flusssteuerung in Kombination mit dem Activities-Client und `Promise` über den Kontrollfluss der Anwendung eine Vielzahl von Workflow-Topologien implementieren. ### Activities-Client `GreeterActivitiesClientImpl` ist im Grunde ein Proxy für `GreeterActivitiesImpl`, der es einer Workflow-Implementierung ermöglicht, die `GreeterActivitiesImpl`-Methoden asynchron auszuführen. Die Klassen `GreeterActivitiesClient` und `GreeterActivitiesClientImpl` werden anhand der Angaben in den Annotionen Ihrer `GreeterActivities`-Klasse automatisch generiert. Sie müssen diese nicht selbst implementieren. **Anmerkung** Eclipse generiert die Klassen, wenn Sie Ihr Projekt speichern. Sie können den generierten Code im Unterverzeichnis `.apt_generated` Ihres Projektverzeichnisses einsehen. Um Kompilierungsfehler in Ihrer `GreeterWorkflowImpl`-Klasse zu vermeiden, empfiehlt es sich, das Verzeichnis `.apt_generated` auf der Registerkarte **Order and Export** (Reihenfolge und Export) des Dialogfelds **Java-Buildpfad** nach ganz oben zu verschieben. Ein Workflow-Worker führt eine Aktivität aus, indem er die entsprechende Client-Methode aufruft. Die Methode arbeitet asynchron. Sie gibt sofort ein `Promise`-Objekt zurück, wobei `T` der Rückgabetyp der Aktivität ist. Das zurückgegebene `Promise`-Objekt ist im Grunde ein Platzhalter für den Wert, den die Aktivitätsmethode zurückgeben kann. + Bei der Rückkehr aus der Activities-Client-Methode befindet sich das `Promise`-Objekt zunächst im Status *Unready*. Dies bedeutet, dass das Objekt noch keinen gültigen Rückgabewert darstellt. + Wenn die entsprechende Aktivitätsmethode ihre Aufgabe abschließt und die Ausführung zurückgibt, weist das Framework dem `Promise`-Objekt den Rückgabewert zu und versetzt es in den Zustand *Ready*. ### Promise Type Der Hauptzweck von `Promise`-Objekten ist die Verwaltung des Datenflusses zwischen asynchronen Komponenten und der Steuerung ihrer Ausführung. Ihre Anwendung muss die Synchronisation nicht explizit verwalten oder von Mechanismen wie Timer nutzen, um sicherzustellen, dass asynchrone Komponenten nicht vorzeitig ausgeführt werden. Wenn Sie eine Activity-Client-Methode aufrufen, gibt sie die Kontrolle sofort zurück. Das Framework verschiebt die Ausführung der entsprechenden Aktivitätsmethode, bis alle übergebenen `Promise`-Objekte bereit sind und gültige Daten enthalten. Aus der Sicht von `GreeterWorkflowImpl` geben alle drei Aktivity-Client-Methoden die Kontrolle sofort zurück. Aus Sicht von `GreeterActivitiesImpl` ruft das Framework `getGreeting` erst auf, wenn `name` abgeschlossen ist. `say` wird erst aufgerufen, wenn `getGreeting` abgeschlossen ist. Durch die Verwendung von `Promise` zur Übergabe von Daten von einer Aktivität an die nächste, stellt `HelloWorldWorkflow` nicht nur sicher, dass Aktivitätsmethoden keine ungültigen Daten verwenden, sondern steuert auch, wann die Aktivitäten ausgeführt werden und definiert die Workflow-Topologie. Um den `Promise`-Rückgabewert jeder Aktivität an die nächste Aktivität zu übergeben, müssen die Aktivitäten nacheinander ausgeführt werden. Dies definiert die zuvor beschriebene lineare Topologie. Mit AWS Flow Framework for Java müssen Sie keinen speziellen Modellierungscode verwenden, um selbst komplexe Topologien zu definieren, sondern nur die standardmäßige Java-Flusskontrolle und`Promise`. Ein Beispiel für die Implementierung einer einfachen parallelen Topologie finden Sie unter [HelloWorldWorkflowParallel Aktivitäten Arbeiter](getting-started-example-helloworldworkflowparallel.md#getting-started-example-helloworldworkflowparallel.activities). **Anmerkung** Wenn eine Aktivitätsmethode wie `say` keinen Wert zurückgibt, gibt die entsprechende Client-Methode ein `Promise`-Objekt zurück. Das Objekt repräsentiert keine Daten. Es hat zunächst den Status "Unready". Es ist erst dann bereit, wenn die Aktivität abgeschlossen ist. Sie können ein `Promise`-Objekt an andere Activity-Client-Methoden übergeben. So können Sie sicherzustellen, dass diese die Ausführung bis zum Abschluss der ursprünglichen Aktivität verschieben. `Promise` ermöglicht es einer Workflow-Implementierung, die Activity-Client-Methoden und deren Rückgabewerte ähnlich wie bei synchronen Methoden zu verwenden. Sie müssen allerdings beim Zugriff auf den Wert eines `Promise`-Objekts vorsichtig sein. Im Gegensatz zum Java-Typ [Future](http://docs.oracle.com/javase/6/docs/api/java/util/concurrent/Future.html) übernimmt das Framework und nicht die Anwendung die Synchronisation für `Promise`. Wenn Sie `Promise.get` aufrufen und das Objekt nicht bereit ist, löst `get` eine Ausnahme aus. Beachten Sie, dass `HelloWorldWorkflow` nie direkt auf ein `Promise`-Objekt zugreift. Es übergibt die Objekte einfach von einer Aktivität zur nächsten. Wenn ein Objekt bereit ist, extrahiert das Framework den Wert und übergibt ihn als Standardtyp an die Aktivitätsmethode. Auf `Promise`-Objekte sollte nur über asynchronen Code zugegriffen werden, wobei das Framework gewährleistet, dass das Objekt bereit ist und einen gültigen Wert darstellt. `HelloWorldWorkflow` löst dieses Problem, indem `Promise`-Objekte nur an Methoden des Activities-Clients übergeben werden. Sie können in Ihrer Workflow-Implementierung auf den Wert eines `Promise`-Objekts zugreifen, indem Sie das Objekt an eine *asynchrone Workflow-Methode* übergeben, die sich wie eine Aktivität verhält. Ein Beispiel finden Sie unter [HelloWorldWorkflowAsync Bewerbung](getting-started-example-helloworldworkflowasync.md). ## HelloWorldWorkflow Implementierung von Arbeitsabläufen und Aktivitäten Den Implementierungen von Workflows und Aktivitäten sind Worker-Klassen zugeordnet, [ActivityWorker](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/simpleworkflow/flow/ActivityWorker.html)und [WorkflowWorker](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/simpleworkflow/flow/WorkflowWorker.html). Sie kümmern sich um die Kommunikation zwischen Amazon SWF und den Aktivitäten und Workflow-Implementierungen, indem sie die entsprechende Amazon SWF SWF-Aufgabenliste für Aufgaben abrufen, die entsprechende Methode für jede Aufgabe ausführen und den Datenfluss verwalten. Details hierzu finden Sie unter [AWS Flow Framework Grundbegriffe: Anwendungsstruktur](awsflow-basics-application-structure.md) Um die Aktivitäts- und Workflow-Implementierungen mit den entsprechenden Worker-Objekten zu verknüpfen, implementieren Sie eine oder mehrere Worker-Anwendungen. Diese haben die folgenden Aufgaben: + Registrieren Sie Workflows oder Aktivitäten bei Amazon SWF. + Erstellen von Worker-Objekten und Zuordnen dieser Objekte zu den Workflow- oder Aktivitäts-Worker-Implementierungen + Weisen Sie die Worker-Objekte an, mit der Kommunikation mit Amazon SWF zu beginnen. Wenn Sie den Workflow und die Aktivitäten als getrennte Prozesse ausführen möchten, müssen Sie separate Workflow- und Aktivitäts-Worker-Hosts implementieren. Ein Beispiel finden Sie unter [HelloWorldWorkflowDistributed Bewerbung](getting-started-example-helloworldworkflowdistributed.md). HelloWorldWorkflowImplementiert der Einfachheit halber einen einzelnen Worker-Host, der Aktivitäten und Workflow-Worker im selben Prozess ausführt, und zwar wie folgt: ``` 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(); } } ``` `GreeterWorker`hat kein HelloWorld Gegenstück, daher müssen Sie dem Projekt eine Java-Klasse mit `GreeterWorker` dem Namen hinzufügen und den Beispielcode in diese Datei kopieren. Der erste Schritt besteht darin, ein [AmazonSimpleWorkflowClient](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/simpleworkflow/AmazonSimpleWorkflowClient.html)Objekt zu erstellen und zu konfigurieren, das die zugrunde liegenden Amazon SWF-Servicemethoden aufruft. Hierzu geht `GreeterWorker` folgendermaßen vor: 1. Erstellt ein [ClientConfiguration](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/ClientConfiguration.html)Objekt und gibt ein Socket-Timeout von 70 Sekunden an. Dieser Wert gibt an, wie lange auf die Übertragung der Daten über eine bestehende offene Verbindung gewartet wird, bevor der Socket geschlossen wird. 1. Erstellt ein [AWSCredentialsBasic-Objekt](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/auth/BasicAWSCredentials.html) zur Identifizierung des AWS Kontos und übergibt die Kontoschlüssel an den Konstruktor. Zur Vereinfachung und um diese nicht als Klartext im Code zu hinterlegen, werden die Schlüssel als Umgebungsvariablen gespeichert. 1. Erstellt ein [AmazonSimpleWorkflowClient](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/simpleworkflow/AmazonSimpleWorkflowClient.html)Objekt zur Darstellung des Workflows und übergibt die `ClientConfiguration` Objekte `BasicAWSCredentials` und an den Konstruktor. 1. Legt die Service-Endpunkt-URL des Client-Objekts fest. Amazon SWF ist derzeit in allen AWS Regionen verfügbar. Der Einfachheit halber definiert `GreeterWorker` zwei String-Konstanten. + `domain`ist der Amazon SWF-Domainname des Workflows, den Sie bei der Einrichtung Ihres Amazon SWF SWF-Kontos erstellt haben. `HelloWorldWorkflow`geht davon aus, dass Sie den Workflow in der Domäne "helloWorldWalkthrough" ausführen. + `taskListToPoll`ist der Name der Aufgabenlisten, die Amazon SWF verwendet, um die Kommunikation zwischen den Workflow- und Aktivitätsmitarbeitern zu verwalten. Sie können den Namen auf eine beliebige beliebige Zeichenfolge setzen. HelloWorldWorkflow verwendet "HelloWorldList" sowohl für Workflow- als auch für Aktivitätsaufgabenlisten. Hinter den Kulissen werden die Namen in verschiedene Namespaces umgesetzt. Daher bleiben beide Aufgabenlisten unterscheidbar. `GreeterWorker`verwendet die Zeichenkettenkonstanten und das [AmazonSimpleWorkflowClient](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/simpleworkflow/AmazonSimpleWorkflowClient.html)Objekt, um Worker-Objekte zu erstellen, die die Interaktion zwischen den Aktivitäten und Worker-Implementierungen und Amazon SWF verwalten. Insbesondere übernehmen die Worker-Objekte die Aufgabe, die entsprechende Aufgabenliste für Aufgaben abzufragen. `GreeterWorker` erstellt ein `ActivityWorker`-Objekt und konfiguriert es so, dass es `GreeterActivitiesImpl` behandelt, indem es eine neue Klasseninstance hinzufügt. `GreeterWorker` ruft dann die `start`-Methode des `ActivityWorker`-Objekts auf, die das Objekt anweist, mit der Abfrage der angegebenen Aktivitätsaufgabenliste zu beginnen. `GreeterWorker` erzeugt ein `WorkflowWorker`-Objekt und konfiguriert es über das Hinzufügen des Klassen-Dateinamens `GreeterWorkflowImpl.class` so, dass es `GreeterWorkflowImpl` nutzt. Es ruft dann die `WorkflowWorker`-Methode des `start`-Objekts auf, die das Objekt anweist, die angegebene Workflow-Aufgabenliste abzufragen. Sie können `GreeterWorker` nun erfolgreich ausführen. Es registriert den Workflow und die Aktivitäten bei Amazon SWF und startet, dass die Worker-Objekte ihre jeweiligen Aufgabenlisten abfragen. Um dies zu überprüfen, starten `GreeterWorker` Sie die Amazon SWF SWF-Konsole, rufen Sie sie auf und wählen Sie eine Domain `helloWorldWalkthrough` aus der Liste der Domains aus. Wenn Sie **Workflow Types** (Workflow-Typen) im Bereich **Navigation** auswählen, sollten Sie `GreeterWorkflow.greet` sehen: ![\[HelloWorldWorkflow Workflow-Typ\]](http://docs.aws.amazon.com/de_de/amazonswf/latest/awsflowguide/images/Workflow_Type.png) Wenn Sie **Aktivity Types** (Aktivitätstypen) auswählen, werden die `GreeterActivities`-Methoden angezeigt: ![\[HelloWorldWorkflow Arten von Aktivitäten\]](http://docs.aws.amazon.com/de_de/amazonswf/latest/awsflowguide/images/Activity_Types.png) Wenn Sie **Workflow Executions** (Workflow-Ausführungen) auswählen, sehen Sie jedoch keine aktiven Ausführungen. Die Workflow- und Aktivitäts-Worker suchen zwar nach Aufgaben, aber wir haben noch keine Workflow-Ausführung gestartet. ## HelloWorldWorkflow Vorspeise Als letztes muss ein Workflow-Starter implementiert werden – eine Anwendung, die die Workflow-Ausführung startet. Der Ausführungsstatus wird von Amazon SWF gespeichert, sodass Sie dessen Verlauf und Ausführungsstatus einsehen können. HelloWorldWorkflow implementiert einen Workflow-Starter, indem die `GreeterMain` Klasse wie folgt geändert wird: ``` 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` erzeugt ein `AmazonSimpleWorkflowClient`-Objekt mit dem gleichen Code wie `GreeterWorker`. Es stellt dann ein `GreeterWorkflowClientExternal`-Objekt, das als Proxy für den Workflow fungiert (ähnlich wie der in `GreeterWorkflowClientImpl` angelegte Activity-Client als Proxy für die Aktivitätsmethoden agiert). Anstatt ein Workflow-Client-Objekt mit `new` anzulegen, gehen Sie folgendermaßen vor: 1. Erstellen Sie ein externes Client-Factory-Objekt und übergeben Sie das `AmazonSimpleWorkflowClient` Objekt und den Amazon SWF-Domänennamen an den Konstruktor. Das Client-Factory-Objekt wird vom Annotationsprozessor des Frameworks erstellt, der den Objektnamen erstellt, indem einfach "ClientExternalFactoryImpl" an den Namen der Workflow-Schnittstelle angehängt wird. 1. Erstellen Sie ein externes Client-Objekt, indem Sie die `getClient` Methode des Factory-Objekts aufrufen, die den Objektnamen erstellt, indem "ClientExternal" an den Namen der Workflow-Schnittstelle angehängt wird. Sie können optional `getClient` eine Zeichenfolge übergeben, die Amazon SWF verwendet, um diese Instanz des Workflows zu identifizieren. Andernfalls stellt Amazon SWF eine Workflow-Instanz mithilfe einer generierten GUID dar. Der von der Factory zurückgegebene Client erstellt nur Workflows, die mit der Zeichenfolge benannt sind, die an die Methode [getClient](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/simpleworkflow/flow/WorkflowClientFactoryExternal.html#getClient(java.lang.String)) übergeben wurde (der von der Factory zurückgegebene Client hat bereits den Status in Amazon SWF). Um einen Workflow mit einer anderen ID auszuführen, müssen Sie zurück zur Factory wechseln und einen neuen Client mit der anderen ID anlegen. Der Workflow-Client stellt eine `greet`-Methode zur Verfügung, die `GreeterMain` aufruft, um den Workflow zu starten (da `greet()` die mit der `@Execute`-Annotation angegebene Methode war). **Anmerkung** Der Annotationsprozessor erzeugt außerdem ein internes Client-Factory-Objekt, das zur Erstellung von untergeordneten Workflows verwendet wird. Details hierzu finden Sie unter [Untergeordnete Workflow-Ausführungen](childworkflow.md). Beenden Sie `GreeterWorker` (falls noch ausgeführt). Starten Sie `GreeterMain`. Sie sollten jetzt SomeID in der Liste der aktiven Workflow-Ausführungen der Amazon SWF SWF-Konsole sehen:. ![\[HelloWorldWorkflow Workflow-Ausführungen\]](http://docs.aws.amazon.com/de_de/amazonswf/latest/awsflowguide/images/Active_Execution.png) Wenn Sie `someID` und die Registerkarte **Events** (Ereignisse) auswählen, werden die Ereignisse angezeigt: ![\[HelloWorldWorkflow erste Workflow-Ereignisse\]](http://docs.aws.amazon.com/de_de/amazonswf/latest/awsflowguide/images/Events1.png) **Anmerkung** Wenn Sie `GreeterWorker` bereits früher gestartet haben und es noch ausgeführt wird, sehen Sie eine längere Ereignisliste. Die Gründe hierfür werden gleich besprochen. Halten Sie `GreeterWorker` an und versuchen Sie erneut, `GreaterMain` zu starten. Die Registerkarte **Events** (Ereignisse) zeigt nur zwei Ereignisse an: + `WorkflowExecutionStarted` zeigt an, dass der Workflow mit der Ausführung begonnen hat. + `DecisionTaskScheduled`gibt an, dass Amazon SWF die erste Entscheidungsaufgabe in die Warteschlange gestellt hat. Der Grund dafür, dass der Workflow bei der ersten Entscheidungsaufgabe blockiert wird, ist, dass der Workflow auf zwei Anwendungen verteilt ist, `GreeterMain` und `GreeterWorker`. `GreeterMain` die Workflow-Ausführung gestartet haben, aber `GreeterWorker` nicht läuft, sodass die Worker die Listen nicht abfragen und Aufgaben ausführen. Sie können beide Anwendungen unabhängig voneinander ausführen. Sie benötigen jedoch beide, damit die Workflow-Ausführung über die erste Entscheidungsaufgabe hinausgeht. Wenn Sie nun `GreeterWorker` ausführen, beginnen die Workflow- und Aktivitäts-Worker mit dem Abrufen und die verschiedenen Aufgaben werden schnell abgeschlossen. Wenn Sie nun die Registerkarte `Events` prüfen, wird die erste Ereignisgruppe angezeigt. ![\[HelloWorldWorkflow schließt Workflow-Ereignisse ab\]](http://docs.aws.amazon.com/de_de/amazonswf/latest/awsflowguide/images/Events2.png) Sie können einzelne Ereignisse auswählen, um weitere Informationen zu erhalten. Wenn Sie mit der Suche fertig sind, sollte der Workflow „Hello World\$1“ gedruckt haben auf deine Konsole. Nach dem Abschluss des Workflows erscheint er nicht mehr in der Liste der aktiven Ausführungen. Wenn Sie dies überprüfen möchten, wählen Sie die Schaltfläche für den Ausführungsstatus **Closed** (Geschlossen) und dann **List Executions** (Ausführungen auflisten) aus. Es werden alle abgeschlossenen Workflow-Instances in der angegebenen Domäne (`helloWorldWalkthrough`) angezeigt (die die beim Anlegen der Domäne angegebene Aufbewahrungszeit nicht überschritten haben). ![\[HelloWorldWorkflow abgeschlossene Workflows\]](http://docs.aws.amazon.com/de_de/amazonswf/latest/awsflowguide/images/Closed_Workflows.png) Beachten Sie, dass jede Workflow-Instance einen eindeutigen **Run ID**-Wert hat. Sie können dieselbe Workflow-ID für verschiedene Workflow-Instanzen verwenden, jedoch jeweils nur für eine aktive Ausführung. # HelloWorldWorkflowAsync Bewerbung Gelegentlich ist es vorteilhaft, einen Workflow bestimmte Aufgaben lokal durchführt zu lassen, statt eine Aktivität zu verwenden. Jedoch umfassen Workflow-Aufgaben häufig die Verarbeitung der Werte, die von `Promise`-Objekten repräsentiert werden. Wenn Sie ein `Promise`-Objekt an eine synchrone Workflow-Methode weiterleiten, wird die Methode sofort ausgeführt, aber sie kann nicht auf den Wert des `Promise`-Objekts zugreifen, bevor das Objekt bereit ist. Sie könnten `Promise.isReady` abfragen, bis es `true` zurückgibt, dies ist jedoch ineffizient und die Methode könnte lange blockiert sein. Eine besserer Ansatz ist das Verwenden einer *asynchronen Methode*. Eine asynchrone Methode wird ähnlich wie eine Standardmethode implementiert — oft als Mitglied der Workflow-Implementierungsklasse — und wird im Kontext der Workflow-Implementierung ausgeführt. Sie legen sie als asynchrone Methode fest, indem Sie eine `@Asynchronous`-Anmerkung anwenden, wodurch das Framework angewiesen wird, sie ähnlich wie eine Aktivität zu behandeln. + Wenn eine Workflow-Implementierung eine asynchrone Methode aufruft, wird sie sofort zurückgegeben. Asynchrone Methoden geben in der Regel ein `Promise`-Objekt zurück, das verfügbar wird, wenn die Methode abgeschlossen ist. + Wenn Sie einer asynchronen Methode eine oder mehrere `Promise`-Objekte übergeben, verschiebt sie die Ausführung, bis alle Eingabeobjekte bereit sind. Eine asynchrone Methode kann daher auf ihre `Promise`-Werte der Eingabe zugreifen, ohne eine Ausnahme zu riskieren. **Anmerkung** Aufgrund der Art und Weise, wie die AWS Flow Framework für Java den Workflow ausführt, werden asynchrone Methoden in der Regel mehrfach ausgeführt. Sie sollten sie daher nur für schnelle Aufgaben mit geringem Overhead verwenden. Aktivitäten sollten Sie zur Durchführung zeitintensiver Aufgaben wie großen Berechnungen verwenden. Details hierzu finden Sie unter [AWS Flow Framework Grundbegriffe: Verteilte Ausführung](awsflow-basics-distributed-execution.md). Dieses Thema ist eine exemplarische Vorgehensweise für eine modifizierte Version HelloWorldWorkflowAsync, HelloWorldWorkflow die eine der Aktivitäten durch eine asynchrone Methode ersetzt. Um die Anwendung zu implementieren, erstellen Sie eine Kopie von HelloWorld. HelloWorldWorkflow packe es in dein Projektverzeichnis und nenne es HelloWorld. HelloWorldWorkflowAsync. **Anmerkung** Dieses Thema baut auf den Konzepten und Dateien auf, die in den Themen [HelloWorld Bewerbung](getting-started-example-helloworld.md) und [HelloWorldWorkflow Bewerbung](getting-started-example-helloworldworkflow.md) vorgestellt werden. Machen Sie sich mit den Dateien und vorgestellten Konzepten finden Sie in diesen Themen, bevor Sie fortfahren. In den folgenden Abschnitten wird beschrieben, wie der ursprüngliche HelloWorldWorkflow Code geändert wird, um eine asynchrone Methode zu verwenden. ## HelloWorldWorkflowAsync Implementierung der Aktivitäten HelloWorldWorkflowAsync implementiert seine Worker-Schnittstelle für Aktivitäten wie folgt: `GreeterActivities` ``` 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); } ``` Diese Schnittstelle ähnelt der von verwendeten HelloWorldWorkflow, mit den folgenden Ausnahmen: + Sie lässt die `getGreeting`-Aktivität weg. Diese Aufgabe wird jetzt von einer asynchronen Methode verarbeitet. + Die Versionsnummer wird auf 2.0. Nachdem Sie eine Aktivitätsschnittstelle bei Amazon SWF registriert haben, können Sie sie nur ändern, wenn Sie die Versionsnummer ändern. Die übrigen Implementierungen der Aktivitätsmethoden sind identisch mit. HelloWorldWorkflow Löschen Sie einfach `getGreeting` aus `GreeterActivitiesImpl`. ## HelloWorldWorkflowAsync Workflow-Implementierung HelloWorldWorkflowAsync definiert die Workflow-Schnittstelle wie folgt: ``` 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(); } ``` Die Schnittstelle ist bis auf HelloWorldWorkflow eine neue Versionsnummer identisch mit. Wenn Sie einen registrierten Workflow ändern möchten, müssen Sie wie bei Aktivitäten seine Version ändern. HelloWorldWorkflowAsync implementiert den Workflow wie folgt: ``` 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 ersetzt die `getGreeting` Aktivität durch eine `getGreeting` asynchrone Methode, aber die `greet` Methode funktioniert fast genauso: 1. Führen Sie die `getName`-Aktivität aus, die sofort ein `Promise`-Objekt, `name`, zurückgibt, das den Namen repräsentiert. 1. Rufen Sie die asynchrone Methode `getGreeting` auf und übergeben Sie ihr das `name`-Objekt. `getGreeting` gibt umgehend ein `Promise`-Objekt, `greeting`, zurück, das die Begrüßung repräsentiert. 1. Führen Sie die `say`-Aktivität aus und übergeben Sie ihr das `greeting`-Objekt. 1. Wenn `getName` abgeschlossen wird, ist `name` einsatzbereit und `getGreeting` verwendet seinen Wert zur Erstellung der Begrüßung. 1. Wenn `getGreeting` abgeschlossen wird, ist `greeting` einsatzbereit und `say` gibt die Zeichenfolge in der Konsole aus. Der Unterschied liegt darin, dass Greet (Gruß) nicht den Aktivitäten-Client aufruft, um eine `getGreeting`-Aktivität auszuführen, sondern die asynchrone `getGreeting`-Methode. Das Endergebnis ist dasselbe, aber die `getGreeting`-Methode funktioniert etwas anders als die `getGreeting`-Aktivität. + Der Workflow-Worker verwendet Aufrufsemantiken der Standardfunktion für die Ausführung von `getGreeting`. Die asynchrone Ausführung der Aktivität wird jedoch von Amazon SWF vermittelt. + `getGreeting` wird im Prozess der Workflow-Implementierung ausgeführt. + `getGreeting` gibt ein `Promise`-Objekt anstelle eines `String`-Objekts zurück. Um den Zeichenfolgewert abzurufen, der sich im Besitz von `Promise` befindet, rufen Sie seine `get()`-Methode auf. Da die Aktivität jedoch asynchron ausgeführt wird, ist ihr Rückgabewert möglicherweise nicht sofort bereit. Es `get()` wird eine Ausnahme ausgelöst, bis der Rückgabewert der asynchronen Methode verfügbar ist. Weitere Informationen zur Funktionsweise von `Promise` finden Sie unter [AWS Flow Framework Grundbegriffe: Data Exchange zwischen Aktivitäten und Workflows](awsflow-basics-data-exchange-activities-workflows.md). `getGreeting` erstellt einen Rückgabewert, indem die Begrüßungszeichenfolge an die statische `Promise.asPromise`-Methode übergeben wird. Diese Methode erstellt ein `Promise`-Objekt des entsprechenden Typs, legt den Wert fest und versetzt es in den betriebsbereiten Zustand. ## HelloWorldWorkflowAsync Arbeitsablauf und Aktivitäten: Host und Starter HelloWorldWorkflowAsync implementiert `GreeterWorker` als Hostklasse für die Workflow- und Aktivitätsimplementierungen. Sie ist mit der HelloWorldWorkflow Implementierung identisch, mit Ausnahme des `taskListToPoll` Namens, der auf "`HelloWorldAsyncList`" gesetzt ist. ``` 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 implementiert den Workflow-Starter in`GreeterMain`; er ist identisch mit der HelloWorldWorkflow Implementierung. Um den Workflow auszuführen, führen Sie `GreeterWorker` und aus`GreeterMain`, genau wie bei HelloWorldWorkflow. # HelloWorldWorkflowDistributed Bewerbung Mit HelloWorldWorkflow und HelloWorldWorkflowAsync vermittelt Amazon SWF die Interaktion zwischen den Implementierungen des Workflows und der Aktivitäten, sie werden jedoch lokal als ein einziger Prozess ausgeführt. `GreeterMain`befindet sich in einem separaten Prozess, läuft aber immer noch auf demselben System. Ein wesentliches Merkmal von Amazon SWF ist die Unterstützung verteilter Anwendungen. Sie könnten beispielsweise den Workflow-Worker auf einer EC2 Amazon-Instance, den Workflow-Starter auf einem Rechenzentrumscomputer und die Aktivitäten auf einem Client-Desktop-Computer ausführen. Sie können sogar unterschiedliche Aktivitäten auf unterschiedlichen Systemen ausführen. Die HelloWorldWorkflowDistributed Anwendung erstreckt sich HelloWorldWorkflowAsync auf die Verteilung der Anwendung auf zwei Systeme und drei Prozesse. + Der Workflow und der Workflow-Starter werden als getrennte Prozesse auf einem System ausgeführt. + Die Aktivitäten werden auf einem getrennten System ausgeführt. Um die Anwendung zu implementieren, erstellen Sie eine Kopie von HelloWorld. HelloWorldWorkflowAsync packe es in dein Projektverzeichnis und nenne es HelloWorld. HelloWorldWorkflowDistributed. In den folgenden Abschnitten wird beschrieben, wie Sie den HelloWorldWorkflowAsync Originalcode ändern, um die Anwendung auf zwei Systeme und drei Prozesse zu verteilen. Sie müssen den Workflow oder das Implementieren der Aktivitäten nicht ändern, um sie auf getrennten Systemen auszuführen, auch nicht die Versionsnummern. Sie müssen `GreeterMain` auch nicht ändern. Sie müssen lediglich den Aktivitäten- und Workflow-Host ändern. Dabei HelloWorldWorkflowAsync dient eine einzige Anwendung als Host für den Workflow und die Aktivität. Um den Workflow und das Implementieren der Aktivitäten auf getrennten Systemen auszuführen, müssen Sie getrennte Anwendungen implementieren. GreeterWorker Aus dem Projekt löschen und zwei neue Klassendateien hinzufügen, GreeterWorkflowWorker und GreeterActivitiesWorker. HelloWorldWorkflowDistributed implementiert seinen Aktivitäten-Host in GreeterActivitiesWorker wie folgt: ``` 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; public class GreeterActivitiesWorker { 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 = "helloWorldExamples"; String taskListToPoll = "HelloWorldAsyncList"; ActivityWorker aw = new ActivityWorker(service, domain, taskListToPoll); aw.addActivitiesImplementation(new GreeterActivitiesImpl()); aw.start(); } } ``` HelloWorldWorkflowDistributed implementiert seinen Workflow-Host wie folgt: `GreeterWorkflowWorker` ``` 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.WorkflowWorker; public class GreeterWorkflowWorker { 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 = "helloWorldExamples"; String taskListToPoll = "HelloWorldAsyncList"; WorkflowWorker wfw = new WorkflowWorker(service, domain, taskListToPoll); wfw.addWorkflowImplementationType(GreeterWorkflowImpl.class); wfw.start(); } } ``` Beachten Sie, dass `GreeterActivitiesWorker` nur `GreeterWorker` ohne den `WorkflowWorker`-Code ist und `GreeterWorkflowWorker` nur `GreeterWorker` ohne den `ActivityWorker`-Code ist. **So führen Sie den Workflow aus:** 1. Erstellen Sie eine ausführbare JAR-Datei mit `GreeterActivitiesWorker` als Eingangspunkt. 1. Kopieren Sie die JAR-Datei aus Schritt 1 in ein anderes System, das jedes von Java unterstütztes Betriebssystem ausführen kann. 1. Stellen Sie sicher, dass AWS Anmeldeinformationen mit Zugriff auf dieselbe Amazon SWF-Domain auf dem anderen System verfügbar sind. 1. Führen Sie die JAR-Datei aus. 1. Verwenden Sie auf Ihrem Entwicklungssystem Eclipse zum Ausführen von `GreeterWorkflowWorker` und `GreeterMain`. Abgesehen von der Tatsache, dass die Aktivitäten auf einem anderen System als dem Workflow-Worker und dem Workflow-Starter ausgeführt werden, funktioniert der Workflow genauso wie HelloWorldAsync. Allerdings, weil das `println` Aufrufen „Hello World\$1“ ausgibt Wenn sich die `say` Aktivität auf der Konsole befindet, erscheint die Ausgabe auf dem System, auf dem der Activities Worker ausgeführt wird. # HelloWorldWorkflowParallel Bewerbung In den Vorgängerversionen von Hello World\$1 wird eine lineare Workflow-Topologie verwendet. Amazon SWF ist jedoch nicht auf lineare Topologien beschränkt. Die HelloWorldWorkflowParallel Anwendung ist eine modifizierte Version davon HelloWorldWorkflow , die eine parallel Topologie verwendet, wie in der folgenden Abbildung dargestellt. ![\[HelloWorldWorkflowParallel Workflow-Topologie\]](http://docs.aws.amazon.com/de_de/amazonswf/latest/awsflowguide/images/helloworld_parallel_topology.png) Mit HelloWorldWorkflowParallel, `getName` und parallel `getGreeting` laufen und jeweils einen Teil der Begrüßung zurückgeben. `say`führt dann die beiden Zeichenketten zu einer Begrüßung zusammen und druckt sie auf der Konsole aus. Um die Anwendung zu implementieren, erstellen Sie eine Kopie von HelloWorld. HelloWorldWorkflow packe es in dein Projektverzeichnis und nenne es HelloWorld. HelloWorldWorkflowParallel. In den folgenden Abschnitten wird beschrieben, wie Sie den HelloWorldWorkflow Originalcode so ändern, dass er `getGreeting` parallel ausgeführt `getName` wird. ## HelloWorldWorkflowParallel Aktivitäten Arbeiter Die HelloWorldWorkflowParallel Aktivitätsschnittstelle ist in implementiert`GreeterActivities`, wie im folgenden Beispiel gezeigt. ``` import com.amazonaws.services.simpleworkflow.flow.annotations.Activities; import com.amazonaws.services.simpleworkflow.flow.annotations.ActivityRegistrationOptions; @Activities(version="5.0") @ActivityRegistrationOptions(defaultTaskScheduleToStartTimeoutSeconds = 300, defaultTaskStartToCloseTimeoutSeconds = 10) public interface GreeterActivities { public String getName(); public String getGreeting(); public void say(String greeting, String name); } ``` Die Schnittstelle ist ähnlich wie HelloWorldWorkflow, mit den folgenden Ausnahmen: + `getGreeting` übernimmt keine Eingabe. Sie gibt nur eine Begrüßungszeichenfolge zurück. + `say` übernimmt zwei Eingabezeichenfolgen, die Begrüßung und den Namen. + Die Schnittstelle hat eine neue Versionsnummer. Diese ist bei jeder Änderung an der registrierten Schnittstelle erforderlich. HelloWorldWorkflowParallel implementiert die Aktivitäten wie folgt: `GreeterActivitiesImpl` ``` public class GreeterActivitiesImpl implements GreeterActivities { @Override public String getName() { return "World!"; } @Override public String getGreeting() { return "Hello "; } @Override public void say(String greeting, String name) { System.out.println(greeting + name); } } ``` `getName` und `getGreeting` geben nun einfach die Hälfte der Begrüßungszeichenkette zurück. `say` verkettet die beiden Teile, um die vollständige Zeichenfolge zu erzeugen, und gibt sie auf der Konsole aus. ## HelloWorldWorkflowParallel Workflow-Mitarbeiter Die HelloWorldWorkflowParallel Workflow-Schnittstelle ist wie folgt implementiert: `GreeterWorkflow` ``` 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 = "5.0") public void greet(); } ``` Die Klasse ist identisch mit der HelloWorldWorkflow Version, mit der Ausnahme, dass die Versionsnummer so geändert wurde, dass sie dem Activities Worker entspricht. Der Workflow wird in `GreeterWorkflowImpl` wie folgt implementiert: ``` import com.amazonaws.services.simpleworkflow.flow.core.Promise; public class GreeterWorkflowImpl implements GreeterWorkflow { private GreeterActivitiesClient operations = new GreeterActivitiesClientImpl(); public void greet() { Promise name = operations.getName(); Promise greeting = operations.getGreeting(); operations.say(greeting, name); } } ``` Auf den ersten Blick sieht diese Implementierung sehr ähnlich aus wie die drei Aktivitäten HelloWorldWorkflow, die die Client-Methoden nacheinander ausführen. die Aktivitäten jedoch nicht. + HelloWorldWorkflow übergeben `name` an`getGreeting`. Da `name` ein `Promise`-Objekt ist, verschiebt `getGreeting` die Ausführung der Aktivität, bis `getName` abgeschlossen ist. Daher werden die beiden Aktivitäten nacheinander ausgeführt. + HelloWorldWorkflowParallel übergibt keine Eingabe `getName` oder`getGreeting`. Keine der Methoden verschiebt die Ausführung und die zugehörigen Aktivitätsmethoden werden sofort parallel ausgeführt. Die Aktivität `say` übernimmt sowohl `greeting` als auch `name` als Eingabeparameter. Da es sich dabei um `Promise`-Objekte handelt, verschiebt `say` die Ausführung, bis beide Aktivitäten abgeschlossen sind, erstellt dann die Begrüßung und gibt sie aus. Beachten Sie, dass HelloWorldWorkflowParallel kein spezieller Modellierungscode verwendet wird, um die Workflow-Topologie zu definieren. Dies geschieht implizit, indem es die standardmäßige Java-Ablaufsteuerung verwendet und die Eigenschaften von `Promise` Objekten ausnutzt. AWS Flow Framework für Java-Anwendungen können selbst komplexe Topologien einfach durch die Verwendung von `Promise` Objekten in Verbindung mit herkömmlichen Java-Kontrollflusskonstrukten implementiert werden. ## HelloWorldWorkflowParallel Arbeitsablauf und Aktivitäten: Host und Starter HelloWorldWorkflowParallel implementiert `GreeterWorker` als Hostklasse für die Workflow- und Aktivitätsimplementierungen. Sie ist mit der HelloWorldWorkflow Implementierung identisch, mit Ausnahme des `taskListToPoll` Namens, der auf "HelloWorldParallelList" gesetzt ist. `HelloWorldWorkflowParallel`implementiert den `GreeterMain` Workflow-Starter in und ist mit der HelloWorldWorkflow Implementierung identisch. Führen Sie zur Ausführung des Workflows `GreeterWorker` und `GreeterMain` genau wie bei `HelloWorldWorkflow` aus.