Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

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:

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:

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:

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:

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.

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:

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.

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:

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.

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à.

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.

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:

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:

Per comodità, GreeterWorker definisce due costanti di stringa.

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:

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.

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:

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

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.