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á. # Começando com o AWS Flow Framework for Java Esta seção apresenta uma série AWS Flow Framework de exemplos simples de aplicativos que apresentam o modelo básico de programação e a API. Os aplicativos de exemplo são baseados no aplicativo padrão Hello World que é usado para introduzir C e as linguagens de programação relacionadas. Veja uma implementação típica em Java do Hello World: ``` public class HelloWorld { public static void main(String[] args) { System.out.println("Hello World!"); } } ``` A seguir está uma breve descrição dos aplicativos exemplo. Eles incluem o código fonte completo para que você possa implementar e executar os aplicativos. Antes de começar, você deve primeiro configurar seu ambiente de desenvolvimento e criar um projeto AWS Flow Framework para Java, como em[Configurando o AWS Flow Framework para Java](setup.md). + [HelloWorld Aplicação](getting-started-example-helloworld.md) introduz aplicativos de fluxo de trabalho ao implementar Hello World como um aplicativo Java padrão, mas estruturando-o como um aplicativo de fluxo de trabalho. + [HelloWorldWorkflow Aplicação](getting-started-example-helloworldworkflow.md)usa o AWS Flow Framework for Java para converter HelloWorld em um fluxo de trabalho Amazon SWF. + [HelloWorldWorkflowAsync Aplicação](getting-started-example-helloworldworkflowasync.md) modifica o `HelloWorldWorkflow` para usar um método de *fluxo de trabalho assíncrono*. + [HelloWorldWorkflowDistributed Aplicação](getting-started-example-helloworldworkflowdistributed.md) modifica `HelloWorldWorkflowAsync` para que os operadores de fluxo de trabalho e de atividade possam ser executados em sistemas separados. + [HelloWorldWorkflowParallel Aplicação](getting-started-example-helloworldworkflowparallel.md) modifica `HelloWorldWorkflow` para executar duas atividades em paralelo. # Configurando o AWS Flow Framework para Java O AWS Flow Framework for Java está incluído no [AWS SDK para Java](https://aws.amazon.com/sdkforjava/). Se você ainda não configurou o AWS SDK para Java, acesse [Introdução](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/getting-started.html) no Guia do AWS SDK para Java Desenvolvedor para obter informações sobre como instalar e configurar o SDK em si. ## Adicione a estrutura de fluxo com o Maven As ferramentas de criação do Amazon SWF são de código aberto. Para visualizar ou baixar o código ou para criar as ferramentas você mesmo, visite o repositório em. [https://github.com/aws/aws-swf-build-tools](https://github.com/aws/aws-swf-build-tools) A [Amazon fornece ferramentas de criação do Amazon SWF no repositório](https://mvnrepository.com/artifact/com.amazonaws/aws-swf-build-tools) central do Maven. Para configurar a estrutura de fluxo para o Maven, adicione a seguinte dependência a seu arquivo `pom.xml` do projeto: ``` com.amazonaws aws-swf-build-tools 2.0.0 ``` # HelloWorld Aplicação Para apresentar a forma como as aplicações do Amazon SWF são estruturadas, criaremos uma aplicação Java que se comporta como um fluxo de trabalho, mas que é executada localmente em um único processo. Nenhuma conexão com a Amazon Web Services será necessária. **nota** O [HelloWorldWorkflow](getting-started-example-helloworldworkflow.md)exemplo se baseia nesse exemplo, conectando-se ao Amazon SWF para lidar com o gerenciamento do fluxo de trabalho. Um aplicativo de fluxo de trabalho consiste em três componentes básicos: + Um *operador de atividades* oferece suporte a um conjunto de *atividades*, cada uma das quais é um método que é executado independentemente para realizar uma tarefa específica. + Um *operador de fluxo de trabalho* coordena a execução das atividades e gerencia o fluxo de dados. É uma realização programática de uma *topologia de fluxo de trabalho*, que é basicamente um fluxograma que define quando as várias atividades são executadas, se são executadas sequencialmente ou simultaneamente etc. + Um *iniciador de fluxo de trabalho* inicia uma instância de fluxo de trabalho, chamada de uma *execução*, e pode interagir com ela durante a execução. HelloWorld é implementado como três classes e duas interfaces relacionadas, que são descritas nas seções a seguir. Antes de começar, você deve configurar seu ambiente de desenvolvimento e criar um novo projeto AWS Java conforme descrito em[Configurando o AWS Flow Framework para Java](setup.md). Todos os pacotes usados para as seguintes demonstrações são denominados `helloWorld.XYZ`. Para usar esses nomes, defina o atributo `within` no aop.xml seguinte da seguinte forma: ``` ... ``` Para implementar HelloWorld, crie um novo pacote Java em seu projeto AWS SDK chamado `helloWorld.HelloWorld` e adicione os seguintes arquivos: + Um arquivo de interface denominado `GreeterActivities.java` + Um arquivo de classe denominado `GreeterActivitiesImpl.java`, que executa o operador de atividades. + Um arquivo de interface denominado `GreeterWorkflow.java`. + Um arquivo de classe denominado `GreeterWorkflowImpl.java`, que implementa o operador de fluxo de trabalho. + Um arquivo de classe denominado `GreeterMain.java`, que implementa o iniciador do fluxo de trabalho. Os detalhes são discutidos nas seções a seguir e incluem o código completo de cada componente, que você pode adicionar ao arquivo apropriado. ## HelloWorld Implantação de atividades HelloWorld divide a tarefa geral de imprimir uma `"Hello World!"` saudação no console em três tarefas, cada uma das quais é executada por um *método de atividade*. Os métodos de atividade são definidos na interface de `GreeterActivities`, da seguinte forma. ``` public interface GreeterActivities { public String getName(); public String getGreeting(String name); public void say(String what); } ``` HelloWorld tem uma implementação de atividade`GreeterActivitiesImpl`,, que fornece os `GreeterActivities` métodos conforme mostrado: ``` 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); } } ``` As atividades são independentes uma da outra e podem ser usadas com frequência por fluxos de trabalho diferentes. Por exemplo, qualquer fluxo de trabalho pode usar a atividade `say` para imprimir uma sequência no console. Os fluxos de trabalho também podem ter várias implementações de atividade, cada uma executando um conjunto diferente de tarefas. ## HelloWorld Trabalhador de fluxo Para imprimir “Olá mundo\$1” para o console, as tarefas de atividade devem ser executadas em sequência, na ordem correta, com os dados corretos. O trabalhador do HelloWorld fluxo de trabalho orquestra a execução das atividades com base em uma *topologia de fluxo de trabalho linear* simples, mostrada na figura a seguir. ![\[Topologia linear do fluxo de trabalho\]](http://docs.aws.amazon.com/pt_br/amazonswf/latest/awsflowguide/images/helloworld_topology.png) As três atividades são executadas em sequência e os dados fluem de uma atividade para a próxima. O trabalhador do HelloWorld fluxo de trabalho tem um único método, o ponto de entrada do fluxo de trabalho, que é definido na `GreeterWorkflow` interface, da seguinte forma: ``` public interface GreeterWorkflow { public void greet(); } ``` A classe `GreeterWorkflowImpl` implementa essa interface, da seguinte forma: ``` public class GreeterWorkflowImpl implements GreeterWorkflow{ private GreeterActivities operations = new GreeterActivitiesImpl(); public void greet() { String name = operations.getName(); String greeting = operations.getGreeting(name); operations.say(greeting); } } ``` O `greet` método implementa a HelloWorld topologia criando uma instância de`GreeterActivitiesImpl`, chamando cada método de atividade na ordem correta e transmitindo os dados apropriados para cada método. ## HelloWorld Iniciador de fluxo de trabalho Um *iniciador de fluxo de trabalho* é um aplicativo que inicia uma execução de fluxo de trabalho e também pode se comunicar com o fluxo de trabalho enquanto o executa. A `GreeterMain` classe implementa o iniciador do HelloWorld fluxo de trabalho, da seguinte forma: ``` public class GreeterMain { public static void main(String[] args) { GreeterWorkflow greeter = new GreeterWorkflowImpl(); greeter.greet(); } } ``` `GreeterMain` cria uma instância de `GreeterWorkflowImpl` e chama `greet` para executar o operador do fluxo de trabalho. Execute `GreeterMain` como uma aplicação Java, e você verá "Hello World\$1" na saída do console. # HelloWorldWorkflow Aplicação Embora o [HelloWorld](getting-started-example-helloworld.md)exemplo básico seja estruturado como um fluxo de trabalho, ele difere de um fluxo de trabalho do Amazon SWF em vários aspectos importantes: **Aplicações de fluxo de trabalho convencionais e do Amazon SWF** | HelloWorld | Fluxo de trabalho do Amazon SWF | | --- | --- | | É executado localmente como um processo único. | É executado como vários processos que podem ser distribuídos em vários sistemas, incluindo EC2 instâncias da Amazon, data centers privados, computadores clientes e assim por diante. Ele nem precisa ser executado no mesmo sistema operacional. | | As atividades são métodos síncronos, que são bloqueados até que sejam concluídos. | As atividades são representadas por métodos assíncronos, que retornam imediatamente e permitem que o fluxo de trabalho execute outras tarefas enquanto aguarda que a atividade seja concluída. | | O operador do fluxo de trabalho interage com um operador de atividades chamando o método apropriado. | Os operadores do fluxo de trabalho interagem com os operadores das atividades usando solicitações HTTP, com o Amazon SWF atuando como intermediário. | | O iniciador do fluxo de trabalho interage com o operador do fluxo de trabalho chamando o método apropriado. | Os iniciadores de fluxo de trabalho interagem com os operadores do fluxo de trabalho usando solicitações HTTP, com o Amazon SWF atuando como um intermediário. | Você pode implementar um aplicativo de fluxo de trabalho assíncrono distribuído a partir do zero, por exemplo, fazendo com que o operador do fluxo de trabalho interaja com um operador de atividades diretamente por meio de chamadas a serviços web. No entanto, você deve implementar todo o código complicado necessário para gerenciar a execução assíncrona de várias atividades, manipular o fluxo de dados etc. O AWS Flow Framework for Java e o Amazon SWF cuidam de todos esses detalhes, o que permite que você se concentre na implementação da lógica de negócios. HelloWorldWorkflow é uma versão modificada HelloWorld que é executada como um fluxo de trabalho do Amazon SWF. A figura a seguir resume a forma como os dois aplicativos funcionam. ![\[Versões convencionais e do Amazon SWF do Hello World!\]](http://docs.aws.amazon.com/pt_br/amazonswf/latest/awsflowguide/images/workflow_conceptual_welcome.png) HelloWorld é executado como um único processo e o iniciante, o trabalhador do fluxo de trabalho e o trabalhador das atividades interagem usando chamadas de métodos convencionais. Com `HelloWorldWorkflow`, o iniciador, o operador do fluxo de trabalho e o operador de atividades são componentes distribuídos que interagem por meio do Amazon SWF usando solicitações HTTP. O Amazon SWF gerencia a interação mantendo listas de tarefas de fluxo de trabalho e atividades, que são despachadas para os respectivos componentes. Esta seção descreve como a estrutura funciona para HelloWorldWorkflow. HelloWorldWorkflow é implementado usando a API AWS Flow Framework for Java, que lida com os detalhes às vezes complicados da interação com o Amazon SWF em segundo plano e simplifica consideravelmente o processo de desenvolvimento. Você pode usar o mesmo projeto que usou HelloWorld, que já está configurado AWS Flow Framework para aplicativos Java. No entanto, para executar a aplicação, você deve configurar uma conta do Amazon SWF, como segue: + Crie uma AWS conta, se você ainda não tiver uma, na [Amazon Web Services](https://aws.amazon.com/). + Atribua o ID de acesso e o ID secreto da sua conta às variáveis de AWS\$1SECRET\$1KEY ambiente AWS\$1ACCESS\$1KEY\$1ID e, respectivamente. É uma boa prática não expor os valores literais das chaves no código. O armazenamento das chaves em variáveis de ambiente é uma maneira conveniente para lidar com o problema. + Registre-se para obter uma conta Amazon SWF no [Amazon Simple Workflow Service](https://aws.amazon.com/swf/). + Faça login Console de gerenciamento da AWS e selecione o serviço Amazon SWF. + Escolha **Gerenciar domínios** no canto superior direito e registre um novo domínio Amazon SWF. Um *domínio* é um contêiner lógico dos recursos de seus aplicativos, como os tipos de fluxo de trabalho e de atividade e as execuções de fluxo de trabalho. Você pode usar qualquer nome de domínio conveniente, mas as orientações usam "”. helloWorldWalkthrough Para implementar o HelloWorldWorkflow, crie uma cópia do HelloWorld. HelloWorld pacote no diretório do seu projeto e chame-o de HelloWorld. HelloWorldWorkflow. As seções a seguir descrevem como modificar o HelloWorld código original para usar o AWS Flow Framework para Java e executá-lo como um aplicativo de fluxo de trabalho do Amazon SWF. ## HelloWorldWorkflow Trabalhador de atividades HelloWorld implementou suas atividades de trabalhador como uma única classe. Um trabalhador de atividades AWS Flow Framework para Java tem três componentes básicos: + Os *métodos de atividade*, que executam as tarefas reais, são definidos em uma interface e implementados em uma classe relacionada. + Uma [ActivityWorker](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/simpleworkflow/flow/ActivityWorker.html)classe gerencia a interação entre os métodos de atividade e o Amazon SWF. + Um aplicativo *host de atividades* registra e inicia o operador de atividades e processa a limpeza. Esta seção discute os métodos de atividade. As outras duas classes são discutidas posteriormente. HelloWorldWorkflow define a interface de atividades em`GreeterActivities`, da seguinte forma: ``` 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); } ``` Essa interface não era estritamente necessária para HelloWorld, mas é AWS Flow Framework para um aplicativo Java. Observe que a própria definição da interface não foi alterada. No entanto, você deve aplicar dois AWS Flow Framework para anotações Java [@ActivityRegistrationOptions](annotations.md#annotations-activityregistration) e para a [@Atividades](annotations.md#annotations-activities) definição da interface. As anotações fornecem informações de configuração e orientam o processador de anotações AWS Flow Framework para Java a usar a definição da interface para gerar uma classe *cliente de atividades*, que será discutida posteriormente. `@ActivityRegistrationOptions`tem vários valores nomeados que são usados para configurar o comportamento das atividades. HelloWorldWorkflow especifica dois tempos limite: + `defaultTaskScheduleToStartTimeoutSeconds` especifica por quanto tempo as tarefas podem ser enfileiradas na lista de tarefas de atividades, e é definido como 300 segundos (5 minutos). + `defaultTaskStartToCloseTimeoutSeconds` especifica o tempo máximo que a atividade pode levar para executar a tarefa e é definido como 10 segundos. Esses tempos limite garantem que a atividade conclua sua tarefa em uma quantidade de tempo razoável. Se um dos tempos limite for excedido, a estrutura gerará um erro e o operador do fluxo de trabalho deverá decidir como lidar com o problema. Para obter uma discussão de como tratar esses erros, consulte [Tratamento de erros](errorhandling.md). `@Activities` tem vários valores, mas geralmente apenas especifica o número da versão das atividades, permitindo que você controle as diferentes gerações de implementações de atividades. Se você alterar uma interface de atividade depois de registrá-la no Amazon SWF, incluindo a alteração dos valores `@ActivityRegistrationOptions`, deverá usar um novo número de versão. HelloWorldWorkflow implementa os métodos de atividade em`GreeterActivitiesImpl`, da seguinte forma: ``` 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); } } ``` Observe que o código é idêntico à HelloWorld implementação. Em essência, uma AWS Flow Framework atividade é apenas um método que executa algum código e talvez retorne um resultado. A diferença entre uma aplicação padrão e uma aplicação de fluxo de trabalho do Amazon SWF está em como o fluxo de trabalho executa as atividades, onde as atividades são executadas e como os resultados são retornados ao operador do fluxo de trabalho. ## HelloWorldWorkflow Trabalhador de fluxo Um operador de fluxo de trabalho do Amazon SWF tem três componentes básicos. + Uma *implementação de fluxo de trabalho* que é uma classe que executa tarefas relacionadas ao fluxo de trabalho. + Uma classe de *cliente de atividades* que é basicamente um proxy da classe de atividades e é usada por uma implementação de fluxo de trabalho para executar métodos de atividade de forma assíncrona. + Uma [WorkflowWorker](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/simpleworkflow/flow/WorkflowWorker.html)classe que gerencia a interação entre o fluxo de trabalho e o Amazon SWF. Esta seção discute a implementação do fluxo de trabalho e do cliente de atividades. A classe `WorkflowWorker` é discutida posteriormente. HelloWorldWorkflow define a interface do fluxo de trabalho em`GreeterWorkflow`, 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 = "1.0") public void greet(); } ``` Essa interface também não é estritamente necessária HelloWorld , mas é essencial AWS Flow Framework para um aplicativo Java. Você deve aplicar dois AWS Flow Framework para anotações Java [@Fluxo de trabalho](annotations.md#annotations-workflow) e [@WorkflowRegistrationOptions](annotations.md#annotations-workflowregistrationoptions) para a definição da interface do fluxo de trabalho. As anotações fornecem informações de configuração e também orientam o processador de anotações AWS Flow Framework para Java a gerar uma classe cliente de fluxo de trabalho com base na interface, conforme discutido posteriormente. `@Workflow`tem um parâmetro opcional, *dataConverter*, que geralmente é usado com seu valor padrão NullDataConverter, o que indica JsonDataConverter que deve ser usado. `@WorkflowRegistrationOptions` também tem vários parâmetros opcionais que podem ser usados para configurar o operador de fluxo de trabalho. Aqui, definimos `defaultExecutionStartToCloseTimeoutSeconds`, que especifica por quanto tempo o fluxo de trabalho pode ser executado, como 3.600 segundos (1 hora). A definição da `GreeterWorkflow` interface difere de uma HelloWorld forma importante, a [@Execute](annotations.md#annotations-execute) anotação. As interfaces de fluxo de trabalho especificam os métodos que podem ser chamados por aplicativos, como o iniciador do fluxo de trabalho, e são limitadas a alguns dos métodos, cada um com uma função específica. O framework não especifica um nome ou uma lista de parâmetros para métodos de interface de fluxo de trabalho; você usa um nome e uma lista de parâmetros adequados ao seu fluxo de trabalho e aplica uma anotação do AWS Flow Framework para Java para identificar a função do método. `@Execute` tem dois objetivos: + Identifica `greet` como o ponto de entrada do fluxo de trabalho — o método que o iniciador do fluxo de trabalho chama para iniciar o fluxo de trabalho. Geralmente, um ponto de entrada pode ter um ou mais parâmetros, o que permite que o iniciador inicialize o fluxo de trabalho, mas este exemplo não requer inicialização. + Ele especifica o número da versão do fluxo de trabalho permitindo que você controle as diferentes gerações de implementações de fluxo de trabalho. Para alterar uma interface de fluxo de trabalho depois de registrá-la no Amazon SWF, incluindo a alteração dos valores de tempo limite, você deve usar um novo número de versão. Para obter informações sobre os outros métodos que podem ser incluídos em uma interface de fluxo de trabalho, consulte [Contratos de atividades e de fluxo de trabalho](features.workflow.md). HelloWorldWorkflow implementa o fluxo de trabalho em`GreeterWorkflowImpl`, da seguinte forma: ``` 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); } } ``` O código é semelhante HelloWorld, mas com duas diferenças importantes. + O `GreeterWorkflowImpl` cria uma instância de `GreeterActivitiesClientImpl`, o cliente de atividades, em vez de `GreeterActivitiesImpl`, e executa as atividades chamando os métodos no objeto do cliente. + Atividades de nome e de saudação retornam objetos `Promise` em vez de objetos `String`. HelloWorld é um aplicativo Java padrão executado localmente como um único processo, portanto, `GreeterWorkflowImpl` pode implementar a topologia do fluxo de trabalho simplesmente criando uma instância de`GreeterActivitiesImpl`, chamando os métodos em ordem e passando os valores de retorno de uma atividade para a próxima. Com um fluxo de trabalho do Amazon SWF, a tarefa de uma atividade ainda é executada por um método de atividade de `GreeterActivitiesImpl`. No entanto, o método não é necessariamente executado no mesmo processo que o fluxo de trabalho, talvez ele nem execute no mesmo sistema, e o fluxo de trabalho precisa executar a atividade de maneira assíncrona. Esses requisitos geram os seguintes problemas: + Como executar um método de atividade que possa ser executado em outro processo, talvez em outro sistema. + Como executar um método de atividade de forma assíncrona. + Como gerenciar entradas e valores de retorno de atividades. Por exemplo, se o valor de retorno da atividade A for uma entrada para a atividade B, você deverá garantir que a atividade B não seja executada até que a atividade A esteja concluída. Você pode implementar várias topologias de fluxo de trabalho por meio do fluxo de controle do aplicativo usando o controle de fluxo familiar do Java combinado com o cliente de atividades e o `Promise`. ### Cliente de atividades O `GreeterActivitiesClientImpl` é basicamente um proxy para `GreeterActivitiesImpl` que permite que uma implementação de fluxo de trabalho execute os métodos `GreeterActivitiesImpl` de forma assíncrona. As classes `GreeterActivitiesClient` e `GreeterActivitiesClientImpl` são geradas automaticamente para você usando as informações fornecidas nas anotações aplicadas a sua classe `GreeterActivities`. Não é necessário implementá-las você mesmo. **nota** O Eclipse gera essas classes quando você salva o projeto. Você pode visualizar o código gerado no subdiretório `.apt_generated` do diretório do projeto. Para evitar erros de compilação na classe `GreeterWorkflowImpl`, é uma boa prática mover o diretório `.apt_generated` para a parte superior da guia **Order and Export** (Pedir e exportar) da caixa de diálogo **Java Build Path** (Caminho de compilação do Java). Um operador de fluxo de trabalho executa uma atividade chamando o método do cliente correspondente. O método é assíncrono e retorna imediatamente um objeto `Promise`, em que `T` é o tipo de retorno da atividade. O objeto `Promise` retornado é basicamente um espaço reservado para o valor que o método da atividade retornará eventualmente. + Quando o método do cliente de atividades retorna, o objeto `Promise` inicialmente está em um *estado não pronto*, o que indica que o objeto ainda não representa um valor de retorno válido. + Quando o método da atividade correspondente conclui suas tarefas e retornos, a estrutura atribui o valor de retorno ao objeto `Promise` e o coloca no *estado pronto*. ### Promessa Type A finalidade principal de objetos `Promise` é gerenciar o fluxo de dados entre componentes assíncronos e controlar quando eles são executados. Ele libera o aplicativo da necessidade de gerenciar explicitamente a sincronização ou de depender de mecanismos como temporizadores para garantir que os componentes assíncronos não sejam executados prematuramente. Quando você chama um método de cliente de atividades, ele retorna imediatamente, mas a estrutura adia a execução do método de atividade correspondente até que todos os objetos `Promise` de entrada estejam prontos e representem dados válidos. Da perspectiva do `GreeterWorkflowImpl`, todos os três métodos de cliente de atividades retornam imediatamente. Da perspectiva do `GreeterActivitiesImpl`, a estrutura não chama `getGreeting` até que `name` seja concluído e não chama `say` até que `getGreeting` seja concluído. O uso de `Promise` para passar dados de uma atividade para a próxima, `HelloWorldWorkflow` não só garante que os métodos de atividade não tentem usar dados inválidos, ela também controla quando as atividades são executadas e define implicitamente a topologia do fluxo de trabalho. A passagem do valor de retorno `Promise` de cada atividade para a atividade seguinte requer que as atividades sejam executadas em sequência definindo a topologia linear discutida anteriormente. Com AWS Flow Framework o for Java, você não precisa usar nenhum código de modelagem especial para definir até mesmo topologias complexas, apenas controle de fluxo Java padrão e. `Promise` Para obter um exemplo de como implementar uma topologia paralela simples, consulte [HelloWorldWorkflowParallel Trabalhador de atividades](getting-started-example-helloworldworkflowparallel.md#getting-started-example-helloworldworkflowparallel.activities). **nota** Quando um método de atividade como `say` não retorna um valor, o método do cliente correspondente retorna um objeto `Promise`. O objeto não representa dados, mas inicialmente não está pronto e se torna pronto quando a atividade é concluída. Portanto, você pode passar um objeto `Promise` para outros métodos de cliente de atividades para garantir que eles adiem a execução até que a atividade original seja concluída. O `Promise` permite que uma implementação de fluxo de trabalho use métodos de cliente de atividades e seus valores de retorno da mesma forma como os métodos sincronizados. No entanto, você deve ter cuidado ao acessar o valor de um objeto `Promise`. Ao contrário do tipo [Future](http://docs.oracle.com/javase/6/docs/api/java/util/concurrent/Future.html) do Java, a estrutura controla a sincronização de `Promise`, não o aplicativo. Se você chamar `Promise.get` e o objeto não estiver pronto, `get` gerará uma exceção. Observe que o `HelloWorldWorkflow` nunca acessa um objeto `Promise` diretamente. Ele simplesmente passa os objetos de uma atividade para a próxima. Quando um objeto torna-se pronto, a estrutura extrai o valor e passa-o para o método de atividade como um tipo padrão. Os objetos `Promise` devem ser acessados apenas pelo código assíncrono, em que a estrutura garante que o objeto está pronto e representa um valor válido. O `HelloWorldWorkflow` trata esse problema passando os objetos `Promise` somente para métodos de cliente de atividades. Você pode acessar o valor de um objeto `Promise` em sua implementação de fluxo de trabalho passando o objeto para um *método de fluxo de trabalho assíncrono*, que se comporta de forma semelhante à forma de uma atividade. Para obter um exemplo, consulte [HelloWorldWorkflowAsync Aplicação](getting-started-example-helloworldworkflowasync.md). ## HelloWorldWorkflow Fluxo de trabalho e implementação de atividades As implementações de fluxo de trabalho e atividades têm classes de trabalhadores associadas [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) Eles lidam com a comunicação entre o Amazon SWF e as atividades e implementações de fluxo de trabalho, pesquisando a lista de tarefas apropriada do Amazon SWF para tarefas, executando o método apropriado para cada tarefa e gerenciando o fluxo de dados. Para obter detalhes, consulte [AWS Flow Framework Conceitos básicos: Estrutura do aplicativo](awsflow-basics-application-structure.md) Para associar as implementações das atividades e do fluxo de trabalho aos objetos correspondentes do operador, você implementa um ou mais aplicativos de operador que: + Registre fluxos de trabalho ou atividades com o Amazon SWF. + Cria objetos de operador e os associa às implementações operador de fluxo de trabalho ou de atividades. + Direcione os objetos de trabalho para iniciar a comunicação com o Amazon SWF. Para executar o fluxo de trabalho e as atividades como processos separados, você deve implementar hosts separados de operador de fluxo de trabalho e de atividades. Para obter um exemplo, consulte [HelloWorldWorkflowDistributed Aplicação](getting-started-example-helloworldworkflowdistributed.md). Para simplificar, HelloWorldWorkflow implementa um único host de trabalho que executa atividades e trabalhadores do fluxo de trabalho no mesmo processo, da seguinte forma: ``` 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`não tem HelloWorld contrapartida, então você deve adicionar uma classe Java nomeada `GreeterWorker` ao projeto e copiar o código de exemplo para esse arquivo. A primeira etapa é criar e configurar um [AmazonSimpleWorkflowClient](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/simpleworkflow/AmazonSimpleWorkflowClient.html)objeto, que invoca os métodos de serviço subjacentes do Amazon SWF. Para fazer isso, o `GreeterWorker`: 1. Cria um [ClientConfiguration](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/ClientConfiguration.html)objeto e especifica um tempo limite de soquete de 70 segundos. Esse valor especifica por quanto tempo esperar para que os dados sejam transferidos por uma conexão aberta estabelecida antes de fechar o soquete. 1. Cria um AWSCredentials objeto [básico](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/auth/BasicAWSCredentials.html) para identificar a AWS conta e passa as chaves da conta para o construtor. Por conveniência, e para evitar sua exposição como texto simples no código, as chaves são armazenadas como variáveis de ambiente. 1. Cria um [AmazonSimpleWorkflowClient](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/simpleworkflow/AmazonSimpleWorkflowClient.html)objeto para representar o fluxo de trabalho e passa os `ClientConfiguration` objetos `BasicAWSCredentials` e para o construtor. 1. Define o URL do endpoint do serviço do objeto cliente. Atualmente, o Amazon SWF está disponível em todas as AWS regiões. Por conveniência, o `GreeterWorker` define duas constantes de sequências de caracteres. + `domain`é o nome de domínio Amazon SWF do fluxo de trabalho, que você criou ao configurar sua conta Amazon SWF. `HelloWorldWorkflow`presume que você esteja executando o fluxo de trabalho no domínio helloWorldWalkthrough "”. + `taskListToPoll` é o nome das listas de tarefas que o Amazon SWF usa para gerenciar a comunicação entre o fluxo de trabalho e os operadores das atividades. Você pode definir o nome para qualquer sequência de caracteres conveniente. HelloWorldWorkflow usa "HelloWorldList" para listas de tarefas de fluxo de trabalho e atividades. Nos bastidores, os nomes ficam em namespaces diferentes e, portanto, as duas listas de tarefas são distintas. `GreeterWorker`usa as constantes de string e o [AmazonSimpleWorkflowClient](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/simpleworkflow/AmazonSimpleWorkflowClient.html)objeto para criar objetos de trabalho, que gerenciam a interação entre as atividades e as implementações do trabalhador e o Amazon SWF. Especificamente, os objetos de operador processam a tarefa de pesquisa de tarefas na lista de tarefas adequada. O `GreeterWorker` cria um objeto `ActivityWorker` e o configura para processar o `GreeterActivitiesImpl` adicionando uma nova instância de classe. Em seguida, o `GreeterWorker` chama o método `ActivityWorker` do objeto `start`, que direciona o objeto para iniciar a pesquisa na lista de tarefas de atividades especificada. O `GreeterWorker` cria um objeto `WorkflowWorker` e o configura para processar o `GreeterWorkflowImpl` adicionando o nome do arquivo de classe, `GreeterWorkflowImpl.class`. Em seguida, ele chama o método do objeto `WorkflowWorker`, `start`, que direciona o objeto para iniciar a pesquisa na lista de tarefas de fluxo de trabalho especificada. Você pode executar o `GreeterWorker` com êxito neste ponto. Ele registra o fluxo de trabalho e as atividades com o Amazon SWF e inicia os objetos de trabalho pesquisando suas respectivas listas de tarefas. Para verificar isso, execute `GreeterWorker` e vá para o console do Amazon SWF e selecione `helloWorldWalkthrough` na lista de domínios. Se você escolher **Workflow Types** (Tipos de fluxo de trabalho) no painel **Navigation** (Navegação), deverá ver o `GreeterWorkflow.greet`: ![\[HelloWorldWorkflow tipo de fluxo de trabalho\]](http://docs.aws.amazon.com/pt_br/amazonswf/latest/awsflowguide/images/Workflow_Type.png) Se você escolher **Activity Types** (Tipos de atividade), os métodos de `GreeterActivities` serão exibidos: ![\[HelloWorldWorkflow tipos de atividade\]](http://docs.aws.amazon.com/pt_br/amazonswf/latest/awsflowguide/images/Activity_Types.png) No entanto, se você escolher **Workflow Executions** (Execuções de fluxo de trabalho), você não verá nenhuma execução ativa. Embora os operadores de fluxo de trabalho e de atividades estejam pesquisando tarefas, ainda não iniciamos uma execução de fluxo de trabalho. ## HelloWorldWorkflow Iniciante A parte final do quebra-cabeça é implementar um iniciador de fluxo de trabalho que seja um aplicativo que inicia a execução do fluxo de trabalho. O estado de execução é armazenado pelo Amazon SWF, para que você possa visualizar seu histórico e status de execução. HelloWorldWorkflow implementa um iniciador de fluxo de trabalho modificando a `GreeterMain` classe, da seguinte forma: ``` 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(); } } ``` O `GreeterMain` cria um objeto `AmazonSimpleWorkflowClient` usando o mesmo código que o `GreeterWorker` usa. Em seguida, ele cria um objeto `GreeterWorkflowClientExternal` que atua como um proxy para o fluxo de trabalho da mesma forma como o cliente de atividades criado em `GreeterWorkflowClientImpl` atua como um proxy para os métodos de atividade. Em vez de criar um objeto de cliente de fluxo de trabalho usando `new`, você deve: 1. Crie um objeto de fábrica de cliente externo e passe o objeto `AmazonSimpleWorkflowClient` e o nome de domínio do Amazon SWF para o construtor. O objeto de fábrica do cliente é criado pelo processador de anotações da estrutura, que cria o nome do objeto simplesmente anexando "ClientExternalFactoryImpl" ao nome da interface do fluxo de trabalho. 1. Crie um objeto cliente externo chamando o `getClient` método do objeto de fábrica, que cria o nome do objeto anexando "ClientExternal" ao nome da interface do fluxo de trabalho. Opcionalmente, você pode passar `getClient`, uma string que o Amazon SWF usará para identificar essa instância do fluxo de trabalho. Caso contrário, o Amazon SWF representa uma instância de fluxo de trabalho usando um GUID gerado. O cliente retornado da fábrica criará apenas fluxos de trabalho nomeados com a string passada no método [getClient](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/simpleworkflow/flow/WorkflowClientFactoryExternal.html#getClient(java.lang.String)) (o cliente retornado da fábrica já tem estado no Amazon SWF). Para executar um fluxo de trabalho com outro id, você precisará voltar à fábrica e criar um cliente novo com o outro id especificado. O cliente de fluxo de trabalho expõe um método `greet` que o `GreeterMain` chama para iniciar o fluxo de trabalho, porque `greet()` foi o método especificado com a anotação `@Execute`. **nota** O processador de anotação também cria um objeto interno da fábrica de cliente que é usado para criar fluxos de trabalho filhos. Para obter detalhes, consulte [Execuções do fluxo de trabalho filho](childworkflow.md). Desligue o `GreeterWorker` por enquanto, se ele ainda estiver em execução e executar `GreeterMain`. Agora você deve ver someID na lista de execuções de fluxo de trabalho ativas do console do Amazon SWF: ![\[HelloWorldWorkflow execuções de fluxo de trabalho\]](http://docs.aws.amazon.com/pt_br/amazonswf/latest/awsflowguide/images/Active_Execution.png) Se você escolher `someID` e escolher a guia **Events** (Eventos), os eventos serão exibidos: ![\[HelloWorldWorkflow eventos iniciais do fluxo de trabalho\]](http://docs.aws.amazon.com/pt_br/amazonswf/latest/awsflowguide/images/Events1.png) **nota** Se você tiver iniciado o `GreeterWorker` anteriormente, e ele inda estiver em execução, verá uma lista de eventos mais longa pelos motivos discutidos brevemente. Interrompa o `GreeterWorker` e tente executar `GreaterMain` novamente. A guia **Events** (Eventos) mostra apenas dois eventos: + O `WorkflowExecutionStarted` indica que o fluxo de trabalho começou a execução. + `DecisionTaskScheduled` indica que o Amazon SWF enfileirou a primeira tarefa de decisão. O motivo pelo qual o fluxo de trabalho é bloqueado na primeira tarefa de administração é que o fluxo de trabalho é distribuído entre dois aplicativos, `GreeterMain` e `GreeterWorker`. O `GreeterMain` começou a execução do fluxo de trabalho, mas o `GreeterWorker` não está em execução, portanto os operadores não estão pesquisando as listas e executando as tarefas. Você pode executar qualquer um dos aplicativos de forma independente, mas precisa dos dois para que a execução do fluxo de trabalho continue além da primeira tarefa de decisão. Se você executar o `GreeterWorker` agora, os operadores de fluxo de trabalho e de atividades começarão a pesquisa, e as várias tarefas serão concluídas rapidamente. Se você verificar a guia `Events` agora, o primeiro lote de eventos será exibido. ![\[HelloWorldWorkflow eventos completos de fluxo de trabalho\]](http://docs.aws.amazon.com/pt_br/amazonswf/latest/awsflowguide/images/Events2.png) Você pode escolher eventos individuais para obter mais informações. Quando você terminar de olhar, o fluxo de trabalho deverá ter impresso "Hello World\$1". para o seu console. Quando o fluxo de trabalho estiver concluído, ele não aparecerá mais na lista de execuções ativas. No entanto, para revê-lo, escolha o botão de status de execução **Closed** (Fechado) e, em seguida, escolha **List Executions** (Listar execuções). Isso exibe todas as instâncias de fluxo de trabalho concluídas no domínio especificado (`helloWorldWalkthrough`) que não excederam o período de retenção especificado ao criar o domínio. ![\[HelloWorldWorkflow fluxos de trabalho concluídos\]](http://docs.aws.amazon.com/pt_br/amazonswf/latest/awsflowguide/images/Closed_Workflows.png) Observe que cada instância de fluxo de trabalho tem um valor de **Run ID** (ID de execução) exclusivo. Você pode usar a mesma ID do fluxo de trabalho para diferentes instâncias do fluxo de trabalho, mas somente para uma execução ativa por vez. # 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. # HelloWorldWorkflowDistributed Aplicação Com HelloWorldWorkflow e HelloWorldWorkflowAsync, o Amazon SWF medeia a interação entre o fluxo de trabalho e as implementações de atividades, mas elas são executadas localmente como um único processo. `GreeterMain`está em um processo separado, mas ainda é executado no mesmo sistema. Um recurso importante do Amazon SWF é que ele oferece suporte a aplicações distribuídas. Por exemplo, você pode executar o trabalhador do fluxo de trabalho em uma EC2 instância da Amazon, o iniciador do fluxo de trabalho em um computador de data center e as atividades em um computador desktop cliente. Você pode ainda executar atividades diferentes em sistemas diferentes. O HelloWorldWorkflowDistributed aplicativo se estende HelloWorldWorkflowAsync para distribuir o aplicativo em dois sistemas e três processos. + O fluxo de trabalho e o acionador do fluxo de trabalho são executados como processos separados em um sistema. + As atividades são executadas em um sistema separado. Para implementar o aplicativo, crie uma cópia do HelloWorld. HelloWorldWorkflowAsync pacote no diretório do seu projeto e chame-o de HelloWorld. HelloWorldWorkflowDistributed. As seções a seguir descrevem como modificar o HelloWorldWorkflowAsync código original para distribuir o aplicativo em dois sistemas e três processos. Não é necessário alterar as implementações do fluxo de trabalho ou das atividades para executá-los em sistemas separados, nem mesmo os números de versão. Também não é necessário modificar o `GreeterMain`. Mude apenas o host das atividades e do fluxo de trabalho. Com HelloWorldWorkflowAsync, um único aplicativo serve como host do fluxo de trabalho e da atividade. Para executar as implementações do fluxo de trabalho e de atividade em sistemas separados, é necessário implementar aplicativos separados. Exclua GreeterWorker do projeto e adicione dois novos arquivos de classe GreeterWorkflowWorker GreeterActivitiesWorker e. HelloWorldWorkflowDistributed implementa suas atividades hospedadas em GreeterActivitiesWorker, da seguinte forma: ``` 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; public class GreeterActivitiesWorker { 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 = "helloWorldExamples"; String taskListToPoll = "HelloWorldAsyncList"; ActivityWorker aw = new ActivityWorker(service, domain, taskListToPoll); aw.addActivitiesImplementation(new GreeterActivitiesImpl()); aw.start(); } } ``` HelloWorldWorkflowDistributed implementa seu host de fluxo de trabalho em`GreeterWorkflowWorker`, da seguinte forma: ``` 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.WorkflowWorker; public class GreeterWorkflowWorker { 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 = "helloWorldExamples"; String taskListToPoll = "HelloWorldAsyncList"; WorkflowWorker wfw = new WorkflowWorker(service, domain, taskListToPoll); wfw.addWorkflowImplementationType(GreeterWorkflowImpl.class); wfw.start(); } } ``` Observe que o `GreeterActivitiesWorker` é apenas `GreeterWorker` sem o código `WorkflowWorker` e o `GreeterWorkflowWorker` é apenas `GreeterWorker` sem o código `ActivityWorker`. **Para executar o fluxo de trabalho:** 1. Crie um arquivo executável JAR com `GreeterActivitiesWorker` como ponto de entrada. 1. Copie o arquivo JAR da Etapa 1 para outro sistema, que pode estar executando qualquer sistema operacional que suporta Java. 1. Certifique-se de que AWS as credenciais com acesso ao mesmo domínio Amazon SWF sejam disponibilizadas no outro sistema. 1. Execute o arquivo JAR. 1. No sistema de desenvolvimento, use o Eclipse para executar o `GreeterWorkflowWorker` e o `GreeterMain`. Além do fato de que as atividades estão sendo executadas em um sistema diferente do trabalhador do fluxo de trabalho e do iniciador do fluxo de trabalho, o fluxo de trabalho funciona exatamente da mesma maneira que HelloWorldAsync. No entanto, pelo fato de a chamada `println` que imprime “Olá, mundo\$1” para o console estar na atividade `say`, a saída aparecerá no sistema que está executando o operador de atividade. # HelloWorldWorkflowParallel Aplicação As versões anteriores do Hello World\$1 usam uma topologia de fluxo linear. Contudo, o Amazon SWF não se limita a topologias lineares. O HelloWorldWorkflowParallel aplicativo é uma versão modificada HelloWorldWorkflow que usa uma topologia paralela, conforme mostrado na figura a seguir. ![\[HelloWorldWorkflowParallel topologia do fluxo de trabalho\]](http://docs.aws.amazon.com/pt_br/amazonswf/latest/awsflowguide/images/helloworld_parallel_topology.png) Com HelloWorldWorkflowParallel, `getName` e `getGreeting` corra paralelamente e cada um retorne parte da saudação. `say`em seguida, mescla as duas sequências em uma saudação e a imprime no console. Para implementar o aplicativo, crie uma cópia do HelloWorld. HelloWorldWorkflow pacote no diretório do seu projeto e chame-o de HelloWorld. HelloWorldWorkflowParallel. As seções a seguir descrevem como modificar o HelloWorldWorkflow código original para ser executado `getName` e `getGreeting` em paralelo. ## HelloWorldWorkflowParallel Trabalhador de atividades A interface de HelloWorldWorkflowParallel atividades é implementada em`GreeterActivities`, conforme mostrado no exemplo a seguir. ``` import com.amazonaws.services.simpleworkflow.flow.annotations.Activities; import com.amazonaws.services.simpleworkflow.flow.annotations.ActivityRegistrationOptions; @Activities(version="5.0") @ActivityRegistrationOptions(defaultTaskScheduleToStartTimeoutSeconds = 300, defaultTaskStartToCloseTimeoutSeconds = 10) public interface GreeterActivities { public String getName(); public String getGreeting(); public void say(String greeting, String name); } ``` A interface é semelhante à HelloWorldWorkflow, com as seguintes exceções: + `getGreeting` não usa nenhuma entrada, simplesmente retorna uma sequência da saudação. + `say` usa duas sequências de entrada, a saudação e o nome. + A interface tem um novo número de versão que é necessário sempre que você altera uma interface registrada. HelloWorldWorkflowParallel implementa as atividades em`GreeterActivitiesImpl`, da seguinte forma: ``` public class GreeterActivitiesImpl implements GreeterActivities { @Override public String getName() { return "World!"; } @Override public String getGreeting() { return "Hello "; } @Override public void say(String greeting, String name) { System.out.println(greeting + name); } } ``` `getName` e `getGreeting` agora simplesmente retornam metade da string da saudação. `say` concatena as duas partes para produzir a frase completa e a imprime no console. ## HelloWorldWorkflowParallel Trabalhador de fluxo A interface do HelloWorldWorkflowParallel fluxo de trabalho é implementada em`GreeterWorkflow`, 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 = "5.0") public void greet(); } ``` A classe é idêntica à HelloWorldWorkflow versão, exceto que o número da versão foi alterado para corresponder ao trabalhador das atividades. O fluxo de trabalho é implementado em `GreeterWorkflowImpl`, da seguinte maneira: ``` 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(); operations.say(greeting, name); } } ``` À primeira vista, essa implementação parece muito semelhante às HelloWorldWorkflow três atividades que os métodos do cliente executam em sequência. No entanto, as atividades não são. + HelloWorldWorkflow passado `name` para`getGreeting`. Como `name` era um objeto `Promise`, `getGreeting` adiou a execução da atividade até a conclusão de `getName`, portanto, as duas atividades foram executadas em sequência. + HelloWorldWorkflowParallel não passa nenhuma entrada `getName` ou`getGreeting`. Nenhum dos métodos adia a execução e os métodos de atividade associados são executados imediatamente em paralelo. A atividade `say` usa `greeting` e `name` como parâmetros de entrada. Como eles são objetos `Promise`, `say` adia a execução até que as duas atividades sejam concluídas e, em seguida, constrói e imprime a saudação. Observe que HelloWorldWorkflowParallel não usa nenhum código de modelagem especial para definir a topologia do fluxo de trabalho. Ele faz isso implicitamente usando o controle de fluxo Java padrão e aproveitando as propriedades dos `Promise` objetos. AWS Flow Framework para aplicativos Java, é possível implementar até mesmo topologias complexas simplesmente usando `Promise` objetos em conjunto com construções convencionais de fluxo de controle Java. ## HelloWorldWorkflowParallel Anfitrião e iniciador de fluxo de trabalho e atividades HelloWorldWorkflowParallel 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 "HelloWorldParallelList”. `HelloWorldWorkflowParallel`implementa o iniciador do fluxo de trabalho em `GreeterMain` e é idêntico à HelloWorldWorkflow implementação. Para executar o fluxo de trabalho, execute `GreeterWorker` e `GreeterMain`, da mesma forma como no `HelloWorldWorkflow`.