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

# Contratos de atividades e de fluxo de trabalho
<a name="features.workflow"></a>

As interfaces Java são usadas para declarar as assinaturas de fluxos de trabalho e de atividades. A interface forma o contrato entre a implementação do fluxo de trabalho (ou da atividade) e o cliente do fluxo de trabalho (ou da atividade). Por exemplo, um tipo de fluxo de trabalho `MyWorkflow` é definido usando uma interface anotada com a anotação `@Workflow`: 

```
@Workflow
@WorkflowRegistrationOptions(
   defaultExecutionStartToCloseTimeoutSeconds = 60,
   defaultTaskStartToCloseTimeoutSeconds = 10)
public interface MyWorkflow
{
    @Execute(version = "1.0")
    void startMyWF(int a, String b);

    @Signal
    void signal1(int a, int b, String c);

    @GetState
    MyWorkflowState getState();
}
```

O contrato não tem nenhuma configuração específica à implementação. O uso de contratos com neutralidade de implementação permite que os clientes sejam separados da implementação e, portanto, fornece a flexibilidade de alterar os detalhes da implementação sem interromper o cliente. Por outro lado, você também pode alterar o cliente sem precisar alterar o fluxo de trabalho ou a atividade que está sendo consumida. Por exemplo, o cliente pode ser modificado para chamar uma atividade de forma assíncrona usando promessas (`Promise<T>`) sem exigir uma alteração na implementação da atividade. Da mesma forma, a implementação da atividade pode ser alterada para que seja concluída de forma assíncrona, por exemplo, por uma pessoa que envia um e-mail, sem exigir que os clientes da atividade sejam alterados. 

No exemplo acima, a interface do fluxo de trabalho `MyWorkflow` contém um método, `startMyWF`, para iniciar uma nova execução. O método é anotado com a anotação `@Execute` e deve ter um tipo de retorno de `void` ou `Promise<>`. Em uma determinada interface de fluxo de trabalho, no máximo um método poder ser anotado com essa anotação. O método é o ponto de entrada da lógica do fluxo de trabalho, e a estrutura chama esse método para executar a lógica do fluxo de trabalho quando uma tarefa de decisão é recebida. 

A interface de fluxo de trabalho também define os sinais que podem ser enviados ao fluxo de trabalho. O método de sinal é invocado quando um sinal com um nome correspondente é recebido pela execução do fluxo de trabalho. Por exemplo, a interface de `MyWorkflow` declara um método de sinal, `signal1`, anotado com a anotação `@Signal`. 

A anotação `@Signal` é necessária em métodos de sinal. O tipo de retorno de um método de sinal deve ser `void`. Uma interface de fluxo de trabalho pode ter zero ou mais métodos de sinal definidos nela. Você pode declarar uma interface de fluxo de trabalho sem um método `@Execute` e alguns métodos `@Signal` para gerar clientes que não podem iniciar sua execução, mas podem enviar sinais a execuções em execução.

Os métodos anotados com as anotações `@Execute` e `@Signal` podem ter qualquer número de parâmetros de qualquer tipo além de `Promise<T>` ou de seus derivados. Isso permite que você passe entradas fortemente tipadas para uma execução de fluxo de trabalho no início e durante sua execução. O tipo de retorno do método `@Execute` deve ser `void` ou `Promise<>`. 

Além disso, também é possível declarar um método na interface de fluxo de trabalho para relatar o estado mais recente de uma execução de fluxo de trabalho, por exemplo, o método `getState` do exemplo anterior. Esse estado não é o estado inteiro do aplicativo de fluxo de trabalho. O uso pretendido desse recurso é permitir que você armazene até 32 KB de dados para indicar o status mais recente da execução. Por exemplo, em um fluxo de trabalho de processamento de pedido, você pode armazenar uma sequência que indique que o pedido foi recebido, processado ou cancelado. O método é chamado pela estrutura sempre que uma tarefa de decisão é concluída para obter o estado mais recente. O estado é armazenado no Amazon Simple Workflow Service (Amazon SWF) e pode ser recuperado usando o cliente externo gerado. Isso permite que você verifique o estado mais recente de uma execução de fluxo de trabalho. Os métodos anotados com `@GetState` não devem usar nenhum argumento e não devem ter um tipo de retorno `void`. Você pode retornar qualquer tipo que atenda às suas necessidades desse método. No exemplo acima, um objeto de `MyWorkflowState` (consulte a definição a seguir) é retornado pelo método que é usado para armazenar um estado de sequência e uma porcentagem numérica completos. Espera-se que o método execute o acesso de somente leitura do objeto de implementação de fluxo de trabalho e seja invocado de forma síncrona, o que não permite o uso de qualquer operação assíncrona, como a chamada de métodos anotados com `@Asynchronous`. No máximo um método em uma interface de fluxo de trabalho pode ser anotado com a anotação `@GetState`. 

```
public class MyWorkflowState {
   public String status;
   public int percentComplete;
}
```

Da mesma forma, um conjunto de atividades é definido usando uma interface anotada com a anotação `@Activities`. Cada método na interface corresponde a uma atividade; por exemplo: 

```
@Activities(version = "1.0")
@ActivityRegistrationOptions(
     defaultTaskScheduleToStartTimeoutSeconds = 300,
     defaultTaskStartToCloseTimeoutSeconds = 3600)
public interface MyActivities {
    // Overrides values from annotation found on the interface
    @ActivityRegistrationOptions(description = "This is a sample activity",
         defaultTaskScheduleToStartTimeoutSeconds = 100,
         defaultTaskStartToCloseTimeoutSeconds = 60)
    int activity1();

    void activity2(int a);
}
```

A interface permite que você agrupe um conjunto de atividades relacionadas. Você pode definir qualquer número de atividades em uma interface de atividades e definir quantas interfaces de atividades desejar. Semelhante aos métodos `@Execute` e `@Signal`, os métodos de atividades podem usar qualquer número de argumentos de qualquer tipo diferente de `Promise<T>` ou de seus derivados. O tipo de retorno de uma atividade não deve ser `Promise<T>` ou seus derivados.