

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Arbeiten Sie mit Amazon S3
<a name="examples-s3"></a>

Dieser Abschnitt enthält Hintergrundinformationen für die Arbeit mit Amazon S3 mithilfe von AWS SDK for Java 2.x. Dieser Abschnitt ergänzt die [Amazon S3 Java v2-Beispiele](java_s3_code_examples.md), die im Abschnitt *Codebeispiele* dieses Handbuchs vorgestellt werden.

## S3-Clients in der AWS SDK for Java 2.x
<a name="s3-clients"></a>

Das AWS SDK for Java 2.x bietet verschiedene Arten von S3-Clients. Die folgende Tabelle zeigt die Unterschiede und kann Ihnen bei der Entscheidung helfen, was für Ihre Anwendungsfälle am besten geeignet ist.


**Verschiedene Varianten von Amazon S3 S3-Clients**  

| S3-Klient | Kurzbeschreibung | Wann sollte dies verwendet werden? | Einschränkung/Nachteil | 
| --- | --- | --- | --- | 
|  **AWS CRT-basierter S3-Client** [Schnittstelle: S3 AsyncClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/S3AsyncClient.html) Baumeister: [S3 CrtAsyncClientBuilder](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/S3AsyncClient.html)  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sdk-for-java/latest/developer-guide/examples-s3.html) Siehe [Verwenden Sie einen leistungsstarken S3-Client: AWS CRT-basierter S3-Client](crt-based-s3-client.md).  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sdk-for-java/latest/developer-guide/examples-s3.html)  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sdk-for-java/latest/developer-guide/examples-s3.html)  | 
|  ***Java-basierter asynchroner S3-Client mit aktiviertem Multipart*** Schnittstelle[:](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/S3AsyncClient.html) S3 AsyncClient Baumeister: [S3 AsyncClientBuilder](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/S3AsyncClientBuilder.html)  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sdk-for-java/latest/developer-guide/examples-s3.html) Siehe [Konfigurieren Sie den Java-basierten asynchronen S3-Client für parallel Übertragungen](s3-async-client-multipart.md).  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sdk-for-java/latest/developer-guide/examples-s3.html)  | Weniger leistungsfähig als der AWS CRT-basierte S3-Client. | 
|  ***Java-basierter asynchroner S3-Client ohne aktiviertes Multipart*** Schnittstelle[:](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/S3AsyncClient.html) S3 AsyncClient Baumeister: [S3 AsyncClientBuilder](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/S3AsyncClientBuilder.html) |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sdk-for-java/latest/developer-guide/examples-s3.html)  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sdk-for-java/latest/developer-guide/examples-s3.html)  |  Keine Leistungsoptimierung.  | 
|  **Java-basierter S3-Synchronisierungsclient** [Schnittstelle: S3Client](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/S3Client.html) [Baumeister: S3 ClientBuilder](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/S3ClientBuilder.html) |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sdk-for-java/latest/developer-guide/examples-s3.html)  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sdk-for-java/latest/developer-guide/examples-s3.html)  |  Keine Leistungsoptimierung.  | 

**Anmerkung**  
Ab Version 2.18.x AWS SDK for Java 2.x verwendet der eine [Adressierung im virtuellen Hosting-Stil, wenn eine Endpunkt-Override enthalten](https://docs.aws.amazon.com/AmazonS3/latest/userguide/VirtualHosting.html#virtual-hosted-style-access) ist. Dies gilt, solange der Bucket-Name ein gültiges DNS-Label ist.   
Rufen Sie die [https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/S3BaseClientBuilder.html#forcePathStyle(java.lang.Boolean](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/S3BaseClientBuilder.html#forcePathStyle(java.lang.Boolean)Methode with `true` in Ihrem Client Builder auf, um den Client zu zwingen, die Pfadadressierung für Buckets zu verwenden.  
Das folgende Beispiel zeigt einen Service-Client, der mit einer Endpunktüberschreibung konfiguriert ist und eine Pfadadressierung verwendet.  

```
S3Client client = S3Client.builder()
                          .region(Region.US_WEST_2)
                          .endpointOverride(URI.create("https://s3.us-west-2.amazonaws.com"))
                          .forcePathStyle(true)
                          .build();
```

**Topics**
+ [S3-Clients im SDK](#s3-clients)
+ [Hochladen von Streams auf S3](best-practices-s3-uploads.md)
+ [Vorsigniert URLs](examples-s3-presign.md)
+ [Regionsübergreifender Zugriff](s3-cross-region.md)
+ [Schutz der Datenintegrität mit Prüfsummen](s3-checksums.md)
+ [Verwenden Sie einen performanten S3-Client](crt-based-s3-client.md)
+ [Unterstützung für parallel Übertragung konfigurieren](s3-async-client-multipart.md)
+ [Dateien und Verzeichnisse übertragen](transfer-manager.md)
+ [S3-Ereignisbenachrichtigungen](examples-s3-event-notifications.md)

# Hochladen von Streams auf Amazon S3 mit dem AWS SDK for Java 2.x
<a name="best-practices-s3-uploads"></a>

Wenn Sie einen Stream verwenden, um Inhalte mithilfe von [https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/S3Client.html#putObject(software.amazon.awssdk.services.s3.model.PutObjectRequest,software.amazon.awssdk.core.sync.RequestBody)](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/S3Client.html#putObject(software.amazon.awssdk.services.s3.model.PutObjectRequest,software.amazon.awssdk.core.sync.RequestBody))oder auf S3 hochzuladen [https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/S3Client.html#uploadPart(software.amazon.awssdk.services.s3.model.UploadPartRequest,software.amazon.awssdk.core.sync.RequestBody)](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/S3Client.html#uploadPart(software.amazon.awssdk.services.s3.model.UploadPartRequest,software.amazon.awssdk.core.sync.RequestBody)), verwenden Sie eine `RequestBody` Factory-Klasse für die synchrone API, um den Stream bereitzustellen. Für die asynchrone API `AsyncRequestBody` ist das die entsprechende Factory-Klasse.

## Welche Methoden laden Streams hoch?
<a name="s3-stream-upload-methods"></a>

Für die synchrone API können Sie die folgenden Factory-Methoden verwenden`RequestBody`, um den Stream bereitzustellen:
+ `[fromInputStream](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/core/sync/RequestBody.html#fromInputStream(java.io.InputStream,long))(InputStream inputStream, long contentLength)`

  `[fromContentProvider](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/core/sync/RequestBody.html#fromContentProvider(software.amazon.awssdk.http.ContentStreamProvider,long,java.lang.String))(ContentStreamProvider provider, long contentLength, String mimeType)`
  + Das `ContentStreamProvider` hat die `fromInputStream(InputStream inputStream)` Factory-Methode
+ `[fromContentProvider](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/core/sync/RequestBody.html#fromContentProvider(software.amazon.awssdk.http.ContentStreamProvider,java.lang.String))(ContentStreamProvider provider, String mimeType)`

Für die asynchrone API können Sie die folgenden Factory-Methoden verwenden: `AsyncRequestBody`
+ `[fromInputStream](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/core/async/AsyncRequestBody.html#fromInputStream(java.io.InputStream,java.lang.Long,java.util.concurrent.ExecutorService))(InputStream inputStream, Long contentLength, ExecutorService executor)` 
+ `[fromInputStream](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/core/async/AsyncRequestBody.html#fromInputStream(software.amazon.awssdk.core.async.AsyncRequestBodyFromInputStreamConfiguration))(AsyncRequestBodyFromInputStreamConfiguration configuration)`
  + Sie verwenden den AsyncRequestBodyFromInputStreamConfiguration .Builder, um den Stream bereitzustellen
+ `[fromInputStream](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/core/async/AsyncRequestBody.html#fromInputStream(java.util.function.Consumer))(Consumer<AsyncRequestBodyFromInputStreamConfiguration.Builder> configuration)`
+ `[forBlockingInputStream](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/core/async/AsyncRequestBody.html#forBlockingInputStream(java.lang.Long))(Long contentLength)`
  + Das Ergebnis `[BlockingInputStreamAsyncRequestBody](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/core/async/BlockingInputStreamAsyncRequestBody.html)` enthält die Methode`writeInputStream(InputStream inputStream)`, mit der Sie den Stream bereitstellen können

## Der Upload wird durchgeführt
<a name="s3-upload-stream-perform"></a>

### Wenn du die Länge des Streams kennst
<a name="s3-stream-upload-supply-content-length"></a>

Wie Sie der Signatur der zuvor gezeigten Methoden entnehmen können, akzeptieren die meisten Methoden einen Parameter für die Inhaltslänge. 

Wenn Sie die Inhaltslänge in Byte kennen, geben Sie den genauen Wert an:

```
// Always provide the exact content length when it's available.
long contentLength = 1024; // Exact size in bytes.
s3Client.putObject(req -> req
    .bucket("amzn-s3-demo-bucket")
    .key("my-key"),
RequestBody.fromInputStream(inputStream, contentLength));
```

**Warnung**  
 Wenn Sie aus einem Eingabestream hochladen und die angegebene Inhaltslänge nicht der tatsächlichen Byteanzahl entspricht, kann Folgendes auftreten:  
Verkürzte Objekte, wenn die angegebene Länge zu klein ist
Fehlgeschlagene Uploads oder hängende Verbindungen, wenn die angegebene Länge zu groß ist

### Wenn Sie die Länge des Streams nicht kennen
<a name="s3-stream-upload-unknown-length"></a>

#### Verwenden der synchronen API
<a name="s3-upload-unknown-sync-client"></a>

Verwenden Sie das`fromContentProvider(ContentStreamProvider provider, String mimeType)`:

```
public PutObjectResponse syncClient_stream_unknown_size(String bucketName, String key, InputStream inputStream) {

    S3Client s3Client = S3Client.create();

    RequestBody body = RequestBody.fromContentProvider(ContentStreamProvider.fromInputStream(inputStream), "text/plain");
    PutObjectResponse putObjectResponse = s3Client.putObject(b -> b.bucket(BUCKET_NAME).key(KEY_NAME), body);
    return putObjectResponse;
}
```

Da das SDK den gesamten Stream im Speicher puffert, um die Inhaltslänge zu berechnen, kann es bei großen Streams zu Speicherproblemen kommen. Wenn Sie große Streams mit dem synchronen Client hochladen müssen, sollten Sie die Verwendung der mehrteiligen API in Betracht ziehen:

##### Laden Sie einen Stream mithilfe der synchronen Client-API und der Multipart-API hoch
<a name="sync-multipart-upload-stream"></a>

```
public static void uploadStreamToS3(String bucketName, String key, InputStream inputStream) {
    // Create S3 client
    S3Client s3Client = S3Client.create();
    try {
        // Step 1: Initiate the multipart upload
        CreateMultipartUploadRequest createMultipartUploadRequest = CreateMultipartUploadRequest.builder()
                .bucket(bucketName)
                .key(key)
                .build();

        CreateMultipartUploadResponse createResponse = s3Client.createMultipartUpload(createMultipartUploadRequest);
        String uploadId = createResponse.uploadId();
        System.out.println("Started multipart upload with ID: " + uploadId);

        // Step 2: Upload parts
        List<CompletedPart> completedParts = new ArrayList<>();
        int partNumber = 1;
        byte[] buffer = new byte[PART_SIZE];
        int bytesRead;

        try {
            while ((bytesRead = readFullyOrToEnd(inputStream, buffer)) > 0) {
                // Create request to upload a part
                UploadPartRequest uploadPartRequest = UploadPartRequest.builder()
                        .bucket(bucketName)
                        .key(key)
                        .uploadId(uploadId)
                        .partNumber(partNumber)
                        .build();

                // If we didn't read a full buffer, create a properly sized byte array
                RequestBody requestBody;
                if (bytesRead < PART_SIZE) {
                    byte[] lastPartBuffer = new byte[bytesRead];
                    System.arraycopy(buffer, 0, lastPartBuffer, 0, bytesRead);
                    requestBody = RequestBody.fromBytes(lastPartBuffer);
                } else {
                    requestBody = RequestBody.fromBytes(buffer);
                }

                // Upload the part and save the response's ETag
                UploadPartResponse uploadPartResponse = s3Client.uploadPart(uploadPartRequest, requestBody);
                CompletedPart part = CompletedPart.builder()
                        .partNumber(partNumber)
                        .eTag(uploadPartResponse.eTag())
                        .build();
                completedParts.add(part);

                System.out.println("Uploaded part " + partNumber + " with size " + bytesRead + " bytes");
                partNumber++;
            }

            // Step 3: Complete the multipart upload
            CompletedMultipartUpload completedMultipartUpload = CompletedMultipartUpload.builder()
                    .parts(completedParts)
                    .build();

            CompleteMultipartUploadRequest completeRequest = CompleteMultipartUploadRequest.builder()
                    .bucket(bucketName)
                    .key(key)
                    .uploadId(uploadId)
                    .multipartUpload(completedMultipartUpload)
                    .build();

            CompleteMultipartUploadResponse completeResponse = s3Client.completeMultipartUpload(completeRequest);
            System.out.println("Multipart upload completed. Object URL: " + completeResponse.location());

        } catch (Exception e) {
            // If an error occurs, abort the multipart upload
            System.err.println("Error during multipart upload: " + e.getMessage());
            AbortMultipartUploadRequest abortRequest = AbortMultipartUploadRequest.builder()
                    .bucket(bucketName)
                    .key(key)
                    .uploadId(uploadId)
                    .build();
            s3Client.abortMultipartUpload(abortRequest);
            System.err.println("Multipart upload aborted");
        } finally {
            try {
                inputStream.close();
            } catch (IOException e) {
                System.err.println("Error closing input stream: " + e.getMessage());
            }
        }
    } finally {
        s3Client.close();
    }
}

/**
 * Reads from the input stream into the buffer, attempting to fill the buffer completely
 * or until the end of the stream is reached.
 *
 * @param inputStream the input stream to read from
 * @param buffer      the buffer to fill
 * @return the number of bytes read, or -1 if the end of the stream is reached before any bytes are read
 * @throws IOException if an I/O error occurs
 */
private static int readFullyOrToEnd(InputStream inputStream, byte[] buffer) throws IOException {
    int totalBytesRead = 0;
    int bytesRead;

    while (totalBytesRead < buffer.length) {
        bytesRead = inputStream.read(buffer, totalBytesRead, buffer.length - totalBytesRead);
        if (bytesRead == -1) {
            break; // End of stream
        }
        totalBytesRead += bytesRead;
    }

    return totalBytesRead > 0 ? totalBytesRead : -1;
}
```

**Anmerkung**  
Für die meisten Anwendungsfälle empfehlen wir die Verwendung der asynchronen Client-API für Streams unbekannter Größe. Dieser Ansatz ermöglicht parallel Übertragungen und bietet eine einfachere Programmierschnittstelle, da das SDK die Stream-Segmentierung in mehrteilige Blöcke übernimmt, wenn der Stream groß ist.   
Sowohl der standardmäßige asynchrone S3-Client mit aktiviertem Multipart als auch der AWS CRT-basierte S3-Client implementieren diesen Ansatz. Im folgenden Abschnitt zeigen wir Beispiele für diesen Ansatz.

#### Verwendung der asynchronen API
<a name="s3-stream-upload-unknown-async-client"></a>

Sie können das `contentLength` Argument `null` für das angeben `fromInputStream(InputStream inputStream, Long contentLength, ExecutorService executor)`

**Example mit dem AWS CRT-basierten asynchronen Client:**  

```
public PutObjectResponse crtClient_stream_unknown_size(String bucketName, String key, InputStream inputStream) {

    S3AsyncClient s3AsyncClient = S3AsyncClient.crtCreate();
    ExecutorService executor = Executors.newSingleThreadExecutor();
    AsyncRequestBody body = AsyncRequestBody.fromInputStream(inputStream, null, executor);  // 'null' indicates that the
                                                                                            // content length is unknown.
    CompletableFuture<PutObjectResponse> responseFuture =
            s3AsyncClient.putObject(r -> r.bucket(bucketName).key(key), body)
                    .exceptionally(e -> {
                        if (e != null){
                            logger.error(e.getMessage(), e);
                        }
                        return null;
                    });

    PutObjectResponse response = responseFuture.join(); // Wait for the response.
    executor.shutdown();
    return response;
}
```

**Example unter Verwendung des standardmäßigen asynchronen Clients mit aktiviertem Multipart:**  

```
public PutObjectResponse asyncClient_multipart_stream_unknown_size(String bucketName, String key, InputStream inputStream) {

    S3AsyncClient s3AsyncClient = S3AsyncClient.builder().multipartEnabled(true).build();
    ExecutorService executor = Executors.newSingleThreadExecutor();
    AsyncRequestBody body = AsyncRequestBody.fromInputStream(inputStream, null, executor); // 'null' indicates that the
                                                                                           // content length is unknown.
    CompletableFuture<PutObjectResponse> responseFuture =
            s3AsyncClient.putObject(r -> r.bucket(bucketName).key(key), body)
                    .exceptionally(e -> {
                        if (e != null) {
                            logger.error(e.getMessage(), e);
                        }
                        return null;
                    });

    PutObjectResponse response = responseFuture.join(); // Wait for the response.
    executor.shutdown();
    return response;
}
```

# Arbeiten Sie mit Amazon S3 vorsignierten URLs
<a name="examples-s3-presign"></a>

Vorsignierte URLs ermöglichen temporären Zugriff auf private S3-Objekte, ohne dass Benutzer über AWS Anmeldeinformationen oder Berechtigungen verfügen müssen. 

Angenommen, Alice hat Zugriff auf ein S3-Objekt, und sie möchte den Zugriff auf dieses Objekt vorübergehend mit Bob teilen. Alice kann eine vorsignierte GET-Anfrage zur Weitergabe an Bob generieren, sodass er das Objekt herunterladen kann, ohne Zugriff auf Alices Anmeldeinformationen zu benötigen. Sie können vorsignierte URLs HTTP-GET- und HTTP-PUT-Anfragen generieren.

## Generieren Sie eine vorsignierte URL für ein Objekt und laden Sie sie dann herunter (GET-Anfrage)
<a name="get-presignedobject"></a>

Das folgende Beispiel besteht aus zwei Teilen.
+ Teil 1: Alice generiert die vorsignierte URL für ein Objekt.
+ Teil 2: Bob lädt das Objekt mithilfe der vorsignierten URL herunter.

### Teil 1: Generieren Sie die URL
<a name="get-presigned-object-part1"></a>

Alice hat bereits ein Objekt in einem S3-Bucket. Sie verwendet den folgenden Code, um eine URL-Zeichenfolge zu generieren, die Bob in einer nachfolgenden GET-Anfrage verwenden kann.

#### Importe
<a name="get-presigned-example-imports"></a>

```
import com.example.s3.util.PresignUrlUtils;
import org.slf4j.Logger;
import software.amazon.awssdk.http.HttpExecuteRequest;
import software.amazon.awssdk.http.HttpExecuteResponse;
import software.amazon.awssdk.http.SdkHttpClient;
import software.amazon.awssdk.http.SdkHttpMethod;
import software.amazon.awssdk.http.SdkHttpRequest;
import software.amazon.awssdk.http.apache.ApacheHttpClient;
import software.amazon.awssdk.services.s3.S3Client;
import software.amazon.awssdk.services.s3.model.GetObjectRequest;
import software.amazon.awssdk.services.s3.model.S3Exception;
import software.amazon.awssdk.services.s3.presigner.S3Presigner;
import software.amazon.awssdk.services.s3.presigner.model.GetObjectPresignRequest;
import software.amazon.awssdk.services.s3.presigner.model.PresignedGetObjectRequest;
import software.amazon.awssdk.utils.IoUtils;

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URISyntaxException;
import java.net.URL;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.file.Paths;
import java.time.Duration;
import java.util.UUID;
```

```
    /* Create a pre-signed URL to download an object in a subsequent GET request. */
    public String createPresignedGetUrl(String bucketName, String keyName) {
        try (S3Presigner presigner = S3Presigner.create()) {

            GetObjectRequest objectRequest = GetObjectRequest.builder()
                    .bucket(bucketName)
                    .key(keyName)
                    .build();

            GetObjectPresignRequest presignRequest = GetObjectPresignRequest.builder()
                    .signatureDuration(Duration.ofMinutes(10))  // The URL will expire in 10 minutes.
                    .getObjectRequest(objectRequest)
                    .build();

            PresignedGetObjectRequest presignedRequest = presigner.presignGetObject(presignRequest);
            logger.info("Presigned URL: [{}]", presignedRequest.url().toString());
            logger.info("HTTP method: [{}]", presignedRequest.httpRequest().method());

            return presignedRequest.url().toExternalForm();
        }
    }
```

### Teil 2: Laden Sie das Objekt herunter
<a name="get-presigned-object-part2"></a>

Bob verwendet eine der folgenden drei Codeoptionen, um das Objekt herunterzuladen. Alternativ könnte er einen Browser verwenden, um die GET-Anfrage auszuführen.

#### Benutze JDK `HttpURLConnection` (seit v1.1)
<a name="get-presigned-example-useHttpUrlConnection"></a>

```
    /* Use the JDK HttpURLConnection (since v1.1) class to do the download. */
    public byte[] useHttpUrlConnectionToGet(String presignedUrlString) {
        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream(); // Capture the response body to a byte array.

        try {
            URL presignedUrl = new URL(presignedUrlString);
            HttpURLConnection connection = (HttpURLConnection) presignedUrl.openConnection();
            connection.setRequestMethod("GET");
            // Download the result of executing the request.
            try (InputStream content = connection.getInputStream()) {
                IoUtils.copy(content, byteArrayOutputStream);
            }
            logger.info("HTTP response code is " + connection.getResponseCode());

        } catch (S3Exception | IOException e) {
            logger.error(e.getMessage(), e);
        }
        return byteArrayOutputStream.toByteArray();
    }
```

#### Benutze JDK `HttpClient` (seit v11)
<a name="get-presigned-example-useHttpClient"></a>

```
    /* Use the JDK HttpClient (since v11) class to do the download. */
    public byte[] useHttpClientToGet(String presignedUrlString) {
        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream(); // Capture the response body to a byte array.

        HttpRequest.Builder requestBuilder = HttpRequest.newBuilder();
        HttpClient httpClient = HttpClient.newHttpClient();
        try {
            URL presignedUrl = new URL(presignedUrlString);
            HttpResponse<InputStream> response = httpClient.send(requestBuilder
                            .uri(presignedUrl.toURI())
                            .GET()
                            .build(),
                    HttpResponse.BodyHandlers.ofInputStream());

            IoUtils.copy(response.body(), byteArrayOutputStream);

            logger.info("HTTP response code is " + response.statusCode());

        } catch (URISyntaxException | InterruptedException | IOException e) {
            logger.error(e.getMessage(), e);
        }
        return byteArrayOutputStream.toByteArray();
    }
```

#### Verwendung `SdkHttpClient` aus dem SDK for Java
<a name="get-presigned-example-useSdkHttpClient"></a>

```
    /* Use the AWS SDK for Java SdkHttpClient class to do the download. */
    public byte[] useSdkHttpClientToGet(String presignedUrlString) {

        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream(); // Capture the response body to a byte array.
        try {
            URL presignedUrl = new URL(presignedUrlString);
            SdkHttpRequest request = SdkHttpRequest.builder()
                    .method(SdkHttpMethod.GET)
                    .uri(presignedUrl.toURI())
                    .build();

            HttpExecuteRequest executeRequest = HttpExecuteRequest.builder()
                    .request(request)
                    .build();

            try (SdkHttpClient sdkHttpClient = ApacheHttpClient.create()) {
                HttpExecuteResponse response = sdkHttpClient.prepareRequest(executeRequest).call();
                response.responseBody().ifPresentOrElse(
                        abortableInputStream -> {
                            try {
                                IoUtils.copy(abortableInputStream, byteArrayOutputStream);
                            } catch (IOException e) {
                                throw new RuntimeException(e);
                            }
                        },
                        () -> logger.error("No response body."));

                logger.info("HTTP Response code is {}", response.httpResponse().statusCode());
            }
        } catch (URISyntaxException | IOException e) {
            logger.error(e.getMessage(), e);
        }
        return byteArrayOutputStream.toByteArray();
    }
```

Sehen Sie sich das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/d73001daea05266eaa9e074ccb71b9383832369a/javav2/example_code/s3/src/main/java/com/example/s3/GeneratePresignedGetUrlAndRetrieve.java) an und [testen Sie](https://github.com/awsdocs/aws-doc-sdk-examples/blob/d73001daea05266eaa9e074ccb71b9383832369a/javav2/example_code/s3/src/test/java/com/example/s3/presignurl/GeneratePresignedGetUrlTests.java) es weiter GitHub.

## Generieren Sie eine vorsignierte URL für einen Upload und laden Sie dann eine Datei hoch (PUT-Anfrage)
<a name="put-presignedobject"></a>

Das folgende Beispiel besteht aus zwei Teilen.
+ Teil 1: Alice generiert die vorsignierte URL, um ein Objekt hochzuladen.
+ Teil 2: Bob lädt eine Datei mithilfe der vorsignierten URL hoch.

### Teil 1: Generieren Sie die URL
<a name="put-presigned-object-part1"></a>

Alice hat bereits einen S3-Bucket. Sie verwendet den folgenden Code, um eine URL-Zeichenfolge zu generieren, die Bob in einer nachfolgenden PUT-Anfrage verwenden kann.

#### Importe
<a name="put-presigned-example-imports"></a>

```
import com.example.s3.util.PresignUrlUtils;
import org.slf4j.Logger;
import software.amazon.awssdk.core.internal.sync.FileContentStreamProvider;
import software.amazon.awssdk.http.HttpExecuteRequest;
import software.amazon.awssdk.http.HttpExecuteResponse;
import software.amazon.awssdk.http.SdkHttpClient;
import software.amazon.awssdk.http.SdkHttpMethod;
import software.amazon.awssdk.http.SdkHttpRequest;
import software.amazon.awssdk.http.apache.ApacheHttpClient;
import software.amazon.awssdk.services.s3.S3Client;
import software.amazon.awssdk.services.s3.model.PutObjectRequest;
import software.amazon.awssdk.services.s3.model.S3Exception;
import software.amazon.awssdk.services.s3.presigner.S3Presigner;
import software.amazon.awssdk.services.s3.presigner.model.PresignedPutObjectRequest;
import software.amazon.awssdk.services.s3.presigner.model.PutObjectPresignRequest;

import java.io.File;
import java.io.IOException;
import java.io.OutputStream;
import java.io.RandomAccessFile;
import java.net.HttpURLConnection;
import java.net.URISyntaxException;
import java.net.URL;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.time.Duration;
import java.util.Map;
import java.util.UUID;
```

```
    /* Create a presigned URL to use in a subsequent PUT request */
    public String createPresignedUrl(String bucketName, String keyName, Map<String, String> metadata) {
        try (S3Presigner presigner = S3Presigner.create()) {

            PutObjectRequest objectRequest = PutObjectRequest.builder()
                    .bucket(bucketName)
                    .key(keyName)
                    .metadata(metadata)
                    .build();

            PutObjectPresignRequest presignRequest = PutObjectPresignRequest.builder()
                    .signatureDuration(Duration.ofMinutes(10))  // The URL expires in 10 minutes.
                    .putObjectRequest(objectRequest)
                    .build();


            PresignedPutObjectRequest presignedRequest = presigner.presignPutObject(presignRequest);
            String myURL = presignedRequest.url().toString();
            logger.info("Presigned URL to upload a file to: [{}]", myURL);
            logger.info("HTTP method: [{}]", presignedRequest.httpRequest().method());

            return presignedRequest.url().toExternalForm();
        }
    }
```

### Teil 2: Laden Sie ein Dateiobjekt hoch
<a name="put-presigned-object-part2"></a>

Bob verwendet eine der folgenden drei Codeoptionen, um eine Datei hochzuladen.

#### Benutze JDK `HttpURLConnection` (seit v1.1)
<a name="put-presigned-example-useHttpUrlConnection"></a>

```
    /* Use the JDK HttpURLConnection (since v1.1) class to do the upload. */
    public void useHttpUrlConnectionToPut(String presignedUrlString, File fileToPut, Map<String, String> metadata) {
        logger.info("Begin [{}] upload", fileToPut.toString());
        try {
            URL presignedUrl = new URL(presignedUrlString);
            HttpURLConnection connection = (HttpURLConnection) presignedUrl.openConnection();
            connection.setDoOutput(true);
            metadata.forEach((k, v) -> connection.setRequestProperty("x-amz-meta-" + k, v));
            connection.setRequestMethod("PUT");
            OutputStream out = connection.getOutputStream();

            try (RandomAccessFile file = new RandomAccessFile(fileToPut, "r");
                 FileChannel inChannel = file.getChannel()) {
                ByteBuffer buffer = ByteBuffer.allocate(8192); //Buffer size is 8k

                while (inChannel.read(buffer) > 0) {
                    buffer.flip();
                    for (int i = 0; i < buffer.limit(); i++) {
                        out.write(buffer.get());
                    }
                    buffer.clear();
                }
            } catch (IOException e) {
                logger.error(e.getMessage(), e);
            }

            out.close();
            connection.getResponseCode();
            logger.info("HTTP response code is " + connection.getResponseCode());

        } catch (S3Exception | IOException e) {
            logger.error(e.getMessage(), e);
        }
    }
```

#### Benutze JDK `HttpClient` (seit v11)
<a name="put-presigned-example-useHttpClient"></a>

```
    /* Use the JDK HttpClient (since v11) class to do the upload. */
    public void useHttpClientToPut(String presignedUrlString, File fileToPut, Map<String, String> metadata) {
        logger.info("Begin [{}] upload", fileToPut.toString());

        HttpRequest.Builder requestBuilder = HttpRequest.newBuilder();
        metadata.forEach((k, v) -> requestBuilder.header("x-amz-meta-" + k, v));

        HttpClient httpClient = HttpClient.newHttpClient();
        try {
            final HttpResponse<Void> response = httpClient.send(requestBuilder
                            .uri(new URL(presignedUrlString).toURI())
                            .PUT(HttpRequest.BodyPublishers.ofFile(Path.of(fileToPut.toURI())))
                            .build(),
                    HttpResponse.BodyHandlers.discarding());

            logger.info("HTTP response code is " + response.statusCode());

        } catch (URISyntaxException | InterruptedException | IOException e) {
            logger.error(e.getMessage(), e);
        }
    }
```

#### Verwendung `SdkHttpClient` aus dem SDK for Java
<a name="put-presigned-example-useSdkHttpClient"></a>

```
    /* Use the AWS SDK for Java V2 SdkHttpClient class to do the upload. */
    public void useSdkHttpClientToPut(String presignedUrlString, File fileToPut, Map<String, String> metadata) {
        logger.info("Begin [{}] upload", fileToPut.toString());

        try {
            URL presignedUrl = new URL(presignedUrlString);

            SdkHttpRequest.Builder requestBuilder = SdkHttpRequest.builder()
                    .method(SdkHttpMethod.PUT)
                    .uri(presignedUrl.toURI());
            // Add headers
            metadata.forEach((k, v) -> requestBuilder.putHeader("x-amz-meta-" + k, v));
            // Finish building the request.
            SdkHttpRequest request = requestBuilder.build();

            HttpExecuteRequest executeRequest = HttpExecuteRequest.builder()
                    .request(request)
                    .contentStreamProvider(new FileContentStreamProvider(fileToPut.toPath()))
                    .build();

            try (SdkHttpClient sdkHttpClient = ApacheHttpClient.create()) {
                HttpExecuteResponse response = sdkHttpClient.prepareRequest(executeRequest).call();
                logger.info("Response code: {}", response.httpResponse().statusCode());
            }
        } catch (URISyntaxException | IOException e) {
            logger.error(e.getMessage(), e);
        }
    }
```

Sehen Sie sich das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/d73001daea05266eaa9e074ccb71b9383832369a/javav2/example_code/s3/src/main/java/com/example/s3/GeneratePresignedUrlAndPutFileWithMetadata.java) an und [testen Sie](https://github.com/awsdocs/aws-doc-sdk-examples/blob/d73001daea05266eaa9e074ccb71b9383832369a/javav2/example_code/s3/src/test/java/com/example/s3/presignurl/GeneratePresignedPutUrlTests.java) es weiter GitHub.

# Regionsübergreifender Zugriff für Amazon S3
<a name="s3-cross-region"></a>

Wenn Sie mit Amazon Simple Storage Service (Amazon S3) -Buckets arbeiten, kennen Sie normalerweise das AWS-Region für den Bucket. Die Region, mit der Sie arbeiten, wird bei der Erstellung des S3-Clients festgelegt. 

Manchmal müssen Sie jedoch möglicherweise mit einem bestimmten Bucket arbeiten, wissen aber nicht, ob sich dieser in derselben Region befindet, die für den S3-Client festgelegt ist. 

Anstatt mehr Aufrufe zu tätigen, um die Bucket-Region zu ermitteln, können Sie das SDK verwenden, um den Zugriff auf S3-Buckets in verschiedenen Regionen zu ermöglichen.

## Aufstellen
<a name="s3-cross-region-setup"></a>

Die Support für den regionsübergreifenden Zugriff wurde mit `2.20.111` der Version des SDK verfügbar. Verwenden Sie diese oder eine neuere Version in Ihrer Maven-Build-Datei für die `s3` Abhängigkeit, wie im folgenden Codeausschnitt gezeigt.

```
<dependency>
  <groupId>software.amazon.awssdk</groupId>
  <artifactId>s3</artifactId>
  <version>2.27.21</version>
</dependency>
```

Wenn Sie als Nächstes Ihren S3-Client erstellen, aktivieren Sie den regionsübergreifenden Zugriff, wie im Snippet gezeigt. Standardmäßig ist der Zugriff nicht aktiviert.

```
S3AsyncClient client = S3AsyncClient.builder()
                                    .crossRegionAccessEnabled(true)
                                    .build();
```

## Wie das SDK regionsübergreifenden Zugriff bietet
<a name="s3-cross-region-routing"></a>

Wenn Sie in einer Anfrage auf einen vorhandenen Bucket verweisen, z. B. wenn Sie die `putObject` Methode verwenden, initiiert das SDK eine Anfrage an die für den Client konfigurierte Region. 

Wenn der Bucket in dieser bestimmten Region nicht existiert, umfasst die Fehlerantwort die tatsächliche Region, in der sich der Bucket befindet. Das SDK verwendet dann in einer zweiten Anfrage die richtige Region.

Um future Anfragen an denselben Bucket zu optimieren, speichert das SDK diese Regionszuweisung im Client zwischen.

## Überlegungen
<a name="s3-cross-region-considerations"></a>

Wenn Sie den regionsübergreifenden Bucket-Zugriff aktivieren, beachten Sie, dass der erste API-Aufruf zu einer erhöhten Latenz führen kann, wenn sich der Bucket nicht in der konfigurierten Region des Clients befindet. Nachfolgende Aufrufe profitieren jedoch von zwischengespeicherten Regionsinformationen, was zu einer verbesserten Leistung führt.

Wenn Sie den regionsübergreifenden Zugriff aktivieren, wird der Zugriff auf den Bucket nicht beeinträchtigt. Der Benutzer muss berechtigt sein, auf den Bucket in der Region zuzugreifen, in der er sich befindet.

# Schutz der Datenintegrität mit Prüfsummen
<a name="s3-checksums"></a>

Amazon Simple Storage Service (Amazon S3) bietet die Möglichkeit, beim Hochladen eines Objekts eine Prüfsumme anzugeben. Wenn Sie eine Prüfsumme angeben, wird diese zusammen mit dem Objekt gespeichert und kann beim Herunterladen des Objekts überprüft werden.

Prüfsummen bieten eine zusätzliche Ebene der Datenintegrität bei der Übertragung von Dateien. Mit Prüfsummen können Sie die Datenkonsistenz überprüfen, indem Sie sicherstellen, dass die empfangene Datei mit der Originaldatei übereinstimmt. Weitere Informationen zu Prüfsummen mit Amazon S3 finden Sie im [Amazon Simple Storage Service-Benutzerhandbuch](https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html), einschließlich der [unterstützten Algorithmen](https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#using-additional-checksums).

Sie haben die Flexibilität, den Algorithmus auszuwählen, der Ihren Anforderungen am besten entspricht, und das SDK die Prüfsumme berechnen zu lassen. Alternativ können Sie mithilfe eines der unterstützten Algorithmen einen vorab berechneten Prüfsummenwert angeben. 

**Anmerkung**  
Ab Version 2.30.0 von bietet das SDK standardmäßige Integritätsschutzmaßnahmen AWS SDK for Java 2.x, indem es automatisch eine Prüfsumme für Uploads berechnet. `CRC32` Das SDK berechnet diese Prüfsumme, wenn Sie keinen vorab berechneten Prüfsummenwert angeben oder wenn Sie keinen Algorithmus angeben, den das SDK zur Berechnung einer Prüfsumme verwenden soll.   
[Das SDK bietet auch globale Einstellungen für den Schutz der Datenintegrität, die Sie extern festlegen können. Weitere Informationen finden Sie im Referenzhandbuch und im Tools-Referenzhandbuch.AWS SDKs ](https://docs.aws.amazon.com/sdkref/latest/guide/feature-dataintegrity.html)

Wir behandeln Prüfsummen in zwei Anforderungsphasen: beim Hochladen eines Objekts und beim Herunterladen eines Objekts. 

## Hochladen eines Objekts
<a name="use-service-S3-checksum-upload"></a>

 Wenn Sie ein Objekt mit der `putObject` Methode hochladen und einen Prüfsummenalgorithmus bereitstellen, berechnet das SDK die Prüfsumme für den angegebenen Algorithmus. 

Der folgende Codeausschnitt zeigt eine Anfrage zum Hochladen eines Objekts mit einer Prüfsumme. `SHA256` Wenn das SDK die Anfrage sendet, berechnet es die `SHA256` Prüfsumme und lädt das Objekt hoch. Amazon S3 validiert die Integrität des Inhalts, indem es die Prüfsumme berechnet und mit der vom SDK bereitgestellten Prüfsumme vergleicht. Amazon S3 speichert dann die Prüfsumme mit dem Objekt.

```
public void putObjectWithChecksum() {
        s3Client.putObject(b -> b
                .bucket(bucketName)
                .key(key)
                .checksumAlgorithm(ChecksumAlgorithm.SHA256),
            RequestBody.fromString("This is a test"));
}
```

Wenn Sie mit der Anfrage keinen Prüfsummenalgorithmus angeben, variiert das Prüfsummenverhalten je nach der Version des verwendeten SDK, wie in der folgenden Tabelle dargestellt.

**Prüfsummenverhalten, wenn kein Prüfsummenalgorithmus bereitgestellt wird**


| Java-SDK-Version | Verhalten der Prüfsumme | 
| --- | --- | 
| früher als 2.30.0 | Das SDK berechnet nicht automatisch eine CRC-basierte Prüfsumme und gibt sie in der Anfrage an. | 
| 2.30.0 oder später | Das SDK verwendet den `CRC32` Algorithmus zur Berechnung der Prüfsumme und stellt sie in der Anfrage bereit. Amazon S3 validiert die Integrität der Übertragung, indem es seine eigene `CRC32` Prüfsumme berechnet und sie mit der vom SDK bereitgestellten Prüfsumme vergleicht. Wenn die Prüfsummen übereinstimmen, wird die Prüfsumme zusammen mit dem Objekt gespeichert. | 

### Verwenden Sie einen vorberechneten Prüfsummenwert
<a name="use-service-S3-checksum-upload-pre"></a>

Ein mit der Anfrage bereitgestellter vorberechneter Prüfsummenwert deaktiviert die automatische Berechnung durch das SDK und verwendet stattdessen den angegebenen Wert.

Das folgende Beispiel zeigt eine Anfrage mit einer vorberechneten Prüfsumme. SHA256

```
    public void putObjectWithPrecalculatedChecksum(String filePath) {
        String checksum = calculateChecksum(filePath, "SHA-256");

        s3Client.putObject((b -> b
                .bucket(bucketName)
                .key(key)
                .checksumSHA256(checksum)),
            RequestBody.fromFile(Paths.get(filePath)));
    }
```

Wenn Amazon S3 feststellt, dass der Prüfsummenwert für den angegebenen Algorithmus falsch ist, gibt der Service eine Fehlerantwort zurück.

### Mehrteilige Uploads
<a name="use-service-S3-checksum-upload-multi"></a>

Sie können Prüfsummen auch bei mehrteiligen Uploads verwenden.

 Das SDK for Java 2.x bietet zwei Optionen zur Verwendung von Prüfsummen bei mehrteiligen Uploads. Die erste Option verwendet die. `S3TransferManager` 

Das folgende Transfer-Manager-Beispiel spezifiziert den SHA1 Algorithmus für den Upload.

```
    public void multipartUploadWithChecksumTm(String filePath) {
        S3TransferManager transferManager = S3TransferManager.create();
        UploadFileRequest uploadFileRequest = UploadFileRequest.builder()
            .putObjectRequest(b -> b
                .bucket(bucketName)
                .key(key)
                .checksumAlgorithm(ChecksumAlgorithm.SHA1))
            .source(Paths.get(filePath))
            .build();
        FileUpload fileUpload = transferManager.uploadFile(uploadFileRequest);
        fileUpload.completionFuture().join();
        transferManager.close();
    }
```

Wenn Sie bei der Verwendung des Transfer-Managers für Uploads keinen Prüfsummenalgorithmus angeben, berechnet das SDK automatisch eine Prüfsumme auf der Grundlage des Algorithmus. `CRC32` Das SDK führt diese Berechnung für alle Versionen des SDK durch.

Die zweite Option verwendet die [`S3Client`API](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/S3Client.html) (oder die [`S3AsyncClient`API](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/S3AsyncClient.html)), um den mehrteiligen Upload durchzuführen. Wenn Sie bei diesem Ansatz eine Prüfsumme angeben, müssen Sie den Algorithmus angeben, der bei der Initiierung des Uploads verwendet werden soll. Sie müssen auch den Algorithmus für jede Teilanforderung angeben und die für jedes Teil nach dem Hochladen berechnete Prüfsumme bereitstellen.

```
    public void multipartUploadWithChecksumS3Client(String filePath) {
        ChecksumAlgorithm algorithm = ChecksumAlgorithm.CRC32;

        // Initiate the multipart upload.
        CreateMultipartUploadResponse createMultipartUploadResponse = s3Client.createMultipartUpload(b -> b
            .bucket(bucketName)
            .key(key)
            .checksumAlgorithm(algorithm)); // Checksum specified on initiation.
        String uploadId = createMultipartUploadResponse.uploadId();

        // Upload the parts of the file.
        int partNumber = 1;
        List<CompletedPart> completedParts = new ArrayList<>();
        ByteBuffer bb = ByteBuffer.allocate(1024 * 1024 * 5); // 5 MB byte buffer

        try (RandomAccessFile file = new RandomAccessFile(filePath, "r")) {
            long fileSize = file.length();
            long position = 0;
            while (position < fileSize) {
                file.seek(position);
                long read = file.getChannel().read(bb);

                bb.flip(); // Swap position and limit before reading from the buffer.
                UploadPartRequest uploadPartRequest = UploadPartRequest.builder()
                    .bucket(bucketName)
                    .key(key)
                    .uploadId(uploadId)
                    .checksumAlgorithm(algorithm) // Checksum specified on each part.
                    .partNumber(partNumber)
                    .build();

                UploadPartResponse partResponse = s3Client.uploadPart(
                    uploadPartRequest,
                    RequestBody.fromByteBuffer(bb));

                CompletedPart part = CompletedPart.builder()
                    .partNumber(partNumber)
                    .checksumCRC32(partResponse.checksumCRC32()) // Provide the calculated checksum.
                    .eTag(partResponse.eTag())
                    .build();
                completedParts.add(part);

                bb.clear();
                position += read;
                partNumber++;
            }
        } catch (IOException e) {
            System.err.println(e.getMessage());
        }

        // Complete the multipart upload.
        s3Client.completeMultipartUpload(b -> b
            .bucket(bucketName)
            .key(key)
            .uploadId(uploadId)
            .multipartUpload(CompletedMultipartUpload.builder().parts(completedParts).build()));
    }
```

Der [Code für die vollständigen Beispiele](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javav2/example_code/s3/src/main/java/com/example/s3/PerformMultiPartUpload.java) und [Tests befindet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javav2/example_code/s3/src/test/java/com/example/s3/PerformMultiPartUploadTests.java) sich im GitHub Codebeispiel-Repository.

## Herunterladen eines Objekts
<a name="use-service-S3-checksum-download"></a>

Wenn Sie die [https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/S3Client.html#getObject(software.amazon.awssdk.services.s3.model.GetObjectRequest)](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/S3Client.html#getObject(software.amazon.awssdk.services.s3.model.GetObjectRequest)) verwenden, um ein Objekt herunterzuladen, validiert das SDK automatisch die Prüfsumme, . `ChecksumMode` `enabled` wenn die `checksumMode` Methode des Builders für auf gesetzt ist. `GetObjectRequest` `ChecksumMode.ENABLED` 

Die Anfrage im folgenden Codeausschnitt weist das SDK an, die Prüfsumme in der Antwort zu validieren, indem es die Prüfsumme berechnet und die Werte vergleicht.

```
    public GetObjectResponse getObjectWithChecksum() {
        return s3Client.getObject(b -> b
                        .bucket(bucketName)
                        .key(key)
                        .checksumMode(ChecksumMode.ENABLED))
                .response();
    }
```

**Anmerkung**  
Wenn das Objekt nicht mit einer Prüfsumme hochgeladen wurde, findet keine Überprüfung statt. 

## Andere Optionen zur Berechnung der Prüfsumme
<a name="S3-checsum-calculation-options"></a>

**Anmerkung**  
Um die Datenintegrität der übertragenen Daten zu überprüfen und etwaige Übertragungsfehler zu identifizieren, empfehlen wir Benutzern, die SDK-Standardeinstellungen für die Optionen zur Berechnung der Prüfsumme beizubehalten. Standardmäßig fügt das SDK diese wichtige Prüfung für viele S3-Operationen hinzu, einschließlich `PutObject` und`GetObject`.

Wenn Ihre Verwendung von Amazon S3 jedoch nur eine minimale Prüfsummenvalidierung erfordert, können Sie viele Prüfungen deaktivieren, indem Sie die Standardkonfigurationseinstellungen ändern. 

### Deaktivieren Sie die automatische Prüfsummenberechnung, sofern sie nicht erforderlich ist
<a name="S3-minimize-checksum-calc-global"></a>

Sie können die automatische Prüfsummenberechnung durch das SDK für Operationen deaktivieren, die sie unterstützen, z. B. `PutObject` und. `GetObject` Einige S3-Operationen erfordern jedoch eine Prüfsummenberechnung. Sie können die Prüfsummenberechnung für diese Operationen nicht deaktivieren.

Das SDK bietet separate Einstellungen für die Berechnung einer Prüfsumme für die Nutzlast einer Anfrage und für die Nutzlast einer Antwort.

In der folgenden Liste werden die Einstellungen beschrieben, die Sie verwenden können, um die Prüfsummenberechnungen in den verschiedenen Bereichen zu minimieren.
+ **Geltungsbereich für alle Anwendungen** — Wenn Sie die Einstellungen in Umgebungsvariablen oder in einem Profil in den gemeinsam genutzten AWS `config` `credentials` Dateien ändern, können alle Anwendungen diese Einstellungen verwenden. Diese Einstellungen wirken sich auf alle Service-Clients in allen AWS SDK-Anwendungen aus, sofern sie nicht im Anwendungs- oder Service-Client-Bereich außer Kraft gesetzt werden.
  + Fügen Sie die Einstellungen zu einem Profil hinzu:

    ```
    [default]
    request_checksum_calculation = WHEN_REQUIRED
    response_checksum_validation = WHEN_REQUIRED
    ```
  + Umgebungsvariablen hinzufügen:

    ```
    AWS_REQUEST_CHECKSUM_CALCULATION=WHEN_REQUIRED
    AWS_RESPONSE_CHECKSUM_VALIDATION=WHEN_REQUIRED
    ```
+ **Aktueller Anwendungsbereich** — Sie können die Java-Systemeigenschaft auf einstellen, `aws.requestChecksumCalculation` `WHEN_REQUIRED` um die Prüfsummenberechnung einzuschränken. Die entsprechende Systemeigenschaft für Antworten ist. `aws.responseChecksumValidation`

  Diese Einstellungen wirken sich auf alle SDK-Dienstclients in der Anwendung aus, sofern sie nicht bei der Erstellung des Dienstclients außer Kraft gesetzt werden.

  Stellen Sie die Systemeigenschaft zu Beginn Ihrer Anwendung ein:

  ```
  import software.amazon.awssdk.core.SdkSystemSetting;
  import software.amazon.awssdk.core.checksums.RequestChecksumCalculation;
  import software.amazon.awssdk.core.checksums.ResponseChecksumValidation;
  import software.amazon.awssdk.services.s3.S3Client;
  
  class DemoClass {
      public static void main(String[] args) {
  
          System.setProperty(SdkSystemSetting.AWS_REQUEST_CHECKSUM_CALCULATION.property(), // Resolves to "aws.requestChecksumCalculation".
                  "WHEN_REQUIRED");
          System.setProperty(SdkSystemSetting.AWS_RESPONSE_CHECKSUM_VALIDATION.property(), // Resolves to "aws.responseChecksumValidation".
                  "WHEN_REQUIRED");
  
          S3Client s3Client = S3Client.builder().build();
  
          // Use s3Client.
      }
  }
  ```
+ **Einzelner S3-Dienstclientbereich** — Sie können einen einzelnen S3-Serviceclient so konfigurieren, dass er mithilfe von Builder-Methoden die Mindestanzahl an Prüfsummen berechnet:

  ```
  import software.amazon.awssdk.core.checksums.RequestChecksumCalculation;
  import software.amazon.awssdk.services.s3.S3Client;
  
  public class RequiredChecksums {
      public static void main(String[] args) {
          S3Client s3 = S3Client.builder()
                  .requestChecksumCalculation(RequestChecksumCalculation.WHEN_REQUIRED)
                  .responseChecksumValidation(ResponseChecksumValidation.WHEN_REQUIRED)
                  .build();
  
          // Use s3Client. 
      }
  // ...
  }
  ```

### Verwenden Sie aus Gründen der `LegacyMd5Plugin` vereinfachten Kompatibilität MD5
<a name="S3-checksum-legacy-md5"></a>

Mit der Veröffentlichung des CRC32 Prüfsummenverhaltens in Version 2.30.0 hat das SDK die Berechnung von MD5 Prüfsummen für erforderliche Operationen eingestellt.

Wenn Sie ein veraltetes MD5 Prüfsummenverhalten für S3-Operationen benötigen, können Sie das verwenden`LegacyMd5Plugin`, das mit Version 2.31.32 des SDK veröffentlicht wurde.

Dies `LegacyMd5Plugin` ist besonders nützlich, wenn Sie die Kompatibilität mit Anwendungen aufrechterhalten müssen, die vom alten MD5 Prüfsummenverhalten abhängen, insbesondere wenn Sie mit S3-kompatiblen Speicheranbietern von Drittanbietern arbeiten, z. B. solchen, die mit S3A-Dateisystem-Konnektoren (Apache Spark, Iceberg) verwendet werden.

Um das zu verwenden`LegacyMd5Plugin`, fügen Sie es Ihrem S3-Client-Builder hinzu:

```
// For synchronous S3 client.
S3Client s3Client = S3Client.builder()
                           .addPlugin(LegacyMd5Plugin.create())
                           .build();

// For asynchronous S3 client.
S3AsyncClient asyncClient = S3AsyncClient.builder()
                                       .addPlugin(LegacyMd5Plugin.create())
                                       .build();
```

Wenn Sie den Vorgängen, die MD5 Prüfsummen erfordern, Prüfsummen hinzufügen und das Hinzufügen von SDK-Standardprüfsummen für Operationen, die Prüfsummen unterstützen, aber nicht erforderlich sind, überspringen möchten, können Sie die `ClientBuilder` Optionen und als aktivieren. `requestChecksumCalculation` `responseChecksumValidation` `WHEN_REQUIRED` Dadurch werden SDK-Standardprüfsummen nur für Operationen hinzugefügt, für die Prüfsummen erforderlich sind:

```
// Use the `LegacyMd5Plugin` with `requestChecksumCalculation` and `responseChecksumValidation` set to WHEN_REQUIRED.
S3AsyncClient asyncClient = S3AsyncClient.builder()
                                       .addPlugin(LegacyMd5Plugin.create())
                                       .requestChecksumCalculation(RequestChecksumCalculation.WHEN_REQUIRED)
                                       .responseChecksumValidation(ResponseChecksumValidation.WHEN_REQUIRED)
                                       .build();
```

Diese Konfiguration ist besonders nützlich, wenn Sie mit S3-kompatiblen Speichersystemen von Drittanbietern arbeiten, die die neueren Prüfsummenalgorithmen möglicherweise nicht vollständig unterstützen, aber dennoch Prüfsummen für bestimmte Operationen benötigen MD5 .

# Verwenden Sie einen leistungsstarken S3-Client: AWS CRT-basierter S3-Client
<a name="crt-based-s3-client"></a>

Der AWS CRT-basierte S3-Client, der auf [AWS Common Runtime (CRT)](https://docs.aws.amazon.com/sdkref/latest/guide/common-runtime.html) aufbaut, ist ein alternativer asynchroner S3-Client. Es überträgt Objekte zu und von Amazon Simple Storage Service (Amazon S3) mit verbesserter Leistung und Zuverlässigkeit, indem es automatisch die [mehrteilige Upload-API](https://docs.aws.amazon.com/AmazonS3/latest/userguide/mpuoverview.html) und [Bytebereichs-Abrufe](https://docs.aws.amazon.com/AmazonS3/latest/userguide/optimizing-performance-guidelines.html#optimizing-performance-guidelines-get-range) von Amazon S3 verwendet. 

Der AWS CRT-basierte S3-Client verbessert die Zuverlässigkeit der Übertragung im Falle eines Netzwerkausfalls. Die Zuverlässigkeit wird verbessert, indem einzelne fehlgeschlagene Teile einer Dateiübertragung erneut versucht werden, ohne die Übertragung von vorne neu zu starten.

Darüber hinaus bietet der AWS CRT-basierte S3-Client ein erweitertes Verbindungspooling und einen DNS-Lastenausgleich (Domain Name System), wodurch auch der Durchsatz verbessert wird.

Sie können den AWS CRT-basierten S3-Client anstelle des standardmäßigen asynchronen S3-Clients des SDK verwenden und sofort von seinem verbesserten Durchsatz profitieren.

**Wichtig**  
Der AWS CRT-basierte S3-Client unterstützt derzeit weder die [Erfassung von SDK-Metriken auf Client- noch auf Anforderungsebene](metrics.md).

**AWS CRT-basierte Komponenten im SDK**

Der AWS CRT-basierte *S3-Client*, der in diesem Thema beschrieben wird, und der AWS CRT-basierte *HTTP-Client* sind unterschiedliche Komponenten im SDK. 

Der **AWS CRT-basierte S3-Client** ist eine Implementierung der [AsyncClientS3-Schnittstelle](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/S3AsyncClient.html) und wird für die Arbeit mit dem Amazon S3 S3-Service verwendet. Es ist eine Alternative zur Java-basierten Implementierung der `S3AsyncClient` Schnittstelle und bietet mehrere Vorteile.

Der [AWS CRT-basierte HTTP-Client](http-configuration-crt.md) ist eine Implementierung der [SdkAsyncHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/async/SdkAsyncHttpClient.html)Schnittstelle und wird für die allgemeine HTTP-Kommunikation verwendet. Es ist eine Alternative zur Netty-Implementierung der `SdkAsyncHttpClient` Schnittstelle und bietet mehrere Vorteile.

Obwohl beide Komponenten Bibliotheken aus der [AWS Common Runtime](https://docs.aws.amazon.com/sdkref/latest/guide/common-runtime.html) verwenden, verwendet der AWS CRT-basierte S3-Client die [3-Bibliothek](https://github.com/awslabs/aws-c-s3) und unterstützt die aws-c-s [S3-Funktionen der mehrteiligen Upload-API](https://docs.aws.amazon.com/AmazonS3/latest/userguide/mpuoverview.html). Da der AWS CRT-basierte HTTP-Client für allgemeine Zwecke vorgesehen ist, unterstützt er die API-Funktionen für mehrteilige Uploads von S3 nicht.

## Fügen Sie Abhängigkeiten hinzu, um den CRT-basierten S3-Client zu verwenden AWS
<a name="crt-based-s3-client-depend"></a>

Um den AWS CRT-basierten S3-Client zu verwenden, fügen Sie Ihrer Maven-Projektdatei die folgenden beiden Abhängigkeiten hinzu. Das Beispiel zeigt die zu verwendenden Mindestversionen. Suchen Sie im zentralen Maven-Repository nach den neuesten Versionen der [s3](https://central.sonatype.com/artifact/software.amazon.awssdk/s3) - und [aws-crt-Artefakte](https://central.sonatype.com/artifact/software.amazon.awssdk.crt/aws-crt).

```
<dependency>
  <groupId>software.amazon.awssdk</groupId>
  <artifactId>s3</artifactId>
  <version>2.27.21</version>
</dependency>
<dependency>
  <groupId>software.amazon.awssdk.crt</groupId>
  <artifactId>aws-crt</artifactId>
  <version>0.30.11</version>
</dependency>
```

## Erstellen Sie eine Instanz des CRT-basierten S3-Clients AWS
<a name="crt-based-s3-client-create"></a>

 Erstellen Sie eine Instanz des AWS CRT-basierten S3-Clients mit Standardeinstellungen, wie im folgenden Codeausschnitt gezeigt.

```
S3AsyncClient s3AsyncClient = S3AsyncClient.crtCreate();
```

Verwenden Sie den CRT-Client-Builder, um den AWS Client zu konfigurieren. Sie können vom standardmäßigen asynchronen S3-Client zum AWS CRT-basierten Client wechseln, indem Sie die Builder-Methode ändern.

```
import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.s3.S3AsyncClient;


S3AsyncClient s3AsyncClient = 
        S3AsyncClient.crtBuilder()
                     .credentialsProvider(DefaultCredentialsProvider.create())
                     .region(Region.US_WEST_2)
                     .targetThroughputInGbps(20.0)
                     .minimumPartSizeInBytes(8 * 1025 * 1024L)
                     .build();
```

**Anmerkung**  
Einige Einstellungen im Standard-Builder werden derzeit möglicherweise nicht im AWS CRT-Client-Builder unterstützt. Rufen `S3AsyncClient#builder()` Sie den Standard Builder an.

## Verwenden Sie den AWS CRT-basierten S3-Client
<a name="crt-based-s3-client-use"></a>

Verwenden Sie den AWS CRT-basierten S3-Client, um Amazon S3 S3-API-Operationen aufzurufen. Das folgende Beispiel zeigt die [GetObject](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/S3AsyncClient.html#getObject(java.util.function.Consumer,software.amazon.awssdk.core.async.AsyncResponseTransformer))Operationen [PutObject](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/S3AsyncClient.html#putObject(java.util.function.Consumer,software.amazon.awssdk.core.async.AsyncRequestBody))und, die über die verfügbar sind. AWS SDK für Java

```
import software.amazon.awssdk.core.async.AsyncRequestBody;
import software.amazon.awssdk.core.async.AsyncResponseTransformer;
import software.amazon.awssdk.services.s3.S3AsyncClient;
import software.amazon.awssdk.services.s3.model.GetObjectResponse;
import software.amazon.awssdk.services.s3.model.PutObjectResponse;


S3AsyncClient s3Client = S3AsyncClient.crtCreate();

// Upload a local file to Amazon S3.
PutObjectResponse putObjectResponse = 
      s3Client.putObject(req -> req.bucket(<BUCKET_NAME>)
                                   .key(<KEY_NAME>),
                        AsyncRequestBody.fromFile(Paths.get(<FILE_NAME>)))
              .join();

// Download an object from Amazon S3 to a local file.
GetObjectResponse getObjectResponse = 
      s3Client.getObject(req -> req.bucket(<BUCKET_NAME>)
                                   .key(<KEY_NAME>),
                        AsyncResponseTransformer.toFile(Paths.get(<FILE_NAME>)))
              .join();
```

## Streams unbekannter Größe werden hochgeladen
<a name="crt-stream-unknown-size"></a>

Ein wesentlicher Vorteil des AWS AWS CRT-basierten S3-Clients ist seine Fähigkeit, Eingabestreams unbekannter Größe effizient zu verarbeiten. Dies ist besonders nützlich, wenn Sie Daten aus einer Quelle hochladen müssen, bei der die Gesamtgröße nicht im Voraus bestimmt werden kann.

```
public PutObjectResponse crtClient_stream_unknown_size(String bucketName, String key, InputStream inputStream) {

    S3AsyncClient s3AsyncClient = S3AsyncClient.crtCreate();
    ExecutorService executor = Executors.newSingleThreadExecutor();
    AsyncRequestBody body = AsyncRequestBody.fromInputStream(inputStream, null, executor);  // 'null' indicates that the
                                                                                            // content length is unknown.
    CompletableFuture<PutObjectResponse> responseFuture =
            s3AsyncClient.putObject(r -> r.bucket(bucketName).key(key), body)
                    .exceptionally(e -> {
                        if (e != null){
                            logger.error(e.getMessage(), e);
                        }
                        return null;
                    });

    PutObjectResponse response = responseFuture.join(); // Wait for the response.
    executor.shutdown();
    return response;
}
```

Diese Funktion hilft dabei, häufig auftretende Probleme bei herkömmlichen Uploads zu vermeiden, bei denen eine falsche Angabe der Inhaltslänge zu verkürzten Objekten oder fehlgeschlagenen Uploads führen kann.

## Einschränkungen der Konfiguration
<a name="crt-based-s3-client-limitations"></a>

Der AWS CRT-basierte S3-Client und der Java-basierte asynchrone S3-Client [bieten vergleichbare Funktionen, wobei der CRT-basierte S3-Client einen](examples-s3.md#s3-clients) Leistungsvorteil bietet. AWS Dem AWS CRT-basierten S3-Client fehlen jedoch die Konfigurationseinstellungen, über die der Java-basierte asynchrone S3-Client verfügt. Diese Einstellungen umfassen Folgendes:
+ *Konfiguration auf Clientebene:* Timeout für API-Aufrufversuche, Interzeptoren für die Ausführung von Komprimierung, Herausgeber von Metriken, benutzerdefinierte Ausführungsattribute, benutzerdefinierte erweiterte Optionen, benutzerdefinierter geplanter Ausführungsdienst, benutzerdefinierte Header
+ *Konfiguration auf Anforderungsebene*: benutzerdefinierte Unterzeichner, Timeout für API-Aufrufversuche

Eine vollständige Liste der Konfigurationsunterschiede finden Sie in der API-Referenz.


| Java-basierter asynchroner S3-Client | AWS CRT-basierter S3-Client | 
| --- | --- | 
| Konfigurationen auf Client-Ebene[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sdk-for-java/latest/developer-guide/crt-based-s3-client.html)Konfigurationen auf Anforderungsebene[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sdk-for-java/latest/developer-guide/crt-based-s3-client.html) | Konfigurationen auf Client-Ebene[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sdk-for-java/latest/developer-guide/crt-based-s3-client.html)Konfigurationen auf Anforderungsebene[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sdk-for-java/latest/developer-guide/crt-based-s3-client.html) | 

# Konfigurieren Sie den Java-basierten asynchronen S3-Client für parallel Übertragungen
<a name="s3-async-client-multipart"></a>

Seit Version 2.27.5 unterstützt der standardmäßige Java-basierte S3-Async-Client automatische parallel Übertragungen (mehrteilige Uploads und Downloads). Sie konfigurieren die Unterstützung für parallel Übertragungen, wenn Sie den Java-basierten asynchronen S3-Client erstellen. 

In diesem Abschnitt wird gezeigt, wie parallel Übertragungen aktiviert und die Konfiguration angepasst werden.

## Erstellen Sie eine Instanz von `S3AsyncClient`
<a name="s3-async-client-multipart-create"></a>

Wenn Sie eine `S3AsyncClient` Instanz erstellen, ohne eine der `multipart*` Methoden auf dem [Builder](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/S3AsyncClientBuilder.html) aufzurufen, sind parallel Übertragungen nicht aktiviert. Jede der folgenden Anweisungen erstellt einen Java-basierten asynchronen S3-Client ohne Unterstützung für mehrteilige Uploads und Downloads.

### *Ohne mehrteilige Unterstützung erstellen*
<a name="s3-async-client-mp-off"></a>

**Example**  

```
import software.amazon.awssdk.auth.credentials.ProcessCredentialsProvider;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.s3.S3AsyncClient;


S3AsyncClient s3Client = S3AsyncClient.create();

S3AsyncClient s3Client2 = S3AsyncClient.builder().build();

S3AsyncClient s3Client3 = S3AsyncClient.builder()
        .credentialsProvider(ProcessCredentialsProvider.builder().build())
        .region(Region.EU_NORTH_1)
        .build();
```

### Erstellen Sie *mit mehrteiliger* Unterstützung
<a name="s3-async-client-mp-on"></a>

Um parallel Übertragungen mit Standardeinstellungen zu aktivieren, rufen Sie den `multipartEnabled` On the Builder auf und übergeben Sie ihn, `true` wie im folgenden Beispiel gezeigt.

**Example**  

```
S3AsyncClient s3AsyncClient2 = S3AsyncClient.builder()
        .multipartEnabled(true)
        .build();
```

Der Standardwert ist 8 MiB für die `minimumPartSizeInBytes` Einstellungen `thresholdInBytes` und.

Wenn Sie die Multipart-Einstellungen anpassen, werden parallel Übertragungen automatisch aktiviert, wie im Folgenden gezeigt.

**Example**  

```
import software.amazon.awssdk.services.s3.S3AsyncClient;
import static software.amazon.awssdk.transfer.s3.SizeConstant.MB;


S3AsyncClient s3AsyncClient2 = S3AsyncClient.builder()
        .multipartConfiguration(b -> b
                .thresholdInBytes(16 * MB)
                .minimumPartSizeInBytes(10 * MB))
        .build();
```

## Streams unbekannter Größe werden hochgeladen
<a name="java-async-client-stream-unknown-size"></a>

Der Java-basierte asynchrone S3-Client mit aktiviertem Multipart kann Eingabestreams effizient verarbeiten, bei denen die Gesamtgröße nicht im Voraus bekannt ist:

```
public PutObjectResponse asyncClient_multipart_stream_unknown_size(String bucketName, String key, InputStream inputStream) {

    S3AsyncClient s3AsyncClient = S3AsyncClient.builder().multipartEnabled(true).build();
    ExecutorService executor = Executors.newSingleThreadExecutor();
    AsyncRequestBody body = AsyncRequestBody.fromInputStream(inputStream, null, executor); // 'null' indicates that the
                                                                                           // content length is unknown.
    CompletableFuture<PutObjectResponse> responseFuture =
            s3AsyncClient.putObject(r -> r.bucket(bucketName).key(key), body)
                    .exceptionally(e -> {
                        if (e != null) {
                            logger.error(e.getMessage(), e);
                        }
                        return null;
                    });

    PutObjectResponse response = responseFuture.join(); // Wait for the response.
    executor.shutdown();
    return response;
}
```

Dieser Ansatz verhindert Probleme, die auftreten können, wenn manuell eine falsche Inhaltslänge angegeben wird, wie z. B. gekürzte Objekte oder fehlgeschlagene Uploads.

# Dateien und Verzeichnisse mit dem Amazon S3 Transfer Manager übertragen
<a name="transfer-manager"></a>

Der Amazon S3 Transfer Manager ist ein Open-Source-Hilfsprogramm zur Dateiübertragung auf hohem Niveau für AWS SDK for Java 2.x. Verwenden Sie es, um Dateien und Verzeichnisse zu und von Amazon Simple Storage Service (Amazon S3) zu übertragen. 

[Wenn der [S3 Transfer Manager auf dem AWS CRT-basierten S3-Client](crt-based-s3-client.md) oder dem [standardmäßigen Java-basierten asynchronen S3-Client mit aktiviertem Multipart](s3-async-client-multipart.md) aufbaut, kann er Leistungsverbesserungen wie die [mehrteilige](https://docs.aws.amazon.com/AmazonS3/latest/userguide/mpuoverview.html) Upload-API und Abrufe im Bytebereich nutzen.](https://docs.aws.amazon.com/AmazonS3/latest/userguide/optimizing-performance-guidelines.html#optimizing-performance-guidelines-get-range) 

Mit dem S3 Transfer Manager können Sie auch den Fortschritt einer Übertragung in Echtzeit überwachen und die Übertragung für eine spätere Ausführung unterbrechen.

## Erste Schritte
<a name="transfer-manager-prerequisites"></a>

### Fügen Sie Ihrer Build-Datei Abhängigkeiten hinzu
<a name="transfer-manager-add-dependency"></a>

Um den S3 Transfer Manager mit verbesserter Mehrteile-Leistung zu verwenden, konfigurieren Sie Ihre Build-Datei mit den erforderlichen Abhängigkeiten.

------
#### [ Use the AWS CRT-based S3 client ]

```
<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>software.amazon.awssdk</groupId>
            <artifactId>bom</artifactId>
            <version>2.27.211</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>
<dependencies>
    <dependency>
        <groupId>software.amazon.awssdk</groupId>
        <artifactId>s3-transfer-manager</artifactId>
    </dependency>
    <dependency>
        <groupId>software.amazon.awssdk.crt</groupId>
        <artifactId>aws-crt</artifactId>
        <version>0.29.1432</version>
    </dependency>
</dependencies>
```

1 [Letzte Version](https://central.sonatype.com/artifact/software.amazon.awssdk/bom). 2 [Letzte Version](https://central.sonatype.com/artifact/software.amazon.awssdk.crt/aws-crt).

------
#### [ Use the Java-based S3 async client ]

```
<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>software.amazon.awssdk</groupId>
            <artifactId>bom</artifactId>
            <version>2.27.211</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>
<dependencies>
    <dependency>
        <groupId>software.amazon.awssdk</groupId>
        <artifactId>s3-transfer-manager</artifactId>
    </dependency>
</dependencies>
```

1 [Letzte Version](https://central.sonatype.com/artifact/software.amazon.awssdk/bom).

------

### Erstellen Sie eine Instanz des S3 Transfer Managers
<a name="transfer-manager-create"></a>

Um die parallel Übertragung zu aktivieren, müssen Sie einen AWS CRT-basierten S3-Client ODER einen Java-basierten asynchronen S3-Client mit aktiviertem Multipart übergeben. Die folgenden Beispiele zeigen, wie Sie einen S3 Transfer Manager mit benutzerdefinierten Einstellungen konfigurieren. 

------
#### [ Use the AWS CRT-based S3 client ]

```
        S3AsyncClient s3AsyncClient = S3AsyncClient.crtBuilder()
                .credentialsProvider(DefaultCredentialsProvider.create())
                .region(Region.US_EAST_1)
                .targetThroughputInGbps(20.0)
                .minimumPartSizeInBytes(8 * MB)
                .build();

        S3TransferManager transferManager = S3TransferManager.builder()
                .s3Client(s3AsyncClient)
                .build();
```

------
#### [ Use the Java-based S3 async client ]

Wenn die `aws-crt` Abhängigkeit nicht in der Build-Datei enthalten ist, baut der S3 Transfer Manager auf dem standardmäßigen Java-basierten asynchronen S3-Client auf, der im SDK for Java 2.x verwendet wird. 

**Benutzerdefinierte Konfiguration des S3-Clients — Multipart muss aktiviert sein**

```
        S3AsyncClient s3AsyncClient = S3AsyncClient.builder()
                .multipartEnabled(true)
                .credentialsProvider(DefaultCredentialsProvider.create())
                .region(Region.US_EAST_1)
                .build();

        S3TransferManager transferManager = S3TransferManager.builder()
                .s3Client(s3AsyncClient)
                .build();
```

**Keine Konfiguration des S3-Clients — Multipart-Support wird automatisch aktiviert**

```
S3TransferManager transferManager = S3TransferManager.create();
```

------

## Laden Sie eine Datei in einen S3-Bucket hoch
<a name="transfer-manager-upload"></a>

Das folgende Beispiel zeigt ein Beispiel für den Datei-Upload zusammen mit der optionalen Verwendung von a [LoggingTransferListener](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/transfer/s3/progress/LoggingTransferListener.html), das den Fortschritt des Uploads protokolliert.

Um eine Datei mit dem S3 Transfer Manager auf Amazon S3 hochzuladen, übergeben Sie ein [https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/transfer/s3/model/UploadFileRequest.html](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/transfer/s3/model/UploadFileRequest.html)Objekt an die [UploadFile-Methode `S3TransferManager`](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/transfer/s3/S3TransferManager.html#uploadFile(software.amazon.awssdk.transfer.s3.model.UploadFileRequest)) von.

Das von der `uploadFile` Methode zurückgegebene [FileUpload](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/transfer/s3/model/FileUpload.html)Objekt repräsentiert den Upload-Vorgang. Nach Abschluss der Anfrage enthält das [CompletedFileUpload](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/transfer/s3/model/CompletedFileUpload.html)Objekt Informationen über den Upload.

```
    public void trackUploadFile(S3TransferManager transferManager, String bucketName,
                             String key, URI filePathURI) {
        UploadFileRequest uploadFileRequest = UploadFileRequest.builder()
                .putObjectRequest(b -> b.bucket(bucketName).key(key))
                .addTransferListener(LoggingTransferListener.create())  // Add listener.
                .source(Paths.get(filePathURI))
                .build();

        FileUpload fileUpload = transferManager.uploadFile(uploadFileRequest);

        fileUpload.completionFuture().join();
        /*
            The SDK provides a LoggingTransferListener implementation of the TransferListener interface.
            You can also implement the interface to provide your own logic.

            Configure log4J2 with settings such as the following.
                <Configuration status="WARN">
                    <Appenders>
                        <Console name="AlignedConsoleAppender" target="SYSTEM_OUT">
                            <PatternLayout pattern="%m%n"/>
                        </Console>
                    </Appenders>

                    <Loggers>
                        <logger name="software.amazon.awssdk.transfer.s3.progress.LoggingTransferListener" level="INFO" additivity="false">
                            <AppenderRef ref="AlignedConsoleAppender"/>
                        </logger>
                    </Loggers>
                </Configuration>

            Log4J2 logs the progress. The following is example output for a 21.3 MB file upload.
                Transfer initiated...
                |                    | 0.0%
                |====                | 21.1%
                |============        | 60.5%
                |====================| 100.0%
                Transfer complete!
        */
    }
```

### Importe
<a name="transfer-manager-upload-imports"></a>

```
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import software.amazon.awssdk.transfer.s3.S3TransferManager;
import software.amazon.awssdk.transfer.s3.model.CompletedFileUpload;
import software.amazon.awssdk.transfer.s3.model.FileUpload;
import software.amazon.awssdk.transfer.s3.model.UploadFileRequest;
import software.amazon.awssdk.transfer.s3.progress.LoggingTransferListener;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;
import java.nio.file.Paths;
import java.util.UUID;
```

## Laden Sie eine Datei aus einem S3-Bucket herunter
<a name="transfer-manager-download"></a>

Das folgende Beispiel zeigt ein Download-Beispiel zusammen mit der optionalen Verwendung von a [LoggingTransferListener](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/transfer/s3/progress/LoggingTransferListener.html), das den Fortschritt des Downloads protokolliert.

Um ein Objekt mit dem S3 Transfer Manager aus einem S3-Bucket herunterzuladen, erstellen Sie ein [DownloadFileRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/transfer/s3/model/DownloadFileRequest.html)Objekt und übergeben es an die Methode [DownloadFile](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/transfer/s3/S3TransferManager.html#downloadFile(software.amazon.awssdk.transfer.s3.model.DownloadFileRequest)).

Das von der `S3TransferManager` `downloadFile` Methode zurückgegebene [FileDownload](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/transfer/s3/model/FileDownload.html)Objekt stellt die Dateiübertragung dar. Nach Abschluss des Downloads [CompletedFileDownload](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/transfer/s3/model/CompletedFileDownload.html)enthält der Zugriff auf Informationen über den Download.

```
    public void trackDownloadFile(S3TransferManager transferManager, String bucketName,
                             String key, String downloadedFileWithPath) {
        DownloadFileRequest downloadFileRequest = DownloadFileRequest.builder()
                .getObjectRequest(b -> b.bucket(bucketName).key(key))
                .addTransferListener(LoggingTransferListener.create())  // Add listener.
                .destination(Paths.get(downloadedFileWithPath))
                .build();

        FileDownload downloadFile = transferManager.downloadFile(downloadFileRequest);

        CompletedFileDownload downloadResult = downloadFile.completionFuture().join();
        /*
            The SDK provides a LoggingTransferListener implementation of the TransferListener interface.
            You can also implement the interface to provide your own logic.

            Configure log4J2 with settings such as the following.
                <Configuration status="WARN">
                    <Appenders>
                        <Console name="AlignedConsoleAppender" target="SYSTEM_OUT">
                            <PatternLayout pattern="%m%n"/>
                        </Console>
                    </Appenders>

                    <Loggers>
                        <logger name="software.amazon.awssdk.transfer.s3.progress.LoggingTransferListener" level="INFO" additivity="false">
                            <AppenderRef ref="AlignedConsoleAppender"/>
                        </logger>
                    </Loggers>
                </Configuration>

            Log4J2 logs the progress. The following is example output for a 21.3 MB file download.
                Transfer initiated...
                |=======             | 39.4%
                |===============     | 78.8%
                |====================| 100.0%
                Transfer complete!
        */
    }
```

### Importe
<a name="transfer-manager-download-import"></a>

```
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import software.amazon.awssdk.core.exception.SdkException;
import software.amazon.awssdk.core.sync.RequestBody;
import software.amazon.awssdk.transfer.s3.S3TransferManager;
import software.amazon.awssdk.transfer.s3.model.CompletedFileDownload;
import software.amazon.awssdk.transfer.s3.model.DownloadFileRequest;
import software.amazon.awssdk.transfer.s3.model.FileDownload;
import software.amazon.awssdk.transfer.s3.progress.LoggingTransferListener;

import java.io.IOException;
import java.net.URISyntaxException;
import java.net.URL;
import java.nio.file.Files;
import java.nio.file.NoSuchFileException;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.UUID;
```

## Ein Amazon S3 S3-Objekt in einen anderen Bucket kopieren
<a name="transfer-manager-copy"></a>

Das folgende Beispiel zeigt, wie ein Objekt mit dem S3 Transfer Manager kopiert wird.

Um mit dem Kopieren eines Objekts von einem S3-Bucket in einen anderen Bucket zu beginnen, erstellen Sie eine [CopyObjectRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/model/CopyObjectRequest.html)Basisinstanz.

Verpacken Sie als Nächstes die Basisdatei `CopyObjectRequest` in eine [CopyRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/transfer/s3/model/CopyRequest.html), die vom S3 Transfer Manager verwendet werden kann. 

Das von der `S3TransferManager` `copy` Methode zurückgegebene `Copy` Objekt stellt den Kopiervorgang dar. Nach Abschluss des Kopiervorgangs enthält das [CompletedCopy](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/transfer/s3/model/CompletedCopy.html)Objekt Details zur Antwort.

```
    public String copyObject(S3TransferManager transferManager, String bucketName,
            String key, String destinationBucket, String destinationKey) {
        CopyObjectRequest copyObjectRequest = CopyObjectRequest.builder()
                .sourceBucket(bucketName)
                .sourceKey(key)
                .destinationBucket(destinationBucket)
                .destinationKey(destinationKey)
                .build();

        CopyRequest copyRequest = CopyRequest.builder()
                .copyObjectRequest(copyObjectRequest)
                .build();

        Copy copy = transferManager.copy(copyRequest);

        CompletedCopy completedCopy = copy.completionFuture().join();
        return completedCopy.response().copyObjectResult().eTag();
    }
```

**Anmerkung**  
Um eine regionsübergreifende Kopie mit dem S3 Transfer Manager durchzuführen, aktivieren Sie ihn `crossRegionAccessEnabled` auf dem AWS CRT-basierten S3-Client-Builder, wie im folgenden Codeausschnitt gezeigt.  

```
S3AsyncClient s3AsyncClient = S3AsyncClient.crtBuilder()
                .crossRegionAccessEnabled(true)
                .build();

S3TransferManager transferManager = S3TransferManager.builder()
                .s3Client(s3AsyncClient)
                .build();
```

### Importe
<a name="transfer-manager-copy-import"></a>

```
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import software.amazon.awssdk.core.sync.RequestBody;
import software.amazon.awssdk.services.s3.model.CopyObjectRequest;
import software.amazon.awssdk.transfer.s3.S3TransferManager;
import software.amazon.awssdk.transfer.s3.model.CompletedCopy;
import software.amazon.awssdk.transfer.s3.model.Copy;
import software.amazon.awssdk.transfer.s3.model.CopyRequest;

import java.util.UUID;
```

## Laden Sie ein lokales Verzeichnis in einen S3-Bucket hoch
<a name="transfer-manager-upload_directory"></a>

Das folgende Beispiel zeigt, wie Sie ein lokales Verzeichnis auf S3 hochladen können.

Rufen Sie zunächst die [UploadDirectory-Methode](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/transfer/s3/S3TransferManager.html#uploadDirectory(software.amazon.awssdk.transfer.s3.model.UploadDirectoryRequest)) der `S3TransferManager` Instanz auf und übergeben Sie eine [UploadDirectoryRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/transfer/s3/model/UploadDirectoryRequest.html).

Das [DirectoryUpload](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/transfer/s3/model/DirectoryUpload.html)Objekt stellt den Upload-Vorgang dar, der nach [CompletedDirectoryUpload](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/transfer/s3/model/CompletedDirectoryUpload.html)Abschluss der Anforderung eine generiert. Das `CompleteDirectoryUpload` Objekt enthält Informationen über die Ergebnisse der Übertragung, einschließlich der Dateien, die nicht übertragen werden konnten.

```
    public Integer uploadDirectory(S3TransferManager transferManager,
            URI sourceDirectory, String bucketName) {
        DirectoryUpload directoryUpload = transferManager.uploadDirectory(UploadDirectoryRequest.builder()
                .source(Paths.get(sourceDirectory))
                .bucket(bucketName)
                .build());

        CompletedDirectoryUpload completedDirectoryUpload = directoryUpload.completionFuture().join();
        completedDirectoryUpload.failedTransfers()
                .forEach(fail -> logger.warn("Object [{}] failed to transfer", fail.toString()));
        return completedDirectoryUpload.failedTransfers().size();
    }
```

### Importe
<a name="transfer-manager-upload_directory-import"></a>

```
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import software.amazon.awssdk.services.s3.model.ObjectIdentifier;
import software.amazon.awssdk.transfer.s3.S3TransferManager;
import software.amazon.awssdk.transfer.s3.model.CompletedDirectoryUpload;
import software.amazon.awssdk.transfer.s3.model.DirectoryUpload;
import software.amazon.awssdk.transfer.s3.model.UploadDirectoryRequest;

import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;
import java.nio.file.Paths;
import java.util.UUID;
```

## Laden Sie S3-Bucket-Objekte in ein lokales Verzeichnis herunter
<a name="transfer-manager-download_directory"></a>

Sie können die Objekte in einem S3-Bucket in ein lokales Verzeichnis herunterladen, wie im folgenden Beispiel gezeigt.

Um die Objekte in einem S3-Bucket in ein lokales Verzeichnis herunterzuladen, rufen Sie zunächst die Methode [DownloadDirectory](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/transfer/s3/S3TransferManager.html#downloadDirectory(software.amazon.awssdk.transfer.s3.model.DownloadDirectoryRequest)) des Transfer Managers auf und übergeben Sie eine [DownloadDirectoryRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/transfer/s3/model/DownloadDirectoryRequest.html).

Das [DirectoryDownload](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/transfer/s3/model/DirectoryDownload.html)Objekt stellt den Download-Vorgang dar, der nach [CompletedDirectoryDownload](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/transfer/s3/model/CompletedDirectoryDownload.html)Abschluss der Anforderung eine generiert. Das `CompleteDirectoryDownload` Objekt enthält Informationen über die Ergebnisse der Übertragung, einschließlich der Dateien, die nicht übertragen werden konnten.

```
    public Integer downloadObjectsToDirectory(S3TransferManager transferManager,
            URI destinationPathURI, String bucketName) {
        DirectoryDownload directoryDownload = transferManager.downloadDirectory(DownloadDirectoryRequest.builder()
                .destination(Paths.get(destinationPathURI))
                .bucket(bucketName)
                .build());
        CompletedDirectoryDownload completedDirectoryDownload = directoryDownload.completionFuture().join();

        completedDirectoryDownload.failedTransfers()
                .forEach(fail -> logger.warn("Object [{}] failed to transfer", fail.toString()));
        return completedDirectoryDownload.failedTransfers().size();
    }
```

### Importe
<a name="transfer-manager-download_directory-import"></a>

```
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import software.amazon.awssdk.core.sync.RequestBody;
import software.amazon.awssdk.services.s3.model.ObjectIdentifier;
import software.amazon.awssdk.transfer.s3.S3TransferManager;
import software.amazon.awssdk.transfer.s3.model.CompletedDirectoryDownload;
import software.amazon.awssdk.transfer.s3.model.DirectoryDownload;
import software.amazon.awssdk.transfer.s3.model.DownloadDirectoryRequest;
import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.HashSet;
import java.util.Set;
import java.util.UUID;
import java.util.stream.Collectors;
```

## Vollständige Beispiele anzeigen
<a name="transfer-manager-example-location"></a>

[GitHub enthält den vollständigen](https://github.com/awsdocs/aws-doc-sdk-examples/tree/d73001daea05266eaa9e074ccb71b9383832369a/javav2/example_code/s3/src/main/java/com/example/s3/transfermanager) Code für alle Beispiele auf dieser Seite.

# Arbeiten Sie mit S3-Ereignisbenachrichtigungen
<a name="examples-s3-event-notifications"></a>

Um Ihnen bei der Überwachung der Aktivitäten in Ihren Buckets zu helfen, kann Amazon S3 Benachrichtigungen senden, wenn bestimmte Ereignisse eintreten. Das Amazon S3 S3-Benutzerhandbuch enthält Informationen zu den [Benachrichtigungen, die ein Bucket versenden kann](https://docs.aws.amazon.com/AmazonS3/latest/userguide/EventNotifications.html#notification-how-to-overview). 

Mit dem SDK for Java können Sie einen Bucket einrichten, um Ereignisse an vier mögliche Ziele zu senden: 
+ Amazon-Simple-Notification-Service-Themen
+ Amazon-Simple-Queue-Service-Warteschlangen als Ziele
+ AWS Lambda Funktionen
+ Amazon EventBridge

Wenn Sie einen Bucket einrichten, an den Ereignisse gesendet werden sollen EventBridge, haben Sie die Möglichkeit, eine EventBridge Regel zu konfigurieren, um dasselbe Ereignis an mehrere Ziele weiterzuleiten. Wenn Sie Ihren Bucket so konfigurieren, dass er direkt an eines der ersten drei Ziele sendet, kann für jedes Ereignis nur ein Zieltyp angegeben werden.

Im nächsten Abschnitt erfahren Sie, wie Sie mithilfe des SDK for Java einen Bucket konfigurieren, um S3-Ereignisbenachrichtigungen auf zwei Arten zu senden: direkt an eine Amazon SQS SQS-Warteschlange und an EventBridge.

Im letzten Abschnitt erfahren Sie, wie Sie die S3-API für Ereignisbenachrichtigungen verwenden, um objektorientiert mit Benachrichtigungen zu arbeiten.

## Konfigurieren Sie einen Bucket so, dass er direkt an ein Ziel gesendet wird
<a name="s3-event-conf-bucket-direct"></a>

Im folgenden Beispiel wird ein Bucket so konfiguriert, dass Benachrichtigungen gesendet werden, wenn in *einem* Bucket Ereignisse zur *Objekterstellung oder Objektkennzeichnung* auftreten.

```
static void processS3Events(String bucketName, String queueArn) {
    // Configure the bucket to send Object Created and Object Tagging notifications to an existing SQS queue.
    s3Client.putBucketNotificationConfiguration(b -> b
            .notificationConfiguration(ncb -> ncb
                    .queueConfigurations(qcb -> qcb
                            .events(Event.S3_OBJECT_CREATED, Event.S3_OBJECT_TAGGING)
                            .queueArn(queueArn)))
                    .bucket(bucketName)
    );
}
```

Der oben gezeigte Code richtet eine Warteschlange für den Empfang von zwei Arten von Ereignissen ein. Praktischerweise können Sie mit `queueConfigurations` dieser Methode bei Bedarf mehrere Warteschlangenziele festlegen. Außerdem können Sie in der `notificationConfiguration` Methode zusätzliche Ziele festlegen, z. B. ein oder mehrere Amazon SNS SNS-Themen oder eine oder mehrere Lambda-Funktionen. Der folgende Ausschnitt zeigt ein Beispiel mit zwei Warteschlangen und drei Arten von Zielen.

```
s3Client.putBucketNotificationConfiguration(b -> b
                .notificationConfiguration(ncb -> ncb
                        .queueConfigurations(qcb -> qcb
                                .events(Event.S3_OBJECT_CREATED, Event.S3_OBJECT_TAGGING)
                                .queueArn(queueArn), 
                                qcb2 -> qcb2.<...>)
                        .topicConfigurations(tcb -> tcb.<...>)
                        .lambdaFunctionConfigurations(lfcb -> lfcb.<...>))
                        .bucket(bucketName)
        );
```

Das GitHub Codebeispiel-Repository enthält das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javav2/example_code/s3/src/main/java/com/example/s3/ProcessS3EventNotification.java) für das direkte Senden von S3-Ereignisbenachrichtigungen an eine Warteschlange.

## Konfigurieren Sie einen Bucket, an den gesendet werden soll EventBridge
<a name="s3-event-conf-bucket-eventbridge"></a>

Im folgenden Beispiel wird ein Bucket konfiguriert, an den Benachrichtigungen gesendet werden sollen EventBridge.

```
public static String setBucketNotificationToEventBridge(String bucketName) {
    // Enable bucket to emit S3 Event notifications to EventBridge.
    s3Client.putBucketNotificationConfiguration(b -> b
            .bucket(bucketName)
            .notificationConfiguration(b1 -> b1
                    .eventBridgeConfiguration(SdkBuilder::build))
    .build());
```

Wenn Sie einen Bucket konfigurieren, an den Ereignisse gesendet werden sollen EventBridge, geben Sie einfach das EventBridge Ziel an, nicht die Art der Ereignisse oder das endgültige Ziel, an das gesendet EventBridge werden soll. Sie konfigurieren die ultimativen Ziele und Ereignistypen mithilfe des Java EventBridge SDK-Clients.

Der folgende Code zeigt, wie Sie die Konfiguration so konfigurieren EventBridge , dass durch *Objekte erzeugte* Ereignisse zu einem Thema und einer Warteschlange aufgefächert werden.

```
   public static String configureEventBridge(String topicArn, String queueArn) {
        try {
            // Create an EventBridge rule to route Object Created notifications.
            PutRuleRequest putRuleRequest = PutRuleRequest.builder()
                    .name(RULE_NAME)
                    .eventPattern("""
                            {
                              "source": ["aws.s3"],
                              "detail-type": ["Object Created"],
                              "detail": {
                                "bucket": {
                                  "name": ["%s"]
                                }
                              }
                            }
                            """.formatted(bucketName))
                    .build();

            // Add the rule to the default event bus.
            PutRuleResponse putRuleResponse = eventBridgeClient.putRule(putRuleRequest)
                    .whenComplete((r, t) -> {
                        if (t != null) {
                            logger.error("Error creating event bus rule: " + t.getMessage(), t);
                            throw new RuntimeException(t.getCause().getMessage(), t);
                        }
                        logger.info("Event bus rule creation request sent successfully. ARN is: {}", r.ruleArn());
                    }).join();

            // Add the existing SNS topic and SQS queue as targets to the rule.
            eventBridgeClient.putTargets(b -> b
                    .eventBusName("default")
                    .rule(RULE_NAME)
                    .targets(List.of (
                            Target.builder()
                                    .arn(queueArn)
                                    .id("Queue")
                                    .build(),
                            Target.builder()
                                    .arn(topicArn)
                                    .id("Topic")
                                    .build())
                            )
                    ).join();
            return putRuleResponse.ruleArn();
        } catch (S3Exception e) {
            System.err.println(e.awsErrorDetails().errorMessage());
            System.exit(1);
        }
        return null;
    }
```

Um EventBridge in Ihrem Java-Code damit zu arbeiten, fügen Sie Ihrer `pom.xml` Maven-Datei eine Abhängigkeit vom `eventbridge` Artefakt hinzu.

```
<dependency>
    <groupId>software.amazon.awssdk</groupId>
    <artifactId>eventbridge</artifactId>
</dependency>
```

Das GitHub Repository mit den Codebeispielen enthält das [vollständige Beispiel zum](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javav2/example_code/s3/src/main/java/com/example/s3/PutBucketS3EventNotificationEventBridge.java) Senden von S3-Ereignisbenachrichtigungen an EventBridge und dann an ein Thema und eine Warteschlange.

## Verwenden Sie die S3-API für Ereignisbenachrichtigungen, um Ereignisse zu verarbeiten
<a name="s3-event-notification-read"></a>

Nachdem ein Ziel S3-Benachrichtigungsereignisse empfangen hat, können Sie diese mithilfe der S3-API für Ereignisbenachrichtigungen objektorientiert verarbeiten. Sie können die S3-API für Ereignisbenachrichtigungen verwenden, um mit Ereignisbenachrichtigungen zu arbeiten, die direkt an ein Ziel gesendet werden (wie im [ersten Beispiel](#s3-event-conf-bucket-direct) gezeigt), aber nicht mit weitergeleiteten Benachrichtigungen. EventBridge S3-Ereignisbenachrichtigungen, die von Buckets gesendet werden und eine [andere Struktur EventBridge ](https://docs.aws.amazon.com/AmazonS3/latest/userguide/ev-events.html#ev-events-list) enthalten, die die S3-API für Ereignisbenachrichtigungen derzeit nicht verarbeitet.

### Abhängigkeit hinzufügen
<a name="s3-event-notifications-dep"></a>

Die S3-API für Ereignisbenachrichtigungen wurde mit Version 2.25.11 des SDK for Java 2.x veröffentlicht.

Um die S3-API für Ereignisbenachrichtigungen zu verwenden, fügen Sie Ihrem Maven das erforderliche Abhängigkeitselement hinzu, `pom.xml` wie im folgenden Codeausschnitt gezeigt.

```
<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>software.amazon.awssdk</groupId>
            <artifactId>bom</artifactId>
            <version>2.X.X1</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>
<dependencies>
    <dependency>
        <groupId>software.amazon.awssdk</groupId>
        <artifactId>s3-event-notifications</artifactId>
    </dependency>
</dependencies>
```

1 Letzte Version[.](https://central.sonatype.com/artifact/software.amazon.awssdk/bom)

### Benutze die `S3EventNotification` Klasse
<a name="s3-event-notifications-use"></a>

#### Erstellen Sie eine `S3EventNotification` Instanz aus einer JSON-Zeichenfolge
<a name="s3-event-notifications-use-from-json"></a>

Um eine JSON-Zeichenfolge in ein `S3EventNotification` Objekt zu konvertieren, verwenden Sie die statischen Methoden der `S3EventNotification` Klasse, wie im folgenden Beispiel gezeigt.

```
import software.amazon.awssdk.eventnotifications.s3.model.S3EventNotification
import software.amazon.awssdk.eventnotifications.s3.model.S3EventNotificationRecord
import software.amazon.awssdk.services.sqs.model.Message; 

public class S3EventNotificationExample {
    ...
    
    void receiveMessage(Message message) {
       // Message received from SQSClient.
       String sqsEventBody = message.body();
       S3EventNotification s3EventNotification = S3EventNotification.fromJson(sqsEventBody);
    
       // Use getRecords() to access all the records in the notification.                                                                                                       
       List<S3EventNotificationRecord> records = s3EventNotification.getRecords();   
    
        S3EventNotificationRecord record = records.stream().findFirst();
        // Use getters on the record to access individual attributes.
        String awsRegion = record.getAwsRegion();
        String eventName = record.getEventName();
        String eventSource = record.getEventSource();                                                                                                   
    }
}
```

In diesem Beispiel konvertiert die `fromJson` Methode die JSON-Zeichenfolge in ein `S3EventNotification` Objekt. Fehlende Felder in der JSON-Zeichenfolge führen zu `null` Werten in den entsprechenden Java-Objektfeldern, und alle zusätzlichen Felder in der JSON-Zeichenfolge werden ignoriert.

 APIs Weitere Informationen zu einer Ereignisbenachrichtigung finden Sie in der API-Referenz für`[S3EventNotificationRecord](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/eventnotifications/s3/model/S3EventNotificationRecord.html)`.

#### Konvertiert eine `S3EventNotification` Instanz in eine JSON-Zeichenfolge
<a name="s3-event-notifications-use-to-json"></a>

Verwenden Sie die Methode `toJson` (or`toJsonPretty`), um ein `S3EventNotification` Objekt in eine JSON-Zeichenfolge zu konvertieren, wie im folgenden Beispiel gezeigt.

```
import software.amazon.awssdk.eventnotifications.s3.model.S3EventNotification

public class S3EventNotificationExample {
    ...

    void toJsonString(S3EventNotification event) {

        String json = event.toJson();
        String jsonPretty = event.toJsonPretty();

        System.out.println("JSON: " + json);
        System.out.println("Pretty JSON: " + jsonPretty);
    }
}
```

Felder für`GlacierEventData`, `ReplicationEventData``IntelligentTieringEventData`, und `LifecycleEventData` sind aus dem JSON ausgeschlossen, falls sie es sind`null`. Andere `null` Felder werden als `null` serialisiert.

Im Folgenden wird eine Beispielausgabe der `toJsonPretty` Methode für ein S3-Objekt-Tagging-Ereignis gezeigt.

```
{
  "Records" : [ {
    "eventVersion" : "2.3",
    "eventSource" : "aws:s3",
    "awsRegion" : "us-east-1",
    "eventTime" : "2024-07-19T20:09:18.551Z",
    "eventName" : "ObjectTagging:Put",
    "userIdentity" : {
      "principalId" : "AWS:XXXXXXXXXXX"
    },
    "requestParameters" : {
      "sourceIPAddress" : "XXX.XX.XX.XX"
    },
    "responseElements" : {
      "x-amz-request-id" : "XXXXXXXXXXXX",
      "x-amz-id-2" : "XXXXXXXXXXXXX"
    },
    "s3" : {
      "s3SchemaVersion" : "1.0",
      "configurationId" : "XXXXXXXXXXXXX",
      "bucket" : {
        "name" : "amzn-s3-demo-bucket",
        "ownerIdentity" : {
          "principalId" : "XXXXXXXXXXX"
        },
        "arn" : "arn:aws:s3:::XXXXXXXXXX"
      },
      "object" : {
        "key" : "akey",
        "size" : null,
        "eTag" : "XXXXXXXXXX",
        "versionId" : null,
        "sequencer" : null
      }
    }
  } ]
}
```

Ein [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/75c3daadf750406156fc87fa30ee499a206b4a36/javav2/example_code/s3/src/main/java/com/example/s3/ProcessS3EventNotification.java#L117) ist verfügbar GitHub , das zeigt, wie die API verwendet wird, um mit Benachrichtigungen zu arbeiten, die von einer Amazon SQS SQS-Warteschlange empfangen wurden.

## S3-Ereignisse in Lambda mit Java-Bibliotheken verarbeiten: AWS SDK for Java 2.x und `aws-lambda-java-events`
<a name="s3-event-notif-processing-options"></a>

Anstatt das SDK for Java 2.x zur Verarbeitung von Amazon S3 S3-Ereignisbenachrichtigungen in einer Lambda-Funktion zu verwenden, können Sie die `[aws-lambda-java-events](https://github.com/aws/aws-lambda-java-libs/tree/main/aws-lambda-java-events)` Bibliothek in Version 3.x.x verwenden. AWS verwaltet die `aws-lambda-java-events` Bibliothek unabhängig und hat ihre eigenen Abhängigkeitsanforderungen. Die `aws-lambda-java-events` Bibliothek funktioniert nur mit S3-Ereignissen in Lambda-Funktionen, wohingegen das SDK for Java 2.x mit S3-Ereignissen in Lambda-Funktionen, Amazon SNS und Amazon SQS funktioniert.

Beide Ansätze modellieren die Nutzlast für JSON-Ereignisbenachrichtigungen auf objektorientierte Weise mit ähnlichen Methoden. APIs Die folgende Tabelle zeigt die wesentlichen Unterschiede zwischen der Verwendung der beiden Ansätze.


****  

|  | AWS SDK für Java | aws-lambda-java-events Bibliothek | 
| --- | --- | --- | 
| Benennung von Paketen |  `software.amazon.awssdk.eventnotifications.s3.model.S3EventNotification`  | com.amazonaws.services.lambda.runtime.events.models.s3.S3EventNotification | 
| RequestHandler Parameter |  Schreiben Sie die `RequestHandler` Implementierung Ihrer Lambda-Funktion, um eine JSON-Zeichenfolge zu erhalten: <pre>import com.amazonaws.services.lambda.runtime.Context;<br />import com.amazonaws.services.lambda.runtime.RequestHandler;<br />import software.amazon.awssdk.eventnotifications.s3.model.S3EventNotification;<br /><br />public class Handler implements RequestHandler<String, String> {<br /><br />    @Override<br />        public String handleRequest(String jsonS3Event, Context context) {<br />            S3EventNotification s3Event = S3EventNotification<br />                                             .fromJson(jsonS3Event);<br />            // Work with the s3Event object.        <br />            ...<br />    }<br />}</pre>  | Schreiben Sie die RequestHandler Implementierung Ihrer Lambda-Funktion, um ein S3Event Objekt zu empfangen:<pre>import com.amazonaws.services.lambda.runtime.Context;<br />import com.amazonaws.services.lambda.runtime.RequestHandler;<br />import com.amazonaws.services.lambda.runtime.events.S3Event;<br /><br />public class Handler implements RequestHandler<S3Event, String> {<br /><br />    @Override<br />        public String handleRequest(S3Event s3event, Context context) {<br />            // Work with the s3Event object.        <br />            ...<br />    }<br />}</pre> | 
| Maven-Abhängigkeiten |  <pre><dependencyManagement><br />    <dependencies><br />        <dependency><br />            <groupId>software.amazon.awssdk</groupId><br />            <artifactId>bom</artifactId><br />            <version>2.X.X</version><br />            <type>pom</type><br />            <scope>import</scope><br />        </dependency><br />    </dependencies><br /></dependencyManagement><br /><dependencies><br />    <dependency><br />        <groupId>software.amazon.awssdk</groupId><br />        <artifactId>s3-event-notifications</artifactId><br />    </dependency><br />    <!-- Add other SDK dependencies that you need. --><br /></dependencies></pre>  |  <pre><dependencyManagement><br />    <dependencies><br />        <dependency><br />            <groupId>software.amazon.awssdk</groupId><br />            <artifactId>bom</artifactId><br />            <version>2.X.X</version><br />            <type>pom</type><br />            <scope>import</scope><br />        </dependency><br />    </dependencies><br /></dependencyManagement><br /><dependencies><br />    <!-- The following two dependencies are for the <br />         aws-lambda-java-events library. --><br />    <dependency><br />        <groupId>com.amazonaws</groupId><br />        <artifactId>aws-lambda-java-core</artifactId><br />        <version>1.2.3</version>     <br />    </dependency><br />    <dependency><br />        <groupId>com.amazonaws</groupId><br />        <artifactId>aws-lambda-java-events</artifactId><br />        <version>3.15.0</version><br />    </dependency><br />    <!-- Add other SDK dependencies that you need. --><br /></dependencies></pre>  | 