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