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.

# Workflow-Implementierung
<a name="workflowimpl"></a>

Um einen Workflow zu implementieren, schreiben Sie eine Klasse, die die gewünschte `@Workflow`-Schnittstelle implementiert. Das Beispiel für die Workflow-Schnittstelle (`MyWorkflow`) kann wie folgt implementiert werden: 

```
public class MyWFImpl implements MyWorkflow
{
  MyActivitiesClient client = new MyActivitiesClientImpl();
  @Override
  public void startMyWF(int a, String b){
    Promise<Integer> result = client.activity1();
    client.activity2(result);
  }
  @Override
  public void signal1(int a, int b, String c){
    //Process signal
     client.activity2(a + b);
  }
}
```

Die `@Execute`-Methode in dieser Klasse ist der Eintrittspunkt der Workflow-Logik. Da das Framework Replay verwendet, um den Objektstatus zu rekonstruieren, wenn eine Entscheidungsaufgabe verarbeitet werden soll, wird für jede Entscheidungsaufgabe ein neues Objekt erstellt.

Die Verwendung von `Promise<T>` als Parameter ist in der `@Execute`-Methode innerhalb einer `@Workflow`-Schnittstelle nicht erlaubt. Der Grund hierfür ist, dass das Ausführen eines asynchronen Aufrufs allein eine Entscheidung des Aufrufers ist. Die Workflow-Implementierung selbst hängt nicht davon ab, ob der Aufruf synchron oder asynchron erfolgt. Daher hat die generierte Client-Schnittstelle Überlastungen, die `Promise<T>`-Parameter akzeptieren, sodass diese Methoden asynchron aufgerufen werden können. 

Der Rückgabetyp einer `@Execute`-Methode kann entweder `void` oder `Promise<T>` sein. Beachten Sie, dass ein Rückgabetyp des entsprechenden externen Clients `void` und nicht `Promise<>` ist. Da der externe Client nicht für die Verwendung im asynchronen Code vorgesehen ist, gibt der externe Client keine Objekte zurück. `Promise` Um extern festgelegte Ergebnisse von Workflow-Ausführungen zu erhalten, können Sie den Workflow so entwerfen, dass der Status in einem externen Datenspeicher durch eine Aktivität aktualisiert wird. Die Sichtbarkeit von Amazon SWF APIs kann auch verwendet werden, um das Ergebnis eines Workflows zu Diagnosezwecken abzurufen. Es wird nicht empfohlen, die Sichtbarkeit APIs zum Abrufen von Ergebnissen von Workflow-Ausführungen als allgemeine Praxis zu verwenden, da diese API-Aufrufe von Amazon SWF gedrosselt werden können. Um die Sichtbarkeit zu gewährleisten, APIs müssen Sie die Workflow-Ausführung anhand einer Struktur identifizieren. `WorkflowExecution` Diese Struktur können Sie vom generierten Workflow-Client durch Aufrufen der `getWorkflowExecution`-Methode abrufen. Diese Methode gibt die `WorkflowExecution`-Struktur zurück, die der Workflow-Ausführung entspricht, an die der Client gebunden ist. Weitere Informationen zur Sichtbarkeit finden Sie in der [Amazon Simple Workflow Service API-Referenz](https://docs.aws.amazon.com/amazonswf/latest/apireference/) APIs. 

Beim Aufrufen von Aktivitäten aus Ihrer Workflow-Implementierung sollten Sie den generierten Aktivitäten-Client verwenden. Zum Senden von Signalen verwenden Sie entsprechend die generierten Workflow-Clients. 

## Entscheidungskontext
<a name="workflowimpl.decisioncontext"></a>

Das Framework stellt bei jeder Ausführung von Workflow-Code durch das Framework einen Umgebungskontext zur Verfügung. Dieser Kontext bietet kontextspezifische Funktionalität, auf die Sie in Ihrer Workflow-Implementierung zugreifen können, z. B. Erstellen eines Timers. Weitere Informationen finden Sie im Abschnitt [Ausführungskontext](executioncontext.md).

## Offenlegen des Ausführungsstatus
<a name="workflowimpl.executionstate"></a>

Amazon SWF ermöglicht es Ihnen, dem Workflow-Verlauf einen benutzerdefinierten Status hinzuzufügen. Der letzte Status, der von der Workflow-Ausführung gemeldet wurde, wird Ihnen durch Visibility-Aufrufe an den Amazon SWF-Service und in der Amazon SWF SWF-Konsole zurückgegeben. In einem Auftragsverarbeitungs-Workflow können Sie z. B. den Bestellungsstatus in verschiedenen Phasen melden, z. B. Bestellung erhalten, Bestellung versendet usw. In der AWS Flow Framework Version für Java wird dies durch eine Methode auf Ihrer Workflow-Oberfläche erreicht, die mit der `@GetState` Anmerkung versehen ist. Wenn der Entscheider die Verarbeitung einer Entscheidungsaufgabe abgeschlossen hat, wird diese Methode aufgerufen, um den aktuellen Status von der Workflow-Implementierung abzurufen. Neben Sichtbarkeitsaufrufen kann der Status auch mit dem generierten, externen Client abgerufen werden (der die Sichtbarkeits-API-Aufrufe intern verwendet).

Das folgende Beispiel zeigt, wie Sie den Ausführungskontext festlegen.

```
@Workflow
@WorkflowRegistrationOptions(defaultExecutionStartToCloseTimeoutSeconds = 60,
               defaultTaskStartToCloseTimeoutSeconds = 10)
public interface PeriodicWorkflow {

    @Execute(version = "1.0")
    void periodicWorkflow();

    @GetState
    String getState();
}

@Activities(version = "1.0")
@ActivityRegistrationOptions(defaultTaskScheduleToStartTimeoutSeconds = 300,
                             defaultTaskStartToCloseTimeoutSeconds = 3600)
public interface PeriodicActivity {
    void activity1();

}

public class PeriodicWorkflowImpl implements PeriodicWorkflow {

    private DecisionContextProvider contextProvider
               = new DecisionContextProviderImpl();

    private WorkflowClock clock
               = contextProvider.getDecisionContext().getWorkflowClock();

    private PeriodicActivityClient activityClient
               = new PeriodicActivityClientImpl();

    private String state;

    @Override
    public void periodicWorkflow() {
        state = "Just Started";
        callPeriodicActivity(0);
    }

    @Asynchronous
    private void callPeriodicActivity(int count,
                                      Promise<?>... waitFor)
    {
        if(count == 100) {
            state = "Finished Processing";
            return;
        }

        // call activity
        activityClient.activity1();

        // Repeat the activity after 1 hour.
        Promise<Void> timer = clock.createTimer(3600);
        state = "Waiting for timer to fire. Count = "+count;
        callPeriodicActivity(count+1, timer);
    }

    @Override
    public String getState() {
        return state;
    }
}

public class PeriodicActivityImpl implements PeriodicActivity
{
@Override
      public static void activity1()
   {
      ...
    }
}
```

Der generierte externe Client kann jederzeit zum Abrufen des aktuellen Status der Workflow-Ausführung verwendet werden.

```
PeriodicWorkflowClientExternal client
        = new PeriodicWorkflowClientExternalFactoryImpl().getClient();
System.out.println(client.getState());
```

Im obigen Beispiel wird der Ausführungsstatus in verschiedenen Stufen gemeldet. Wenn die Workflow-Instance startet, meldet `periodicWorkflow` den Anfangsstatus "Just Started" (Soeben gestartet). Mit jedem Aufruf an `callPeriodicActivity` wird der Workflow-Status anschließend aktualisiert. Sobald `activity1` 100 Mal aufgerufen wurde, wird die Methode zurückgegeben und die Workflow-Instance abgeschlossen.

## Workflow-Lokale
<a name="workflowimpl.workflowlocals"></a>

Es kann vorkommen, das Sie statische Variablen in Ihrer Workflow-Implementierung verwenden müssen. Beispielsweise wenn Sie einen Zähler speichern möchten, auf den von verschiedenen Orten (möglicherweise unterschiedlichen Klassen) in der Implementierung des Workflows zugegriffen werden kann. Sie können jedoch nicht auf statische Variablen in Ihren Workflows vertrauen, da diese für verschiedene Threads freigegeben sind. Dies ist problematisch, da ein Worker möglicherweise verschiedene Entscheidungsaufgaben in unterschiedlichen Threads verarbeitet. Alternativ können Sie einen solchen Status in einem Feld in der Workflow-Implementierung speichern. In diesem Fall müssen Sie allerdings das Implementierungsobjekt weitergeben. Für diesen Fall stellt das Framework eine `WorkflowExecutionLocal<?>`-Klasse zur Verfügung. Jeder Status, der eine statische Variable wie Semantik erfordert, sollte als Instance-Lokal unter Verwendung von `WorkflowExecutionLocal<?>` gespeichert werden. Sie können eine statische Variable dieses Typs deklarieren und verwenden. Im folgenden Ausschnitt wird eine `WorkflowExecutionLocal<String>` zum Speichern eines Benutzernamens verwendet.

```
public class MyWFImpl implements MyWF {
  public static WorkflowExecutionLocal<String> username
      = new WorkflowExecutionLocal<String>();

  @Override
  public void start(String username){
    this.username.set(username);
    Processor p = new Processor();
    p.updateLastLogin();
    p.greetUser();
   }

  public static WorkflowExecutionLocal<String> getUsername() {
    return username;
  }

  public static void setUsername(WorkflowExecutionLocal<String> username) {
    MyWFImpl.username = username;
  }
}

public class Processor {
  void updateLastLogin(){
    UserActivitiesClient c = new UserActivitiesClientImpl();
    c.refreshLastLogin(MyWFImpl.getUsername().get());
  }
   void greetUser(){
    GreetingActivitiesClient c = new GreetingActivitiesClientImpl();
    c.greetUser(MyWFImpl.getUsername().get());
  }
}
```