Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Memulai menggunakan DynamoDB Enhanced Client API
Tutorial berikut memperkenalkan Anda pada dasar-dasar yang Anda butuhkan untuk bekerja dengan DynamoDB Enhanced Client API.
## Tambahkan dependensi
Untuk mulai bekerja dengan DynamoDB Enhanced Client API di project Anda, tambahkan dependensi pada artefak Maven. `dynamodb-enhanced` Ini ditunjukkan dalam contoh berikut.
------
#### [ Maven ]
```
software.amazon.awssdk
bom
pom
import
software.amazon.awssdk
dynamodb-enhanced
...
```
Lakukan pencarian repositori pusat Maven untuk [versi terbaru](https://central.sonatype.com/artifact/software.amazon.awssdk/bom) dan ganti ** dengan nilai ini.
------
#### [ Gradle ]
```
repositories {
mavenCentral()
}
dependencies {
implementation(platform("software.amazon.awssdk:bom:"))
implementation("software.amazon.awssdk:dynamodb-enhanced")
...
}
```
Lakukan pencarian repositori pusat Maven untuk [versi terbaru](https://central.sonatype.com/artifact/software.amazon.awssdk/bom) dan ganti ** dengan nilai ini.
------
# Menghasilkan `TableSchema` dari kelas data
A `[TableSchema](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/TableSchema.html)` memungkinkan klien yang disempurnakan untuk memetakan nilai atribut DynamoDB ke dan dari kelas sisi klien Anda. Dalam tutorial ini, Anda belajar tentang `TableSchema` s yang berasal dari kelas data statis dan dihasilkan dari kode dengan menggunakan pembangun.
## Gunakan kelas data beranotasi
SDK for Java 2.x menyertakan [serangkaian anotasi](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/mapper/annotations/package-summary.html) yang dapat Anda gunakan dengan kelas data untuk menghasilkan `TableSchema` cepat untuk memetakan kelas Anda ke tabel.
Mulailah dengan membuat kelas data yang sesuai dengan [JavaBean spesifikasi](https://download.oracle.com/otn-pub/jcp/7224-javabeans-1.01-fr-spec-oth-JSpec/beans.101.pdf). Spesifikasi mensyaratkan bahwa kelas memiliki konstruktor publik tanpa argumen dan memiliki getter dan setter untuk setiap atribut di kelas. Sertakan anotasi tingkat kelas untuk menunjukkan bahwa kelas data adalah a. `DynamoDbBean` Juga, minimal, sertakan `DynamoDbPartitionKey` anotasi pada pengambil atau penyetel untuk atribut kunci utama.
Anda dapat menerapkan [anotasi tingkat atribut](ddb-en-client-anno-index.md) ke getter atau setter, tetapi tidak keduanya.
**catatan**
Istilah `property` ini biasanya digunakan untuk nilai yang dienkapsulasi dalam a. JavaBean Namun, panduan ini menggunakan istilah `attribute` sebagai gantinya, agar konsisten dengan terminologi yang digunakan oleh DynamoDB.
`Customer`Kelas berikut menunjukkan anotasi yang menghubungkan definisi kelas ke tabel DynamoDB.
### `Customer` kelas
```
package org.example.tests.model;
import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.DynamoDbBean;
import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.DynamoDbPartitionKey;
import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.DynamoDbSortKey;
import java.time.Instant;
@DynamoDbBean
public class Customer {
private String id;
private String name;
private String email;
private Instant regDate;
@DynamoDbPartitionKey
public String getId() { return this.id; }
public void setId(String id) { this.id = id; }
public String getCustName() { return this.name; }
public void setCustName(String name) { this.name = name; }
@DynamoDbSortKey
public String getEmail() { return this.email; }
public void setEmail(String email) { this.email = email; }
public Instant getRegistrationDate() { return this.regDate; }
public void setRegistrationDate(Instant registrationDate) { this.regDate = registrationDate; }
@Override
public String toString() {
return "Customer [id=" + id + ", name=" + name + ", email=" + email
+ ", regDate=" + regDate + "]";
}
}
```
Setelah Anda membuat kelas data beranotasi, gunakan untuk membuat`TableSchema`, seperti yang ditunjukkan pada cuplikan berikut.
```
static final TableSchema customerTableSchema = TableSchema.fromBean(Customer.class);
```
A `TableSchema` dirancang untuk menjadi statis dan tidak dapat diubah. Anda biasanya dapat membuat instance pada waktu pemuatan kelas.
Metode `TableSchema.fromBean()` pabrik statis mengintrospeksi kacang untuk menghasilkan pemetaan atribut kelas data (properti) ke dan dari atribut DynamoDB.
Untuk contoh bekerja dengan model data yang terdiri dari beberapa kelas data, lihat `Person` kelas di [Bekerja dengan atribut yang kacang, peta, daftar, dan set](ddb-en-client-adv-features-nested.md) bagian tersebut.
## Gunakan pembangun
Anda dapat melewatkan biaya introspeksi kacang jika Anda menentukan skema tabel dalam kode. Jika Anda membuat kode skema, kelas Anda tidak perlu mengikuti standar JavaBean penamaan dan juga tidak perlu dianotasi. Contoh berikut menggunakan pembangun dan setara dengan contoh `Customer` kelas yang menggunakan anotasi.
```
static final TableSchema customerTableSchema =
TableSchema.builder(Customer.class)
.newItemSupplier(Customer::new)
.addAttribute(String.class, a -> a.name("id")
.getter(Customer::getId)
.setter(Customer::setId)
.tags(StaticAttributeTags.primaryPartitionKey()))
.addAttribute(String.class, a -> a.name("email")
.getter(Customer::getEmail)
.setter(Customer::setEmail)
.tags(StaticAttributeTags.primarySortKey()))
.addAttribute(String.class, a -> a.name("name")
.getter(Customer::getCustName)
.setter(Customer::setCustName))
.addAttribute(Instant.class, a -> a.name("registrationDate")
.getter(Customer::getRegistrationDate)
.setter(Customer::setRegistrationDate))
.build();
```
# Buat klien yang disempurnakan dan `DynamoDbTable`
## Buat klien yang disempurnakan
[DynamoDbEnhancedClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/DynamoDbEnhancedClient.html)Kelas atau rekan asinkron, [DynamoDbEnhancedAsyncClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/DynamoDbEnhancedAsyncClient.html), adalah titik masuk untuk bekerja dengan DynamoDB Enhanced Client API.
Klien yang disempurnakan membutuhkan standar `[DynamoDbClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/dynamodb/DynamoDbClient.html)` untuk melakukan pekerjaan. API menawarkan dua cara untuk membuat `DynamoDbEnhancedClient` instance. Opsi pertama, yang ditunjukkan dalam cuplikan berikut, membuat standar `DynamoDbClient` dengan pengaturan default diambil dari pengaturan konfigurasi.
```
DynamoDbEnhancedClient enhancedClient = DynamoDbEnhancedClient.create();
```
Jika Anda ingin mengonfigurasi klien standar yang mendasarinya, Anda dapat menyediakannya ke metode pembangun klien yang disempurnakan seperti yang ditunjukkan pada cuplikan berikut.
```
// Configure an instance of the standard DynamoDbClient.
DynamoDbClient standardClient = DynamoDbClient.builder()
.region(Region.US_EAST_1)
.credentialsProvider(ProfileCredentialsProvider.create())
.build();
// Use the configured standard client with the enhanced client.
DynamoDbEnhancedClient enhancedClient = DynamoDbEnhancedClient.builder()
.dynamoDbClient(standardClient)
.build();
```
## Buat sebuah `DynamoDbTable` instance
Pikirkan a [https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/DynamoDbTable.html](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/DynamoDbTable.html)sebagai representasi sisi klien dari tabel DynamoDB yang menggunakan fungsionalitas pemetaan yang disediakan oleh file. `TableSchema` `DynamoDbTable`Kelas menyediakan metode untuk operasi CRUD yang memungkinkan Anda berinteraksi dengan tabel DynamoDB tunggal.
`DynamoDbTable`adalah kelas generik yang mengambil argumen tipe tunggal, apakah itu kelas khusus atau `EnhancedDocument` saat bekerja dengan item tipe dokumen. Jenis argumen ini menetapkan hubungan antara kelas yang Anda gunakan dan tabel DynamoDB tunggal.
Gunakan metode `table()` pabrik `DynamoDbEnhancedClient` untuk membuat `DynamoDbTable` instance seperti yang ditunjukkan pada cuplikan berikut.
```
static final DynamoDbTable customerTable =
enhancedClient.table("Customer", TableSchema.fromBean(Customer.class));
```
`DynamoDbTable`contoh adalah kandidat untuk lajang karena mereka tidak dapat diubah dan dapat digunakan di seluruh aplikasi Anda.
Kode Anda sekarang memiliki representasi dalam memori dari tabel DynamoDB yang dapat bekerja dengan instance. `Customer` Tabel DynamoDB yang sebenarnya mungkin atau mungkin tidak ada. Jika tabel bernama `Customer` sudah ada, Anda dapat mulai melakukan operasi CRUD terhadapnya. Jika tidak ada, gunakan `DynamoDbTable` instance untuk membuat tabel seperti yang dibahas di bagian berikutnya.
# Buat tabel DynamoDB jika diperlukan
Setelah Anda membuat `DynamoDbTable` instance, gunakan untuk melakukan pembuatan tabel *satu kali* di DynamoDB.
## Buat kode contoh tabel
Contoh berikut membuat tabel DynamoDB berdasarkan `Customer` kelas data.
Contoh ini membuat tabel DynamoDB dengan `Customer` nama —identik dengan nama kelas—tetapi nama tabel bisa menjadi sesuatu yang lain. Apa pun nama Anda tabel, Anda harus menggunakan nama ini dalam aplikasi tambahan untuk bekerja dengan tabel. Berikan nama ini ke `table()` metode kapan pun Anda membuat `DynamoDbTable` objek lain agar dapat bekerja dengan tabel DynamoDB yang mendasarinya.
Parameter lambda Java`builder`,, diteruskan ke `createTable` metode memungkinkan Anda [menyesuaikan tabel](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/model/CreateTableEnhancedRequest.Builder.html). Dalam contoh ini, [throughput yang disediakan dikonfigurasi](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.ReadWriteCapacityMode.html#HowItWorks.ProvisionedThroughput.Manual). Jika Anda ingin menggunakan pengaturan default saat membuat tabel, lewati pembangun seperti yang ditunjukkan pada cuplikan berikut.
```
customerTable.createTable();
```
Saat pengaturan default digunakan, nilai untuk throughput yang disediakan tidak disetel. Sebagai gantinya, mode penagihan untuk tabel diatur ke [sesuai permintaan](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.ReadWriteCapacityMode.html#HowItWorks.OnDemand).
Contoh ini juga menggunakan `[DynamoDbWaiter](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/dynamodb/waiters/DynamoDbWaiter.html)` sebelum mencoba untuk mencetak nama tabel yang diterima dalam respon. Pembuatan meja membutuhkan waktu. Oleh karena itu, menggunakan pelayan berarti Anda tidak perlu menulis logika yang melakukan polling layanan DynamoDB untuk melihat apakah tabel ada sebelum menggunakan tabel.
### Impor
```
import com.example.dynamodb.Customer;
import software.amazon.awssdk.core.internal.waiters.ResponseOrException;
import software.amazon.awssdk.enhanced.dynamodb.DynamoDbEnhancedClient;
import software.amazon.awssdk.enhanced.dynamodb.DynamoDbTable;
import software.amazon.awssdk.enhanced.dynamodb.TableSchema;
import software.amazon.awssdk.enhanced.dynamodb.model.CreateTableEnhancedRequest;
import software.amazon.awssdk.services.dynamodb.model.DescribeTableResponse;
import software.amazon.awssdk.services.dynamodb.waiters.DynamoDbWaiter;
```
### Kode
```
public static void createCustomerTable(DynamoDbTable customerTable, DynamoDbClient standardClient) {
// Create the DynamoDB table using the 'customerTable' DynamoDbTable instance.
customerTable.createTable(builder -> builder
.provisionedThroughput(b -> b
.readCapacityUnits(10L)
.writeCapacityUnits(10L)
.build())
);
// The DynamoDbClient instance (named 'standardClient') passed to the builder for the DynamoDbWaiter is the same instance
// that was passed to the builder of the DynamoDbEnhancedClient instance that we created previously.
// By using the same instance, it ensures that the same Region that was configured on the standard DynamoDbClient
// instance is used for other service clients that accept a DynamoDbClient during construction.
try (DynamoDbWaiter waiter = DynamoDbWaiter.builder().client(standardClient).build()) { // DynamoDbWaiter is Autocloseable
ResponseOrException response = waiter
.waitUntilTableExists(builder -> builder.tableName("Customer").build())
.matched();
DescribeTableResponse tableDescription = response.response().orElseThrow(
() -> new RuntimeException("Customer table was not created."));
// The actual error can be inspected in response.exception()
logger.info("Customer table was created.");
}
}
```
**catatan**
Nama atribut tabel DynamoDB dimulai dengan huruf kecil ketika tabel dihasilkan dari kelas data. Jika Anda ingin nama atribut tabel dimulai dengan huruf besar, gunakan [`@DynamoDbAttribute(NAME)`anotasi](ddb-en-client-adv-features-inex-attr.md) dan berikan nama yang Anda inginkan sebagai parameter.
# Lakukan operasi
Setelah tabel dibuat, gunakan `DynamoDbTable` instance untuk melakukan operasi terhadap tabel DynamoDB.
Dalam contoh berikut, singleton `DynamoDbTable` dilewatkan sebagai parameter bersama dengan contoh [kelas `Customer` data](ddb-en-client-gs-tableschema.md#ddb-en-client-gs-tableschema-anno-bean-cust) untuk menambahkan item baru ke tabel.
```
public static void putItemExample(DynamoDbTable customerTable, Customer customer){
logger.info(customer.toString());
customerTable.putItem(customer);
}
```
## Objek `Customer`
```
Customer customer = new Customer();
customer.setId("1");
customer.setCustName("Customer Name");
customer.setEmail("customer@example.com");
customer.setRegistrationDate(Instant.parse("2023-07-03T10:15:30.00Z"));
```
Sebelum mengirim `customer` objek ke layanan DynamoDB, catat output dari metode objek untuk membandingkannya dengan apa yang dikirim `toString()` klien yang disempurnakan.
```
Customer [id=1, name=Customer Name, email=customer@example.com, regDate=2023-07-03T10:15:30Z]
```
Pencatatan tingkat kabel menunjukkan muatan permintaan yang dihasilkan. Klien yang disempurnakan menghasilkan representasi tingkat rendah dari kelas data. `regDate`Atribut, yang merupakan `Instant` tipe di Java, direpresentasikan sebagai string DynamoDB.
```
{
"TableName": "Customer",
"Item": {
"registrationDate": {
"S": "2023-07-03T10:15:30Z"
},
"id": {
"S": "1"
},
"custName": {
"S": "Customer Name"
},
"email": {
"S": "customer@example.com"
}
}
}
```
# Bekerja dengan tabel yang ada
Bagian sebelumnya menunjukkan cara membuat tabel DynamoDB dimulai dengan kelas data Java. Jika Anda sudah memiliki tabel yang ada dan ingin menggunakan fitur klien yang disempurnakan, Anda dapat membuat kelas data Java untuk bekerja dengan tabel. Anda perlu memeriksa tabel DynamoDB dan menambahkan anotasi yang diperlukan ke kelas data.
Sebelum Anda bekerja dengan tabel yang ada, panggil `DynamoDbEnhanced.table()` metode. Ini dilakukan pada contoh sebelumnya dengan pernyataan berikut.
```
DynamoDbTable customerTable = enhancedClient.table("Customer", TableSchema.fromBean(Customer.class));
```
Setelah `DynamoDbTable` instance dikembalikan, Anda dapat mulai bekerja segera dengan tabel yang mendasarinya. Anda tidak perlu membuat ulang tabel dengan memanggil `DynamoDbTable.createTable()` metode.
Contoh berikut menunjukkan ini dengan segera mengambil `Customer` contoh dari tabel DynamoDB.
```
DynamoDbTable customerTable = enhancedClient.table("Customer", TableSchema.fromBean(Customer.class));
// The Customer table exists already and has an item with a primary key value of "1" and a sort key value of "customer@example.com".
customerTable.getItem(
Key.builder().
partitionValue("1").
sortValue("customer@example.com").build());
```
**penting**
Nama tabel yang digunakan dalam `table()` metode harus cocok dengan nama tabel DynamoDB yang ada.