Impaginazione sincrona Impaginazione asincrona

Lavora con risultati impaginati utilizzando la versione 2.x AWS SDK for Java

Molte AWS operazioni restituiscono risultati impaginati quando l'oggetto di risposta è troppo grande per essere restituito in un'unica risposta. Nella AWS SDK for Java versione 1.0, la risposta contiene un token da utilizzare per recuperare la pagina successiva dei risultati. Al contrario, la versione AWS SDK for Java 2.x dispone di metodi di autopaginazione che effettuano più chiamate di servizio per visualizzare automaticamente la pagina successiva dei risultati. Occorre solo scrivere il codice che elabora i risultati. L'autopaginazione è disponibile sia per i client sincroni che asincroni.

Nota

Questi frammenti di codice presuppongono che tu conosca le basi dell'utilizzo dell'SDK e che tu abbia configurato il tuo ambiente con l'accesso Single Sign-On.

Impaginazione sincrona

Gli esempi seguenti mostrano i metodi di impaginazione sincroni per elencare gli oggetti in un bucket. Amazon S3

Iterate sulle pagine

Il primo esempio dimostra l'uso di un oggetto listRes paginator, un'ListObjectsV2Iterableistanza, per scorrere tutte le pagine di risposta con il metodo. stream Il codice scorre sulle pagine di risposta, converte il flusso di risposta in un flusso di S3Object contenuti e quindi elabora il contenuto dell'oggetto. Amazon S3

Le seguenti importazioni si applicano a tutti gli esempi di questa sezione di impaginazione sincrona.


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

Vedi l'esempio completo su. GitHub

Iterate sugli oggetti

Negli esempi seguenti vengono mostrati dei metodi per effettuare l'iterazione sugli oggetti restituiti nella risposta invece che delle pagine della risposta. Il contents metodo di ListObjectsV2Iterable classe restituisce un SdkIterableche fornisce diversi metodi per elaborare gli elementi di contenuto sottostanti.

Usa uno stream

Il seguente frammento utilizza il stream metodo sul contenuto della risposta per iterare sulla raccolta di elementi impaginati.


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

Vedi l'esempio completo su. GitHub

Usa un ciclo for-each

Poiché SdkIterable estende l'Iterableinterfaccia, puoi elaborare i contenuti come qualsiasi altro. Iterable Il seguente frammento utilizza un for-each ciclo standard per scorrere il contenuto della risposta.


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

Vedi l'esempio completo su. GitHub

Impaginazione manuale

Se il caso d'uso lo richiede, la paginazione manuale è ancora disponibile. Utilizza il token successivo dell'oggetto di risposta per le richieste successive. L'esempio seguente utilizza un while ciclo.


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

Vedi l'esempio completo su GitHub.

Impaginazione asincrona

Gli esempi seguenti mostrano i metodi di impaginazione asincrona per elencare le tabelle. DynamoDB

Iterate su pagine di nomi di tabelle

I due esempi seguenti utilizzano un client DynamoDB asincrono che chiama listTablesPaginator il metodo con una richiesta per ottenere un. ListTablesPublisher ListTablesPublisherimplementa due interfacce, che forniscono molte opzioni per elaborare le risposte. Esamineremo i metodi di ciascuna interfaccia.

Usa un `Subscriber`

Il seguente esempio di codice dimostra come elaborare i risultati impaginati utilizzando l'org.reactivestreams.Publisherinterfaccia implementata da. ListTablesPublisher Per ulteriori informazioni sul modello Reactive Streams, consulta il repository Reactive Streams. GitHub

Le seguenti importazioni si applicano a tutti gli esempi di questa sezione di impaginazione asincrona.


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;

Il codice seguente acquisisce un'istanza. ListTablesPublisher


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

Il codice seguente utilizza un'implementazione anonima di org.reactivestreams.Subscriber per elaborare i risultati di ogni pagina.

Il metodo onSubscribe chiama il metodo Subscription.request per avviare le richieste per i dati del publisher. Questo metodo deve essere chiamato per iniziare a ottenere i dati dal publisher.

Il onNext metodo del sottoscrittore elabora una pagina di risposta accedendo a tutti i nomi delle tabelle e stampandoli ciascuno. Dopo l'elaborazione della pagina, viene richiesta un'altra pagina all'editore. Questo metodo viene chiamato ripetutamente fino al recupero di tutte le pagine.

Il metodo onError viene attivato se si verifica un errore durante il recupero dei dati. Infine, il metodo onComplete viene chiamato quando tutte le pagine sono state richieste.


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

Vedi l'esempio completo su. GitHub

Usa un `Consumer`

L'SdkPublisherinterfaccia che ListTablesPublisher implementa ha un subscribe metodo che accetta un Consumer e restituisce unCompletableFuture<Void>.

Il subscribe metodo di questa interfaccia può essere utilizzato per casi d'uso semplici in cui un org.reactivestreams.Subscriber potrebbe comportare un sovraccarico eccessivo. Poiché il codice seguente utilizza ogni pagina, chiama il tableNames metodo su ciascuna di esse. Il tableNames metodo restituisce uno java.util.List dei nomi di tabella DynamoDB elaborati con il metodo. forEach


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

Vedi l'esempio completo su. GitHub

Esegui iterazioni sui nomi delle tabelle

Negli esempi seguenti vengono mostrati dei metodi per effettuare l'iterazione sugli oggetti restituiti nella risposta invece che delle pagine della risposta. Analogamente all'esempio sincrono di Amazon S3 illustrato in precedenza con il contents relativo metodo, la classe ListTablesPublisher di risultati asincrona di DynamoDB ha il metodo pratico per interagire con tableNames la raccolta di elementi sottostante. Il tipo di restituzione del tableNames metodo è un metodo SdkPublisherche può essere utilizzato per richiedere elementi su tutte le pagine.

Usa un `Subscriber`

Il codice seguente acquisisce uno SdkPublisher dei nomi di tabella sottostanti.


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

Il codice seguente utilizza un'implementazione anonima di org.reactivestreams.Subscriber per elaborare i risultati di ogni pagina.

Il onNext metodo del sottoscrittore elabora un singolo elemento della raccolta. In questo caso, è un nome di tabella. Dopo l'elaborazione del nome della tabella, viene richiesto un altro nome di tabella all'editore. Questo metodo viene chiamato ripetutamente fino al recupero di tutti i nomi delle tabelle.


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

Vedi l'esempio completo su. GitHub

Usa un `Consumer`

L'esempio seguente utilizza il subscribe metodo SdkPublisher che richiede Consumer a per elaborare ogni elemento.


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

Vedi l'esempio completo su GitHub.

Usa una libreria di terze parti

Puoi utilizzare altre librerie di terze parti anziché implementare un sottoscrittore personalizzato. Questo esempio dimostra l'uso di RxJava, ma è possibile utilizzare qualsiasi libreria che implementa le interfacce di flusso reattivo. Vedi la pagina RxJava wiki su GitHub per ulteriori informazioni su quella libreria.

Per utilizzare la libreria, aggiungerla come una dipendenza. Se utilizzi Maven, l'esempio illustra lo snippet POM da utilizzare.

Voce POM


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

Codice


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

Vedi l'esempio completo su GitHub.

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

Usa le funzionalità dell'SDK

Sondaggio sugli stati delle risorse

Lavora con risultati impaginati utilizzando la versione 2.x AWS SDK for Java

Nota

Impaginazione sincrona

Iterate sulle pagine

Iterate sugli oggetti

Usa uno stream

Usa un ciclo for-each

Impaginazione manuale

Impaginazione asincrona

Iterate su pagine di nomi di tabelle

Usa un Subscriber

Usa un Consumer

Esegui iterazioni sui nomi delle tabelle

Usa un Subscriber

Usa un Consumer

Usa una libreria di terze parti

Usa un `Subscriber`

Usa un `Consumer`

Usa un `Subscriber`

Usa un `Consumer`