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à.
# Utilizzo dei risultati impaginati nella versione 2.x AWS SDK per Java
Molte AWS operazioni restituiscono risultati impaginati quando l'oggetto di risposta è troppo grande per essere restituito in un'unica risposta. Nella AWS SDK per Java versione 1.0, la risposta contiene un token da utilizzare per recuperare la pagina successiva dei risultati. Al contrario, la versione AWS SDK per 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](using.md).](get-started-auth.md#setup-credentials)
## 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'[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)istanza, 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](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/model/S3Object.html)` 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.
#### Importazioni
```
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](https://github.com/awsdocs/aws-doc-sdk-examples/blob/f807d60010caf3d14fe4cd0801b842fb8e9511ca/javav2/example_code/s3/src/main/java/com/example/s3/S3ObjectOperations.java#L112) 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 [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)che 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.](https://github.com/awsdocs/aws-doc-sdk-examples/blob/f807d60010caf3d14fe4cd0801b842fb8e9511ca/javav2/example_code/s3/src/main/java/com/example/s3/S3ObjectOperations.java#L127) GitHub
#### 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](https://github.com/awsdocs/aws-doc-sdk-examples/blob/f807d60010caf3d14fe4cd0801b842fb8e9511ca/javav2/example_code/s3/src/main/java/com/example/s3/S3ObjectOperations.java#L133) 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](https://github.com/awsdocs/aws-doc-sdk-examples/blob/f807d60010caf3d14fe4cd0801b842fb8e9511ca/javav2/example_code/s3/src/main/java/com/example/s3/S3ObjectOperations.java#L90) 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. [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`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 ](https://github.com/reactive-streams/reactive-streams-jvm/blob/v1.0.2/README.md)
Le seguenti importazioni si applicano a tutti gli esempi di questa sezione di impaginazione asincrona.
##### Importazioni
```
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() {
// 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](https://github.com/awsdocs/aws-doc-sdk-examples/blob/f807d60010caf3d14fe4cd0801b842fb8e9511ca/javav2/example_code/dynamodbasync/src/main/java/com/example/dynamodbasync/AsyncPagination.java#L83) su. GitHub
#### Usa un `Consumer`
L'`SdkPublisher`interfaccia che `ListTablesPublisher` implementa ha un `subscribe` metodo che accetta un `Consumer` e restituisce un`CompletableFuture`.
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 future = publisher.subscribe(
response -> response.tableNames()
.forEach(System.out::println));
```
Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/f807d60010caf3d14fe4cd0801b842fb8e9511ca/javav2/example_code/dynamodbasync/src/main/java/com/example/dynamodbasync/AsyncPagination.java#L96) 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 [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)che 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 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() {
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](https://github.com/awsdocs/aws-doc-sdk-examples/blob/f807d60010caf3d14fe4cd0801b842fb8e9511ca/javav2/example_code/dynamodbasync/src/main/java/com/example/dynamodbasync/AsyncPagination.java#L147) 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 future = publisher.subscribe(System.out::println);
future.get();
```
Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/f807d60010caf3d14fe4cd0801b842fb8e9511ca/javav2/example_code/dynamodbasync/src/main/java/com/example/dynamodbasync/AsyncPagination.java#L161) 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](https://github.com/ReactiveX/RxJava/wiki) quella libreria.
Per utilizzare la libreria, aggiungerla come una dipendenza. Se utilizzi Maven, l'esempio illustra lo snippet POM da utilizzare.
**Voce POM**
```
io.reactivex.rxjava3
rxjava
3.1.6
```
**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 tables = Flowable.fromPublisher(publisher)
.flatMapIterable(ListTablesResponse::tableNames)
.toList()
.blockingGet();
System.out.println(tables);
```
Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/f807d60010caf3d14fe4cd0801b842fb8e9511ca/javav2/example_code/dynamodbasync/src/main/java/com/example/dynamodbasync/AsyncPagination.java#L198) su GitHub.