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

HelloWorldWorkflow Aplicação

Embora o HelloWorldexemplo básico seja estruturado como um fluxo de trabalho, ele difere de um fluxo de trabalho do Amazon SWF em vários aspectos importantes:

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.

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 starter, o workflow worker e o activities worker 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 o aplicativo, você deve configurar uma conta Amazon SWF, como segue:

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:

Esta seção discute os métodos de atividade. As outras duas classes são discutidas posteriormente.

HelloWorldWorkflow define a interface de atividades emGreeterActivities, 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 e para a @Atividades 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.

@ActivityRegistrationOptionstem vários valores nomeados que são usados para configurar o comportamento das atividades. HelloWorldWorkflow especifica dois tempos limite:

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 Como tratar erros.

@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 emGreeterActivitiesImpl, 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 um aplicativo padrão e um aplicativo 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 trabalhador do fluxo de trabalho.

HelloWorldWorkflow Trabalhador de fluxo

Um trabalhador de fluxo de trabalho do Amazon SWF tem três componentes básicos.

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 emGreeterWorkflow, 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 e @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.

@Workflowtem 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 3600 segundos (1 hora).

A definição da GreeterWorkflow interface difere de uma HelloWorld forma importante, a @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. A estrutura 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 AWS Flow Framework para Java para identificar a função do método.

@Execute tem dois objetivos:

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.

HelloWorldWorkflow implementa o fluxo de trabalho emGreeterWorkflowImpl, 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<String> name = operations.getName();
     Promise<String> greeting = operations.getGreeting(name);
     operations.say(greeting);
   }
}

O código é semelhante HelloWorld, mas com duas diferenças importantes.

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 deGreeterActivitiesImpl, 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:

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

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.

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<T>, em que T é o tipo de retorno da atividade. O objeto Promise<T> retornado é basicamente um espaço reservado para o valor que o método da atividade retornará eventualmente.

Promessa <T> Type

A finalidade principal de objetos Promise<T> é 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<T> 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<T> 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<T> 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<T> Para obter um exemplo de como implementar uma topologia paralela simples, consulte Operador de atividades do HelloWorldWorkflowParallel.

O Promise<T> 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<T>. Ao contrário do tipo Future<T> do Java, a estrutura controla a sincronização de Promise<T>, não o aplicativo. Se você chamar Promise<T>.get e o objeto não estiver pronto, get gerará uma exceção. Observe que o HelloWorldWorkflow nunca acessa um objeto Promise<T> 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<T> 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<T> somente para métodos de cliente de atividades. Você pode acessar o valor de um objeto Promise<T> 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 ver um exemplo, consulte Aplicativo HelloWorldWorkflowAsync.

HelloWorldWorkflow Fluxo de trabalho e implementação de atividades

As implementações de fluxo de trabalho e atividades têm classes de trabalhadores associadas ActivityWorkere. WorkflowWorker 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 Conceitos básicos do AWS Flow Framework: Estrutura do aplicativo

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:

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 ver um exemplo, consulte Aplicativo HelloWorldWorkflowDistributed. 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();
   }
}

GreeterWorkernã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 AmazonSimpleWorkflowClientobjeto, que invoca os métodos de serviço subjacentes do Amazon SWF. Para fazer isso, o GreeterWorker:

Por conveniência, o GreeterWorker define duas constantes de sequências de caracteres.

GreeterWorkerusa as constantes de string e o AmazonSimpleWorkflowClientobjeto 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:

Se você escolher Activity Types (Tipos de atividade), os métodos de GreeterActivities serão exibidos:

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:

O cliente retornado da fábrica criará apenas fluxos de trabalho nomeados com a string passada no método getClient (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.

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

Se você escolher someID e escolher a guia Events (Eventos), os eventos serão exibidos:

A guia Events (Eventos) mostra apenas dois eventos:

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.

Você pode escolher eventos individuais para obter mais informações. Quando você terminar de olhar, o fluxo de trabalho deverá ter impresso "Hello World!". 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.

Observe que cada instância de fluxo de trabalho tem um valor de Run ID (ID de execução) exclusivo. Você pode usar o mesmo ID de execução para instâncias diferentes de fluxo de trabalho, mas apenas para uma execução ativa de cada vez.