Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# Bekerja dengan Amazon S3
<a name="examples-s3"></a>

Bagian ini memberikan informasi latar belakang untuk bekerja dengan Amazon S3 dengan menggunakan file. AWS SDK for Java 2.x Bagian ini melengkapi contoh [Amazon S3 Java v2](java_s3_code_examples.md) yang disajikan di *bagian Contoh kode* panduan ini.

## Klien S3 di AWS SDK for Java 2.x
<a name="s3-clients"></a>

 AWS SDK for Java 2.x Menyediakan berbagai jenis klien S3. Tabel berikut menunjukkan perbedaan dan dapat membantu Anda memutuskan apa yang terbaik untuk kasus penggunaan Anda.


**Rasa yang berbeda dari klien Amazon S3**  

| Klien S3 | Deskripsi singkat | Kapan harus digunakan | Batasan/kelemahan | 
| --- | --- | --- | --- | 
|  **AWS Klien S3 berbasis CRT** Antarmuka: [S3 AsyncClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/S3AsyncClient.html) Pembangun: [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/id_id/sdk-for-java/latest/developer-guide/examples-s3.html) Lihat [Gunakan klien S3 berkinerja: klien S3 berbasis AWS CRT](crt-based-s3-client.md).  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/sdk-for-java/latest/developer-guide/examples-s3.html)  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/sdk-for-java/latest/developer-guide/examples-s3.html)  | 
|  ***Klien asinkron S3 berbasis Java dengan multipart diaktifkan*** Antarmuka: [S3 AsyncClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/S3AsyncClient.html) Pembangun: [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/id_id/sdk-for-java/latest/developer-guide/examples-s3.html) Lihat [Konfigurasikan klien async S3 berbasis Java untuk menggunakan transfer paralel](s3-async-client-multipart.md).  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/sdk-for-java/latest/developer-guide/examples-s3.html)  | Kinerja kurang dari klien S3 AWS berbasis CRT. | 
|  ***Klien asinkron S3 berbasis Java tanpa multipart diaktifkan*** Antarmuka: [S3 AsyncClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/S3AsyncClient.html) Pembangun: [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/id_id/sdk-for-java/latest/developer-guide/examples-s3.html)  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/sdk-for-java/latest/developer-guide/examples-s3.html)  |  Tidak ada optimasi kinerja.  | 
|  **Klien sinkronisasi S3 berbasis Java** Antarmuka: [S3Client](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/S3Client.html) Pembangun: [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/id_id/sdk-for-java/latest/developer-guide/examples-s3.html)  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/sdk-for-java/latest/developer-guide/examples-s3.html)  |  Tidak ada optimasi kinerja.  | 

**catatan**  
Dari versi 2.18.x dan seterusnya, AWS SDK for Java 2.x menggunakan [pengalamatan bergaya host virtual saat menyertakan penggantian titik akhir](https://docs.aws.amazon.com/AmazonS3/latest/userguide/VirtualHosting.html#virtual-hosted-style-access). Ini berlaku selama nama bucket adalah label DNS yang valid.   
Panggil [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)metode dengan `true` pembuat klien Anda untuk memaksa klien menggunakan pengalamatan gaya jalur untuk bucket.  
Contoh berikut menunjukkan klien layanan yang dikonfigurasi dengan penggantian titik akhir dan menggunakan pengalamatan gaya jalur.  

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

**Topics**
+ [Klien S3 di SDK](#s3-clients)
+ [Mengunggah stream ke S3](best-practices-s3-uploads.md)
+ [Pra-ditandatangani URLs](examples-s3-presign.md)
+ [Akses Lintas Wilayah](s3-cross-region.md)
+ [Perlindungan integritas data dengan checksum](s3-checksums.md)
+ [Gunakan klien S3 yang berkinerja](crt-based-s3-client.md)
+ [Konfigurasikan dukungan transfer paralel](s3-async-client-multipart.md)
+ [Transfer file dan direktori](transfer-manager.md)
+ [Notifikasi Peristiwa S3](examples-s3-event-notifications.md)

# Mengunggah streaming ke Amazon S3 menggunakan AWS SDK for Java 2.x
<a name="best-practices-s3-uploads"></a>

Saat Anda menggunakan streaming untuk mengunggah konten ke S3 menggunakan [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))atau [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)), Anda menggunakan kelas `RequestBody` pabrik untuk API sinkron untuk memasok aliran. Untuk API asinkron, `AsyncRequestBody` ini adalah kelas pabrik yang setara.

## Metode mana yang mengunggah aliran?
<a name="s3-stream-upload-methods"></a>

Untuk API sinkron, Anda dapat menggunakan metode pabrik berikut `RequestBody` untuk memasok aliran:
+ `[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)`
  + `ContentStreamProvider`Memiliki metode `fromInputStream(InputStream inputStream)` pabrik
+ `[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)`

Untuk API asinkron, Anda dapat menggunakan metode pabrik berikut: `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)`
  + Anda menggunakan AsyncRequestBodyFromInputStreamConfiguration .Builder untuk memasok aliran
+ `[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)`
  + Hasilnya `[BlockingInputStreamAsyncRequestBody](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/core/async/BlockingInputStreamAsyncRequestBody.html)` berisi metode `writeInputStream(InputStream inputStream)` yang dapat Anda gunakan untuk menyediakan aliran

## Melakukan upload
<a name="s3-upload-stream-perform"></a>

### Jika Anda tahu panjang aliran
<a name="s3-stream-upload-supply-content-length"></a>

Seperti yang Anda lihat dari tanda tangan metode yang ditunjukkan sebelumnya, sebagian besar metode menerima parameter panjang konten. 

Jika Anda mengetahui panjang konten dalam byte, berikan nilai yang tepat:

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

**Awas**  
 Saat mengunggah dari aliran input, jika panjang konten yang ditentukan tidak sesuai dengan jumlah byte yang sebenarnya, Anda mungkin mengalami:  
Objek terpotong jika panjang yang Anda tentukan terlalu kecil
Gagal mengunggah atau menggantung koneksi jika panjang yang Anda tentukan terlalu besar

### Jika Anda tidak tahu panjang aliran
<a name="s3-stream-upload-unknown-length"></a>

#### Menggunakan API sinkron
<a name="s3-upload-unknown-sync-client"></a>

Gunakan`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;
}
```

Karena SDK menyangga seluruh aliran dalam memori untuk menghitung panjang konten, Anda dapat mengalami masalah memori dengan aliran besar. Jika Anda perlu mengunggah aliran besar dengan klien sinkron, pertimbangkan untuk menggunakan API multibagian:

##### Unggah aliran menggunakan API klien sinkron dan API multibagian
<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;
}
```

**catatan**  
Untuk sebagian besar kasus penggunaan, sebaiknya gunakan API klien asinkron untuk aliran dengan ukuran yang tidak diketahui. Pendekatan ini memungkinkan transfer paralel dan menawarkan antarmuka pemrograman yang lebih sederhana, karena SDK menangani segmentasi aliran menjadi potongan multibagian jika alirannya besar.   
Baik klien asinkron S3 standar dengan multipart diaktifkan dan klien S3 berbasis AWS CRT menerapkan pendekatan ini. Kami menunjukkan contoh pendekatan ini di bagian berikut.

#### Menggunakan API asinkron
<a name="s3-stream-upload-unknown-async-client"></a>

Anda dapat memberikan `null` `contentLength` argumen untuk `fromInputStream(InputStream inputStream, Long contentLength, ExecutorService executor)`

**Example menggunakan klien AWS asinkron berbasis CRT:**  

```
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 menggunakan klien asinkron standar dengan multipart diaktifkan:**  

```
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;
}
```

# Bekerja dengan Amazon S3 pra-ditandatangani URLs
<a name="examples-s3-presign"></a>

Pra-ditandatangani URLs menyediakan akses sementara ke objek S3 pribadi tanpa mengharuskan pengguna memiliki AWS kredensi atau izin. 

Misalnya, asumsikan Alice memiliki akses ke objek S3, dan dia ingin sementara berbagi akses ke objek itu dengan Bob. Alice dapat membuat permintaan GET yang telah ditandatangani sebelumnya untuk dibagikan dengan Bob sehingga ia dapat mengunduh objek tanpa memerlukan akses ke kredensi Alice. Anda dapat membuat pra-ditandatangani URLs untuk HTTP GET dan untuk permintaan HTTP PUT.

## Buat URL yang telah ditandatangani sebelumnya untuk suatu objek, lalu unduh (GET request)
<a name="get-presignedobject"></a>

Contoh berikut terdiri dari dua bagian.
+ Bagian 1: Alice menghasilkan URL yang telah ditandatangani sebelumnya untuk suatu objek.
+ Bagian 2: Bob mengunduh objek dengan menggunakan URL yang telah ditandatangani sebelumnya.

### Bagian 1: Menghasilkan URL
<a name="get-presigned-object-part1"></a>

Alice sudah memiliki objek di ember S3. Dia menggunakan kode berikut untuk menghasilkan string URL yang dapat digunakan Bob dalam permintaan GET berikutnya.

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

### Bagian 2: Unduh objek
<a name="get-presigned-object-part2"></a>

Bob menggunakan salah satu dari tiga opsi kode berikut untuk mengunduh objek. Atau, dia bisa menggunakan browser untuk melakukan permintaan GET.

#### Gunakan JDK `HttpURLConnection` (sejak 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();
    }
```

#### Gunakan JDK `HttpClient` (sejak 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();
    }
```

#### Gunakan `SdkHttpClient` dari 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();
    }
```

Lihat [contoh lengkapnya](https://github.com/awsdocs/aws-doc-sdk-examples/blob/d73001daea05266eaa9e074ccb71b9383832369a/javav2/example_code/s3/src/main/java/com/example/s3/GeneratePresignedGetUrlAndRetrieve.java) dan [uji](https://github.com/awsdocs/aws-doc-sdk-examples/blob/d73001daea05266eaa9e074ccb71b9383832369a/javav2/example_code/s3/src/test/java/com/example/s3/presignurl/GeneratePresignedGetUrlTests.java) GitHub.

## Buat URL yang telah ditandatangani sebelumnya untuk unggahan, lalu unggah file (permintaan PUT)
<a name="put-presignedobject"></a>

Contoh berikut terdiri dari dua bagian.
+ Bagian 1: Alice menghasilkan URL yang telah ditandatangani sebelumnya untuk mengunggah objek.
+ Bagian 2: Bob mengunggah file dengan menggunakan URL yang telah ditandatangani sebelumnya.

### Bagian 1: Menghasilkan URL
<a name="put-presigned-object-part1"></a>

Alice sudah memiliki ember S3. Dia menggunakan kode berikut untuk menghasilkan string URL yang dapat digunakan Bob dalam permintaan PUT berikutnya.

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

### Bagian 2: Unggah objek file
<a name="put-presigned-object-part2"></a>

Bob menggunakan salah satu dari tiga opsi kode berikut untuk mengunggah file.

#### Gunakan JDK `HttpURLConnection` (sejak 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);
        }
    }
```

#### Gunakan JDK `HttpClient` (sejak 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);
        }
    }
```

#### Gunakan `SdkHttpClient` dari 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);
        }
    }
```

Lihat [contoh lengkapnya](https://github.com/awsdocs/aws-doc-sdk-examples/blob/d73001daea05266eaa9e074ccb71b9383832369a/javav2/example_code/s3/src/main/java/com/example/s3/GeneratePresignedUrlAndPutFileWithMetadata.java) dan [uji](https://github.com/awsdocs/aws-doc-sdk-examples/blob/d73001daea05266eaa9e074ccb71b9383832369a/javav2/example_code/s3/src/test/java/com/example/s3/presignurl/GeneratePresignedPutUrlTests.java) GitHub.

# Akses Lintas Wilayah untuk Amazon S3
<a name="s3-cross-region"></a>

Saat Anda bekerja dengan bucket Amazon Simple Storage Service (Amazon S3), Anda biasanya tahu Wilayah AWS bucket tersebut. Wilayah tempat Anda bekerja ditentukan saat Anda membuat klien S3. 

Namun, terkadang Anda mungkin perlu bekerja dengan bucket tertentu, tetapi Anda tidak tahu apakah itu terletak di Wilayah yang sama yang ditetapkan untuk klien S3. 

Alih-alih melakukan lebih banyak panggilan untuk menentukan Wilayah bucket, Anda dapat menggunakan SDK untuk mengaktifkan akses ke bucket S3 di berbagai Wilayah.

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

Support untuk akses lintas wilayah tersedia dengan `2.20.111` versi SDK. Gunakan versi ini atau yang lebih baru di file build Maven Anda untuk `s3` ketergantungan seperti yang ditunjukkan pada cuplikan berikut.

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

Selanjutnya, saat Anda membuat klien S3, aktifkan akses lintas wilayah seperti yang ditunjukkan pada cuplikan. Secara default, akses tidak diaktifkan.

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

## Bagaimana SDK menyediakan akses Lintas wilayah
<a name="s3-cross-region-routing"></a>

Saat Anda mereferensikan bucket yang ada dalam permintaan, seperti saat Anda menggunakan `putObject` metode, SDK akan memulai permintaan ke Wilayah yang dikonfigurasi untuk klien. 

Jika bucket tidak ada di Region tertentu, respons kesalahan menyertakan Region sebenarnya tempat bucket berada. SDK kemudian menggunakan Region yang benar dalam permintaan kedua.

Untuk mengoptimalkan permintaan future ke bucket yang sama, SDK menyimpan pemetaan Region ini di klien.

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

Saat Anda mengaktifkan akses bucket lintas wilayah, ketahuilah bahwa panggilan API pertama dapat meningkatkan latensi jika bucket tidak berada di Region yang dikonfigurasi klien. Namun, panggilan berikutnya mendapat manfaat dari informasi Wilayah yang di-cache, menghasilkan peningkatan kinerja.

Saat Anda mengaktifkan akses lintas wilayah, akses ke bucket tidak terpengaruh. Pengguna harus diberi wewenang untuk mengakses bucket di Wilayah mana pun tempat tinggalnya.

# Perlindungan integritas data dengan checksum
<a name="s3-checksums"></a>

Amazon Simple Storage Service (Amazon S3) menyediakan kemampuan untuk menentukan checksum saat Anda mengunggah objek. Ketika Anda menentukan checksum, itu disimpan dengan objek dan dapat divalidasi ketika objek diunduh.

Checksum menyediakan lapisan integritas data tambahan saat Anda mentransfer file. Dengan checksum, Anda dapat memverifikasi konsistensi data dengan mengonfirmasi bahwa file yang diterima cocok dengan file asli. [Untuk informasi selengkapnya tentang checksum dengan Amazon S3, lihat Panduan [Pengguna Layanan Penyimpanan Sederhana Amazon](https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html) termasuk algoritme yang didukung.](https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#using-additional-checksums)

Anda memiliki fleksibilitas untuk memilih algoritma yang paling sesuai dengan kebutuhan Anda dan membiarkan SDK menghitung checksum. Atau, Anda dapat memberikan nilai checksum yang telah dihitung sebelumnya dengan menggunakan salah satu algoritme yang didukung. 

**catatan**  
Dimulai dengan versi 2.30.0 AWS SDK for Java 2.x, SDK menyediakan perlindungan integritas default dengan menghitung checksum secara otomatis untuk unggahan. `CRC32` SDK menghitung checksum ini jika Anda tidak memberikan nilai checksum yang telah dihitung sebelumnya atau jika Anda tidak menentukan algoritme yang harus digunakan SDK untuk menghitung checksum.   
SDK juga menyediakan pengaturan global untuk perlindungan integritas data yang dapat Anda atur secara eksternal, yang dapat Anda baca di Panduan Referensi Alat [AWS SDKs dan](https://docs.aws.amazon.com/sdkref/latest/guide/feature-dataintegrity.html) Alat.

Kami membahas checksum dalam dua fase permintaan: mengunggah objek dan mengunduh objek. 

## Mengunggah objek
<a name="use-service-S3-checksum-upload"></a>

 Saat Anda mengunggah objek dengan `putObject` metode dan menyediakan algoritma checksum, SDK menghitung checksum untuk algoritme yang ditentukan. 

Cuplikan kode berikut menunjukkan permintaan untuk mengunggah objek dengan checksum. `SHA256` Ketika SDK mengirim permintaan, ia menghitung `SHA256` checksum dan mengunggah objek. Amazon S3 memvalidasi integritas konten dengan menghitung checksum dan membandingkannya dengan checksum yang disediakan oleh SDK. Amazon S3 kemudian menyimpan checksum dengan objek.

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

Jika Anda tidak menyediakan algoritma checksum dengan permintaan, perilaku checksum bervariasi tergantung pada versi SDK yang Anda gunakan seperti yang ditunjukkan pada tabel berikut.

**Perilaku checksum ketika tidak ada algoritma checksum yang disediakan**


| Versi Java SDK | Perilaku checksum | 
| --- | --- | 
| lebih awal dari 2.30.0 | SDK tidak secara otomatis menghitung checksum berbasis CRC dan menyediakannya dalam permintaan. | 
| 2.30.0 atau yang lebih baru | SDK menggunakan `CRC32` algoritma untuk menghitung checksum dan menyediakannya dalam permintaan. Amazon S3 memvalidasi integritas transfer dengan menghitung checksumnya sendiri dan membandingkannya dengan `CRC32` checksum yang disediakan oleh SDK. Jika checksum cocok, checksum disimpan dengan objek. | 

### Gunakan nilai checksum yang telah dihitung sebelumnya
<a name="use-service-S3-checksum-upload-pre"></a>

Nilai checksum yang telah dihitung sebelumnya yang disertakan dengan permintaan menonaktifkan komputasi otomatis oleh SDK dan menggunakan nilai yang disediakan sebagai gantinya.

Contoh berikut menunjukkan permintaan dengan SHA256 checksum yang telah dihitung sebelumnya.

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

Jika Amazon S3 menentukan nilai checksum salah untuk algoritme yang ditentukan, layanan akan mengembalikan respons kesalahan.

### Unggahan multipart
<a name="use-service-S3-checksum-upload-multi"></a>

Anda juga dapat menggunakan checksum dengan unggahan multipart.

 SDK for Java 2.x menyediakan dua opsi untuk menggunakan checksum dengan unggahan multipart. Opsi pertama menggunakan`S3TransferManager`. 

Contoh manajer transfer berikut menentukan SHA1 algoritma untuk 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();
    }
```

Jika Anda tidak menyediakan algoritma checksum saat menggunakan manajer transfer untuk upload, SDK secara otomatis menghitung dan checksum berdasarkan algoritma. `CRC32` SDK melakukan perhitungan ini untuk semua versi SDK.

Opsi kedua menggunakan [`S3Client`API (atau [`S3AsyncClient`API](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/S3AsyncClient.html)](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/S3Client.html)) untuk melakukan pengunggahan multibagian. Jika Anda menentukan checksum dengan pendekatan ini, Anda harus menentukan algoritma yang akan digunakan pada inisiasi unggahan. Anda juga harus menentukan algoritma untuk setiap permintaan bagian dan memberikan checksum yang dihitung untuk setiap bagian setelah diunggah.

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

[Kode untuk contoh dan [tes](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javav2/example_code/s3/src/test/java/com/example/s3/PerformMultiPartUploadTests.java) lengkap](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javav2/example_code/s3/src/main/java/com/example/s3/PerformMultiPartUpload.java) ada di repositori contoh GitHub kode.

## Unduh objek
<a name="use-service-S3-checksum-download"></a>

Saat Anda menggunakan metode [getObject](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/S3Client.html#getObject(software.amazon.awssdk.services.s3.model.GetObjectRequest)) untuk mengunduh objek, SDK secara otomatis memvalidasi checksum nilai kuncinya. `ChecksumMode` `enabled` ketika `checksumMode` metode pembangun untuk `GetObjectRequest` diatur ke`ChecksumMode.ENABLED`. 

Permintaan dalam cuplikan berikut mengarahkan SDK untuk memvalidasi checksum dalam respons dengan menghitung checksum dan membandingkan nilainya.

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

**catatan**  
Jika objek tidak diunggah dengan checksum, tidak ada validasi yang terjadi. 

## Opsi perhitungan checksum lainnya
<a name="S3-checsum-calculation-options"></a>

**catatan**  
Untuk memverifikasi integritas data data yang ditransmisikan dan untuk mengidentifikasi kesalahan transmisi, kami mendorong pengguna untuk menjaga pengaturan default SDK untuk opsi perhitungan checksum. Secara default, SDK menambahkan pemeriksaan penting ini untuk banyak operasi S3 termasuk `PutObject` dan. `GetObject`

Namun, jika penggunaan Amazon S3 memerlukan validasi checksum minimal, Anda dapat menonaktifkan banyak pemeriksaan dengan mengubah pengaturan konfigurasi default. 

### Nonaktifkan perhitungan checksum otomatis kecuali diperlukan
<a name="S3-minimize-checksum-calc-global"></a>

Anda dapat menonaktifkan perhitungan checksum otomatis oleh SDK untuk operasi yang mendukungnya, misalnya `PutObject` dan. `GetObject` Beberapa operasi S3, bagaimanapun, memerlukan perhitungan checksum; Anda tidak dapat menonaktifkan perhitungan checksum untuk operasi ini.

SDK menyediakan pengaturan terpisah untuk perhitungan checksum untuk muatan permintaan dan untuk muatan respons.

Daftar berikut menjelaskan pengaturan yang dapat Anda gunakan untuk meminimalkan perhitungan checksum pada cakupan yang berbeda.
+ **Semua ruang lingkup aplikasi** —Dengan mengubah pengaturan dalam variabel lingkungan atau dalam profil di bersama AWS `config` dan `credentials` file, semua aplikasi dapat menggunakan pengaturan ini. Pengaturan ini memengaruhi semua klien layanan di semua aplikasi AWS SDK kecuali diganti pada cakupan klien aplikasi atau layanan.
  + Tambahkan pengaturan di profil:

    ```
    [default]
    request_checksum_calculation = WHEN_REQUIRED
    response_checksum_validation = WHEN_REQUIRED
    ```
  + Tambahkan variabel lingkungan:

    ```
    AWS_REQUEST_CHECKSUM_CALCULATION=WHEN_REQUIRED
    AWS_RESPONSE_CHECKSUM_VALIDATION=WHEN_REQUIRED
    ```
+ **Lingkup aplikasi saat ini** —Anda dapat mengatur properti sistem Java `aws.requestChecksumCalculation` `WHEN_REQUIRED` untuk membatasi perhitungan checksum. Properti sistem yang sesuai untuk tanggapan adalah`aws.responseChecksumValidation`.

  Pengaturan ini memengaruhi semua klien layanan SDK dalam aplikasi kecuali diganti selama pembuatan klien layanan.

  Mengatur properti sistem di awal aplikasi Anda:

  ```
  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.
      }
  }
  ```
+ **Lingkup klien layanan S3 tunggal** —Anda dapat mengonfigurasi satu klien layanan S3 untuk menghitung jumlah minimum checksum menggunakan metode pembangun:

  ```
  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. 
      }
  // ...
  }
  ```

### Gunakan `LegacyMd5Plugin` untuk MD5 kompatibilitas yang disederhanakan
<a name="S3-checksum-legacy-md5"></a>

Seiring dengan rilis perilaku CRC32 checksum dengan versi 2.30.0, SDK berhenti menghitung MD5 checksum pada operasi yang diperlukan.

Jika Anda memerlukan perilaku MD5 checksum lama untuk operasi S3, Anda dapat menggunakan`LegacyMd5Plugin`, yang dirilis dengan SDK versi 2.31.32.

`LegacyMd5Plugin`Ini sangat berguna ketika Anda perlu mempertahankan kompatibilitas dengan aplikasi yang bergantung pada perilaku MD5 checksum lama, terutama ketika bekerja dengan penyedia penyimpanan pihak ketiga yang kompatibel dengan S3 seperti yang digunakan dengan konektor sistem file S3A (Apache Spark, Iceberg).

Untuk menggunakan`LegacyMd5Plugin`, tambahkan ke pembuat klien S3 Anda:

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

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

Jika Anda ingin menambahkan MD5 checksum ke operasi yang memerlukan checksum dan ingin melewatkan penambahan checksum default SDK untuk operasi yang mendukung checksum tetapi tidak diperlukan, Anda dapat mengaktifkan opsi dan as. `ClientBuilder` `requestChecksumCalculation` `responseChecksumValidation` `WHEN_REQUIRED` Ini akan menambahkan checksum default SDK hanya untuk operasi yang memerlukan checksum:

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

Konfigurasi ini sangat berguna ketika bekerja dengan sistem penyimpanan pihak ketiga yang kompatibel dengan S3 yang mungkin tidak sepenuhnya mendukung algoritma checksum yang lebih baru tetapi masih memerlukan MD5 checksum untuk operasi tertentu.

# Gunakan klien S3 berkinerja: klien S3 berbasis AWS CRT
<a name="crt-based-s3-client"></a>

Klien S3 AWS berbasis CRT — dibangun di atas [AWS Common Runtime (CRT) — adalah klien asinkron](https://docs.aws.amazon.com/sdkref/latest/guide/common-runtime.html) S3 alternatif. [Ini mentransfer objek ke dan dari Amazon Simple Storage Service (Amazon S3) Simple Storage Service (Amazon S3) dengan peningkatan kinerja dan keandalan dengan secara otomatis menggunakan API unggahan [multipart Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/mpuoverview.html) dan pengambilan rentang byte.](https://docs.aws.amazon.com/AmazonS3/latest/userguide/optimizing-performance-guidelines.html#optimizing-performance-guidelines-get-range) 

Klien S3 AWS berbasis CRT meningkatkan keandalan transfer jika ada kegagalan jaringan. Keandalan ditingkatkan dengan mencoba kembali bagian-bagian individual yang gagal dari transfer file tanpa memulai ulang transfer dari awal.

Selain itu, klien S3 AWS berbasis CRT menawarkan penyatuan koneksi yang ditingkatkan dan penyeimbangan beban Sistem Nama Domain (DNS), yang juga meningkatkan throughput.

Anda dapat menggunakan klien S3 AWS berbasis CRT sebagai pengganti klien asinkron S3 standar SDK dan segera memanfaatkan throughputnya yang ditingkatkan.

**penting**  
Klien S3 AWS berbasis CRT saat ini tidak mendukung [pengumpulan metrik SDK](metrics.md) di tingkat klien maupun di tingkat permintaan.

**AWS Komponen berbasis CRT di SDK**

Klien *S3 AWS * berbasis CRT, dijelaskan dalam topik ini, dan klien *HTTP AWS * berbasis CRT adalah komponen yang berbeda dalam SDK. 

**Klien S3 AWS berbasis CRT** adalah implementasi AsyncClient antarmuka [S3](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/S3AsyncClient.html) dan digunakan untuk bekerja dengan layanan Amazon S3. Ini adalah alternatif untuk implementasi `S3AsyncClient` antarmuka berbasis Java dan menawarkan beberapa manfaat.

[Client HTTP AWS berbasis CRT](http-configuration-crt.md) adalah implementasi [SdkAsyncHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/async/SdkAsyncHttpClient.html)antarmuka dan digunakan untuk komunikasi HTTP umum. Ini adalah alternatif untuk implementasi `SdkAsyncHttpClient` antarmuka Netty dan menawarkan beberapa keuntungan.

Meskipun kedua komponen menggunakan pustaka dari [AWS Common Runtime](https://docs.aws.amazon.com/sdkref/latest/guide/common-runtime.html), klien S3 AWS berbasis CRT menggunakan [pustaka aws-c-s 3](https://github.com/awslabs/aws-c-s3) dan mendukung fitur API unggahan multipart [S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/mpuoverview.html). Karena klien HTTP AWS berbasis CRT dimaksudkan untuk penggunaan tujuan umum, itu tidak mendukung fitur API unggahan multibagian S3.

## Tambahkan dependensi untuk menggunakan klien S3 berbasis AWS CRT
<a name="crt-based-s3-client-depend"></a>

Untuk menggunakan klien S3 AWS berbasis CRT, tambahkan dua dependensi berikut ke file proyek Maven Anda. Contoh menunjukkan versi minimum yang akan digunakan. [Cari repositori pusat Maven untuk versi terbaru dari artefak [s3](https://central.sonatype.com/artifact/software.amazon.awssdk/s3) dan aws-crt.](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>
```

## Buat instance klien S3 AWS berbasis CRT
<a name="crt-based-s3-client-create"></a>

 Buat instance klien S3 AWS berbasis CRT dengan pengaturan default seperti yang ditunjukkan pada cuplikan kode berikut.

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

Untuk mengkonfigurasi klien, gunakan pembuat klien AWS CRT. Anda dapat beralih dari klien asinkron S3 standar ke klien AWS berbasis CRT dengan mengubah metode pembangun.

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

**catatan**  
Beberapa pengaturan di pembuat standar mungkin saat ini tidak didukung di pembuat klien AWS CRT. Dapatkan pembangun standar dengan menelepon`S3AsyncClient#builder()`.

## Gunakan klien AWS S3 berbasis CRT
<a name="crt-based-s3-client-use"></a>

Gunakan klien S3 AWS berbasis CRT untuk memanggil operasi API Amazon S3. Contoh berikut menunjukkan [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))dan [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))operasi yang tersedia melalui. AWS SDK untuk 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();
```

## Mengunggah aliran dengan ukuran yang tidak diketahui
<a name="crt-stream-unknown-size"></a>

Salah satu keuntungan signifikan dari klien S3 AWS AWS berbasis CRT adalah kemampuannya untuk menangani aliran input dengan ukuran yang tidak diketahui secara efisien. Ini sangat berguna ketika Anda perlu mengunggah data dari sumber di mana ukuran totalnya tidak dapat ditentukan sebelumnya.

```
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;
}
```

Kemampuan ini membantu menghindari masalah umum dengan unggahan tradisional di mana spesifikasi panjang konten yang salah dapat menyebabkan objek terpotong atau unggahan gagal.

## Batasan konfigurasi
<a name="crt-based-s3-client-limitations"></a>

Klien S3 AWS berbasis CRT dan klien async S3 berbasis Java [menyediakan fitur yang sebanding](examples-s3.md#s3-clients), dengan klien S3 berbasis CRT yang menawarkan keunggulan kinerja. AWS Namun, klien S3 AWS berbasis CRT tidak memiliki pengaturan konfigurasi yang dimiliki klien async S3 berbasis Java. Pengaturan ini meliputi:
+ *Konfigurasi tingkat klien:* Batas waktu upaya panggilan API, pencegat eksekusi kompresi, penerbit metrik, atribut eksekusi kustom, opsi lanjutan khusus, layanan pelaksana terjadwal khusus, header khusus
+ *Konfigurasi tingkat permintaan:* penandatangan khusus, batas waktu upaya panggilan API

Untuk daftar lengkap perbedaan konfigurasi, lihat referensi API.


| Klien asinkron S3 berbasis Java | AWS Klien S3 berbasis CRT | 
| --- | --- | 
| Konfigurasi tingkat klien[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/sdk-for-java/latest/developer-guide/crt-based-s3-client.html)Konfigurasi tingkat permintaan[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/sdk-for-java/latest/developer-guide/crt-based-s3-client.html) | Konfigurasi tingkat klien[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/sdk-for-java/latest/developer-guide/crt-based-s3-client.html)Konfigurasi tingkat permintaan[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/sdk-for-java/latest/developer-guide/crt-based-s3-client.html) | 

# Konfigurasikan klien async S3 berbasis Java untuk menggunakan transfer paralel
<a name="s3-async-client-multipart"></a>

Sejak versi 2.27.5, klien async S3 berbasis Java standar mendukung transfer paralel otomatis (unggahan dan unduhan multipart). Anda mengonfigurasi dukungan untuk transfer paralel saat membuat klien asinkron S3 berbasis Java. 

Bagian ini menunjukkan cara mengaktifkan transfer paralel dan cara menyesuaikan konfigurasi.

## Buat sebuah instance dari `S3AsyncClient`
<a name="s3-async-client-multipart-create"></a>

Saat Anda membuat `S3AsyncClient` instance tanpa memanggil `multipart*` metode apa pun di [builder](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/S3AsyncClientBuilder.html), transfer paralel tidak diaktifkan. Setiap pernyataan berikut membuat klien asinkron S3 berbasis Java tanpa dukungan untuk unggahan dan unduhan multibagian.

### Buat *tanpa dukungan* multipart
<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();
```

### Buat *dengan dukungan* multipart
<a name="s3-async-client-mp-on"></a>

Untuk mengaktifkan transfer paralel dengan pengaturan default, panggil `multipartEnabled` pembangun dan teruskan `true` seperti yang ditunjukkan pada contoh berikut.

**Example**  

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

Nilai default adalah 8 MiB untuk `thresholdInBytes` dan `minimumPartSizeInBytes` pengaturan.

Jika Anda menyesuaikan pengaturan multipart, transfer paralel secara otomatis diaktifkan seperti yang ditunjukkan pada berikut ini.

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

## Mengunggah aliran dengan ukuran yang tidak diketahui
<a name="java-async-client-stream-unknown-size"></a>

Klien asinkron S3 berbasis Java dengan multipart diaktifkan dapat secara efisien menangani aliran input di mana ukuran total tidak diketahui sebelumnya:

```
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;
}
```

Pendekatan ini mencegah masalah yang dapat terjadi saat menentukan panjang konten yang salah secara manual, seperti objek terpotong atau unggahan yang gagal.

# Transfer file dan direktori dengan Amazon S3 Transfer Manager
<a name="transfer-manager"></a>

Amazon S3 Transfer Manager adalah sumber terbuka, utilitas transfer file tingkat tinggi untuk file. AWS SDK for Java 2.x Gunakan untuk mentransfer file dan direktori ke dan dari Amazon Simple Storage Service (Amazon S3). 

[https://docs.aws.amazon.com/AmazonS3/latest/userguide/mpuoverview.html](https://docs.aws.amazon.com/AmazonS3/latest/userguide/mpuoverview.html) 

Dengan S3 Transfer Manager, Anda juga dapat memantau kemajuan transfer secara real time dan menjeda transfer untuk eksekusi nanti.

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

### Tambahkan dependensi ke file build
<a name="transfer-manager-add-dependency"></a>

Untuk menggunakan S3 Transfer Manager dengan performa multipart yang disempurnakan, konfigurasikan file build Anda dengan dependensi yang diperlukan.

------
#### [ 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 [Versi terbaru](https://central.sonatype.com/artifact/software.amazon.awssdk/bom). 2 [Versi terbaru](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 [Versi terbaru](https://central.sonatype.com/artifact/software.amazon.awssdk/bom).

------

### Buat instance dari S3 Transfer Manager
<a name="transfer-manager-create"></a>

Untuk mengaktifkan transfer paralel, Anda harus meneruskan klien S3 AWS berbasis CRT ATAU klien async S3 berbasis Java dengan multipart diaktifkan. Contoh berikut menunjukkan cara mengkonfigurasi Manajer Transfer S3 dengan pengaturan khusus. 

------
#### [ 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 ]

Jika `aws-crt` dependensi tidak disertakan dalam file build, S3 Transfer Manager dibangun di atas klien async S3 berbasis Java standar yang digunakan dalam SDK for Java 2.x. 

**Konfigurasi kustom klien S3 - memerlukan multipart diaktifkan**

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

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

**Tidak ada konfigurasi klien S3 - dukungan multipart diaktifkan secara otomatis**

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

------

## Unggah file ke bucket S3
<a name="transfer-manager-upload"></a>

Contoh berikut menunjukkan contoh upload file bersama dengan penggunaan opsional dari [LoggingTransferListener](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/transfer/s3/progress/LoggingTransferListener.html), yang mencatat kemajuan upload.

[Untuk mengunggah file ke Amazon S3 menggunakan S3 Transfer Manager, teruskan [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)objek ke metode UploadFile. `S3TransferManager`](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/transfer/s3/S3TransferManager.html#uploadFile(software.amazon.awssdk.transfer.s3.model.UploadFileRequest))

[FileUpload](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/transfer/s3/model/FileUpload.html)Objek yang dikembalikan dari `uploadFile` metode mewakili proses upload. Setelah permintaan selesai, [CompletedFileUpload](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/transfer/s3/model/CompletedFileUpload.html)objek berisi informasi tentang unggahan.

```
    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!
        */
    }
```

### Impor
<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;
```

## Unduh file dari ember S3
<a name="transfer-manager-download"></a>

Contoh berikut menunjukkan contoh download bersama dengan penggunaan opsional dari [LoggingTransferListener](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/transfer/s3/progress/LoggingTransferListener.html), yang mencatat kemajuan download.

Untuk mengunduh objek dari bucket S3 menggunakan S3 Transfer Manager, buat [DownloadFileRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/transfer/s3/model/DownloadFileRequest.html)objek dan teruskan ke metode [DownloadFile](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/transfer/s3/S3TransferManager.html#downloadFile(software.amazon.awssdk.transfer.s3.model.DownloadFileRequest)).

[FileDownload](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/transfer/s3/model/FileDownload.html)Objek yang `S3TransferManager` dikembalikan oleh `downloadFile` metode ini mewakili transfer file. Setelah unduhan selesai, [CompletedFileDownload](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/transfer/s3/model/CompletedFileDownload.html)berisi akses ke informasi tentang unduhan.

```
    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!
        */
    }
```

### Impor
<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;
```

## Salin objek Amazon S3 ke ember lain
<a name="transfer-manager-copy"></a>

Contoh berikut menunjukkan cara menyalin objek dengan S3 Transfer Manager.

Untuk memulai salinan objek dari bucket S3 ke bucket lain, buat [CopyObjectRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/model/CopyObjectRequest.html)instance dasar.

Selanjutnya, bungkus dasar `CopyObjectRequest` dalam [CopyRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/transfer/s3/model/CopyRequest.html)yang dapat digunakan oleh S3 Transfer Manager. 

`Copy`Objek yang dikembalikan oleh `copy` metode ini mewakili proses penyalinan. `S3TransferManager` Setelah proses penyalinan selesai, [CompletedCopy](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/transfer/s3/model/CompletedCopy.html)objek berisi detail tentang respons.

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

**catatan**  
Untuk melakukan salinan Lintas wilayah dengan S3 Transfer Manager, aktifkan `crossRegionAccessEnabled` pada pembuat klien S3 AWS berbasis CRT seperti yang ditunjukkan pada cuplikan berikut.  

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

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

### Impor
<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;
```

## Unggah direktori lokal ke bucket S3
<a name="transfer-manager-upload_directory"></a>

Contoh berikut menunjukkan bagaimana Anda dapat meng-upload direktori lokal ke S3.

Mulailah dengan memanggil metode [uploadDirectory](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/transfer/s3/S3TransferManager.html#uploadDirectory(software.amazon.awssdk.transfer.s3.model.UploadDirectoryRequest)) dari `S3TransferManager` instance, meneruskan file. [UploadDirectoryRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/transfer/s3/model/UploadDirectoryRequest.html)

[DirectoryUpload](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/transfer/s3/model/DirectoryUpload.html)Objek mewakili proses upload, yang menghasilkan [CompletedDirectoryUpload](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/transfer/s3/model/CompletedDirectoryUpload.html)ketika permintaan selesai. `CompleteDirectoryUpload`Objek berisi informasi tentang hasil transfer, termasuk file mana yang gagal ditransfer.

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

### Impor
<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;
```

## Unduh objek bucket S3 ke direktori lokal
<a name="transfer-manager-download_directory"></a>

Anda dapat mengunduh objek dalam bucket S3 ke direktori lokal seperti yang ditunjukkan pada contoh berikut.

Untuk mengunduh objek dalam bucket S3 ke direktori lokal, mulailah dengan memanggil metode [DownloadDirectory](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/transfer/s3/S3TransferManager.html#downloadDirectory(software.amazon.awssdk.transfer.s3.model.DownloadDirectoryRequest)) dari Transfer Manager, meneruskan file. [DownloadDirectoryRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/transfer/s3/model/DownloadDirectoryRequest.html)

[DirectoryDownload](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/transfer/s3/model/DirectoryDownload.html)Objek mewakili proses download, yang menghasilkan [CompletedDirectoryDownload](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/transfer/s3/model/CompletedDirectoryDownload.html)ketika permintaan selesai. `CompleteDirectoryDownload`Objek berisi informasi tentang hasil transfer, termasuk file mana yang gagal ditransfer.

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

### Impor
<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;
```

## Lihat contoh lengkap
<a name="transfer-manager-example-location"></a>

[GitHub berisi kode lengkap](https://github.com/awsdocs/aws-doc-sdk-examples/tree/d73001daea05266eaa9e074ccb71b9383832369a/javav2/example_code/s3/src/main/java/com/example/s3/transfermanager) untuk semua contoh di halaman ini.

# Bekerja dengan Pemberitahuan Acara S3
<a name="examples-s3-event-notifications"></a>

Untuk membantu Anda memantau aktivitas di bucket, Amazon S3 dapat mengirim notifikasi saat peristiwa tertentu terjadi. Panduan Pengguna Amazon S3 memberikan informasi tentang [notifikasi yang dapat dikirimkan bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/EventNotifications.html#notification-how-to-overview). 

Anda dapat menyiapkan bucket untuk mengirim peristiwa ke empat kemungkinan tujuan menggunakan SDK for Java: 
+ Topik Amazon Simple Notification Service
+ Antrean Amazon Simple Queue Service
+ AWS Lambda fungsi
+ Amazon EventBridge

Saat menyiapkan bucket untuk mengirim acara EventBridge, Anda memiliki kemampuan untuk mengonfigurasi EventBridge aturan untuk meng-fanout acara yang sama ke beberapa tujuan. Saat Anda mengonfigurasi bucket untuk dikirim langsung ke salah satu dari tiga tujuan pertama, hanya satu jenis tujuan yang dapat ditentukan untuk setiap acara.

Di bagian selanjutnya, Anda akan melihat cara mengonfigurasi bucket menggunakan SDK for Java untuk mengirim Pemberitahuan Acara S3 dengan dua cara: langsung ke antrian Amazon SQS dan ke. EventBridge

Bagian terakhir menunjukkan cara menggunakan S3 Event Notifications API untuk bekerja dengan notifikasi dengan cara berorientasi objek.

## Konfigurasikan bucket untuk mengirim langsung ke tujuan
<a name="s3-event-conf-bucket-direct"></a>

Contoh berikut mengonfigurasi bucket untuk mengirim notifikasi saat peristiwa *pembuatan objek* atau peristiwa *penandaan objek* terjadi terhadap bucket.

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

Kode yang ditunjukkan di atas mengatur satu antrian untuk menerima dua jenis acara. Dengan mudah, `queueConfigurations` metode ini memungkinkan Anda untuk mengatur beberapa tujuan antrian jika diperlukan. Selain itu, dalam `notificationConfiguration` metode ini Anda dapat mengatur tujuan tambahan, seperti satu atau beberapa topik Amazon SNS atau satu atau lebih fungsi Lambda. Cuplikan berikut menunjukkan contoh dengan dua antrian dan tiga jenis tujuan.

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

 GitHub Repositori Contoh Kode berisi [contoh lengkap](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javav2/example_code/s3/src/main/java/com/example/s3/ProcessS3EventNotification.java) untuk mengirim pemberitahuan acara S3 langsung ke antrian.

## Konfigurasikan bucket untuk dikirim EventBridge
<a name="s3-event-conf-bucket-eventbridge"></a>

Contoh berikut mengonfigurasi bucket untuk mengirim notifikasi. 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());
```

Saat Anda mengonfigurasi bucket untuk mengirim acara EventBridge, Anda cukup menunjukkan EventBridge tujuan, bukan jenis acara atau tujuan akhir yang EventBridge akan dikirim. Anda mengonfigurasi target akhir dan jenis acara dengan menggunakan EventBridge klien Java SDK.

Kode berikut menunjukkan cara mengkonfigurasi EventBridge untuk menyebarkan peristiwa yang *dibuat objek* ke topik dan antrian.

```
   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;
    }
```

Untuk bekerja dengan EventBridge kode Java Anda, tambahkan ketergantungan pada `eventbridge` artefak ke file `pom.xml` Maven Anda.

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

 GitHub Repositori Contoh Kode berisi [contoh lengkap](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javav2/example_code/s3/src/main/java/com/example/s3/PutBucketS3EventNotificationEventBridge.java) untuk mengirim pemberitahuan acara S3 ke EventBridge dan kemudian ke topik dan antrian.

## Gunakan API Pemberitahuan Acara S3 untuk memproses peristiwa
<a name="s3-event-notification-read"></a>

Setelah tujuan menerima peristiwa notifikasi S3, Anda dapat memprosesnya dengan cara berorientasi objek dengan menggunakan S3 Event Notifications API. Anda dapat menggunakan S3 Event Notifications API untuk bekerja dengan pemberitahuan peristiwa yang dikirim langsung ke target (seperti yang ditunjukkan pada [contoh pertama](#s3-event-conf-bucket-direct)), tetapi tidak dengan notifikasi yang diarahkan. EventBridge Pemberitahuan peristiwa S3 dikirim oleh bucket untuk EventBridge berisi [struktur berbeda](https://docs.aws.amazon.com/AmazonS3/latest/userguide/ev-events.html#ev-events-list) yang saat ini tidak ditangani oleh API Pemberitahuan Acara S3.

### Tambahkan ketergantungan
<a name="s3-event-notifications-dep"></a>

S3 Event Notifications API dirilis dengan SDK for Java 2.x versi 2.25.11.

Untuk menggunakan S3 Event Notifications API, tambahkan elemen dependensi yang diperlukan ke Maven Anda `pom.xml` seperti yang ditunjukkan pada cuplikan berikut.

```
<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 [Versi terbaru](https://central.sonatype.com/artifact/software.amazon.awssdk/bom).

### Gunakan `S3EventNotification` kelas
<a name="s3-event-notifications-use"></a>

#### Buat `S3EventNotification` instance dari string JSON
<a name="s3-event-notifications-use-from-json"></a>

Untuk mengkonversi string JSON menjadi `S3EventNotification` objek, menggunakan metode statis `S3EventNotification` kelas seperti yang ditunjukkan pada contoh berikut.

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

Dalam contoh ini, `fromJson` metode mengubah string JSON menjadi objek`S3EventNotification`. Bidang yang hilang dalam string JSON akan menghasilkan `null` nilai di bidang objek Java yang sesuai dan bidang tambahan apa pun di JSON akan diabaikan.

Lainnya APIs untuk catatan pemberitahuan peristiwa dapat ditemukan di referensi API untuk`[S3EventNotificationRecord](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/eventnotifications/s3/model/S3EventNotificationRecord.html)`.

#### Mengkonversi `S3EventNotification` instance ke string JSON
<a name="s3-event-notifications-use-to-json"></a>

Gunakan metode `toJson` (or`toJsonPretty`) untuk mengubah `S3EventNotification` objek menjadi string JSON seperti yang ditunjukkan pada contoh berikut.

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

Bidang untuk `GlacierEventData``ReplicationEventData`,`IntelligentTieringEventData`,, dan `LifecycleEventData` dikecualikan dari JSON jika memang `null` demikian. `null`Bidang lainnya akan diserialkan sebagai`null`.

Berikut ini menunjukkan contoh output dari `toJsonPretty` metode untuk peristiwa penandaan objek S3.

```
{
  "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
      }
    }
  } ]
}
```

[Contoh lengkap](https://github.com/awsdocs/aws-doc-sdk-examples/blob/75c3daadf750406156fc87fa30ee499a206b4a36/javav2/example_code/s3/src/main/java/com/example/s3/ProcessS3EventNotification.java#L117) tersedia GitHub yang menunjukkan cara menggunakan API untuk bekerja dengan notifikasi yang diterima oleh antrean Amazon SQS.

## Proses Acara S3 di Lambda dengan Perpustakaan Java: dan AWS SDK for Java 2.x `aws-lambda-java-events`
<a name="s3-event-notif-processing-options"></a>

Alih-alih menggunakan SDK for Java 2.x untuk memproses notifikasi peristiwa Amazon S3 dalam fungsi Lambda, Anda dapat menggunakan pustaka pada versi 3.xx. `[aws-lambda-java-events](https://github.com/aws/aws-lambda-java-libs/tree/main/aws-lambda-java-events)` AWS memelihara `aws-lambda-java-events` perpustakaan secara independen, dan memiliki persyaratan ketergantungan sendiri. `aws-lambda-java-events`Pustaka hanya berfungsi dengan peristiwa S3 dalam fungsi Lambda, sedangkan SDK for Java 2.x berfungsi dengan peristiwa S3 di fungsi Lambda, Amazon SNS, dan Amazon SQS.

Kedua pendekatan memodelkan payload notifikasi acara JSON dengan cara yang berorientasi objek dengan yang serupa. APIs Tabel berikut menunjukkan perbedaan mencolok antara menggunakan dua pendekatan.


****  

|  | AWS SDK untuk Java | aws-lambda-java-events perpustakaan | 
| --- | --- | --- | 
| Penamaan Package |  `software.amazon.awssdk.eventnotifications.s3.model.S3EventNotification`  | com.amazonaws.services.lambda.runtime.events.models.s3.S3EventNotification | 
| RequestHandlerparameter |  Tulis `RequestHandler` implementasi fungsi Lambda Anda untuk menerima String JSON: <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>  | Tulis RequestHandler implementasi fungsi Lambda Anda untuk menerima objekS3Event:<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> | 
| Ketergantungan Maven |  <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>  |