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'[HelloWorld](getting-started-example-helloworld.md)esempio 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 EC2 istanze Amazon, 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. ![\[Versioni convenzionali e Amazon SWF di Hello World!\]](http://docs.aws.amazon.com/it_it/amazonswf/latest/awsflowguide/images/workflow_conceptual_welcome.png) HelloWorld viene eseguito come un unico processo e starter, workflow worker e Activities Worker interagiscono utilizzando chiamate di metodo convenzionali. Con`HelloWorldWorkflow`, 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](https://aws.amazon.com/). + Assegna l'ID di accesso e l'ID segreto del tuo account rispettivamente alle variabili AWS\$1ACCESS\$1KEY\$1ID e di AWS\$1SECRET\$1KEY ambiente. È 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](https://aws.amazon.com/swf/). + Accedi Console di gestione AWS 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 [ActivityWorker](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/simpleworkflow/flow/ActivityWorker.html)classe 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à in`GreeterActivities`, 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](annotations.md#annotations-activityregistration) e[@Activities](annotations.md#annotations-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. `@ActivityRegistrationOptions`ha 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](errorhandling.md). `@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à in`GreeterActivitiesImpl`, 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 al workflow worker. ## 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 [WorkflowWorker](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/simpleworkflow/flow/WorkflowWorker.html)classe 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 in`GreeterWorkflow`, 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](annotations.md#annotations-workflow) e[@WorkflowRegistrationOptions](annotations.md#annotations-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. `@Workflow`ha 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'`GreeterWorkflow`interfaccia differisce da un aspetto importante, l' HelloWorld annotazione. [@Execute](annotations.md#annotations-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à](features.workflow.md). HelloWorldWorkflow implementa il flusso di lavoro in`GreeterWorkflowImpl`, come segue: ``` 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); } } ``` 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` 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 di`GreeterActivitiesImpl`, 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`. ### 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`, dove `T` è il tipo restituito dell'attività. L'oggetto `Promise` 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` è 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`, il cui stato diventa *pronto*. ### Tipo di Promise Lo scopo primario degli oggetti `Promise` è 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` 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` 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` 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` Per un esempio di implementazione di una topologia parallela semplice, consulta [HelloWorldWorkflowParallel Attività: Lavoratore](getting-started-example-helloworldworkflowparallel.md#getting-started-example-helloworldworkflowparallel.activities). **Nota** Quando un metodo di attività come `say` non restituisce un valore, il metodo di client corrispondente restituisce un oggetto `Promise`. L'oggetto non rappresenta dati, ma è inizialmente non pronto e diventa pronto quando l'attività è completata. Puoi quindi passare un oggetto `Promise` a altri metodi di client di attività per assicurarti che questi differiscano l'esecuzione fino al completamento dell'attività originale. `Promise` 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`. A differenza del tipo Java [Future](http://docs.oracle.com/javase/6/docs/api/java/util/concurrent/Future.html), il framework gestisce la sincronizzazione per `Promise`, non l'applicazione. Se chiami `Promise.get` e l'oggetto non è pronto, `get` genera un'eccezione. Nota che `HelloWorldWorkflow` non accede mai direttamente a un oggetto `Promise`, 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` 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` solo a metodi di client di attività. Puoi accedere al valore di un oggetto `Promise` 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 [HelloWorldWorkflowAsync Applicazione](getting-started-example-helloworldworkflowasync.md). ## HelloWorldWorkflow Implementazione del workflow e delle attività Le implementazioni del flusso di lavoro e delle attività hanno classi di lavoro associate [ActivityWorker](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/simpleworkflow/flow/ActivityWorker.html)e [WorkflowWorker](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/simpleworkflow/flow/WorkflowWorker.html). Gestiscono la comunicazione tra Amazon SWF e le attività e le implementazioni del flusso di lavoro analizzando l'elenco di attività di Amazon SWF appropriato, eseguendo il metodo appropriato per ogni attività e gestendo il flusso di dati. Per maggiori dettagli, consulta [AWS Flow Framework Concetti di base: struttura dell'applicazione](awsflow-basics-application-structure.md). 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 [HelloWorldWorkflowDistributed Applicazione](getting-started-example-helloworldworkflowdistributed.md). 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(); } } ``` `GreeterWorker`non 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 [AmazonSimpleWorkflowClient](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/simpleworkflow/AmazonSimpleWorkflowClient.html)oggetto, che richiama i metodi di servizio Amazon SWF sottostanti. A questo proposito, `GreeterWorker`: 1. Crea un [ClientConfiguration](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/ClientConfiguration.html)oggetto 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. 1. Crea un AWSCredentials oggetto [Basic](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/auth/BasicAWSCredentials.html) 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. 1. Crea un [AmazonSimpleWorkflowClient](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/simpleworkflow/AmazonSimpleWorkflowClient.html)oggetto per rappresentare il flusso di lavoro e passa gli `ClientConfiguration` oggetti `BasicAWSCredentials` and al costruttore. 1. 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. `HelloWorldWorkflow`presuppone 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 conveniente. 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. `GreeterWorker`utilizza le costanti di stringa e l'[AmazonSimpleWorkflowClient](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/simpleworkflow/AmazonSimpleWorkflowClient.html)oggetto 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 accedi 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: ![\[HelloWorldWorkflow tipo di flusso di lavoro\]](http://docs.aws.amazon.com/it_it/amazonswf/latest/awsflowguide/images/Workflow_Type.png) Se scegli **Activity Types** (Tipi di attività), vengono visualizzati i metodi `GreeterActivities`: ![\[HelloWorldWorkflow tipi di attività\]](http://docs.aws.amazon.com/it_it/amazonswf/latest/awsflowguide/images/Activity_Types.png) 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'`AmazonSimpleWorkflowClient`oggetto 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. 1. 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](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/simpleworkflow/flow/WorkflowClientFactoryExternal.html#getClient(java.lang.String)) (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, consultare [Esecuzioni del flusso di lavoro figlio](childworkflow.md). 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:. ![\[HelloWorldWorkflow esecuzioni di flussi di lavoro\]](http://docs.aws.amazon.com/it_it/amazonswf/latest/awsflowguide/images/Active_Execution.png) Se scegli `someID` e quindi la scheda **Events** (Eventi), gli eventi vengono visualizzati: ![\[HelloWorldWorkflow eventi iniziali del flusso di lavoro\]](http://docs.aws.amazon.com/it_it/amazonswf/latest/awsflowguide/images/Events1.png) **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. + `DecisionTaskScheduled`indica 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. ![\[HelloWorldWorkflow eventi completi del flusso di lavoro\]](http://docs.aws.amazon.com/it_it/amazonswf/latest/awsflowguide/images/Events2.png) Puoi scegliere singoli eventi per visualizzare ulteriori informazioni sugli stessi. Quando avrai finito di cercare, il flusso di lavoro dovrebbe avere stampato «Hello World\$1» 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. ![\[HelloWorldWorkflow flussi di lavoro completati\]](http://docs.aws.amazon.com/it_it/amazonswf/latest/awsflowguide/images/Closed_Workflows.png) Nota che ogni istanza di flusso di lavoro ha un valore **Run ID** (ID di esecuzione) univoco. È possibile utilizzare lo stesso ID di workflow per diverse istanze di workflow, ma solo per un'esecuzione attiva alla volta.