Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
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.
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'ListObjectsV2Iterable
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
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 SdkIterable
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.
Usa un ciclo for-each
Poiché SdkIterable
estende l'Iterable
interfaccia, 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
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
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
ListTablesPublisher
implementa 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.Publisher
interfaccia 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
Usa un Consumer
L'SdkPublisher
interfaccia 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
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 SdkPublisher
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
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
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
Per utilizzare la libreria, aggiungerla come una dipendenza. Se usi Maven, l'esempio mostra lo POM snippet da usare.
POMEntrata
<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);
Guarda l'esempio completo