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

# Usando garçons no AWS SDK for Java 2.x
<a name="waiters"></a>

O utilitário waiters do AWS SDK para Java 2.x permite que você valide se AWS os recursos estão em um estado especificado antes de realizar operações nesses recursos.

Um *garçom* é uma abstração usada para pesquisar AWS recursos, como DynamoDB tabelas ou Amazon S3 compartimentos, até que o estado desejado seja alcançado (ou até que seja determinado que o recurso nunca alcançará o estado desejado). Em vez de escrever uma lógica para pesquisar continuamente seus AWS recursos, o que pode ser complicado e propenso a erros, você pode usar garçons para pesquisar um recurso e fazer com que seu código continue sendo executado depois que o recurso estiver pronto.

## Pré-requisitos
<a name="prerequisiteswaiters"></a>

Antes de usar garçons em um projeto com o AWS SDK para Java, você deve concluir as etapas em [Configurando](setup.md) o 2.x. AWS SDK para Java 

Você também deve configurar as dependências do projeto (por exemplo, no seu arquivo `pom.xml` ou `build.gradle`) para usar a versão `2.15.0` ou posterior do AWS SDK para Java.

Por exemplo:

```
<project>
  <dependencyManagement>
   <dependencies>
      <dependency>
        <groupId>software.amazon.awssdk</groupId>
        <artifactId>bom</artifactId>
        <version>2.27.21</version>
        <type>pom</type>
        <scope>import</scope>
      </dependency>
   </dependencies>
  </dependencyManagement>
</project>
```

## Usar agentes de espera
<a name="id1waiters"></a>

Para instanciar um objeto de waiters, primeiro crie um cliente de serviço. Defina o método `waiter()` do cliente de serviço como o valor do objeto waiter. Quando a instância do waiter existir, defina suas opções de resposta para executar o código apropriado.

### Programação síncrona
<a name="synchronous-programming"></a>

O trecho de código a seguir mostra como esperar que uma DynamoDB tabela exista e esteja em um estado **ATIVO**.

```
DynamoDbClient dynamo = DynamoDbClient.create();
DynamoDbWaiter waiter = dynamo.waiter();

WaiterResponse<DescribeTableResponse> waiterResponse =
  waiter.waitUntilTableExists(r -> r.tableName("myTable"));

// print out the matched response with a tableStatus of ACTIVE
waiterResponse.matched().response().ifPresent(System.out::println);
```

### Programação assíncrona
<a name="asynchronous-programming"></a>

O trecho de código a seguir mostra como esperar que uma DynamoDB tabela não exista mais.

```
DynamoDbAsyncClient asyncDynamo = DynamoDbAsyncClient.create();
DynamoDbAsyncWaiter asyncWaiter = asyncDynamo.waiter();

CompletableFuture<WaiterResponse<DescribeTableResponse>> waiterResponse =
          asyncWaiter.waitUntilTableNotExists(r -> r.tableName("myTable"));

waiterResponse.whenComplete((r, t) -> {
  if (t == null) {
   // print out the matched ResourceNotFoundException
   r.matched().exception().ifPresent(System.out::println);
  }
}).join();
```

## Configurar waiters
<a name="configuring-waiters"></a>

Você pode personalizar a configuração de um waiter usando o `overrideConfiguration()` em seu construtor. Para algumas operações, você pode aplicar uma configuração personalizada ao fazer a solicitação.

### Configurar um waiter
<a name="configure-a-waiter"></a>

O trecho de código a seguir mostra como substituir a configuração em um waiter.

```
// sync
DynamoDbWaiter waiter =
   DynamoDbWaiter.builder()
          .overrideConfiguration(b -> b.maxAttempts(10))
          .client(dynamoDbClient)
          .build();
// async
DynamoDbAsyncWaiter asyncWaiter =
   DynamoDbAsyncWaiter.builder()
          .client(dynamoDbAsyncClient)
          .overrideConfiguration(o -> o.backoffStrategy(
               FixedDelayBackoffStrategy.create(Duration.ofSeconds(2))))
          .scheduledExecutorService(Executors.newScheduledThreadPool(3))
          .build();
```

### Substituir configuração para uma solicitação específica
<a name="override-configuration-for-a-specific-request"></a>

O trecho de código a seguir mostra como substituir a configuração de um waiter por solicitação. Observe que somente algumas operações têm configurações personalizáveis.

```
waiter.waitUntilTableNotExists(b -> b.tableName("myTable"),
               o -> o.maxAttempts(10));

asyncWaiter.waitUntilTableExists(b -> b.tableName("myTable"),
                 o -> o.waitTimeout(Duration.ofMinutes(1)));
```

## Exemplos de código
<a name="code-examples"></a>

Para ver um exemplo completo do uso de garçons com DynamoDB, consulte [CreateTable.java](https://github.com/awsdocs/aws-doc-sdk-examples/blob/869b7ddbc7c8f66c7c45acd5b813429aff37003e/javav2/example_code/dynamodb/src/main/java/com/example/dynamodb/CreateTable.java) no Repositório de exemplos de AWS código.

Para ver um exemplo completo do uso de garçons com Amazon S3, consulte [S3 BucketOps .java](https://github.com/awsdocs/aws-doc-sdk-examples/blob/869b7ddbc7c8f66c7c45acd5b813429aff37003e/javav2/example_code/s3/src/main/java/com/example/s3/S3BucketOps.java) no Repositório de exemplos de código. AWS