Arbeiten Sie mit der Version 2.x mit paginierten Ergebnissen AWS SDK for 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 for Java Version 1.0 enthält die Antwort ein Token, mit dem Sie die nächste Ergebnisseite abrufen. Im Gegensatz dazu verfügt Version AWS SDK for 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.

Synchrone Paginierung

Die folgenden Beispiele zeigen synchrone Paginierungsmethoden zum Auflisten von Objekten in einem Bucket. Amazon S3

Iterieren Sie über mehrere Seiten

Das erste Beispiel demonstriert die Verwendung eines listRes Paginator-Objekts, einer ListObjectsV2IterableInstanz, um mit der Methode durch alle Antwortseiten zu iterieren. stream Der Code streamt über die Antwortseiten, konvertiert den Antwortstream in einen S3Object Inhaltsstream und verarbeitet dann den Inhalt des Objekts. Amazon S3

Die folgenden Importe gelten für alle Beispiele in diesem Abschnitt zur synchronen Paginierung.

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 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 SdkIterable, 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. 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 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 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. ListTablesPublisher ListTablesPublisherimplementiert zwei Schnittstellen, was viele Optionen für die 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.

Die folgenden Importe gelten für alle Beispiele in diesem Abschnitt zur asynchronen Paginierung.

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 vonorg.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<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.
            }
        });

Das vollständige Beispiel finden Sie unter GitHub.

Benutze ein Consumer

Die SdkPublisher ListTablesPublisher implementierte Schnittstelle hat eine subscribe Methode, die a annimmt Consumer und a zurückgibtCompletableFuture<Void>.

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<Void> future = publisher.subscribe(
                response -> response.tableNames()
                        .forEach(System.out::println));

Das vollständige Beispiel 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 SdkPublisher, der verwendet werden kann, um Artikel auf allen Seiten anzufordern.

Verwenden Sie ein Subscriber

Mit dem folgenden Code wird eine SdkPublisher der zugrunde liegenden Sammlungen von Tabellennamen abgerufen.

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

Der folgende Code verwendet eine anonyme Implementierung vonorg.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<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() {
            }
        });

Das vollständige Beispiel 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<Void> future = publisher.subscribe(System.out::println);
        future.get();

Das vollständige Beispiel 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 unter.

Um die Bibliothek zu verwenden, fügen Sie sie als Abhängigkeit hinzu. Wenn Sie Maven verwenden, zeigt das Beispiel das zu verwendende POM Snippet.

POMEintrag

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

Das vollständige Beispiel finden Sie unter GitHub.