Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Verwenden von paginierten Ergebnissen in der 2.x AWS SDK für Java
Viele AWS Operationen geben paginierte Ergebnisse zurück, wenn das Antwortobjekt zu groß ist, um es in einer einzigen Antwort zurückzugeben. In AWS SDK für Java Version 1.0 enthält die Antwort ein Token, mit dem Sie die nächste Ergebnisseite abrufen. Im Gegensatz dazu verfügt die Version AWS SDK für Java 2.x über Autopaginationsmethoden, die mehrere Serviceaufrufe tätigen, um automatisch die nächste Ergebnisseite für Sie abzurufen. Sie müssen nur Code schreiben, der die Ergebnisse verarbeitet. Autopagination ist sowohl für synchrone als auch für asynchrone Clients verfügbar.
**Anmerkung**
[Bei diesen Codefragmenten wird davon ausgegangen, dass Sie die [Grundlagen der Verwendung des SDK](using.md) verstehen und Ihre Umgebung mit Single Sign-On-Zugriff konfiguriert haben.](get-started-auth.md#setup-credentials)
## Synchrone Paginierung
Die folgenden Beispiele zeigen synchrone Paginierungsmethoden zum Auflisten von Objekten in einem Bucket. Amazon S3
### Iterieren Sie über Seiten hinweg
Das erste Beispiel demonstriert die Verwendung eines `listRes` Paginator-Objekts, einer [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)Instanz, um mit der Methode durch alle Antwortseiten zu iterieren. `stream` Der Code streamt über die Antwortseiten, konvertiert den Antwortstream in einen `[S3Object](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/model/S3Object.html)` Inhaltsstream und verarbeitet dann den Inhalt des Objekts. Amazon S3
Die folgenden Importe gelten für alle Beispiele in diesem Abschnitt zur synchronen Paginierung.
#### Importe
```
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()));
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/f807d60010caf3d14fe4cd0801b842fb8e9511ca/javav2/example_code/s3/src/main/java/com/example/s3/S3ObjectOperations.java#L112) finden Sie unter. GitHub
### Iteriere über Objekte
Die folgenden Beispiele zeigen Möglichkeit, um über die in der Antwort zurückgegebenen Objekte anstatt über die Seiten der Antwort zu iterieren. Die `contents` Methode der `ListObjectsV2Iterable` Klasse gibt eine zurück [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), die mehrere Methoden zur Verarbeitung der zugrunde liegenden Inhaltselemente bereitstellt.
#### Verwenden Sie einen Stream
Das folgende Snippet verwendet die `stream` Methode für den Inhalt der Antwort, um über die Sammlung von paginierten Elementen zu iterieren.
```
// Helper method to work with paginated collection of items directly.
listRes.contents().stream()
.forEach(content -> System.out
.println(" Key: " + content.key() + " size = " + content.size()));
```
[Das vollständige Beispiel finden Sie unter.](https://github.com/awsdocs/aws-doc-sdk-examples/blob/f807d60010caf3d14fe4cd0801b842fb8e9511ca/javav2/example_code/s3/src/main/java/com/example/s3/S3ObjectOperations.java#L127) GitHub
#### Verwenden Sie eine For-Each-Schleife
Da die `Iterable` Schnittstelle `SdkIterable` erweitert wird, können Sie den Inhalt wie jeden anderen `Iterable` bearbeiten. Das folgende Snippet verwendet eine `for-each` Standardschleife, um durch den Inhalt der Antwort zu iterieren.
```
for (S3Object content : listRes.contents()) {
System.out.println(" Key: " + content.key() + " size = " + content.size());
}
```
Das [vollständige](https://github.com/awsdocs/aws-doc-sdk-examples/blob/f807d60010caf3d14fe4cd0801b842fb8e9511ca/javav2/example_code/s3/src/main/java/com/example/s3/S3ObjectOperations.java#L133) Beispiel finden Sie unter. GitHub
### Manuelle Paginierung
Wenn Ihr Anwendungsfall es erfordert, ist die manuelle Paginierung weiterhin verfügbar. Verwenden Sie das nächste Token im Antwortobjekte für die nachfolgenden Anforderungen. Im folgenden Beispiel wird eine `while` Schleife verwendet.
```
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();
}
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/f807d60010caf3d14fe4cd0801b842fb8e9511ca/javav2/example_code/s3/src/main/java/com/example/s3/S3ObjectOperations.java#L90) finden Sie unter GitHub.
## Asynchrone Paginierung
Die folgenden Beispiele zeigen asynchrone Paginierungsmethoden zum Auflisten von Tabellen. DynamoDB
### Iterieren Sie über Seiten mit Tabellennamen
In den folgenden beiden Beispielen wird ein asynchroner DynamoDB-Client verwendet, der die `listTablesPaginator` Methode mit einer Anforderung zum Abrufen von aufruft. [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`implementiert zwei Schnittstellen, was viele Optionen zur Verarbeitung von Antworten bietet. Wir werden uns die Methoden der einzelnen Schnittstellen ansehen.
#### Benutze ein `Subscriber`
Das folgende Codebeispiel zeigt, wie paginierte Ergebnisse mithilfe der von `ListTablesPublisher` implementierten `org.reactivestreams.Publisher` Schnittstelle verarbeitet werden. Weitere Informationen zum Modell mit reaktiven Streams finden Sie im [Reactive GitHub Streams-Repo](https://github.com/reactive-streams/reactive-streams-jvm/blob/v1.0.2/README.md).
Die folgenden Importe gelten für alle Beispiele in diesem Abschnitt zur asynchronen Paginierung.
##### Importe
```
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;
```
Der folgende Code erwirbt eine `ListTablesPublisher` Instanz.
```
// 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);
```
Der folgende Code verwendet eine anonyme Implementierung von`org.reactivestreams.Subscriber`, um die Ergebnisse für jede Seite zu verarbeiten.
Die `onSubscribe`-Methode ruft die `Subscription.request`-Methode auf, um Anforderungen von Daten vom Publisher zu initiieren. Diese Methode muss aufgerufen werden, um den Abruf von Daten vom Publisher zu starten.
Die `onNext` Methode des Abonnenten verarbeitet eine Antwortseite, indem sie auf alle Tabellennamen zugreift und jeden einzelnen ausdruckt. Nachdem die Seite verarbeitet wurde, wird eine weitere Seite vom Herausgeber angefordert. Diese Methode wird wiederholt aufgerufen, bis alle Seiten abgerufen wurden.
Die `onError`-Methode wird ausgelöst, wenn ein Fehler auftritt, während Daten abgerufen werden. Schließlich wird die `onComplete`-Methode aufgerufen, nachdem alle Seiten angefordert wurden.
```
// 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.
}
});
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/f807d60010caf3d14fe4cd0801b842fb8e9511ca/javav2/example_code/dynamodbasync/src/main/java/com/example/dynamodbasync/AsyncPagination.java#L83) finden Sie unter GitHub.
#### Benutze ein `Consumer`
Die `SdkPublisher` Schnittstelle, die `ListTablesPublisher` implementiert wird, hat eine `subscribe` Methode, die a annimmt `Consumer` und a zurückgibt`CompletableFuture`.
Die `subscribe` Methode aus dieser Schnittstelle kann für einfache Anwendungsfälle verwendet werden, wenn ein zu großer Overhead sein `org.reactivestreams.Subscriber` könnte. Da der folgende Code jede Seite verbraucht, ruft er die `tableNames` Methode auf jeder Seite auf. Die `tableNames` Methode gibt eine Anzahl `java.util.List` von DynamoDB-Tabellennamen zurück, die mit der `forEach` Methode verarbeitet wurden.
```
// Use a Consumer for simple use cases.
CompletableFuture future = publisher.subscribe(
response -> response.tableNames()
.forEach(System.out::println));
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/f807d60010caf3d14fe4cd0801b842fb8e9511ca/javav2/example_code/dynamodbasync/src/main/java/com/example/dynamodbasync/AsyncPagination.java#L96) finden Sie unter. GitHub
### Iteriere über Tabellennamen
Die folgenden Beispiele zeigen Möglichkeit, um über die in der Antwort zurückgegebenen Objekte anstatt über die Seiten der Antwort zu iterieren. Ähnlich wie das zuvor gezeigte synchrone Amazon S3 S3-Beispiel mit seiner `contents` Methode `ListTablesPublisher` verfügt die asynchrone Ergebnisklasse von DynamoDB über die `tableNames` bequeme Methode, um mit der zugrunde liegenden Elementsammlung zu interagieren. Der Rückgabetyp der `tableNames` Methode ist ein [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), der verwendet werden kann, um Artikel auf allen Seiten anzufordern.
#### Verwenden Sie ein `Subscriber`
Der folgende Code erfasst eine `SdkPublisher` der zugrunde liegenden Sammlungen von Tabellennamen.
```
// 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();
```
Der folgende Code verwendet eine anonyme Implementierung von`org.reactivestreams.Subscriber`, um die Ergebnisse für jede Seite zu verarbeiten.
Die `onNext` Methode des Abonnenten verarbeitet ein einzelnes Element der Sammlung. In diesem Fall ist es ein Tabellenname. Nachdem der Tabellenname verarbeitet wurde, wird ein anderer Tabellenname vom Herausgeber angefordert. Diese Methode wird wiederholt aufgerufen, bis alle Tabellennamen abgerufen wurden.
```
// 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() {
}
});
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/f807d60010caf3d14fe4cd0801b842fb8e9511ca/javav2/example_code/dynamodbasync/src/main/java/com/example/dynamodbasync/AsyncPagination.java#L147) finden Sie unter GitHub.
#### Benutze ein `Consumer`
Das folgende Beispiel verwendet die `subscribe` Methode `SdkPublisher` that takes a, `Consumer` um jedes Element zu verarbeiten.
```
// Use a Consumer.
CompletableFuture future = publisher.subscribe(System.out::println);
future.get();
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/f807d60010caf3d14fe4cd0801b842fb8e9511ca/javav2/example_code/dynamodbasync/src/main/java/com/example/dynamodbasync/AsyncPagination.java#L161) finden Sie unter GitHub.
### Verwenden Sie die Bibliothek eines Drittanbieters
Sie können andere Drittanbieter-Bibliotheken verwenden, statt einen benutzerdefinierten Abonnenten zu implementieren. Dieses Beispiel demonstriert die Verwendung von RxJava, aber jede Bibliothek, die die reaktiven Stream-Schnittstellen implementiert, kann verwendet werden. Weitere Informationen zu dieser Bibliothek GitHub finden Sie auf der [RxJava Wiki-Seite](https://github.com/ReactiveX/RxJava/wiki) unter.
Um die Bibliothek zu verwenden, fügen Sie sie als Abhängigkeit hinzu. Bei Verwendung von Maven zeigt das Beispiel den zu verwendenden POM-Ausschnitt.
**POM-Eintrag**
```
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);
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/f807d60010caf3d14fe4cd0801b842fb8e9511ca/javav2/example_code/dynamodbasync/src/main/java/com/example/dynamodbasync/AsyncPagination.java#L198) finden Sie unter GitHub.