As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá. # HelloWorldWorkflowAsync Aplicação Às vezes, é preferível que um fluxo de trabalho execute certas tarefas localmente em vez de usar uma atividade. No entanto, as tarefas do fluxo de trabalho geralmente envolvem o processamento dos valores representados pelos objetos `Promise`. Se enviar um objeto `Promise` para um método do fluxo de trabalho síncrono, o método executa imediatamente mas não é capaz de acessar o valor do objeto `Promise` até que ele esteja pronto. Você pode consultar `Promise.isReady` até ele retornar `true`, mas isso é ineficiente e o método pode ser bloqueado por um longo período. Uma abordagem melhor é usar um *método assíncrono*. Um método assíncrono é implementado de forma muito semelhante a um método padrão, geralmente como membro da classe de implementação do fluxo de trabalho, e é executado no contexto da implementação do fluxo de trabalho. Designe-o como um método assíncrono aplicando uma anotação `@Asynchronous`, que direciona a estrutura para tratá-lo como uma atividade. + Quando uma implementação do fluxo de trabalho chama um método assíncrono, ele retorna imediatamente. Os métodos assíncronos geralmente retornam um objeto `Promise`, o qual se torna pronto quando o método for concluído. + Se enviar um ou mais objetos `Promise` para um método assíncrono, ele adia a execução até que todos os objetos de entrada estejam prontos. Um método assíncrono pode, portanto, acessar os valores `Promise` da sua entrada sem risco de uma exceção. **nota** Devido à forma como o AWS Flow Framework for Java executa o fluxo de trabalho, os métodos assíncronos geralmente são executados várias vezes, portanto, você deve usá-los somente para tarefas rápidas e de baixa sobrecarga. Use atividades para executar tarefas longas como computações grandes. Para obter detalhes, consulte [AWS Flow Framework Conceitos básicos: execução distribuída](awsflow-basics-distributed-execution.md). Este tópico é um passo a passo de HelloWorldWorkflowAsync, uma versão modificada HelloWorldWorkflow que substitui uma das atividades por um método assíncrono. Para implementar o aplicativo, crie uma cópia do HelloWorld. HelloWorldWorkflow pacote no diretório do seu projeto e chame-o de HelloWorld. HelloWorldWorkflowAsync. **nota** Este tópico aprofunda os conceitos e arquivos apresentados nós tópicos [HelloWorld Aplicação](getting-started-example-helloworld.md) e [HelloWorldWorkflow Aplicação](getting-started-example-helloworldworkflow.md). Familiarize-se com os arquivos e os conceitos apresentados nesses tópicos antes de prosseguir. As seções a seguir descrevem como modificar o HelloWorldWorkflow código original para usar um método assíncrono. ## HelloWorldWorkflowAsync Implantação de atividades HelloWorldWorkflowAsync implementa sua interface de trabalho de `GreeterActivities` atividades da seguinte forma: ``` import com.amazonaws.services.simpleworkflow.flow.annotations.Activities; import com.amazonaws.services.simpleworkflow.flow.annotations.ActivityRegistrationOptions; @Activities(version="2.0") @ActivityRegistrationOptions(defaultTaskScheduleToStartTimeoutSeconds = 300, defaultTaskStartToCloseTimeoutSeconds = 10) public interface GreeterActivities { public String getName(); public void say(String what); } ``` Essa interface é semelhante à usada por HelloWorldWorkflow, com as seguintes exceções: + Ela omite a atividade `getGreeting`. Essa tarefa agora é realizada por um método assíncrono. + O número da versão está definido como 2.0. Depois de registrar uma interface de atividades com o Amazon SWF, você não poderá modificá-la, a menos que altere o número da versão. As demais implementações do método de atividade são idênticas a. HelloWorldWorkflow Apenas exclua `getGreeting` de `GreeterActivitiesImpl`. ## HelloWorldWorkflowAsync implementação do fluxo de trabalho HelloWorldWorkflowAsync define a interface do fluxo de trabalho da seguinte forma: ``` import com.amazonaws.services.simpleworkflow.flow.annotations.Execute; import com.amazonaws.services.simpleworkflow.flow.annotations.Workflow; import com.amazonaws.services.simpleworkflow.flow.annotations.WorkflowRegistrationOptions; @Workflow @WorkflowRegistrationOptions(defaultExecutionStartToCloseTimeoutSeconds = 3600) public interface GreeterWorkflow { @Execute(version = "2.0") public void greet(); } ``` A interface é idêntica, HelloWorldWorkflow exceto por um novo número de versão. Como com as atividades, se desejar alterar um fluxo de trabalho registrado, é necessário alterar a sua versão. HelloWorldWorkflowAsync implementa o fluxo de trabalho da seguinte forma: ``` import com.amazonaws.services.simpleworkflow.flow.annotations.Asynchronous; import com.amazonaws.services.simpleworkflow.flow.core.Promise; public class GreeterWorkflowImpl implements GreeterWorkflow { private GreeterActivitiesClient operations = new GreeterActivitiesClientImpl(); @Override public void greet() { Promise name = operations.getName(); Promise greeting = getGreeting(name); operations.say(greeting); } @Asynchronous private Promise getGreeting(Promise name) { String returnString = "Hello " + name.get() + "!"; return Promise.asPromise(returnString); } } ``` HelloWorldWorkflowAsync substitui a `getGreeting` atividade por um método `getGreeting` assíncrono, mas o `greet` método funciona da mesma forma: 1. Execute a atividade `getName`, que retorna imediatamente um objeto `Promise`, `name`, que representa o nome. 1. Chame o método assíncrono `getGreeting` e envie-lhe o objeto `name`. `getGreeting` retorna imediatamente um objeto `Promise`, `greeting`, que representa a saudação. 1. Execute a atividade `say` e envie-lhe o objeto `greeting`. 1. Quando `getName` concluir, `name` se torna pronto e `getGreeting` usa o seu valor para construir a saudação. 1. Quando `getGreeting` concluir, `greeting` se torna pronto e `say` imprime a string no console. A diferença é que, em vez de chamar o cliente de atividades para executar uma atividade `getGreeting`, a saudação chama o método assíncrono `getGreeting`. O resultado final é o mesmo, mas o método `getGreeting` funciona de forma um tanto diferente em relação à atividade `getGreeting`. + O operador do fluxo de trabalho utiliza a semântica de chamada de função padrão para executar o `getGreeting`. No entanto, a execução assíncrona da atividade é mediada pelo Amazon SWF. + `getGreeting` é executado no processo de implementação do fluxo de trabalho. + `getGreeting` retorna um objeto `Promise` em vez de um objeto `String`. Para obter o valor da String mantida pelo `Promise`, chame o seu método `get()`. No entanto, como a atividade está sendo executada de forma assíncrona, seu valor de retorno pode não estar pronto imediatamente; `get()` gerará uma exceção até que o valor de retorno do método assíncrono esteja disponível. Para obter mais informações sobre como o `Promise` funciona, consulte [AWS Flow Framework Conceitos básicos: troca de dados entre atividades e fluxos de trabalho](awsflow-basics-data-exchange-activities-workflows.md). O `getGreeting` cria um valor de retorno enviando a string de saudação para o método `Promise.asPromise` estático. Esse método cria um objeto `Promise` do tipo apropriado, define o valor e coloca-o no estado pronto. ## HelloWorldWorkflowAsync Anfitrião e iniciador de fluxo de trabalho e atividades HelloWorldWorkflowAsync implementa `GreeterWorker` como classe hospedeira para as implementações de fluxo de trabalho e atividades. É idêntico à HelloWorldWorkflow implementação, exceto pelo `taskListToPoll` nome, que está definido como "`HelloWorldAsyncList`”. ``` import com.amazonaws.ClientConfiguration; import com.amazonaws.auth.AWSCredentials; import com.amazonaws.auth.BasicAWSCredentials; import com.amazonaws.services.simpleworkflow.AmazonSimpleWorkflow; import com.amazonaws.services.simpleworkflow.AmazonSimpleWorkflowClient; import com.amazonaws.services.simpleworkflow.flow.ActivityWorker; import com.amazonaws.services.simpleworkflow.flow.WorkflowWorker; public class GreeterWorker { public static void main(String[] args) throws Exception { ClientConfiguration config = new ClientConfiguration().withSocketTimeout(70*1000); String swfAccessId = System.getenv("AWS_ACCESS_KEY_ID"); String swfSecretKey = System.getenv("AWS_SECRET_KEY"); AWSCredentials awsCredentials = new BasicAWSCredentials(swfAccessId, swfSecretKey); AmazonSimpleWorkflow service = new AmazonSimpleWorkflowClient(awsCredentials, config); service.setEndpoint("https://swf.us-east-1.amazonaws.com"); String domain = "helloWorldWalkthrough"; String taskListToPoll = "HelloWorldAsyncList"; ActivityWorker aw = new ActivityWorker(service, domain, taskListToPoll); aw.addActivitiesImplementation(new GreeterActivitiesImpl()); aw.start(); WorkflowWorker wfw = new WorkflowWorker(service, domain, taskListToPoll); wfw.addWorkflowImplementationType(GreeterWorkflowImpl.class); wfw.start(); } } ``` HelloWorldWorkflowAsync implementa o iniciador do fluxo de trabalho em`GreeterMain`; é idêntico à HelloWorldWorkflow implementação. Para executar o fluxo de trabalho, execute `GreeterWorker` e. `GreeterMain` da mesma forma que com HelloWorldWorkflow.