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 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.
**Note**
Ces extraits de code supposent que vous comprenez [les bases de l'utilisation du SDK](using.md) et que vous avez configuré votre environnement avec [un accès par authentification unique](get-started-auth.md#setup-credentials).
## 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 [https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/paginators/ListObjectsV2Iterable.html](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/paginators/ListObjectsV2Iterable.html)instance, 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](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/model/S3Object.html)` contenu, puis traite le contenu de l' Amazon S3 objet.
Les importations suivantes s'appliquent à tous les exemples de cette section de pagination synchrone.
#### Importations
```
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](https://github.com/awsdocs/aws-doc-sdk-examples/blob/f807d60010caf3d14fe4cd0801b842fb8e9511ca/javav2/example_code/s3/src/main/java/com/example/s3/S3ObjectOperations.java#L112) 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 [https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/core/pagination/sync/SdkIterable.html](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/core/pagination/sync/SdkIterable.html)qui 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](https://github.com/awsdocs/aws-doc-sdk-examples/blob/f807d60010caf3d14fe4cd0801b842fb8e9511ca/javav2/example_code/s3/src/main/java/com/example/s3/S3ObjectOperations.java#L127) sur GitHub.
#### Utilisez une boucle pour chaque
Comme l'`SdkIterable``Iterable`interface est étendue, vous pouvez traiter le contenu comme n'importe quel autre`Iterable`. 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](https://github.com/awsdocs/aws-doc-sdk-examples/blob/f807d60010caf3d14fe4cd0801b842fb8e9511ca/javav2/example_code/s3/src/main/java/com/example/s3/S3ObjectOperations.java#L133) 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](https://github.com/awsdocs/aws-doc-sdk-examples/blob/f807d60010caf3d14fe4cd0801b842fb8e9511ca/javav2/example_code/s3/src/main/java/com/example/s3/S3ObjectOperations.java#L90) 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. [https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/dynamodb/paginators/ListTablesPublisher.html](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/dynamodb/paginators/ListTablesPublisher.html) `ListTablesPublisher`implé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.Publisher`interface implémentée par`ListTablesPublisher`. Pour en savoir plus sur le modèle de flux réactifs, consultez le [ GitHub référentiel Reactive Streams](https://github.com/reactive-streams/reactive-streams-jvm/blob/v1.0.2/README.md).
Les importations suivantes s'appliquent à tous les exemples de cette section de pagination asynchrone.
##### Importations
```
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() {
// 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](https://github.com/awsdocs/aws-doc-sdk-examples/blob/f807d60010caf3d14fe4cd0801b842fb8e9511ca/javav2/example_code/dynamodbasync/src/main/java/com/example/dynamodbasync/AsyncPagination.java#L83) sur GitHub.
#### Utilisez un `Consumer`
L'`SdkPublisher`interface qui `ListTablesPublisher` implémente possède une `subscribe` méthode qui prend `Consumer` et renvoie `CompletableFuture` 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 un `java.util.List` des noms de tables DynamoDB qui sont traités avec la méthode. `forEach`
```
// Use a Consumer for simple use cases.
CompletableFuture future = publisher.subscribe(
response -> response.tableNames()
.forEach(System.out::println));
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/f807d60010caf3d14fe4cd0801b842fb8e9511ca/javav2/example_code/dynamodbasync/src/main/java/com/example/dynamodbasync/AsyncPagination.java#L96) 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 [https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/core/async/SdkPublisher.html](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/core/async/SdkPublisher.html)qui 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 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() {
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](https://github.com/awsdocs/aws-doc-sdk-examples/blob/f807d60010caf3d14fe4cd0801b842fb8e9511ca/javav2/example_code/dynamodbasync/src/main/java/com/example/dynamodbasync/AsyncPagination.java#L147) 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 future = publisher.subscribe(System.out::println);
future.get();
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/f807d60010caf3d14fe4cd0801b842fb8e9511ca/javav2/example_code/dynamodbasync/src/main/java/com/example/dynamodbasync/AsyncPagination.java#L161) 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](https://github.com/ReactiveX/RxJava/wiki) 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**
```
io.reactivex.rxjava3
rxjava
3.1.6
```
**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 tables = Flowable.fromPublisher(publisher)
.flatMapIterable(ListTablesResponse::tableNames)
.toList()
.blockingGet();
System.out.println(tables);
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/f807d60010caf3d14fe4cd0801b842fb8e9511ca/javav2/example_code/dynamodbasync/src/main/java/com/example/dynamodbasync/AsyncPagination.java#L198) sur GitHub.