Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Ikhtisar dukungan AWS SDK untuk DynamoDB
Diagram berikut memberikan gambaran tingkat tinggi pemrograman aplikasi Amazon DynamoDB menggunakan file. AWS SDKs
![\[Model pemrograman untuk menggunakan DynamoDB dengan. AWS SDKs\]](http://docs.aws.amazon.com/id_id/amazondynamodb/latest/developerguide/images/SDKSupport.png)
1. Anda menulis aplikasi menggunakan AWS SDK untuk bahasa pemrograman Anda.
1. Setiap AWS SDK menyediakan satu atau lebih antarmuka terprogram untuk bekerja dengan DynamoDB. Antarmuka spesifik yang tersedia bergantung pada bahasa pemrograman dan AWS SDK yang Anda gunakan. Opsinya meliputi:
+ [Antarmuka tingkat rendah yang bekerja dengan DynamoDB](Programming.SDKs.Interfaces.md#Programming.SDKs.Interfaces.LowLevel)
+ [Antarmuka dokumen yang bekerja dengan DynamoDB](Programming.SDKs.Interfaces.md#Programming.SDKs.Interfaces.Document)
+ [Antarmuka persistensi objek yang bekerja dengan DynamoDB](Programming.SDKs.Interfaces.md#Programming.SDKs.Interfaces.Mapper)
+ [Antarmuka Tingkat Tinggi](HigherLevelInterfaces.md)
1. AWS SDK membuat permintaan HTTP (S) untuk digunakan dengan API DynamoDB tingkat rendah.
1. AWS SDK mengirimkan permintaan ke titik akhir DynamoDB.
1. DynamoDB menjalankan permintaan. Jika permintaan berhasil, DynamoDB mengembalikan kode respons HTTP 200 (OK). Jika permintaan tidak berhasil, DynamoDB mengembalikan kode galat dan pesan kesalahan HTTP.
1. AWS SDK memproses respons dan menyebarkannya kembali ke aplikasi Anda.
Masing-masing AWS SDKs menyediakan layanan penting untuk aplikasi Anda, termasuk yang berikut:
+ Memformat permintaan HTTP(S) dan menyerialisasi parameter permintaan.
+ Menghasilkan tanda tangan kriptografi untuk setiap permintaan.
+ Meneruskan permintaan ke titik akhir DynamoDB dan menerima respons dari DynamoDB.
+ Mengekstraksi hasil dari respons tersebut.
+ Menerapkan logika coba lagi dasar dalam kasus kesalahan.
Anda tidak perlu menulis kode untuk semua tugas ini.
**catatan**
Untuk informasi selengkapnya AWS SDKs, termasuk petunjuk penginstalan dan dokumentasi, lihat [Alat untuk Amazon Web Services](https://aws.amazon.com/tools).
## Dukungan SDK dari endpoint berbasis AWS akun
AWS meluncurkan dukungan SDK untuk AWS titik akhir berbasis akun untuk DynamoDB, dimulai dengan SDK for AWS Java V1 pada 4 September 2024. Titik akhir baru ini membantu AWS memastikan kinerja dan skalabilitas yang tinggi. Yang diperbarui SDKs akan secara otomatis menggunakan titik akhir baru, yang memiliki format`https://(account-id).ddb.(region).amazonaws.com`.
Jika Anda menggunakan satu instance klien SDK untuk membuat permintaan ke beberapa akun, aplikasi Anda akan memiliki lebih sedikit kesempatan untuk menggunakan kembali koneksi. AWS merekomendasikan untuk memodifikasi aplikasi Anda untuk terhubung ke lebih sedikit akun per instans klien SDK. Alternatifnya adalah menyetel klien SDK Anda untuk terus menggunakan titik akhir Regional menggunakan `ACCOUNT_ID_ENDPOINT_MODE` pengaturan, seperti yang didokumentasikan dalam Panduan [https://docs.aws.amazon.com/sdkref/latest/guide/feature-account-endpoints.html](https://docs.aws.amazon.com/sdkref/latest/guide/feature-account-endpoints.html).
# Antarmuka terprogram yang bekerja dengan DynamoDB
Setiap [AWS SDK](https://aws.amazon.com/tools) menyediakan satu atau lebih antarmuka program untuk bekerja dengan Amazon DynamoDB. Antarmuka ini memiliki rentang dari pembungkus DynamoDB level rendah sederhana hingga lapisan persistensi berorientasi objek. Antarmuka yang tersedia bervariasi tergantung pada AWS SDK dan bahasa pemrograman yang Anda gunakan.
![\[Antarmuka terprogram tersedia dalam berbagai cara AWS SDKs untuk bekerja dengan DynamoDB.\]](http://docs.aws.amazon.com/id_id/amazondynamodb/latest/developerguide/images/SDKSupport.SDKInterfaces.png)
Bagian berikut menyoroti beberapa antarmuka yang tersedia, menggunakan AWS SDK untuk Java sebagai contoh. (Tidak semua antarmuka tersedia di semua AWS SDKs.)
**Topics**
+ [Antarmuka tingkat rendah yang bekerja dengan DynamoDB](#Programming.SDKs.Interfaces.LowLevel)
+ [Antarmuka dokumen yang bekerja dengan DynamoDB](#Programming.SDKs.Interfaces.Document)
+ [Antarmuka persistensi objek yang bekerja dengan DynamoDB](#Programming.SDKs.Interfaces.Mapper)
## Antarmuka tingkat rendah yang bekerja dengan DynamoDB
Setiap AWS SDK khusus bahasa menyediakan antarmuka tingkat rendah untuk Amazon DynamoDB, dengan metode yang sangat mirip dengan permintaan API DynamoDB tingkat rendah.
Dalam beberapa kasus, Anda akan perlu untuk mengidentifikasi jenis data dari atribut-atribut tersebut menggunakan [Deskriptor jenis data](Programming.LowLevelAPI.md#Programming.LowLevelAPI.DataTypeDescriptors), seperti `S` untuk string, atau `N` untuk angka.
**catatan**
Antarmuka tingkat rendah tersedia dalam setiap AWS SDK khusus bahasa.
Program Java berikut menggunakan antarmuka AWS SDK untuk Java tingkat rendah.
### Contoh antarmuka tingkat rendah
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.dynamodb.model.DynamoDbException;
import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
import software.amazon.awssdk.services.dynamodb.model.AttributeValue;
import software.amazon.awssdk.services.dynamodb.model.GetItemRequest;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
/**
* Before running this Java V2 code example, set up your development
* environment, including your credentials.
*
* For more information, see the following documentation topic:
*
* https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
*
* To get an item from an Amazon DynamoDB table using the AWS SDK for Java V2,
* its better practice to use the
* Enhanced Client, see the EnhancedGetItem example.
*/
public class GetItem {
public static void main(String[] args) {
final String usage = """
Usage:
Where:
tableName - The Amazon DynamoDB table from which an item is retrieved (for example, Music3).\s
key - The key used in the Amazon DynamoDB table (for example, Artist).\s
keyval - The key value that represents the item to get (for example, Famous Band).
""";
if (args.length != 3) {
System.out.println(usage);
System.exit(1);
}
String tableName = args[0];
String key = args[1];
String keyVal = args[2];
System.out.format("Retrieving item \"%s\" from \"%s\"\n", keyVal, tableName);
Region region = Region.US_EAST_1;
DynamoDbClient ddb = DynamoDbClient.builder()
.region(region)
.build();
getDynamoDBItem(ddb, tableName, key, keyVal);
ddb.close();
}
public static void getDynamoDBItem(DynamoDbClient ddb, String tableName, String key, String keyVal) {
HashMap keyToGet = new HashMap<>();
keyToGet.put(key, AttributeValue.builder()
.s(keyVal)
.build());
GetItemRequest request = GetItemRequest.builder()
.key(keyToGet)
.tableName(tableName)
.build();
try {
// If there is no matching item, GetItem does not return any data.
Map returnedItem = ddb.getItem(request).item();
if (returnedItem.isEmpty())
System.out.format("No item found with the key %s!\n", key);
else {
Set keys = returnedItem.keySet();
System.out.println("Amazon DynamoDB table attributes: \n");
for (String key1 : keys) {
System.out.format("%s: %s\n", key1, returnedItem.get(key1).toString());
}
}
} catch (DynamoDbException e) {
System.err.println(e.getMessage());
System.exit(1);
}
}
}
```
## Antarmuka dokumen yang bekerja dengan DynamoDB
Banyak yang AWS SDKs menyediakan antarmuka dokumen, memungkinkan Anda untuk melakukan operasi bidang data (membuat, membaca, memperbarui, menghapus) pada tabel dan indeks. Dengan antarmuka dokumen, Anda tidak perlu menentukan [Deskriptor jenis data](Programming.LowLevelAPI.md#Programming.LowLevelAPI.DataTypeDescriptors). Jenis data yang tersirat oleh semantik data itu sendiri. Ini AWS SDKs juga menyediakan metode untuk dengan mudah mengonversi dokumen JSON ke dan dari tipe data Amazon DynamoDB asli.
**catatan**
Antarmuka dokumen tersedia di AWS SDKs untuk [Java](https://aws.amazon.com/sdk-for-java), [.NET](https://aws.amazon.com/sdk-for-net), [Node.js](https://aws.amazon.com/sdk-for-node-js), dan [JavaScriptSDK](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/).
Program Java berikut menggunakan antarmuka dokumen AWS SDK untuk Java. Program ini menciptakan objek `Table` yang merepresentasikan tabel `Music`, lalu meminta objek tersebut untuk menggunakan `GetItem` guna mengambil lagu. Program ini selanjutnya mencetak tahun lagu tersebut dirilis.
Kelas `software.amazon.dynamodb.document.DynamoDB` mengimplementasikan antarmuka dokumen DynamoDB. Perhatikan bagaimana `DynamoDB` berfungsi sebagai pembungkus di sekitar klien tingkat rendah (`AmazonDynamoDB`).
### Contoh antarmuka dokumen
```
package com.amazonaws.codesamples.gsg;
import software.amazon.dynamodb.AmazonDynamoDB;
import software.amazon.dynamodb.AmazonDynamoDBClientBuilder;
import software.amazon.dynamodb.document.DynamoDB;
import software.amazon.dynamodb.document.GetItemOutcome;
import software.amazon.dynamodb.document.Table;
public class MusicDocumentDemo {
public static void main(String[] args) {
AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();
DynamoDB docClient = new DynamoDB(client);
Table table = docClient.getTable("Music");
GetItemOutcome outcome = table.getItemOutcome(
"Artist", "No One You Know",
"SongTitle", "Call Me Today");
int year = outcome.getItem().getInt("Year");
System.out.println("The song was released in " + year);
}
}
```
## Antarmuka persistensi objek yang bekerja dengan DynamoDB
Beberapa AWS SDKs menyediakan antarmuka persistensi objek di mana Anda tidak secara langsung melakukan operasi bidang data. Sebagai gantinya, Anda akan membuat objek yang mewakili item dalam tabel dan indeks Amazon DynamoDB, dan hanya berinteraksi dengan objek tersebut. Ini memungkinkan Anda menulis kode yang berfokus pada objek, bukan kode yang berfokus pada basis data.
**catatan**
Antarmuka persistensi objek tersedia di AWS SDKs untuk Java dan .NET. Untuk informasi selengkapnya, lihat [Antarmuka pemrograman tingkat tinggi untuk DynamoDB](HigherLevelInterfaces.md) DynamoDB.
### Contoh antarmuka ketekunan objek
```
import com.example.dynamodb.Customer;
import software.amazon.awssdk.enhanced.dynamodb.DynamoDbEnhancedClient;
import software.amazon.awssdk.enhanced.dynamodb.DynamoDbTable;
import software.amazon.awssdk.enhanced.dynamodb.Key;
import software.amazon.awssdk.enhanced.dynamodb.TableSchema;
import software.amazon.awssdk.enhanced.dynamodb.model.GetItemEnhancedRequest;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
import software.amazon.awssdk.services.dynamodb.model.DynamoDbException;
```
```
import com.example.dynamodb.Customer;
import software.amazon.awssdk.enhanced.dynamodb.DynamoDbEnhancedClient;
import software.amazon.awssdk.enhanced.dynamodb.DynamoDbTable;
import software.amazon.awssdk.enhanced.dynamodb.Key;
import software.amazon.awssdk.enhanced.dynamodb.TableSchema;
import software.amazon.awssdk.enhanced.dynamodb.model.GetItemEnhancedRequest;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
import software.amazon.awssdk.services.dynamodb.model.DynamoDbException;
/*
* Before running this code example, create an Amazon DynamoDB table named Customer with these columns:
* - id - the id of the record that is the key. Be sure one of the id values is `id101`
* - custName - the customer name
* - email - the email value
* - registrationDate - an instant value when the item was added to the table. These values
* need to be in the form of `YYYY-MM-DDTHH:mm:ssZ`, such as 2022-07-11T00:00:00Z
*
* Also, ensure that you have set up your development environment, including your credentials.
*
* For information, see this documentation topic:
*
* https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
*/
public class EnhancedGetItem {
public static void main(String[] args) {
Region region = Region.US_EAST_1;
DynamoDbClient ddb = DynamoDbClient.builder()
.region(region)
.build();
DynamoDbEnhancedClient enhancedClient = DynamoDbEnhancedClient.builder()
.dynamoDbClient(ddb)
.build();
getItem(enhancedClient);
ddb.close();
}
public static String getItem(DynamoDbEnhancedClient enhancedClient) {
Customer result = null;
try {
DynamoDbTable table = enhancedClient.table("Customer", TableSchema.fromBean(Customer.class));
Key key = Key.builder()
.partitionValue("id101").sortValue("tred@noserver.com")
.build();
// Get the item by using the key.
result = table.getItem(
(GetItemEnhancedRequest.Builder requestBuilder) -> requestBuilder.key(key));
System.out.println("******* The description value is " + result.getCustName());
} catch (DynamoDbException e) {
System.err.println(e.getMessage());
System.exit(1);
}
return result.getCustName();
}
}
```
# Antarmuka pemrograman tingkat tinggi untuk DynamoDB
AWS SDKs Menyediakan aplikasi dengan antarmuka tingkat rendah untuk bekerja dengan Amazon DynamoDB. Metode dan kelas sisi klien ini berkaitan langsung dengan DynamoDB API tingkat rendah. Namun, banyak developer mengalami putusnya koneksi, atau *ketidakcocokan impedansi*, ketika mereka perlu memetakan jenis data yang kompleks untuk item dalam tabel basis data. Dengan antarmuka basis data tingkat rendah, developer harus menulis metode untuk membaca atau menulis data objek ke tabel basis data, dan sebaliknya. Jumlah kode tambahan yang diperlukan untuk setiap kombinasi jenis objek dan tabel basis data dapat terlihat sangat banyak.
Untuk menyederhanakan pengembangan, AWS SDKs untuk Java dan .NET menyediakan antarmuka tambahan dengan tingkat abstraksi yang lebih tinggi. Antarmuka tingkat yang lebih tinggi untuk DynamoDB memungkinkan Anda menentukan hubungan di antara objek dalam program Anda dan tabel basis data yang menyimpan data objek tersebut. Setelah menentukan pemetaan ini, Anda memanggil metode objek sederhana seperti `save`, `load`, atau `delete`, dan operasi DynamoDB tingkat rendah yang mendasarinya akan dipanggil secara otomatis atas nama Anda. Ini memungkinkan Anda menulis kode yang berfokus pada objek, bukan kode yang berfokus pada basis data.
Antarmuka pemrograman tingkat tinggi untuk DynamoDB tersedia di untuk Java dan .NET. AWS SDKs
**Java**
+ [Java 1.x: Dinamo DBMapper](DynamoDBMapper.md)
+ [Java 2.x: DynamoDB Enhanced Client](DynamoDBEnhanced.md)
**.NET**
+ [Bekerja dengan model dokumen.NET di DynamoDB](DotNetSDKMidLevel.md)
+ [Bekerja dengan model persistensi objek.NET dan DynamoDB](DotNetSDKHighLevel.md)
# Java 1.x: Dinamo DBMapper
**catatan**
SDK for Java memiliki dua versi: 1.x dan 2.x. end-of-supportUntuk 1.x [diumumkan](https://aws.amazon.com/blogs/developer/announcing-end-of-support-for-aws-sdk-for-java-v1-x-on-december-31-2025/) pada 12 Januari 2024. Itu akan dan akan jatuh tempo pada 31 Desember 2025. end-of-support Untuk pengembangan baru, kami sangat menyarankan Anda menggunakan 2.x.
AWS SDK untuk Java Ini menyediakan `DynamoDBMapper` kelas, memungkinkan Anda untuk memetakan kelas sisi klien Anda ke tabel Amazon DynamoDB. Untuk menggunakan `DynamoDBMapper`, tentukan hubungan antara item dalam tabel DynamoDB dan instans objek yang sesuai dalam kode Anda. Kelas `DynamoDBMapper` memungkinkan Anda melakukan berbagai operasi buat, baca, perbarui, dan hapus (CRUD) pada item, dan menjalankan kueri serta memindai tabel.
**Topics**
+ [Kelas Dynamo DBMapper](DynamoDBMapper.Methods.md)
+ [Tipe data yang didukung untuk Dynamo DBMapper untuk Java](DynamoDBMapper.DataTypes.md)
+ [Anotasi Java untuk DynamoDB](DynamoDBMapper.Annotations.md)
+ [Pengaturan konfigurasi opsional untuk Dynamo DBMapper](DynamoDBMapper.OptionalConfig.md)
+ [DynamoDB dan penguncian optimis dengan nomor versi](DynamoDBMapper.OptimisticLocking.md)
+ [Memetakan data arbitrer di DynamoDB](DynamoDBMapper.ArbitraryDataMapping.md)
+ [Contoh Dynamo DBMapper](DynamoDBMapper.Examples.md)
**catatan**
Kelas `DynamoDBMapper` tidak memungkinkan Anda membuat, memperbarui, atau menghapus tabel. Untuk melakukan tugas tersebut, gunakan antarmuka SDK untuk Java tingkat rendah.
SDK untuk Java menyediakan serangkaian jenis anotasi agar Anda dapat memetakan kelas ke tabel. Misalnya, pertimbangkan tabel `ProductCatalog` yang memiliki `Id` sebagai kunci partisi.
```
ProductCatalog(Id, ...)
```
Anda dapat memetakan kelas di aplikasi klien ke tabel `ProductCatalog` seperti yang ditunjukkan dalam kode Java berikut. Kode ini menentukan plain old Java object (POJO) bernama `CatalogItem`, yang menggunakan anotasi untuk memetakan bidang objek ke nama atribut DynamoDB.
**Example**
```
package com.amazonaws.codesamples;
import java.util.Set;
import software.amazon.dynamodb.datamodeling.DynamoDBAttribute;
import software.amazon.dynamodb.datamodeling.DynamoDBHashKey;
import software.amazon.dynamodb.datamodeling.DynamoDBIgnore;
import software.amazon.dynamodb.datamodeling.DynamoDBTable;
@DynamoDBTable(tableName="ProductCatalog")
public class CatalogItem {
private Integer id;
private String title;
private String ISBN;
private Set bookAuthors;
private String someProp;
@DynamoDBHashKey(attributeName="Id")
public Integer getId() { return id; }
public void setId(Integer id) {this.id = id; }
@DynamoDBAttribute(attributeName="Title")
public String getTitle() {return title; }
public void setTitle(String title) { this.title = title; }
@DynamoDBAttribute(attributeName="ISBN")
public String getISBN() { return ISBN; }
public void setISBN(String ISBN) { this.ISBN = ISBN; }
@DynamoDBAttribute(attributeName="Authors")
public Set getBookAuthors() { return bookAuthors; }
public void setBookAuthors(Set bookAuthors) { this.bookAuthors = bookAuthors; }
@DynamoDBIgnore
public String getSomeProp() { return someProp; }
public void setSomeProp(String someProp) { this.someProp = someProp; }
}
```
Dalam kode sebelumnya, anotasi `@DynamoDBTable` memetakan kelas `CatalogItem` ke tabel `ProductCatalog`. Anda dapat menyimpan masing-masing instans kelas sebagai item dalam tabel. Dalam definisi kelas, anotasi `@DynamoDBHashKey` memetakan properti `Id` ke kunci primer.
Secara default, properti kelas memetakan atribut nama yang sama dalam tabel. Properti `Title` dan `ISBN` memetakan atribut nama yang sama di tabel.
Anotasi `@DynamoDBAttribute` bersifat opsional saat nama atribut DynamoDB cocok dengan nama properti yang dinyatakan di kelas. Jika namanya berbeda, gunakan anotasi ini dengan parameter `attributeName` untuk menentukan atribut DynamoDB yang sesuai dengan properti ini.
Dalam contoh sebelumnya, `@DynamoDBAttribute` anotasi ditambahkan ke setiap properti untuk memastikan bahwa nama properti cocok persis dengan tabel yang dibuat pada langkah sebelumnya, dan agar konsisten dengan nama atribut yang digunakan dalam contoh kode lain dalam panduan ini.
Definisi kelas Anda dapat memiliki properti yang tidak dipetakan ke setiap atribut dalam tabel. Anda mengidentifikasi properti ini dengan menambahkan anotasi `@DynamoDBIgnore`. Dalam contoh sebelumnya, properti `SomeProp` ditandai dengan anotasi `@DynamoDBIgnore`. Saat Anda mengunggah instans `CatalogItem` ke tabel, instans `DynamoDBMapper` tidak menyertakan properti `SomeProp`. Selain itu, pemeta tidak mengembalikan atribut ini ketika Anda mengambil item dari tabel.
Setelah menentukan kelas pemetaan, Anda dapat menggunakan metode `DynamoDBMapper` untuk menulis instans kelas tersebut untuk item yang sesuai dalam tabel `Catalog`. Contoh kode berikut mendemonstrasikan teknik ini.
```
AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();
DynamoDBMapper mapper = new DynamoDBMapper(client);
CatalogItem item = new CatalogItem();
item.setId(102);
item.setTitle("Book 102 Title");
item.setISBN("222-2222222222");
item.setBookAuthors(new HashSet(Arrays.asList("Author 1", "Author 2")));
item.setSomeProp("Test");
mapper.save(item);
```
Contoh kode berikut menunjukkan cara mengambil item dan mengakses beberapa atributnya.
```
CatalogItem partitionKey = new CatalogItem();
partitionKey.setId(102);
DynamoDBQueryExpression queryExpression = new DynamoDBQueryExpression()
.withHashKeyValues(partitionKey);
List itemList = mapper.query(CatalogItem.class, queryExpression);
for (int i = 0; i < itemList.size(); i++) {
System.out.println(itemList.get(i).getTitle());
System.out.println(itemList.get(i).getBookAuthors());
}
```
`DynamoDBMapper` menawarkan cara natural yang intuitif untuk menggunakan data DynamoDB dalam Java. Ini juga menyediakan beberapa fitur bawaan, seperti penguncian optimis, transaksi ACID, nilai kunci urutan dan kunci partisi yang dibuat secara otomatis, serta objek penentuan versi.
# Kelas Dynamo DBMapper
Kelas `DynamoDBMapper` adalah titik masuk ke Amazon DynamoDB. Kelas ini menyediakan akses ke titik akhir DynamoDB dan memungkinkan Anda mengakses data Anda dalam berbagai tabel. Kelas ini juga memungkinkan Anda melakukan berbagai operasi buat, baca, perbarui, dan hapus (CRUD) pada item, dan menjalankan kueri serta memindai tabel. Kelas ini menyediakan metode berikut agar berfungsi dengan DynamoDB.
*Untuk dokumentasi Javadoc yang sesuai, lihat [Dynamo DBMapper](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/dynamodbv2/datamodeling/DynamoDBMapper.html) di Referensi API.AWS SDK untuk Java *
**Topics**
+ [save](#DynamoDBMapper.Methods.save)
+ [muat](#DynamoDBMapper.Methods.load)
+ [hapus](#DynamoDBMapper.Methods.delete)
+ [kueri](#DynamoDBMapper.Methods.query)
+ [queryPage](#DynamoDBMapper.Methods.queryPage)
+ [scan](#DynamoDBMapper.Methods.scan)
+ [scanPage](#DynamoDBMapper.Methods.scanPage)
+ [parallelScan](#DynamoDBMapper.Methods.parallelScan)
+ [batchSave](#DynamoDBMapper.Methods.batchSave)
+ [batchLoad](#DynamoDBMapper.Methods.batchLoad)
+ [batchDelete](#DynamoDBMapper.Methods.batchDelete)
+ [batchWrite](#DynamoDBMapper.Methods.batchWrite)
+ [transactionWrite](#DynamoDBMapper.Methods.transactionWrite)
+ [transactionLoad](#DynamoDBMapper.Methods.transactionLoad)
+ [count](#DynamoDBMapper.Methods.count)
+ [generateCreateTablePermintaan](#DynamoDBMapper.Methods.generateCreateTableRequest)
+ [createS3Link](#DynamoDBMapper.Methods.createS3Link)
+ [GetS3 ClientCache](#DynamoDBMapper.Methods.getS3ClientCache)
## save
Menyimpan objek tertentu ke tabel. Objek yang ingin Anda simpan adalah satu-satunya parameter yang diperlukan untuk metode ini. Anda dapat memberikan parameter konfigurasi opsional menggunakan objek `DynamoDBMapperConfig`.
Jika item yang memiliki kunci primer yang sama tidak ada, metode ini akan membuat item baru dalam tabel. Jika item yang memiliki kunci primer yang sama ada, item yang ada akan diperbarui. Jika kunci partisi dan kunci urutan berupa String jenis dan dianotasikan dengan `@DynamoDBAutoGeneratedKey`, kunci tersebut diberi pengidentifikasi unik universal acak (UUID) jika tidak diinisialisasi. Bidang versi yang diberi anotasi dengan `@DynamoDBVersionAttribute` bertambah satu. Selain itu, jika bidang versi diperbarui atau kunci dibuat, objek yang diteruskan akan diperbarui sebagai hasil operasi.
Secara default, hanya atribut yang sesuai dengan properti kelas yang dipetakan yang akan diperbarui. Atribut tambahan yang ada pada item tidak akan terpengaruh. Namun, jika menentukan `SaveBehavior.CLOBBER`, Anda dapat memaksa item untuk ditimpa sepenuhnya.
```
DynamoDBMapperConfig config = DynamoDBMapperConfig.builder()
.withSaveBehavior(DynamoDBMapperConfig.SaveBehavior.CLOBBER).build();
mapper.save(item, config);
```
Jika penentuan versi diaktifkan, versi item sisi klien dan sisi server harus cocok. Namun, versi tidak harus cocok jika opsi `SaveBehavior.CLOBBER` digunakan. Untuk informasi selengkapnya tentang penentuan versi, lihat [DynamoDB dan penguncian optimis dengan nomor versi](DynamoDBMapper.OptimisticLocking.md).
## muat
Mengambil item dari tabel. Anda harus menyediakan kunci primer item yang ingin Anda ambil. Anda dapat memberikan parameter konfigurasi opsional menggunakan objek `DynamoDBMapperConfig`. Misalnya, Anda secara opsional dapat meminta bacaan sangat konsisten untuk memastikan bahwa metode ini hanya mengambil nilai item terbaru seperti yang ditunjukkan dalam pernyataan Java berikut.
```
DynamoDBMapperConfig config = DynamoDBMapperConfig.builder()
.withConsistentReads(DynamoDBMapperConfig.ConsistentReads.CONSISTENT).build();
CatalogItem item = mapper.load(CatalogItem.class, item.getId(), config);
```
Secara default, DynamoDB akan mengembalikan item yang memiliki nilai yang akhirnya konsisten. Untuk informasi tentang model konsistensi akhir DynamoDB, lihat [DynamoDB membaca konsistensi](HowItWorks.ReadConsistency.md).
## hapus
Menghapus item dari tabel. Anda harus meneruskan instans objek dari kelas yang dipetakan.
Jika penentuan versi diaktifkan, versi item sisi klien dan sisi server harus cocok. Namun, versi tidak harus cocok jika opsi `SaveBehavior.CLOBBER` digunakan. Untuk informasi selengkapnya tentang penentuan versi, lihat [DynamoDB dan penguncian optimis dengan nomor versi](DynamoDBMapper.OptimisticLocking.md).
## kueri
Mengkueri tabel atau indeks sekunder.
Misalnya, Anda memiliki tabel, `Reply`, yang menyimpan balasan utas forum. Setiap subjek utas dapat berisi nol atau beberapa balasan. Kunci primer tabel `Reply` terdiri dari bidang `Id` dan `ReplyDateTime`, dengan `Id` sebagai kunci partisi dan `ReplyDateTime` sebagai kunci urutan kunci primer.
```
Reply ( Id, ReplyDateTime, ... )
```
Misalnya, Anda membuat pemetaan antara kelas `Reply` dan tabel `Reply` yang sesuai di DynamoDB. Kode Java berikut menggunakan `DynamoDBMapper` untuk menemukan semua balasan dalam dua minggu terakhir untuk subjek utas tertentu.
**Example**
```
String forumName = "&DDB;";
String forumSubject = "&DDB; Thread 1";
String partitionKey = forumName + "#" + forumSubject;
long twoWeeksAgoMilli = (new Date()).getTime() - (14L*24L*60L*60L*1000L);
Date twoWeeksAgo = new Date();
twoWeeksAgo.setTime(twoWeeksAgoMilli);
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");
String twoWeeksAgoStr = df.format(twoWeeksAgo);
Map eav = new HashMap();
eav.put(":v1", new AttributeValue().withS(partitionKey));
eav.put(":v2",new AttributeValue().withS(twoWeeksAgoStr.toString()));
DynamoDBQueryExpression queryExpression = new DynamoDBQueryExpression()
.withKeyConditionExpression("Id = :v1 and ReplyDateTime > :v2")
.withExpressionAttributeValues(eav);
List latestReplies = mapper.query(Reply.class, queryExpression);
```
Kueri ini mengembalikan koleksi objek `Reply`.
Secara default, metode `query` mengembalikan koleksi "lazy-loaded". Metode ini awalnya hanya mengembalikan satu halaman hasil, lalu membuat panggilan layanan untuk halaman berikutnya jika diperlukan. Untuk mendapatkan semua item yang cocok, iterasikan ke koleksi `latestReplies`.
Perhatikan bahwa memanggil metode `size()` pada koleksi akan memuat setiap hasil untuk memberikan jumlah yang akurat. Hal ini dapat mengakibatkan penggunaan banyak throughput yang disediakan, dan bahkan bisa menghabiskan semua memori di JVM Anda pada tabel yang sangat besar.
Untuk mencari indeks, Anda harus membuat model indeks sebagai kelas pemeta terlebih dahulu. Misalkan `Reply` tabel memiliki indeks sekunder global bernama *PostedBy-Message-Index*. Kunci partisi untuk indeks ini adalah `PostedBy`, dan kunci urutannya adalah `Message`. Definisi kelas untuk item dalam indeks akan tampak seperti berikut ini.
```
@DynamoDBTable(tableName="Reply")
public class PostedByMessage {
private String postedBy;
private String message;
@DynamoDBIndexHashKey(globalSecondaryIndexName = "PostedBy-Message-Index", attributeName = "PostedBy")
public String getPostedBy() { return postedBy; }
public void setPostedBy(String postedBy) { this.postedBy = postedBy; }
@DynamoDBIndexRangeKey(globalSecondaryIndexName = "PostedBy-Message-Index", attributeName = "Message")
public String getMessage() { return message; }
public void setMessage(String message) { this.message = message; }
// Additional properties go here.
}
```
Anotasi `@DynamoDBTable` menunjukkan bahwa indeks ini terkait dengan tabel `Reply`. `@DynamoDBIndexHashKey`Anotasi menunjukkan kunci partisi (*PostedBy*) dari indeks, dan `@DynamoDBIndexRangeKey` menunjukkan kunci sortir (*Pesan*) indeks.
Sekarang, Anda dapat menggunakan `DynamoDBMapper` untuk mengkueri indeks, mengambil subset pesan yang diposting oleh pengguna tertentu. Anda tidak perlu menentukan nama indeks jika Anda tidak memiliki pemetaan yang bertentangan di seluruh tabel dan indeks serta pemetaan sudah dibuat di mapper. Pemeta akan menyimpulkan berdasarkan kunci primer dan kunci urutan. Kode berikut mengkueri indeks sekunder global. Karena indeks sekunder global mendukung bacaan akhir konsisten tetapi bukan bacaan sangat konsisten, Anda harus menentukan `withConsistentRead(false)`.
```
HashMap eav = new HashMap();
eav.put(":v1", new AttributeValue().withS("User A"));
eav.put(":v2", new AttributeValue().withS("DynamoDB"));
DynamoDBQueryExpression queryExpression = new DynamoDBQueryExpression()
.withIndexName("PostedBy-Message-Index")
.withConsistentRead(false)
.withKeyConditionExpression("PostedBy = :v1 and begins_with(Message, :v2)")
.withExpressionAttributeValues(eav);
List iList = mapper.query(PostedByMessage.class, queryExpression);
```
Kueri ini mengembalikan koleksi objek `PostedByMessage`.
## queryPage
Mengkueri tabel atau indeks sekunder dan mengembalikan satu halaman hasil yang cocok. Seperti metode `query`, Anda harus menentukan nilai kunci partisi dan filter kueri yang diterapkan pada atribut kunci urutan. Namun, `queryPage` hanya mengembalikan “halaman” pertama data, yaitu jumlah data yang sesuai dalam ukuran 1 MB
## scan
Memindai seluruh tabel atau indeks sekunder. Anda dapat menentukan `FilterExpression` untuk memfilter kumpulan hasil secara opsional.
Misalnya, Anda memiliki tabel, `Reply`, yang menyimpan balasan utas forum. Setiap subjek utas dapat berisi nol atau beberapa balasan. Kunci primer tabel `Reply` terdiri dari bidang `Id` dan `ReplyDateTime`, dengan `Id` sebagai kunci partisi dan `ReplyDateTime` sebagai kunci urutan kunci primer.
```
Reply ( Id, ReplyDateTime, ... )
```
Jika memetakan kelas Java ke tabel `Reply`, Anda dapat menggunakan `DynamoDBMapper` untuk memindai tabel. Misalnya, kode Java berikut memindai seluruh tabel `Reply`, sehingga hanya mengembalikan balasan untuk tahun tertentu.
**Example**
```
HashMap eav = new HashMap();
eav.put(":v1", new AttributeValue().withS("2015"));
DynamoDBScanExpression scanExpression = new DynamoDBScanExpression()
.withFilterExpression("begins_with(ReplyDateTime,:v1)")
.withExpressionAttributeValues(eav);
List replies = mapper.scan(Reply.class, scanExpression);
```
Secara default, metode `scan` mengembalikan koleksi "lazy-loaded". Metode ini awalnya hanya mengembalikan satu halaman hasil, lalu membuat panggilan layanan untuk halaman berikutnya jika diperlukan. Untuk mendapatkan semua item yang cocok, iterasikan ke koleksi `replies`.
Perhatikan bahwa memanggil metode `size()` pada koleksi akan memuat setiap hasil untuk memberikan jumlah yang akurat. Hal ini dapat mengakibatkan penggunaan banyak throughput yang disediakan, dan bahkan bisa menghabiskan semua memori di JVM Anda pada tabel yang sangat besar.
Untuk memindai indeks, Anda harus membuat model indeks sebagai kelas pemeta terlebih dahulu. Misalkan tabel `Reply` memiliki indeks sekunder global bernama `PostedBy-Message-Index`. Kunci partisi untuk indeks ini adalah `PostedBy`, dan kunci urutannya adalah `Message`. Kelas pemeta untuk indeks ini ditampilkan di bagian [kueri](#DynamoDBMapper.Methods.query). Kelas ini menggunakan anotasi `@DynamoDBIndexHashKey` dan `@DynamoDBIndexRangeKey` untuk menentukan kunci partisi indeks dan kunci urutan.
Contoh kode berikut memindai `PostedBy-Message-Index`. Contoh kode ini tidak menggunakan filter pemindaian, sehingga semua item dalam indeks dikembalikan kepada Anda.
```
DynamoDBScanExpression scanExpression = new DynamoDBScanExpression()
.withIndexName("PostedBy-Message-Index")
.withConsistentRead(false);
List iList = mapper.scan(PostedByMessage.class, scanExpression);
Iterator indexItems = iList.iterator();
```
## scanPage
Memindai tabel atau indeks sekunder dan mengembalikan satu halaman hasil yang cocok. Seperti halnya metode `scan`, Anda dapat menentukan `FilterExpression` untuk memfilter kumpulan hasil secara opsional. Namun, `scanPage` hanya mengembalikan “halaman” pertama data, yaitu jumlah data yang sesuai dalam ukuran 1 MB.
## parallelScan
Melakukan pemindaian paralel dari seluruh tabel atau indeks sekunder. Anda menentukan sejumlah segmen logis untuk tabel, beserta ekspresi pemindaian untuk memfilter hasil. `parallelScan` membagi tugas pemindaian antara beberapa pekerja, satu tugas untuk setiap segmen logis; pekerja akan memproses data secara paralel dan mengembalikan hasilnya.
Contoh kode Java berikut melakukan pemindaian paralel pada tabel `Product`.
```
int numberOfThreads = 4;
Map eav = new HashMap();
eav.put(":n", new AttributeValue().withN("100"));
DynamoDBScanExpression scanExpression = new DynamoDBScanExpression()
.withFilterExpression("Price <= :n")
.withExpressionAttributeValues(eav);
List scanResult = mapper.parallelScan(Product.class, scanExpression, numberOfThreads);
```
## batchSave
Menyimpan objek ke satu atau beberapa tabel menggunakan satu atau beberapa panggilan ke metode `AmazonDynamoDB.batchWriteItem`. Metode ini tidak memberikan jaminan transaksi.
Kode Java berikut menyimpan dua item (buku) ke tabel `ProductCatalog`.
```
Book book1 = new Book();
book1.setId(901);
book1.setProductCategory("Book");
book1.setTitle("Book 901 Title");
Book book2 = new Book();
book2.setId(902);
book2.setProductCategory("Book");
book2.setTitle("Book 902 Title");
mapper.batchSave(Arrays.asList(book1, book2));
```
## batchLoad
Mengambil beberapa item dari satu atau beberapa tabel menggunakan kunci primernya.
Kode Java berikut akan mengambil dua item dari dua tabel yang berbeda.
```
ArrayList