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à.

# Differenze nelle operazioni di streaming tra 1.x e 2.x del AWS SDK per Java
<a name="migration-streaming-ops"></a>

Le operazioni di streaming, come Amazon S3 `getObject` e `putObject` i metodi, supportano il non blocco I/O nella versione 2.x dell'SDK. Di conseguenza, gli oggetti del modello di richiesta e risposta non accettano più un `InputStream` parametro. Per le richieste sincrone, invece, l'oggetto di richiesta accetta`RequestBody`, che è un flusso di byte. L'equivalente asincrono accetta un. `AsyncRequestBody`

**Example del funzionamento `PutObject` di Amazon S3 in 1.x**  

```
s3client.putObject(BUCKET, KEY, new File(file_path));
```

**Example del funzionamento `PutObject` di Amazon S3 nella versione 2.x**  

```
s3client.putObject(PutObjectRequest.builder()
                                 .bucket(BUCKET)
                                 .key(KEY)
                                 .build(),
                 RequestBody.of(Paths.get("myfile.in")));
```

Un oggetto di risposta in streaming accetta un `ResponseTransformer` per i client sincroni e un `AsyncResponseTransformer` per i client asincroni nella V2.

**Example del funzionamento `GetObject` di Amazon S3 in 1.x**  

```
S3Object o = s3.getObject(bucket, key);
S3ObjectInputStream s3is = o.getObjectContent();
FileOutputStream fos = new FileOutputStream(new File(key));
```

**Example del funzionamento di Amazon S3 `GetObject` in 2.x**  

```
s3client.getObject(GetObjectRequest.builder().bucket(bucket).key(key).build(),
		ResponseTransformer.toFile(Paths.get("key")));
```

Nell'SDK for Java 2.x, le operazioni di risposta in streaming dispongono di `AsBytes` un metodo per caricare la risposta in memoria e semplificare le conversioni di tipo comune in memoria.

## Migra la gestione delle risposte GZIP concatenate
<a name="migration-streaming-gzip"></a>

Durante la migrazione da SDK for Java 1.x, aggiorna manualmente il codice che include un flusso di risposta S3. `GZIPInputStream` Apporta questa modifica se la risposta può contenere più membri GZIP concatenati. Seleziona `ResponseTransformer.toGzipCompatibleInputStream()` o, per un client asincrono,. `AsyncResponseTransformer.toGzipCompatibleBlockingInputStream()`

Quando esegui la migrazione di questo codice, considera quanto segue:
+ Lo strumento di migrazione non seleziona automaticamente questi trasformatori.
+ In alcune versioni di JDK, è `GZIPInputStream` possibile interrompere dopo un membro di una risposta GZIP concatenata. Ciò può accadere se il blocco di rete successivo non è arrivato. Il risultato può essere la decompressione di dati troncati senza eccezioni.
+ Questi trasformatori non decomprimono il contenuto della risposta. Usali solo quando racchiudi lo stream restituito. `GZIPInputStream` Altrimenti, usa `ResponseTransformer.toInputStream()` o`AsyncResponseTransformer.toBlockingInputStream()`.

Per un client sincrono:

```
ResponseInputStream<GetObjectResponse> response =
    s3Client.getObject(
        request,
        ResponseTransformer.toGzipCompatibleInputStream());

try (GZIPInputStream gzipInputStream = new GZIPInputStream(response)) {
    // Read the decompressed response.
}
```

È possibile utilizzare `ResponseTransformer.toGzipCompatibleInputStream(Duration)` per configurare il timeout per la prima operazione di lettura.

Per un client asincrono:

```
CompletableFuture<ResponseInputStream<GetObjectResponse>> responseFuture =
    s3AsyncClient.getObject(
        request,
        AsyncResponseTransformer.toGzipCompatibleBlockingInputStream());

try (ResponseInputStream<GetObjectResponse> response = responseFuture.join();
     GZIPInputStream gzipInputStream = new GZIPInputStream(response)) {
    // Read the decompressed response. Reads block the calling thread.
}
```