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

# HelloWorldWorkflowParallel Aplicação
<a name="getting-started-example-helloworldworkflowparallel"></a>

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 name="getting-started-example-helloworldworkflowparallel.activities"></a>

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 name="getting-started-example-helloworldworkflowparallel-worker"></a>

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<String> name = operations.getName();
      Promise<String> 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<T>`, `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<T>`, `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<T>` objetos. AWS Flow Framework para aplicativos Java, é possível implementar até mesmo topologias complexas simplesmente usando `Promise<T>` objetos em conjunto com construções convencionais de fluxo de controle Java.

## HelloWorldWorkflowParallel Anfitrião e iniciador de fluxo de trabalho e atividades
<a name="HelloWorldWorkflowParallel-workflow-activities-host-starter"></a>

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