HelloWorldWorkflow Applicazione

Sebbene l'HelloWorldesempio di base sia strutturato come un flusso di lavoro, si differenzia da un flusso di lavoro Amazon SWF per diversi aspetti chiave:

Applicazioni di workflow convenzionali e Amazon SWF
HelloWorld	Flusso di lavoro Amazon SWF
Viene eseguita localmente come singolo processo.	Viene eseguito come più processi che possono essere distribuiti su più sistemi, tra cui istanze Amazon EC2, data center privati, computer client e così via. Non è necessario eseguirli sullo stesso sistema operativo.
Le attività sono metodi sincroni che vengono bloccati fino a che non risultano completati.	Le attività sono rappresentate da metodi asincroni, i quali restituiscono immediatamente un risultato e consentono al flusso di lavoro di eseguire altri task in attesa del completamento dell'attività.
Il lavoratore di flusso di lavoro interagisce con un lavoratore di attività chiamando il metodo appropriato.	I lavoratori del flusso di lavoro interagiscono con gli addetti alle attività utilizzando richieste HTTP, con Amazon SWF che funge da intermediario.
Lo starter di flusso di lavoro interagisce con un lavoratore di attività chiamando il metodo appropriato.	Gli avviatori di flussi di lavoro interagiscono con gli operatori del flusso di lavoro utilizzando richieste HTTP, con Amazon SWF che funge da intermediario.

Implementare un'applicazione di flusso di lavoro asincrona distribuita da zero, ad esempio, facendo in modo che il lavoratore di flusso di lavoro interagisca direttamente con un lavoratore di attività mediante chiamate di servizi Web, è possibile. Tuttavia, ciò comporterebbe l'implementazione di tutto il codice complesso necessario a gestire l'esecuzione asincrona di molteplici attività, controllare il flusso di dati, ecc. The AWS Flow Framework for Java e Amazon SWF si occupano di tutti questi dettagli, il che ti consente di concentrarti sull'implementazione della logica aziendale.

HelloWorldWorkflow è una versione modificata HelloWorld che funziona come flusso di lavoro Amazon SWF. L'illustrazione seguente riepiloga il funzionamento delle due applicazioni.

HelloWorld viene eseguito come un unico processo e starter, workflow worker e Activities Worker interagiscono utilizzando chiamate di metodo convenzionali. ConHelloWorldWorkflow, starter, workflow worker e activities worker sono componenti distribuiti che interagiscono tramite Amazon SWF utilizzando richieste HTTP. Amazon SWF gestisce l'interazione mantenendo elenchi di attività e flussi di lavoro, che invia ai rispettivi componenti. Questa sezione descrive come funziona il framework. HelloWorldWorkflow

HelloWorldWorkflow viene implementato utilizzando l'API AWS Flow Framework for Java, che gestisce i dettagli a volte complicati dell'interazione con Amazon SWF in background e semplifica notevolmente il processo di sviluppo. Puoi utilizzare lo stesso progetto per cui lo hai creato HelloWorld, che è già configurato per AWS Flow Framework le applicazioni Java. Tuttavia, per eseguire l'applicazione, è necessario configurare un account Amazon SWF, come segue:

• Crea un AWS account, se non ne hai già uno, su Amazon Web Services.

• Assegna rispettivamente l'ID di accesso e l'ID segreto del tuo account alle variabili di ambiente AWS_ACCESS_KEY_ID e AWS_SECRET_KEY. È vivamente sconsigliato esporre i valori di chiave letterali nel codice. L'assegnazione di tali chiavi a variabili di ambiente è un modo pratico di gestire il problema.

• Registrati per creare un account Amazon SWF su Amazon Simple Workflow Service.

• Accedi AWS Management Console e seleziona il servizio Amazon SWF.

• Scegli Gestisci domini nell'angolo in alto a destra e registra un nuovo dominio Amazon SWF. Un dominio è un contenitore logico per le risorse dell'applicazione, come i tipi di flusso di lavoro e attività e le esecuzioni di flusso di lavoro. Puoi utilizzare qualsiasi nome di dominio conveniente, ma nelle procedure dettagliate viene utilizzato "». helloWorldWalkthrough

Per implementare HelloWorldWorkflow, crea una copia di HelloWorld. HelloWorld pacchetto nella directory del progetto e chiamalo HelloWorld. HelloWorldWorkflow. Le seguenti sezioni descrivono come modificare il HelloWorld codice originale per utilizzarlo AWS Flow Framework per Java ed eseguirlo come applicazione di workflow Amazon SWF.

HelloWorldWorkflow Addetto alle attività

HelloWorld ha implementato le sue attività come un'unica classe. An AWS Flow Framework for Java Activities Worker ha tre componenti di base:

• I metodi di attività, che eseguono le attività effettive, sono definiti in un'interfaccia e implementati in una classe correlata.

• Una ActivityWorkerclasse gestisce l'interazione tra i metodi di attività e Amazon SWF.

• Un'applicazione host di attività registra e avvia il lavoratore di attività e gestisce la pulizia.

Questa sezione descrive i metodi di attività. Le altre due classi sono presentate in una sezione successiva.

HelloWorldWorkflow definisce l'interfaccia delle attività inGreeterActivities, come segue:

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

Questa interfaccia non era strettamente necessaria per HelloWorld, ma lo è AWS Flow Framework per un'applicazione Java. Nota che la definizione dell'interfaccia non è cambiata. Tuttavia, è necessario applicarne due AWS Flow Framework per le annotazioni Java @ActivityRegistrationOptions e@Activities, alla definizione dell'interfaccia. Le annotazioni forniscono informazioni di configurazione e indicano al AWS Flow Framework processore di annotazioni Java di utilizzare la definizione dell'interfaccia per generare una classe client di attività, argomento discusso più avanti.

@ActivityRegistrationOptionsha diversi valori denominati che vengono utilizzati per configurare il comportamento delle attività. HelloWorldWorkflow specifica due timeout:

• defaultTaskScheduleToStartTimeoutSeconds indica per quanto tempo i task possono rimanere in coda nell'elenco di task di attività; il valore impostato è 300 secondi (5 minuti).

• defaultTaskStartToCloseTimeoutSeconds indica il tempo massimo di cui l'attività dispone per eseguire il task; il valore impostato è 10 secondi.

Questi timeout assicurano il completamento del task entro un tempo ragionevole. Se uno dei due timeout viene superato, il framework genera un errore e il lavoratore di flusso di lavoro deve decidere come gestire il problema. Per informazioni su come gestire tale errori, consulta Gestione errori.

@Activities comporta vari valori, ma in genere definisce soltanto il numero di versione delle attività, mediante il quale puoi tenere traccia di differenti generazioni di implementazioni di attività. Se modifichi un'interfaccia di attività dopo averla registrata in Amazon SWF, inclusa la modifica @ActivityRegistrationOptions dei valori, devi utilizzare un nuovo numero di versione.

HelloWorldWorkflow implementa i metodi di attività inGreeterActivitiesImpl, come segue:

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

Notate che il codice è identico all' HelloWorld implementazione. Fondamentalmente, un' AWS Flow Framework attività è solo un metodo che esegue del codice e forse restituisce un risultato. La differenza tra un'applicazione standard e un'applicazione di workflow Amazon SWF risiede nel modo in cui il flusso di lavoro esegue le attività, dove vengono eseguite le attività e in che modo i risultati vengono restituiti all'operatore del flusso di lavoro.

HelloWorldWorkflow Workflow Worker

Un workflow worker di Amazon SWF ha tre componenti di base.

• Un'implementazione di flusso di lavoro, ovvero una classe che esegue task correlati al flusso di lavoro.

• Una classe client di attività, che è in pratica un proxy per la classe di attività e viene utilizzata da un'implementazione di flusso di lavoro per eseguire metodi di attività in modo asincrono.

• Una WorkflowWorkerclasse che gestisce l'interazione tra il flusso di lavoro e Amazon SWF.

Questa sezione descrive l'implementazione di flusso di lavoro e il client di attività; la classe WorkflowWorker è descritta in una sezione successiva.

HelloWorldWorkflow definisce l'interfaccia del flusso di lavoro inGreeterWorkflow, come segue:

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

Inoltre, questa interfaccia non è strettamente necessaria HelloWorld , ma è essenziale AWS Flow Framework per un'applicazione Java. È necessario applicarne due AWS Flow Framework per le annotazioni Java @Flusso di lavoro e@WorkflowRegistrationOptions, per la definizione dell'interfaccia del flusso di lavoro. Le annotazioni forniscono informazioni di configurazione e indirizzano inoltre il processore di annotazioni AWS Flow Framework per Java a generare una classe client di workflow basata sull'interfaccia, come discusso più avanti.

@Workflowha un parametro opzionale, DataConverter, che viene spesso utilizzato con il suo valore NullDataConverter predefinito, che indica che deve essere utilizzato. JsonDataConverter

@WorkflowRegistrationOptions comporta ha vari parametri facoltativi che possono essere utilizzati per configurare il lavoratore di flusso di lavoro. Qui, impostiamo, defaultExecutionStartToCloseTimeoutSeconds che specifica per quanto tempo può essere eseguito il flusso di lavoro, a 3600 secondi (1 ora).

La definizione dell'GreeterWorkflowinterfaccia differisce da un aspetto importante, l' HelloWorld annotazione. @Execute Le interfacce di flusso di lavoro definiscono i metodi che possono essere chiamati dalle applicazioni come lo starter di flusso di lavoro e sono limitate a pochi metodi, ognuno con un ruolo particolare. Il framework non specifica un nome o un elenco di parametri per i metodi di interfaccia del flusso di lavoro; si utilizza un elenco di nomi e parametri adatto al flusso di lavoro e si applica un'annotazione AWS Flow Framework per Java per identificare il ruolo del metodo.

@Execute ha due scopi:

• Identifica greet come punto di ingresso del flusso di lavoro, ovvero il metodo che lo starter di flusso di lavoro chiama per avviare il flusso di lavoro. In genere, un punto di ingresso può accettare uno o più parametri, che consentono allo starter di inizializzare il flusso di lavoro, ma questo esempio non richiede l'inizializzazione.

• Definisce il numero di versione del flusso di lavoro, mediante il quale puoi tenere traccia di differenti generazioni di implementazioni di flusso di lavoro. Per modificare l'interfaccia di un flusso di lavoro dopo averla registrata in Amazon SWF, inclusa la modifica dei valori di timeout, devi utilizzare un nuovo numero di versione.

Per informazioni sugli altri metodi che possono essere inclusi in un'interfaccia di flusso di lavoro, consulta Contratti di flusso di lavoro e attività.

HelloWorldWorkflow implementa il flusso di lavoro inGreeterWorkflowImpl, come segue:

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

Il codice è simile a HelloWorld, ma presenta due importanti differenze.

• GreeterWorkflowImpl crea un'istanza di GreeterActivitiesClientImpl, il client di attività, anziché di GreeterActivitiesImpl, ed esegue le attività chiamando i metodi sull'oggetto client.

• Le attività relative a nome e formula di apertura restituiscono oggetti Promise<String> anziché oggetti String.

HelloWorld è un'applicazione Java standard che viene eseguita localmente come un singolo processo, quindi GreeterWorkflowImpl può implementare la topologia del flusso di lavoro semplicemente creando un'istanza diGreeterActivitiesImpl, chiamando i metodi in ordine e passando i valori restituiti da un'attività all'altra. Con un flusso di lavoro Amazon SWF, l'attività di un'attività viene comunque eseguita con un metodo di attività di. GreeterActivitiesImpl Tuttavia, il metodo non viene necessariamente eseguito nello stesso processo del flusso di lavoro (può addirittura non essere eseguito sullo stesso sistema) e il flusso di lavoro deve eseguire l'attività in modo asincrono. Queste condizioni comportano le seguenti problematiche:

• Come eseguire un metodo di attività che può essere eseguito in un processo differente ed eventualmente su un sistema differente.

• Come eseguire un metodo di attività in modo asincrono.

• Come gestire i valori di input e restituiti delle attività. Ad esempio, se il valore restituito dell'Attività A è un input all'Attività B, devi assicurarti che l'Attività B non venga eseguita fino a che l'Attività A non risulta completata.

Il flusso di controllo dell'applicazione ti consente di implementare varie topologie di flusso di lavoro mediante l'utilizzo del controllo di flusso Java standard combinato con il client di attività e Promise<T>.

Client di attività

GreeterActivitiesClientImpl è fondamentalmente un proxy per GreeterActivitiesImpl che consente a un'implementazione di flusso di lavoro di eseguire i metodi GreeterActivitiesImpl in modo asincrono.

Le classi GreeterActivitiesClient e GreeterActivitiesClientImpl sono generate automaticamente utilizzando le informazioni fornite nelle annotazioni applicate alla classe GreeterActivities. Non devi quindi implementarle personalmente.

Nota

Eclipse genera queste classi quando salvi il progetto. Puoi visualizzare il codice generato nella sottodirectory .apt_generated della directory del progetto.

Per evitare errori di compilazione nella classe GreeterWorkflowImpl, è consigliabile spostare la directory .apt_generated nella parte superiore della scheda Order and Export (Ordina ed esporta) della finestra di dialogo Java Build Path (Percorso di compilazione Java).

Un lavoratore di flusso di lavoro esegue un'attività chiamando il metodo di client corrispondente. Il metodo è asincrono e restituisce immediatamente un oggetto Promise<T>, dove T è il tipo restituito dell'attività. L'oggetto Promise<T> restituito è in pratica un segnaposto per il valore che il metodo di attività restituirà.

• Quando il metodo di client di attività restituisce un risultato, lo stato dell'oggetto Promise<T> è inizialmente non pronto, a indicare che l'oggetto non rappresenta ancora un valore restituito valido.

• Quando il metodo di attività corrispondente completa il relativo task e restituisce un risultato, il framework assegna il valore restituito all'oggetto Promise<T>, il cui stato diventa pronto.

Tipo di Promise <T>

Lo scopo primario degli oggetti Promise<T> è gestire il flusso di dati tra i componenti asincroni e controllare quando vengono eseguiti. Grazie a questi oggetti, la tua applicazione non deve gestire in modo esplicito la sincronizzazione o dipendere da meccanismi come i timer per impedire l'esecuzione prematura dei componenti asincroni. Quando chiami un metodo di client di attività, questo restituisce immediatamente un risultato ma il framework ritarda l'esecuzione del metodo di attività corrispondente fino a che un oggetto Promise<T> di input è pronto e rappresenta dati validi.

Dalla prospettiva GreeterWorkflowImpl, i tre metodi di client di attività restituiscono un risultato immediatamente. Dalla prospettiva GreeterActivitiesImpl, il framework chiama getGreeting solo quando name risulta completato e chiama say solo quando getGreeting risulta completato.

L'utilizzo di Promise<T> per passare dati da un'attività a quella successiva consente a HelloWorldWorkflow di impedire ai metodi di attività di tentare di utilizzare dati non validi, ma anche di determinare quando le attività vengono eseguite e di definire implicitamente la topologia di flusso di lavoro. Il passaggio del valore restituito Promise<T> di ogni attività all'attività successiva richiede l'esecuzione in sequenza delle attività, definendo la topologia lineare descritta precedentemente. Con AWS Flow Framework for Java, non è necessario utilizzare alcun codice di modellazione speciale per definire topologie anche complesse, ma solo il controllo di flusso Java standard e. Promise<T> Per un esempio di implementazione di una topologia parallela semplice, consulta Lavoratore di attività di HelloWorldWorkflowParallel.

Nota

Quando un metodo di attività come say non restituisce un valore, il metodo di client corrispondente restituisce un oggetto Promise<Void>. L'oggetto non rappresenta dati, ma è inizialmente non pronto e diventa pronto quando l'attività è completata. Puoi quindi passare un oggetto Promise<Void> a altri metodi di client di attività per assicurarti che questi differiscano l'esecuzione fino al completamento dell'attività originale.

Promise<T> consente a un'implementazione di flusso di lavoro di utilizzare metodi di client di attività e i relativi valori restituiti come con i metodi sincroni. Devi tuttavia prestare attenzione riguardo all'accesso al valore di un oggetto Promise<T>. A differenza del tipo Java Future<T>, il framework gestisce la sincronizzazione per Promise<T>, non l'applicazione. Se chiami Promise<T>.get e l'oggetto non è pronto, get genera un'eccezione. Nota che HelloWorldWorkflow non accede mai direttamente a un oggetto Promise<T>, ma passa semplicemente gli oggetti da un'attività a quella successiva. Quando un oggetto diventa pronto, il framework estrae il valore e lo passa al metodo di attività come tipo standard.

L'accesso agli oggetti Promise<T> deve avvenire solo tramite codice asincrono, dove il framework garantisce che l'oggetto è pronto e rappresenta un valore valido. HelloWorldWorkflow gestisce questa condizione passando gli oggetti Promise<T> solo a metodi di client di attività. Puoi accedere al valore di un oggetto Promise<T> nell'implementazione di flusso di lavoro passando l'oggetto a un metodo di flusso di lavoro asincrono, il cui comportamento è simile a quello di un'attività. Per vedere un esempio, consulta Applicazione HelloWorldWorkflowAsync.

HelloWorldWorkflow Implementazione del workflow e delle attività

Le implementazioni del flusso di lavoro e delle attività hanno classi di lavoro associate ActivityWorkere WorkflowWorker. Gestiscono la comunicazione tra Amazon SWF e le attività e le implementazioni del flusso di lavoro interrogando l'elenco di attività di Amazon SWF appropriato per le attività, eseguendo il metodo appropriato per ogni attività e gestendo il flusso di dati. Per maggiori dettagli, consulta AWS Flow FrameworkConcetti di base: struttura dell'applicazione.

Per associare le implementazioni di flusso di lavoro e attività agli oggetti lavoratore corrispondenti, devi implementare una o più applicazioni lavoratore che:

• Registra flussi di lavoro o attività con Amazon SWF.

• Creano oggetti lavoratore e li associano alle implementazioni di lavoratore di attività o di flusso di lavoro.

• Indirizza gli oggetti di lavoro affinché inizino a comunicare con Amazon SWF.

Se intendi eseguire il flusso di lavoro e le attività come processi distinti, devi implementare host lavoratore di flusso di lavoro e attività distinti. Per vedere un esempio, consulta Applicazione HelloWorldWorkflowDistributed. Per semplicità, HelloWorldWorkflow implementa un singolo host di lavoro che gestisce le attività e i lavoratori del flusso di lavoro nello stesso processo, come segue:

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

GreeterWorkernon ha una HelloWorld controparte, quindi è necessario aggiungere una classe Java denominata GreeterWorker al progetto e copiare il codice di esempio in quel file.

Il primo passaggio consiste nel creare e configurare un AmazonSimpleWorkflowClientoggetto, che richiama i metodi di servizio Amazon SWF sottostanti. A questo proposito, GreeterWorker:

1. Crea un ClientConfigurationoggetto e specifica un timeout del socket di 70 secondi. Questo valore definisce il tempo di attesa per il trasferimento dei dati via una connessione aperta stabilita prima della chiusura del socket.

2. Crea un AWSCredentials oggetto Basic per identificare l' AWS account e passa le chiavi dell'account al costruttore. Per comodità e per evitare di esporle come testo normale nel codice, le chiavi sono memorizzate come variabili di ambiente.

3. Crea un AmazonSimpleWorkflowClientoggetto per rappresentare il flusso di lavoro e passa gli ClientConfiguration oggetti BasicAWSCredentials and al costruttore.

4. Imposta l'URL dell'endpoint del servizio dell'oggetto client. Amazon SWF è attualmente disponibile in tutte le AWS regioni.

Per comodità, GreeterWorker definisce due costanti di stringa.

• domainè il nome di dominio Amazon SWF del flusso di lavoro, che hai creato quando hai configurato il tuo account Amazon SWF. HelloWorldWorkflowpresuppone che stiate eseguendo il flusso di lavoro nel dominio "»helloWorldWalkthrough.

• taskListToPollè il nome degli elenchi di attività utilizzati da Amazon SWF per gestire la comunicazione tra gli addetti al flusso di lavoro e alle attività. Puoi impostare il nome su qualsiasi stringa. HelloWorldWorkflow utilizza "HelloWorldList" sia per il flusso di lavoro che per gli elenchi delle attività. I nomi terminano con spazi dei nomi differenti, di conseguenza gli elenchi di task sono distinti.

GreeterWorkerutilizza le costanti di stringa e l'AmazonSimpleWorkflowClientoggetto per creare oggetti di lavoro, che gestiscono l'interazione tra le attività e le implementazioni dei worker e Amazon SWF. In particolare, gli oggetti lavoratore gestiscono il task di polling dei task nell'elenco di task appropriato.

GreeterWorker crea un oggetto ActivityWorker e lo configura per gestire GreeterActivitiesImpl aggiungendo una nuova istanza della classe. GreeterWorker chiama quindi il metodo start dell'oggetto ActivityWorker, che indica all'oggetto di avviare il polling nell'elenco di task di attività specificato.

GreeterWorker crea un oggetto WorkflowWorker e lo configura per gestire GreeterWorkflowImpl aggiungendo un nome di file di classe, GreeterWorkflowImpl.class. Chiama quindi il metodo start dell'oggetto WorkflowWorker, che indica all'oggetto di avviare il polling dell'elenco di task di flusso di lavoro specificato.

A questo punto, puoi eseguire GreeterWorker senza problemi. Registra il flusso di lavoro e le attività con Amazon SWF e avvia gli oggetti di lavoro analizzando i rispettivi elenchi di attività. Per verificarlo, esegui GreeterWorker e vai alla console Amazon SWF e seleziona helloWorldWalkthrough dall'elenco dei domini. Se scegli Workflow Types (Tipi di flusso di lavoro) nel riquadro Navigation (Navigazione), GreeterWorkflow.greet dovrebbe essere visualizzato nella finestra:

Se scegli Activity Types (Tipi di attività), vengono visualizzati i metodi GreeterActivities:

Tuttavia, se scegli Workflow Executions (Esecuzioni di flusso di lavoro), non verrà visualizzata alcuna esecuzione attiva. Sebbene i lavoratori di flusso di lavoro e di attività eseguano il polling di task, non abbiamo ancora avviato un'esecuzione di flusso di lavoro.

HelloWorldWorkflow Antipasto

L'ultimo pezzo del puzzle consiste nell'implementare uno starter di flusso di lavoro, ovvero un'applicazione che avvia l'esecuzione di flusso di lavoro. Lo stato di esecuzione viene memorizzato da Amazon SWF, in modo da poterne visualizzare la cronologia e lo stato di esecuzione. HelloWorldWorkflow implementa un sistema di avvio del flusso di lavoro modificando la GreeterMain classe nel modo seguente:

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 crea un oggetto AmazonSimpleWorkflowClient utilizzando lo stesso codice di GreeterWorker. Crea quindi un oggetto GreeterWorkflowClientExternal che agisce come proxy per il flusso di lavoro nello stesso modo in cui il client di attività creato in GreeterWorkflowClientImpl agisce come proxy per i metodi di attività. Anziché creare un oggetto client di flusso di lavoro utilizzando new devi:

1. Crea un oggetto client factory esterno e passa l'AmazonSimpleWorkflowClientoggetto e il nome di dominio Amazon SWF al costruttore. L'oggetto client factory viene creato dal processore di annotazioni del framework, che crea il nome dell'oggetto semplicemente aggiungendo "ClientExternalFactoryImpl" al nome dell'interfaccia del flusso di lavoro.

2. Crea un oggetto client esterno chiamando il getClient metodo dell'oggetto factory, che crea il nome dell'oggetto aggiungendo "ClientExternal" al nome dell'interfaccia del flusso di lavoro. Facoltativamente, puoi passare getClient una stringa che Amazon SWF utilizzerà per identificare questa istanza del flusso di lavoro. Altrimenti, Amazon SWF rappresenta un'istanza di flusso di lavoro utilizzando un GUID generato.

Il client restituito dalla fabbrica creerà solo flussi di lavoro denominati con la stringa passata al metodo getClient (il client restituito dalla fabbrica ha già lo stato in Amazon SWF). Per eseguire un flusso di lavoro con un ID differente, nella factory devi creare un nuovo client con l'ID differente specificato.

Il client di flusso di lavoro espone un metodo greet che GreeterMain chiama per iniziare il flusso di lavoro, in quanto greet() era il metodo specificato con l'annotazione @Execute.

Nota

Il processore di annotazione crea anche un oggetto client factory interno utilizzato per creare flussi di lavoro figlio. Per informazioni dettagliate, vedi Esecuzioni del flusso di lavoro figlio.

Chiudi GreeterWorker se è ancora in esecuzione ed esegui GreeterMain. Ora dovresti vedere SomeID nell'elenco delle esecuzioni di flussi di lavoro attive della console Amazon SWF:.

Se scegli someID e quindi la scheda Events (Eventi), gli eventi vengono visualizzati:

Nota

Se in precedenza hai avviato GreeterWorker ed è ancora in esecuzione, l'elenco di eventi sarà più lungo per i motivi che indicheremo più avanti. Chiudi GreeterWorker ed esegui di nuovo GreaterMain.

Nella scheda Events (Eventi) sono elencati solo due eventi:

• WorkflowExecutionStarted indica che l'esecuzione del flusso di lavoro è stata avviata.

• DecisionTaskScheduledindica che Amazon SWF ha messo in coda la prima operazione decisionale.

Il motivo per cui il flusso di lavoro è bloccato a livello del primo task di decisione è che il flusso di lavoro è distribuito su due applicazioni, GreeterMain e GreeterWorker. GreeterMain ha avviato l'esecuzione di flusso di lavoro, ma GreeterWorker non è in esecuzione. Di conseguenza, i lavoratori non effettuano il polling negli elenchi e non eseguono i task. Puoi eseguire l'una o l'altra delle applicazioni indipendentemente, ma hai bisogno di entrambe affinché l'esecuzione di flusso di lavoro continui oltre il primo task di decisione. Se quindi a questo punto esegui GreeterWorker, i lavoratori di flusso di lavoro e attività avvieranno il polling, i task saranno completati rapidamente e nella scheda Events verrà visualizzato il primo batch di eventi.

Puoi scegliere singoli eventi per visualizzare ulteriori informazioni sugli stessi. Al termine della ricerca, il flusso di lavoro dovrebbe avere stampato «Hello World!» sulla tua console.

Una volta completato, il flusso di lavoro non è più visibile nell'elenco di esecuzioni attive. Tuttavia, se vuoi esaminarlo, scegli Closed (Chiuse) in Execution Status (Stato esecuzione), quindi scegli List Executions (Elenca esecuzioni). In questo modo, vengono visualizzate tutte le istanze di flusso di lavoro completate nel dominio specificato (helloWorldWalkthrough) che non hanno superato il relativo periodo di retention impostato alla creazione del dominio.

Nota che ogni istanza di flusso di lavoro ha un valore Run ID (ID di esecuzione) univoco. Puoi utilizzare lo stesso ID di esecuzione per differenti istanze di flusso di lavoro, ma soltanto per un'esecuzione attiva alla volta.