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.

Faire appel à des serveurs dans AWS SDK for Java 2.x

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 seaux, jusqu'à ce que l'é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 sujet aux erreurs, vous pouvez utiliser des serveurs pour interroger une ressource et faire en sorte que votre code continue à s'exécuter une fois que la ressource est prête.

Conditions préalables

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.

Vous devez également configurer les dépendances de votre projet (par exemple, dans votre build.gradle fichier pom.xml ou) pour utiliser une 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

Pour instancier un objet waiters, 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

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

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

Configurer les serveurs

Vous pouvez personnaliser la configuration d'un serveur à l'aide overrideConfiguration() de son générateur. Pour certaines opérations, vous pouvez appliquer une configuration personnalisée lorsque vous faites la demande.

Configurer un serveur

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

Modifier la configuration pour une demande spécifique

L'extrait de code suivant montre comment modifier la configuration d'un serveur sur la base de chaque 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

Pour un exemple complet d'utilisation de waiters with DynamoDB, consultez CreateTable.java le référentiel d'exemples de AWS code.

Pour un exemple complet d'utilisation de waiters with Amazon S3, consultez S3BucketOps.java le référentiel d'exemples de AWS code.