Utilisation de résultats paginés dans la version 2.x AWS SDK pour Java

De nombreuses AWS opérations renvoient des résultats paginés lorsque l'objet de réponse est trop volumineux pour être renvoyé en une seule réponse. Dans la AWS SDK pour Java version 1.0, la réponse contient un jeton que vous utilisez pour récupérer la page de résultats suivante. En revanche, la version AWS SDK pour Java 2.x dispose de méthodes de pagination automatique qui effectuent plusieurs appels de service pour obtenir automatiquement la page de résultats suivante pour vous. Il vous suffit d'écrire le code qui traite les résultats. La pagination automatique est disponible pour les clients synchrones et asynchrones.

Pagination synchrone

Les exemples suivants illustrent les méthodes de pagination synchrone permettant de répertorier les objets d'un Amazon S3 compartiment.

Itérer sur les pages

Le premier exemple montre l'utilisation d'un objet listRes paginateur, une ListObjectsV2Iterableinstance, pour parcourir toutes les pages de réponse à l'aide de la méthode. stream Le code circule sur les pages de réponse, convertit le flux de réponse en flux de S3Object contenu, puis traite le contenu de l' Amazon S3 objet.

Les importations suivantes s'appliquent à tous les exemples de cette section de pagination synchrone.

import java.io.IOException;
import java.nio.ByteBuffer;
import java.util.Random;

import software.amazon.awssdk.core.waiters.WaiterResponse;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.s3.S3Client;
import software.amazon.awssdk.services.s3.paginators.ListObjectsV2Iterable;
import software.amazon.awssdk.core.sync.RequestBody;
import software.amazon.awssdk.services.s3.model.S3Exception;
import software.amazon.awssdk.services.s3.model.PutObjectRequest;
import software.amazon.awssdk.services.s3.model.ListObjectsV2Request;
import software.amazon.awssdk.services.s3.model.ListObjectsV2Response;
import software.amazon.awssdk.services.s3.model.S3Object;
import software.amazon.awssdk.services.s3.model.GetObjectRequest;
import software.amazon.awssdk.services.s3.model.DeleteObjectRequest;
import software.amazon.awssdk.services.s3.model.DeleteBucketRequest;
import software.amazon.awssdk.services.s3.model.CreateMultipartUploadRequest;
import software.amazon.awssdk.services.s3.model.CreateMultipartUploadResponse;
import software.amazon.awssdk.services.s3.model.CompletedMultipartUpload;
import software.amazon.awssdk.services.s3.model.CreateBucketRequest;
import software.amazon.awssdk.services.s3.model.CompletedPart;
import software.amazon.awssdk.services.s3.model.CreateBucketConfiguration;
import software.amazon.awssdk.services.s3.model.UploadPartRequest;
import software.amazon.awssdk.services.s3.model.CompleteMultipartUploadRequest;
import software.amazon.awssdk.services.s3.waiters.S3Waiter;
import software.amazon.awssdk.services.s3.model.HeadBucketRequest;
import software.amazon.awssdk.services.s3.model.HeadBucketResponse;

        ListObjectsV2Request listReq = ListObjectsV2Request.builder()
            .bucket(bucketName)
            .maxKeys(1)
            .build();

        ListObjectsV2Iterable listRes = s3.listObjectsV2Paginator(listReq);
        // Process response pages
        listRes.stream()
            .flatMap(r -> r.contents().stream())
            .forEach(content -> System.out
                .println(" Key: " + content.key() + " size = " + content.size()));

Consultez l'exemple complet sur GitHub.

Itérer sur des objets

Les exemples suivants montrent comment itérer sur les objets retournés dans la réponse à la place des pages de la réponse. La contents méthode de ListObjectsV2Iterable classe renvoie un SdkIterablequi fournit plusieurs méthodes pour traiter les éléments de contenu sous-jacents.

Utiliser un stream

L'extrait suivant utilise la stream méthode sur le contenu de la réponse pour itérer sur la collection d'éléments paginés.

        // Helper method to work with paginated collection of items directly.
        listRes.contents().stream()
            .forEach(content -> System.out
                .println(" Key: " + content.key() + " size = " + content.size()));

Consultez l'exemple complet sur GitHub.

Utilisez une boucle pour chaque

Comme l'SdkIterableIterableinterface est étendue, vous pouvez traiter le contenu comme n'importe quel autreIterable. L'extrait de code suivant utilise for-each une boucle standard pour parcourir le contenu de la réponse.

        for (S3Object content : listRes.contents()) {
            System.out.println(" Key: " + content.key() + " size = " + content.size());
        }

Consultez l'exemple complet sur GitHub.

Pagination manuelle

Si votre cas d'utilisation le requiert, la pagination manuelle demeure disponible. Utilisez le jeton suivant de l'objet de réponse pour les demandes suivantes. L'exemple suivant utilise une while boucle.

        ListObjectsV2Request listObjectsReqManual = ListObjectsV2Request.builder()
            .bucket(bucketName)
            .maxKeys(1)
            .build();

        boolean done = false;
        while (!done) {
            ListObjectsV2Response listObjResponse = s3.listObjectsV2(listObjectsReqManual);
            for (S3Object content : listObjResponse.contents()) {
                System.out.println(content.key());
            }

            if (listObjResponse.nextContinuationToken() == null) {
                done = true;
            }

            listObjectsReqManual = listObjectsReqManual.toBuilder()
                .continuationToken(listObjResponse.nextContinuationToken())
                .build();
        }

Consultez l'exemple complet sur GitHub.

Pagination asynchrone

Les exemples suivants illustrent les méthodes de pagination asynchrone pour répertorier les tables. DynamoDB

Itérer sur les pages des noms de tables

Les deux exemples suivants utilisent un client DynamoDB asynchrone qui appelle la listTablesPaginator méthode avec une demande pour obtenir un. ListTablesPublisher ListTablesPublisherimplémente deux interfaces, qui offrent de nombreuses options pour traiter les réponses. Nous allons examiner les méthodes de chaque interface.

Utilisez un Subscriber

L'exemple de code suivant montre comment traiter les résultats paginés à l'aide de l'org.reactivestreams.Publisherinterface implémentée parListTablesPublisher. Pour en savoir plus sur le modèle de flux réactifs, consultez le GitHub référentiel Reactive Streams.

Les importations suivantes s'appliquent à tous les exemples de cette section de pagination asynchrone.

import io.reactivex.rxjava3.core.Flowable;
import org.reactivestreams.Subscriber;
import org.reactivestreams.Subscription;
import reactor.core.publisher.Flux;
import software.amazon.awssdk.core.async.SdkPublisher;
import software.amazon.awssdk.services.dynamodb.DynamoDbAsyncClient;
import software.amazon.awssdk.services.dynamodb.model.ListTablesRequest;
import software.amazon.awssdk.services.dynamodb.model.ListTablesResponse;
import software.amazon.awssdk.services.dynamodb.paginators.ListTablesPublisher;

import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

Le code suivant permet d'acquérir une ListTablesPublisher instance.

        // Creates a default client with credentials and region loaded from the
        // environment.
        final DynamoDbAsyncClient asyncClient = DynamoDbAsyncClient.create();

        ListTablesRequest listTablesRequest = ListTablesRequest.builder().limit(3).build();
        ListTablesPublisher publisher = asyncClient.listTablesPaginator(listTablesRequest);

Le code suivant utilise une implémentation anonyme de org.reactivestreams.Subscriber pour traiter les résultats de chaque page.

La méthode onSubscribe appelle la méthode Subscription.request pour initier les demandes de données de l'éditeur. Cette méthode doit être appelée pour commencer à obtenir les données à partir de l'éditeur.

La onNext méthode de l'abonné traite une page de réponse en accédant à tous les noms de tables et en les imprimant. Une fois la page traitée, une autre page est demandée à l'éditeur. Cette méthode est appelée à plusieurs reprises jusqu'à ce que toutes les pages soient récupérées.

La méthode onError est déclenchée si une erreur se produit lors de la récupération des données. Enfin, la méthode onComplete est appelée lorsque toutes les pages ont été demandées.

        // A Subscription represents a one-to-one life-cycle of a Subscriber subscribing
        // to a Publisher.
        publisher.subscribe(new Subscriber<ListTablesResponse>() {
            // Maintain a reference to the subscription object, which is required to request
            // data from the publisher.
            private Subscription subscription;

            @Override
            public void onSubscribe(Subscription s) {
                subscription = s;
                // Request method should be called to demand data. Here we request a single
                // page.
                subscription.request(1);
            }

            @Override
            public void onNext(ListTablesResponse response) {
                response.tableNames().forEach(System.out::println);
                // After you process the current page, call the request method to signal that
                // you are ready for next page.
                subscription.request(1);
            }

            @Override
            public void onError(Throwable t) {
                // Called when an error has occurred while processing the requests.
            }

            @Override
            public void onComplete() {
                // This indicates all the results are delivered and there are no more pages
                // left.
            }
        });

Consultez l'exemple complet sur GitHub.

Utilisez un Consumer

L'SdkPublisherinterface qui ListTablesPublisher implémente possède une subscribe méthode qui prend Consumer et renvoie CompletableFuture<Void> a.

La subscribe méthode de cette interface peut être utilisée pour des cas d'utilisation simples où une surcharge org.reactivestreams.Subscriber peut être trop importante. Comme le code ci-dessous occupe chaque page, il appelle la tableNames méthode sur chacune d'elles. La tableNames méthode renvoie java.util.List l'un des noms de tables DynamoDB traités avec la méthode. forEach

        // Use a Consumer for simple use cases.
        CompletableFuture<Void> future = publisher.subscribe(
                response -> response.tableNames()
                        .forEach(System.out::println));

Consultez l'exemple complet sur GitHub.

Itérer sur les noms des tables

Les exemples suivants montrent comment itérer sur les objets retournés dans la réponse à la place des pages de la réponse. À l'instar de l'exemple synchrone d'Amazon S3 présenté précédemment avec sa contents méthode, la classe ListTablesPublisher de résultats asynchrone DynamoDB possède tableNames la méthode pratique pour interagir avec la collection d'éléments sous-jacente. Le type de retour de la tableNames méthode est un SdkPublisherqui peut être utilisé pour demander des éléments sur toutes les pages.

Utilisez un Subscriber

Le code suivant acquiert SdkPublisher l'un des ensembles sous-jacents de noms de tables.

        // Create a default client with credentials and region loaded from the
        // environment.
        final DynamoDbAsyncClient asyncClient = DynamoDbAsyncClient.create();

        ListTablesRequest listTablesRequest = ListTablesRequest.builder().limit(3).build();
        ListTablesPublisher listTablesPublisher = asyncClient.listTablesPaginator(listTablesRequest);
        SdkPublisher<String> publisher = listTablesPublisher.tableNames();

Le code suivant utilise une implémentation anonyme de org.reactivestreams.Subscriber pour traiter les résultats de chaque page.

La onNext méthode de l'abonné traite un élément individuel de la collection. Dans ce cas, il s'agit d'un nom de table. Une fois le nom de table traité, un autre nom de table est demandé à l'éditeur. Cette méthode est appelée à plusieurs reprises jusqu'à ce que tous les noms de table soient récupérés.

        // Use a Subscriber.
        publisher.subscribe(new Subscriber<String>() {
            private Subscription subscription;

            @Override
            public void onSubscribe(Subscription s) {
                subscription = s;
                subscription.request(1);
            }

            @Override
            public void onNext(String tableName) {
                System.out.println(tableName);
                subscription.request(1);
            }

            @Override
            public void onError(Throwable t) {
            }

            @Override
            public void onComplete() {
            }
        });

Consultez l'exemple complet sur GitHub.

Utilisez un Consumer

L'exemple suivant utilise la subscribe méthode SdkPublisher qui prend un Consumer pour traiter chaque élément.

        // Use a Consumer.
        CompletableFuture<Void> future = publisher.subscribe(System.out::println);
        future.get();

Consultez l'exemple complet sur GitHub.

Utiliser une bibliothèque tierce

Vous pouvez utiliser d'autres bibliothèques tierces au lieu d'implémenter un abonné personnalisé. Cet exemple illustre l'utilisation de RxJava, mais n'importe quelle bibliothèque implémentant les interfaces de flux réactives peut être utilisée. Consultez la page RxJava wiki GitHub pour plus d'informations sur cette bibliothèque.

Pour utiliser la bibliothèque, ajoutez-la en tant que dépendance. Si vous utilisez Maven, l'exemple illustre l'extrait POM à utiliser.

Entrée POM

<dependency>
      <groupId>io.reactivex.rxjava3</groupId>
      <artifactId>rxjava</artifactId>
      <version>3.1.6</version>
</dependency>

Code

        DynamoDbAsyncClient asyncClient = DynamoDbAsyncClient.create();
        ListTablesPublisher publisher = asyncClient.listTablesPaginator(ListTablesRequest.builder()
                .build());

        // The Flowable class has many helper methods that work with
        // an implementation of an org.reactivestreams.Publisher.
        List<String> tables = Flowable.fromPublisher(publisher)
                .flatMapIterable(ListTablesResponse::tableNames)
                .toList()
                .blockingGet();
        System.out.println(tables);

Consultez l'exemple complet sur GitHub.