Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Utilisation de serveurs dans le AWS SDK for Java 2.x
<a name="waiters"></a>

L'utilitaire Waiters de la version AWS SDK pour Java 2.x vous permet de vérifier que les AWS ressources sont dans un état spécifié avant d'effectuer des opérations sur ces ressources.

Un *serveur* est une abstraction utilisée pour interroger AWS des ressources, telles que des DynamoDB tables ou des Amazon S3 compartiments, jusqu'à ce qu'un état souhaité soit atteint (ou jusqu'à ce qu'il soit déterminé que la ressource n'atteindra jamais l'état souhaité). Au lieu d'écrire une logique pour interroger continuellement vos AWS ressources, ce qui peut être fastidieux et source d'erreurs, vous pouvez utiliser des serveurs pour interroger une ressource et faire en sorte que votre code continue de s'exécuter une fois que la ressource est prête.

## Conditions préalables
<a name="prerequisiteswaiters"></a>

Avant de pouvoir utiliser des serveurs dans un projet avec le AWS SDK pour Java, vous devez suivre les étapes décrites dans [Configuration de la version AWS SDK pour Java 2.x](setup.md).

Vous devez également configurer les dépendances de votre projet (par exemple, dans votre `build.gradle` fichier `pom.xml` ou dans votre fichier) pour utiliser la version `2.15.0` ou une version ultérieure du AWS SDK pour Java.

Par exemple :

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

## Utiliser des serveurs
<a name="id1waiters"></a>

Pour instancier un objet de serveur, créez d'abord un client de service. Définissez la `waiter()` méthode du client de service comme valeur de l'objet serveur. Une fois que l'instance de serveur existe, définissez ses options de réponse pour exécuter le code approprié.

### Programmation synchrone
<a name="synchronous-programming"></a>

L'extrait de code suivant montre comment attendre qu'une DynamoDB table existe et passe à l'état **ACTIF**.

```
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);
```

### Programmation asynchrone
<a name="asynchronous-programming"></a>

L'extrait de code suivant montre comment attendre qu'une DynamoDB table n'existe plus.

```
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();
```

## Configuration des serveurs
<a name="configuring-waiters"></a>

Vous pouvez personnaliser la configuration d'un serveur en utilisant `overrideConfiguration()` le générateur. Pour certaines opérations, vous pouvez appliquer une configuration personnalisée lorsque vous faites la demande.

### Configurer un serveur
<a name="configure-a-waiter"></a>

L'extrait de code suivant montre comment modifier la configuration d'un serveur.

```
// 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();
```

### Configuration de remplacement pour une demande spécifique
<a name="override-configuration-for-a-specific-request"></a>

L'extrait de code suivant montre comment remplacer la configuration d'un serveur par demande. Notez que seules certaines opérations ont des configurations personnalisables.

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

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

## Exemples de code
<a name="code-examples"></a>

Pour un exemple complet d'utilisation de serveurs avec DynamoDB, consultez [CreateTable.java](https://github.com/awsdocs/aws-doc-sdk-examples/blob/869b7ddbc7c8f66c7c45acd5b813429aff37003e/javav2/example_code/dynamodb/src/main/java/com/example/dynamodb/CreateTable.java) dans le référentiel d'exemples de AWS code.

Pour un exemple complet d'utilisation de serveurs avec Amazon S3, consultez [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) dans le référentiel d'exemples de AWS code.