Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris. # 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 itemsToGet = new ArrayList(); ForumItem forumItem = new ForumItem(); forumItem.setForumName("Amazon DynamoDB"); itemsToGet.add(forumItem); ThreadItem threadItem = new ThreadItem(); threadItem.setForumName("Amazon DynamoDB"); threadItem.setSubject("Amazon DynamoDB thread 1 message text"); itemsToGet.add(threadItem); Map> items = mapper.batchLoad(itemsToGet); ``` ## batchDelete Menghapus objek dari satu atau beberapa tabel menggunakan satu atau beberapa panggilan ke metode `AmazonDynamoDB.batchWriteItem`. Metode ini tidak memberikan jaminan transaksi. Kode Java berikut akan menghapus dua item (buku) dari tabel `ProductCatalog`. ``` Book book1 = mapper.load(Book.class, 901); Book book2 = mapper.load(Book.class, 902); mapper.batchDelete(Arrays.asList(book1, book2)); ``` ## batchWrite Menyimpan objek ke dan menghapus objek dari satu atau beberapa tabel menggunakan satu atau beberapa panggilan ke metode `AmazonDynamoDB.batchWriteItem`. Metode ini tidak memberikan jaminan transaksi atau penentuan versi dukungan (penempatan atau penghapusan bersyarat). Kode Java berikut menulis item baru ke tabel `Forum`, menulis item baru ke tabel `Thread`, dan menghapus item dari tabel `ProductCatalog`. ``` // Create a Forum item to save Forum forumItem = new Forum(); forumItem.setName("Test BatchWrite Forum"); // Create a Thread item to save Thread threadItem = new Thread(); threadItem.setForumName("AmazonDynamoDB"); threadItem.setSubject("My sample question"); // Load a ProductCatalog item to delete Book book3 = mapper.load(Book.class, 903); List objectsToWrite = Arrays.asList(forumItem, threadItem); List objectsToDelete = Arrays.asList(book3); mapper.batchWrite(objectsToWrite, objectsToDelete); ``` ## transactionWrite Menyimpan objek ke dan menghapus objek dari satu atau beberapa tabel menggunakan satu panggilan ke metode `AmazonDynamoDB.transactWriteItems`. [Untuk daftar pengecualian khusus transaksi, lihat kesalahan. TransactWriteItems ](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_TransactWriteItems.html#API_TransactWriteItems_Errors) Untuk informasi selengkapnya tentang transaksi DynamoDB dan jaminan atomisitas, konsistensi, isolasi, dan durabilitas atau atomicity, consistency, isolation, and durability (ACID), lihat [Amazon DynamoDB Transactions](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/transactions.html). **catatan** Metode ini tidak mendukung hal berikut: [Konfigurasi DynamoDBMapper. SaveBehavior](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DynamoDBMapper.OptionalConfig.html). Kode Java berikut menulis item baru ke setiap tabel `Forum` dan `Thread`, secara transaksional. ``` Thread s3ForumThread = new Thread(); s3ForumThread.setForumName("S3 Forum"); s3ForumThread.setSubject("Sample Subject 1"); s3ForumThread.setMessage("Sample Question 1"); Forum s3Forum = new Forum(); s3Forum.setName("S3 Forum"); s3Forum.setCategory("Amazon Web Services"); s3Forum.setThreads(1); TransactionWriteRequest transactionWriteRequest = new TransactionWriteRequest(); transactionWriteRequest.addPut(s3Forum); transactionWriteRequest.addPut(s3ForumThread); mapper.transactionWrite(transactionWriteRequest); ``` ## transactionLoad Memuat objek dari satu atau beberapa tabel menggunakan satu panggilan ke metode `AmazonDynamoDB.transactGetItems`. [Untuk daftar pengecualian khusus transaksi, lihat kesalahan. TransactGetItems ](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_TransactGetItems.html#API_TransactGetItems_Errors) Untuk informasi selengkapnya tentang transaksi DynamoDB dan jaminan atomisitas, konsistensi, isolasi, dan durabilitas atau atomicity, consistency, isolation, and durability (ACID), lihat [Amazon DynamoDB Transactions](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/transactions.html). Kode Java berikut akan memuat satu item dari setiap tabel `Forum` dan `Thread`, secara transaksional. ``` Forum dynamodbForum = new Forum(); dynamodbForum.setName("DynamoDB Forum"); Thread dynamodbForumThread = new Thread(); dynamodbForumThread.setForumName("DynamoDB Forum"); TransactionLoadRequest transactionLoadRequest = new TransactionLoadRequest(); transactionLoadRequest.addLoad(dynamodbForum); transactionLoadRequest.addLoad(dynamodbForumThread); mapper.transactionLoad(transactionLoadRequest); ``` ## count Mengevaluasi ekspresi pemindaian yang ditentukan dan mengembalikan jumlah item yang cocok. Tidak ada data item yang dikembalikan. ## generateCreateTablePermintaan Mengurai kelas POJO yang mewakili tabel DynamoDB, dan mengembalikan `CreateTableRequest` untuk tabel tersebut. ## createS3Link Membuat tautan ke objek di Amazon S3. Anda harus menentukan nama bucket dan nama kunci, yang secara unik mengidentifikasi objek di bucket. Untuk menggunakan `createS3Link`, kelas pemeta Anda harus menentukan metode getter dan setter. Contoh kode berikut menggambarkan hal ini dengan menambahkan atribut dan getter/setter metode baru ke `CatalogItem` kelas. ``` @DynamoDBTable(tableName="ProductCatalog") public class CatalogItem { ... public S3Link productImage; .... @DynamoDBAttribute(attributeName = "ProductImage") public S3Link getProductImage() { return productImage; } public void setProductImage(S3Link productImage) { this.productImage = productImage; } ... } ``` Kode Java berikut mendefinisikan item baru yang akan ditulis ke tabel `Product`. Item tersebut termasuk link ke gambar produk; data gambar diunggah ke Amazon S3. ``` CatalogItem item = new CatalogItem(); item.setId(150); item.setTitle("Book 150 Title"); String amzn-s3-demo-bucket = "amzn-s3-demo-bucket"; String myS3Key = "productImages/book_150_cover.jpg"; item.setProductImage(mapper.createS3Link(amzn-s3-demo-bucket, myS3Key)); item.getProductImage().uploadFrom(new File("/file/path/book_150_cover.jpg")); mapper.save(item); ``` Kelas `S3Link` menyediakan banyak metode lain untuk memanipulasi objek di Amazon S3. Untuk informasi selengkapnya, lihat [Javadocs untuk `S3Link`](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/dynamodbv2/datamodeling/S3Link.html). ## GetS3 ClientCache Mengembalikan `S3ClientCache` yang mendasarinya untuk mengakses Amazon S3. `S3ClientCache` adalah Peta cerdas untuk objek `AmazonS3Client`. Jika Anda memiliki banyak klien, an `S3ClientCache` dapat membantu Anda menjaga klien tetap terorganisir berdasarkan AWS Wilayah, dan dapat membuat klien Amazon S3 baru sesuai permintaan. # Tipe data yang didukung untuk Dynamo DBMapper untuk Java Bagian ini menjelaskan jenis data Java primitif, koleksi, dan jenis data arbitrer yang didukung di Amazon DynamoDB. Amazon DynamoDB mendukung jenis data Java primitif dan kelas pembungkus primitif berikut. + `String` + `Boolean`, `boolean` + `Byte`, `byte` + `Date` (sebagai string [ISO\$18601](http://en.wikipedia.org/wiki/ISO_8601) millisecond-precision, yang beralih ke UTC) + `Calendar` (sebagai string [ISO\$18601](http://en.wikipedia.org/wiki/ISO_8601) millisecond-precision, yang beralih ke UTC) + `Long`, `long` + `Integer`, `int` + `Double`, `double` + `Float`, `float` + `BigDecimal` + `BigInteger` **catatan** Untuk informasi selengkapnya tentang aturan penamaan DynamoDB dan berbagai jenis data yang didukung, lihat [Jenis data dan aturan penamaan yang didukung di Amazon DynamoDB](HowItWorks.NamingRulesDataTypes.md). Nilai biner kosong didukung oleh DynamoDBMapper. Nilai String kosong didukung oleh AWS SDK for Java 2.x. Dalam AWS SDK for Java 1.x, DBMapper Dynamo mendukung pembacaan nilai atribut String kosong, namun, itu tidak akan menulis nilai atribut String kosong karena atribut ini dijatuhkan dari permintaan. DynamoDB mendukung jenis koleksi [Kumpulan](http://docs.oracle.com/javase/6/docs/api/java/util/Set.html), [Daftar](http://docs.oracle.com/javase/6/docs/api/java/util/List.html), dan [Peta](http://docs.oracle.com/javase/6/docs/api/java/util/Map.html) Java. Tabel berikut merangkum bagaimana jenis Java ini dipetakan untuk jenis DynamoDB. **** | Jenis Java | Jenis DynamoDB | | --- | --- | | Semua jenis angka | `N` (jenis angka) | | String | `S` (jenis string) | | Boolean | `BOOL` (jenis Boolean), 0 atau 1. | | ByteBuffer | `B` (jenis biner) | | Tanggal | `S` (jenis string). Nilai data disimpan sebagai string berformat ISO-8601. | | Jenis koleksi [Kumpulan](http://docs.oracle.com/javase/6/docs/api/java/util/Set.html) | Jenis `SS` (kumpulan biner), jenis `NS` (kumpulan angka), atau jenis `BS` (kumpulan biner). | Antarmuka `DynamoDBTypeConverter` memungkinkan Anda memetakan jenis data arbitrer Anda sendiri ke jenis data yang secara asli didukung oleh DynamoDB. Untuk informasi selengkapnya, lihat [Memetakan data arbitrer di DynamoDB](DynamoDBMapper.ArbitraryDataMapping.md). # Anotasi Java untuk DynamoDB Bagian ini menjelaskan anotasi yang tersedia untuk memetakan kelas dan properti ke tabel dan atribut di Amazon DynamoDB. Untuk dokumentasi Javadoc yang sesuai, lihat [Ringkasan Jenis Anotasi](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/dynamodbv2/datamodeling/package-summary.html) di [Referensi API AWS SDK untuk Java](https://docs.aws.amazon.com/sdk-for-java/latest/reference/). **catatan** Dalam anotasi berikut, hanya `DynamoDBTable` dan `DynamoDBHashKey` yang diperlukan. **Topics** + [Dinamo DBAttribute](#DynamoDBMapper.Annotations.DynamoDBAttribute) + [Dinamo DBAuto GeneratedKey](#DynamoDBMapper.Annotations.DynamoDBAutoGeneratedKey) + [Dinamo DBAuto GeneratedTimestamp](#DynamoDBMapper.Annotations.DynamoDBAutoGeneratedTimestamp) + [Dinamo DBDocument](#DynamoDBMapper.Annotations.DynamoDBDocument) + [Kunci Dynamo DBHash](#DynamoDBMapper.Annotations.DynamoDBHashKey) + [Dinamo DBIgnore](#DynamoDBMapper.Annotations.DynamoDBIgnore) + [Dinamo DBIndex HashKey](#DynamoDBMapper.Annotations.DynamoDBIndexHashKey) + [Dinamo DBIndex RangeKey](#DynamoDBMapper.Annotations.DynamoDBIndexRangeKey) + [Kunci Dynamo DBRange](#DynamoDBMapper.Annotations.DynamoDBRangeKey) + [Dinamo DBTable](#DynamoDBMapper.Annotations.DynamoDBTable) + [Dynamo Dikonversi DBType](#DynamoDBMapper.Annotations.DynamoDBTypeConverted) + [Dinamo DBTyped](#DynamoDBMapper.Annotations.DynamoDBTyped) + [Atribut Dynamo DBVersion](#DynamoDBMapper.Annotations.DynamoDBVersionAttribute) ## Dinamo DBAttribute Memetakan properti ke atribut tabel. Secara default, setiap properti kelas dipetakan ke atribut item dengan nama yang sama. Namun, jika nama tidak sama, Anda dapat menggunakan anotasi ini untuk memetakan properti ke atribut. Dalam cuplikan Java berikut, `DynamoDBAttribute` memetakan properti `BookAuthors` ke nama atribut `Authors` dalam tabel. ``` @DynamoDBAttribute(attributeName = "Authors") public List getBookAuthors() { return BookAuthors; } public void setBookAuthors(List BookAuthors) { this.BookAuthors = BookAuthors; } ``` `DynamoDBMapper` menggunakan `Authors` sebagai nama atribut saat menyimpan objek ke tabel. ## Dinamo DBAuto GeneratedKey Menandai kunci partisi atau properti kunci urutan sebagai dibuat otomatis. `DynamoDBMapper` membuat [UUID](http://docs.oracle.com/javase/6/docs/api/java/util/UUID.html) acak saat menyimpan atribut ini. Hanya properti String yang dapat ditandai sebagai kunci yang dibuat otomatis. Contoh berikut mendemonstrasikan menggunakan kunci yang dibuat otomatis. ``` @DynamoDBTable(tableName="AutoGeneratedKeysExample") public class AutoGeneratedKeys { private String id; private String payload; @DynamoDBHashKey(attributeName = "Id") @DynamoDBAutoGeneratedKey public String getId() { return id; } public void setId(String id) { this.id = id; } @DynamoDBAttribute(attributeName="payload") public String getPayload() { return this.payload; } public void setPayload(String payload) { this.payload = payload; } public static void saveItem() { AutoGeneratedKeys obj = new AutoGeneratedKeys(); obj.setPayload("abc123"); // id field is null at this point DynamoDBMapper mapper = new DynamoDBMapper(dynamoDBClient); mapper.save(obj); System.out.println("Object was saved with id " + obj.getId()); } } ``` ## Dinamo DBAuto GeneratedTimestamp Membuat stempel waktu secara otomatis. ``` @DynamoDBAutoGeneratedTimestamp(strategy=DynamoDBAutoGenerateStrategy.ALWAYS) public Date getLastUpdatedDate() { return lastUpdatedDate; } public void setLastUpdatedDate(Date lastUpdatedDate) { this.lastUpdatedDate = lastUpdatedDate; } ``` Secara opsional, strategi pembuatan otomatis dapat didefinisikan dengan menyediakan atribut strategi. Nilai default-nya `ALWAYS`. ## Dinamo DBDocument Menunjukkan bahwa kelas dapat diserialisasi sebagai dokumen Amazon DynamoDB. Misalnya, katakanlah Anda ingin memetakan dokumen JSON ke atribut DynamoDB untuk jenis Peta (`M`). Contoh kode berikut mendefinisikan item yang berisi atribut bersarang (Gambar) untuk jenis Peta. ``` public class ProductCatalogItem { private Integer id; //partition key private Pictures pictures; /* ...other attributes omitted... */ @DynamoDBHashKey(attributeName="Id") public Integer getId() { return id;} public void setId(Integer id) {this.id = id;} @DynamoDBAttribute(attributeName="Pictures") public Pictures getPictures() { return pictures;} public void setPictures(Pictures pictures) {this.pictures = pictures;} // Additional properties go here. @DynamoDBDocument public static class Pictures { private String frontView; private String rearView; private String sideView; @DynamoDBAttribute(attributeName = "FrontView") public String getFrontView() { return frontView; } public void setFrontView(String frontView) { this.frontView = frontView; } @DynamoDBAttribute(attributeName = "RearView") public String getRearView() { return rearView; } public void setRearView(String rearView) { this.rearView = rearView; } @DynamoDBAttribute(attributeName = "SideView") public String getSideView() { return sideView; } public void setSideView(String sideView) { this.sideView = sideView; } } } ``` Kemudian, Anda dapat menyimpan item `ProductCatalog`, dengan `Pictures`, seperti yang ditunjukkan dalam contoh berikut. ``` ProductCatalogItem item = new ProductCatalogItem(); Pictures pix = new Pictures(); pix.setFrontView("http://example.com/products/123_front.jpg"); pix.setRearView("http://example.com/products/123_rear.jpg"); pix.setSideView("http://example.com/products/123_left_side.jpg"); item.setPictures(pix); item.setId(123); mapper.save(item); ``` Item `ProductCatalog` yang dihasilkan akan tampak seperti berikut (dalam format JSON). ``` { "Id" : 123 "Pictures" : { "SideView" : "http://example.com/products/123_left_side.jpg", "RearView" : "http://example.com/products/123_rear.jpg", "FrontView" : "http://example.com/products/123_front.jpg" } } ``` ## Kunci Dynamo DBHash Memetakan properti kelas ke kunci partisi tabel. Properti harus berupa salah satu string skalar, angka, atau jenis biner. Properti tidak dapat berupa jenis koleksi. Asumsikan bahwa Anda memiliki tabel, `ProductCatalog`, yang memiliki `Id` sebagai kunci primer. Kode Java berikut mendefinisikan kelas `CatalogItem` dan memetakan properti `Id`-nya ke kunci primer dari tabel `ProductCatalog` menggunakan tanda `@DynamoDBHashKey`. ``` @DynamoDBTable(tableName="ProductCatalog") public class CatalogItem { private Integer Id; @DynamoDBHashKey(attributeName="Id") public Integer getId() { return Id; } public void setId(Integer Id) { this.Id = Id; } // Additional properties go here. } ``` ## Dinamo DBIgnore Menunjukkan ke instans `DynamoDBMapper` bahwa properti terkait harus diabaikan. Saat menyimpan data ke tabel, `DynamoDBMapper` tidak menyimpan properti ini ke tabel. Diterapkan pada metode getter atau bidang kelas untuk properti yang tidak dimodelkan. Jika anotasi diterapkan langsung ke bidang kelas, getter dan setter yang sesuai harus dinyatakan di kelas yang sama. ## Dinamo DBIndex HashKey Memetakan properti kelas ke kunci partisi untuk indeks sekunder global. Properti harus berupa salah satu string skalar, angka, atau jenis biner. Properti tidak dapat berupa jenis koleksi. Gunakan anotasi ini jika Anda perlu `Query` indeks sekunder global. Anda harus menentukan nama indeks (`globalSecondaryIndexName`). Jika nama properti kelas berbeda dari kunci partisi indeks, Anda juga harus menentukan nama atribut indeks (`attributeName`). ## Dinamo DBIndex RangeKey Memetakan properti kelas untuk kunci urutan indeks sekunder global atau indeks sekunder lokal. Properti harus berupa salah satu string skalar, angka, atau jenis biner. Properti tidak dapat berupa jenis koleksi. Gunakan anotasi ini jika anda perlu `Query` indeks sekunder lokal atau indeks sekunder global dan ingin menyempurnakan hasil menggunakan kunci urutan indeks. Anda harus menentukan nama indeks (baik `globalSecondaryIndexName` maupun `localSecondaryIndexName`). Jika nama properti kelas berbeda dari kunci urutan indeks, Anda juga harus menentukan nama atribut indeks (`attributeName`). ## Kunci Dynamo DBRange Memetakan properti kelas untuk kunci urutan tabel. Properti harus berupa salah satu string skalar, angka, atau jenis biner. Properti ini tidak boleh berupa jenis koleksi. Jika kunci primer adalah komposit (kunci partisi dan kunci urutan), Anda dapat menggunakan tanda ini untuk memetakan bidang kelas Anda ke kunci urutan. Misalnya, Anda memiliki tabel `Reply` yang menyimpan balasan untuk utas forum. Setiap utas dapat berisi banyak balasan. Jadi, kunci primer tabel ini adalah `ThreadId` dan `ReplyDateTime`. `ThreadId` adalah kunci partisinya, dan `ReplyDateTime` adalah kunci urutannya. Kode Java berikut akan mendefinisikan `Reply` dan memetakannya ke tabel `Reply`. Kode tersebut menggunakan tanda `@DynamoDBHashKey` dan `@DynamoDBRangeKey` untuk mengidentifikasi properti kelas yang dipetakan ke kunci primer. ``` @DynamoDBTable(tableName="Reply") public class Reply { private Integer id; private String replyDateTime; @DynamoDBHashKey(attributeName="Id") public Integer getId() { return id; } public void setId(Integer id) { this.id = id; } @DynamoDBRangeKey(attributeName="ReplyDateTime") public String getReplyDateTime() { return replyDateTime; } public void setReplyDateTime(String replyDateTime) { this.replyDateTime = replyDateTime; } // Additional properties go here. } ``` ## Dinamo DBTable Mengidentifikasi tabel target di DynamoDB. Misalnya, kode Java berikut menentukan kelas `Developer` dan memetakannya ke tabel `People` di DynamoDB. ``` @DynamoDBTable(tableName="People") public class Developer { ...} ``` Anotasi `@DynamoDBTable` dapat diwariskan. Setiap kelas baru yang diwariskan dari kelas `Developer` juga dipetakan ke tabel `People` yang sama. Misalnya, Anda membuat kelas `Lead` yang diwariskan dari kelas `Developer`. Karena Anda memetakan kelas `Developer` ke tabel `People`, objek kelas `Lead` juga disimpan dalam tabel yang sama. `@DynamoDBTable` juga dapat diganti. Setiap kelas baru yang diwariskan dari kelas `Developer` secara default dipetakan ke tabel `People` yang sama. Namun, Anda dapat mengganti pemetaan default ini. Misalnya, jika Anda membuat kelas yang diwariskan dari kelas `Developer`, Anda dapat secara eksplisit memetakannya ke tabel lain dengan menambahkan anotasi `@DynamoDBTable` seperti yang ditunjukkan dalam contoh kode Java berikut. ``` @DynamoDBTable(tableName="Managers") public class Manager extends Developer { ...} ``` ## Dynamo Dikonversi DBType Anotasi untuk menandai properti sebagai menggunakan konverter jenis khusus. Dapat dianotasikan pada anotasi yang ditetapkan pengguna untuk meneruskan properti tambahan ke `DynamoDBTypeConverter`. Antarmuka `DynamoDBTypeConverter` memungkinkan Anda memetakan jenis data arbitrer Anda sendiri ke jenis data yang secara asli didukung oleh DynamoDB. Untuk informasi selengkapnya, lihat [Memetakan data arbitrer di DynamoDB](DynamoDBMapper.ArbitraryDataMapping.md). ## Dinamo DBTyped Anotasi untuk menimpa pengikatan jenis atribut standar. Jenis standar tidak memerlukan anotasi jika menerapkan pengikatan atribut default untuk jenis tersebut. ## Atribut Dynamo DBVersion Mengidentifikasi properti kelas untuk menyimpan nomor versi penguncian optimis. `DynamoDBMapper` menetapkan nomor versi untuk properti ini ketika menyimpan item baru, dan menambahkannya setiap kali Anda memperbarui item. Hanya jenis skalar nomor yang didukung. Untuk informasi selengkapnya tentang jenis data, lihat [Jenis Data](HowItWorks.NamingRulesDataTypes.md#HowItWorks.DataTypes). Untuk informasi selengkapnya tentang penentuan versi, lihat [DynamoDB dan penguncian optimis dengan nomor versi](DynamoDBMapper.OptimisticLocking.md). # Pengaturan konfigurasi opsional untuk Dynamo DBMapper Saat Anda membuat instans `DynamoDBMapper`, instans tersebut memiliki perilaku default tertentu; Anda dapat menimpa pengaturan default ini menggunakan kelas `DynamoDBMapperConfig`. Cuplikan kode berikut akan membuat `DynamoDBMapper` dengan pengaturan kustom: ``` AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build(); DynamoDBMapperConfig mapperConfig = DynamoDBMapperConfig.builder() .withSaveBehavior(DynamoDBMapperConfig.SaveBehavior.CLOBBER) .withConsistentReads(DynamoDBMapperConfig.ConsistentReads.CONSISTENT) .withTableNameOverride(null) .withPaginationLoadingStrategy(DynamoDBMapperConfig.PaginationLoadingStrategy.EAGER_LOADING) .build(); DynamoDBMapper mapper = new DynamoDBMapper(client, mapperConfig); ``` Untuk informasi selengkapnya, lihat [https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/dynamodbv2/datamodeling/DynamoDBMapperConfig.html](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/dynamodbv2/datamodeling/DynamoDBMapperConfig.html) di Referensi API [AWS SDK untuk Java .](https://docs.aws.amazon.com/sdk-for-java/latest/reference/) Anda dapat menggunakan argumen berikut untuk instans `DynamoDBMapperConfig`: + Nilai enumerasi `DynamoDBMapperConfig.ConsistentReads`: + `EVENTUAL`—instans pemeta menggunakan permintaan bacaan akhir konsisten. + `CONSISTENT`—instans pemeta menggunakan permintaan bacaan sangat konsisten. Anda dapat menggunakan pengaturan opsional ini dengan operasi `load`, `query`, atau `scan`. Bacaan sangat konsisten memiliki implikasi terhadap performa dan penagihan; lihat [halaman detail produk](https://aws.amazon.com/dynamodb) DynamoDB untuk informasi selengkapnya. Jika Anda tidak menentukan pengaturan konsistensi baca untuk instans pemeta Anda, pengaturan defaultnya adalah `EVENTUAL`. **catatan** Nilai ini diterapkan dalam`query`,, `querypage``load`, dan `batch load` operasi DynamoDBMapper. + Nilai enumerasi `DynamoDBMapperConfig.PaginationLoadingStrategy`—Mengontrol cara instans pemeta memproses daftar data yang diberi nomor halaman, seperti hasil dari `query` atau `scan`: + `LAZY_LOADING`—instans pemeta memuat data jika memungkinkan, dan menyimpan semua hasil yang dimuat dalam memori. + `EAGER_LOADING`—instans pemeta memuat data segera setelah daftar diinisialisasi. + `ITERATION_ONLY`—Anda hanya dapat menggunakan Iterator untuk membaca dari daftar. Selama iterasi, daftar akan menghapus semua hasil lama sebelum memuat halaman berikutnya, sehingga daftar akan menyimpan maksimal satu halaman dari hasil yang dimuat dalam memori. Hal ini juga berarti bahwa daftar hanya dapat diiterasi satu kali. Strategi ini direkomendasikan saat menangani item besar, guna mengurangi overhead memori. Jika Anda tidak menentukan strategi pemuatan pemberian nomor halaman untuk instans pemeta Anda, pengaturan defaultnya adalah `LAZY_LOADING`. + Nilai enumerasi `DynamoDBMapperConfig.SaveBehavior` - Menentukan cara instans pemeta akan menangani atribut selama operasi simpan: + `UPDATE`—selama operasi simpan, semua atribut model diperbarui, dan atribut yang tidak dibuat modelnya tidak terpengaruh. Jenis angka primitif (byte, int, long) diatur ke 0. Jenis objek diatur ke null. + `CLOBBER`—menghapus dan mengganti semua atribut, termasuk yang tidak dibuat modelnya, selama operasi simpan. Hal ini dilakukan dengan menghapus item lalu membuatnya kembali. Batasan bidang dengan versi juga diabaikan. Jika Anda tidak menentukan perilaku simpan untuk instans pemeta, pengaturan defaultnya adalah `UPDATE`. **catatan** Operasi DBMapper transaksional Dynamo tidak mendukung pencacahan. `DynamoDBMapperConfig.SaveBehavior` + Objek `DynamoDBMapperConfig.TableNameOverride`—Menginstruksikan instans pemeta untuk mengabaikan nama tabel yang ditentukan oleh anotasi `DynamoDBTable` kelas, dan menggunakan nama tabel lain yang Anda berikan. Ini berguna saat mempartisi data Anda menjadi beberapa tabel saat runtime. Anda dapat mengganti objek konfigurasi default untuk `DynamoDBMapper` per operasi, jika diperlukan. # DynamoDB dan penguncian optimis dengan nomor versi *Penguncian optimis* adalah strategi untuk memastikan bahwa item sisi klien yang Anda perbarui (atau hapus) sama dengan item di Amazon DynamoDB. Jika Anda menggunakan strategi ini, penulisan basis data Anda dilindungi agar tidak ditimpa oleh penulisan orang lain, dan sebaliknya. Dengan penguncian optimis, setiap item memiliki atribut yang berfungsi sebagai nomor versi. Jika Anda mengambil item dari tabel, aplikasi akan mencatat nomor versi item tersebut. Anda dapat memperbarui item, tetapi hanya jika nomor versi di sisi server tidak berubah. Jika ada ketidakcocokan versi, artinya orang lain telah mengubah item sebelum Anda melakukannya. Upaya pembaruan gagal, karena versi item Anda sudah usang. Jika ini terjadi, coba lagi dengan mengambil item dan kemudian mencoba memperbaruinya. Penguncian optimis mencegah Anda menimpa perubahan secara tidak sengaja yang dibuat oleh orang lain. Penguncian optimis juga mencegah orang lain menimpa perubahan Anda secara tidak sengaja. Meskipun Anda dapat menerapkan strategi penguncian optimis Anda sendiri, AWS SDK untuk Java memberikan `@DynamoDBVersionAttribute` anotasi. Di kelas pemetaan untuk tabel, Anda menetapkan satu properti untuk menyimpan nomor versi, dan menandainya menggunakan anotasi ini. Saat Anda menyimpan objek, item terkait dalam tabel DynamoDB akan memiliki atribut yang menyimpan nomor versi. `DynamoDBMapper` menetapkan nomor versi saat Anda pertama kali menyimpan objek, dan otomatis menambahkan nomor versi setiap kali Anda memperbarui item. Permintaan perbarui atau hapus Anda hanya akan berhasil jika versi objek sisi klien cocok dengan nomor versi item yang sesuai dalam tabel DynamoDB. `ConditionalCheckFailedException` ditampilkan jika: + Anda menggunakan penguncian optimis dengan `@DynamoDBVersionAttribute` dan nilai versi pada server yang berbeda dari nilai pada sisi klien. + Anda menentukan batasan bersyarat Anda sendiri saat menyimpan data menggunakan `DynamoDBMapper` dengan `DynamoDBSaveExpression` dan batasan ini gagal. **catatan** Tabel global DynamoDB menggunakan rekonsiliasi “penulis terakhir menang” antara pembaruan bersamaan. Jika Anda menggunakan tabel global, kebijakan penulis terakhir akan menang. Jadi dalam hal ini, strategi penguncian tidak berfungsi seperti yang diharapkan. Operasi tulis transaksional `DynamoDBMapper` tidak mendukung ekspresi syarat dan anotasi `@DynamoDBVersionAttribute` pada objek yang sama. Jika sebuah objek dalam penulisan transaksional dianotasi dengan `@DynamoDBVersionAttribute` dan juga memiliki ekspresi kondisi, maka akan dilemparkan. SdkClientException Misalnya, kode Java berikut mendefinisikan kelas `CatalogItem` yang memiliki beberapa properti. Properti `Version` ditandai dengan anotasi `@DynamoDBVersionAttribute`. **Example** ``` @DynamoDBTable(tableName="ProductCatalog") public class CatalogItem { private Integer id; private String title; private String ISBN; private Set bookAuthors; private String someProp; private Long version; @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;} @DynamoDBVersionAttribute public Long getVersion() { return version; } public void setVersion(Long version) { this.version = version;} } ``` Anda dapat menerapkan anotasi `@DynamoDBVersionAttribute` untuk jenis yang dapat dinihilkan yang diberikan oleh kelas pembungkus primitif yang menyediakan jenis yang dapat di-null-kan, seperti `Long` dan `Integer`. Penguncian optimis memiliki dampak sebagai berikut pada metode `DynamoDBMapper` ini: + `save` — Untuk item baru, `DynamoDBMapper` menetapkan nomor versi awal 1. Jika Anda mengambil item, memperbarui satu atau beberapa propertinya, dan mencoba untuk menyimpan perubahan, operasi simpan hanya akan berhasil jika nomor versi di sisi klien dan sisi server cocok. `DynamoDBMapper` menambah nomor versi secara otomatis. + `delete` — Metode `delete` mengambil sebuah objek sebagai parameter, dan `DynamoDBMapper` melakukan pemeriksaan versi sebelum menghapus item. Pemeriksaan versi dapat dinonaktifkan jika `DynamoDBMapperConfig.SaveBehavior.CLOBBER` ditentukan dalam permintaan. Implementasi internal penguncian optimis dalam `DynamoDBMapper` menggunakan pembaruan bersyarat dan dukungan penghapusan bersyarat yang disediakan oleh DynamoDB. + `transactionWrite` — + `Put` — Untuk item baru, `DynamoDBMapper` menetapkan nomor versi awal 1. Jika Anda mengambil item, memperbarui satu atau beberapa propertinya, dan mencoba untuk menyimpan perubahan, operasi masukkan hanya akan berhasil jika nomor versi di sisi klien dan sisi server cocok. `DynamoDBMapper` menambah nomor versi secara otomatis. + `Update` — Untuk item baru, `DynamoDBMapper` menetapkan nomor versi awal 1. Jika Anda mengambil item, memperbarui satu atau beberapa propertinya, dan mencoba untuk menyimpan perubahan, operasi perbarui hanya akan berhasil jika nomor versi di sisi klien dan sisi server cocok. `DynamoDBMapper` menambah nomor versi secara otomatis. + `Delete` — `DynamoDBMapper` melakukan pemeriksaan versi sebelum menghapus item. Operasi hapus hanya akan berhasil jika nomor versi pada sisi klien dan sisi server cocok. + `ConditionCheck` — Anotasi `@DynamoDBVersionAttribute` tidak didukung untuk operasi `ConditionCheck`. An SdkClientException akan dilemparkan ketika `ConditionCheck` item dianotasi dengan. `@DynamoDBVersionAttribute` ## Menonaktifkan penguncian optimis Untuk menonaktifkan penguncian optimis, Anda dapat mengubah nilai enumerasi `DynamoDBMapperConfig.SaveBehavior` dari `UPDATE` menjadi `CLOBBER`. Anda dapat melakukannya dengan membuat instans `DynamoDBMapperConfig` yang melewatkan pemeriksaan versi dan menggunakan instans ini untuk semua permintaan Anda. Untuk informasi tentang `DynamoDBMapperConfig.SaveBehavior` dan parameter `DynamoDBMapper` opsional lainnya, lihat [Pengaturan konfigurasi opsional untuk Dynamo DBMapper](DynamoDBMapper.OptionalConfig.md). Anda juga dapat mengatur perilaku penguncian untuk operasi tertentu saja. Misalnya, cuplikan Java berikut menggunakan `DynamoDBMapper` untuk menyimpan item katalog. Cuplikan ini menentukan `DynamoDBMapperConfig.SaveBehavior` dengan menambahkan parameter `DynamoDBMapperConfig` opsional untuk metode `save`. **catatan** Metode TransactionWrite tidak mendukung Dynamo Config. DBMapper SaveBehaviorkonfigurasi. Menonaktifkan penguncian optimis untuk transactionWrite tidak didukung. **Example** ``` DynamoDBMapper mapper = new DynamoDBMapper(client); // Load a catalog item. CatalogItem item = mapper.load(CatalogItem.class, 101); item.setTitle("This is a new title for the item"); ... // Save the item. mapper.save(item, new DynamoDBMapperConfig( DynamoDBMapperConfig.SaveBehavior.CLOBBER)); ``` # Memetakan data arbitrer di DynamoDB Selain jenis Java yang didukung (lihat [Tipe data yang didukung untuk Dynamo DBMapper untuk Java](DynamoDBMapper.DataTypes.md)), Anda dapat menggunakan jenis di aplikasi Anda yang tidak memiliki pemetaan langsung ke jenis Amazon DynamoDB. Untuk memetakan jenis ini, Anda harus menyediakan implementasi yang mengonversi jenis kompleks Anda ke jenis yang didukung DynamoDB dan sebaliknya, serta menganotasi metode penilai jenis kompleks menggunakan anotasi `@DynamoDBTypeConverted`. Kode konverter mengubah data ketika objek disimpan atau dimuat. Kode ini juga digunakan untuk semua operasi yang mengonsumsi jenis kompleks. Perhatikan bahwa saat membandingkan data selama operasi kueri dan pindai, perbandingan pada data yang disimpan dalam DynamoDB akan dilakukan. Misalnya, pertimbangkan kelas `CatalogItem` berikut yang mendefinisikan properti, `Dimension`, yaitu `DimensionType`. Properti ini menyimpan dimensi item sebagai tinggi, lebar, dan ketebalan. Misalnya Anda memutuskan untuk menyimpan dimensi item ini sebagai string (seperti 8.5x11x.05) dalam DynamoDB. Contoh berikut memberikan kode konverter yang mengonversi objek `DimensionType` menjadi string dan string menjadi `DimensionType`. **catatan** Contoh kode ini mengasumsikan bahwa Anda telah memuat data ke DynamoDB untuk akun Anda dengan mengikuti petunjuk di bagian [Membuat tabel dan memuat data untuk contoh kode di DynamoDB](SampleData.md). Untuk step-by-step instruksi untuk menjalankan contoh berikut, lihat[Contoh kode Java](CodeSamples.Java.md). **Example** ``` public class DynamoDBMapperExample { static AmazonDynamoDB client; public static void main(String[] args) throws IOException { // Set the AWS region you want to access. Regions usWest2 = Regions.US_WEST_2; client = AmazonDynamoDBClientBuilder.standard().withRegion(usWest2).build(); DimensionType dimType = new DimensionType(); dimType.setHeight("8.00"); dimType.setLength("11.0"); dimType.setThickness("1.0"); Book book = new Book(); book.setId(502); book.setTitle("Book 502"); book.setISBN("555-5555555555"); book.setBookAuthors(new HashSet(Arrays.asList("Author1", "Author2"))); book.setDimensions(dimType); DynamoDBMapper mapper = new DynamoDBMapper(client); mapper.save(book); Book bookRetrieved = mapper.load(Book.class, 502); System.out.println("Book info: " + "\n" + bookRetrieved); bookRetrieved.getDimensions().setHeight("9.0"); bookRetrieved.getDimensions().setLength("12.0"); bookRetrieved.getDimensions().setThickness("2.0"); mapper.save(bookRetrieved); bookRetrieved = mapper.load(Book.class, 502); System.out.println("Updated book info: " + "\n" + bookRetrieved); } @DynamoDBTable(tableName = "ProductCatalog") public static class Book { private int id; private String title; private String ISBN; private Set bookAuthors; private DimensionType dimensionType; // Partition key @DynamoDBHashKey(attributeName = "Id") public int getId() { return id; } public void setId(int 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; } @DynamoDBTypeConverted(converter = DimensionTypeConverter.class) @DynamoDBAttribute(attributeName = "Dimensions") public DimensionType getDimensions() { return dimensionType; } @DynamoDBAttribute(attributeName = "Dimensions") public void setDimensions(DimensionType dimensionType) { this.dimensionType = dimensionType; } @Override public String toString() { return "Book [ISBN=" + ISBN + ", bookAuthors=" + bookAuthors + ", dimensionType= " + dimensionType.getHeight() + " X " + dimensionType.getLength() + " X " + dimensionType.getThickness() + ", Id=" + id + ", Title=" + title + "]"; } } static public class DimensionType { private String length; private String height; private String thickness; public String getLength() { return length; } public void setLength(String length) { this.length = length; } public String getHeight() { return height; } public void setHeight(String height) { this.height = height; } public String getThickness() { return thickness; } public void setThickness(String thickness) { this.thickness = thickness; } } // Converts the complex type DimensionType to a string and vice-versa. static public class DimensionTypeConverter implements DynamoDBTypeConverter { @Override public String convert(DimensionType object) { DimensionType itemDimensions = (DimensionType) object; String dimension = null; try { if (itemDimensions != null) { dimension = String.format("%s x %s x %s", itemDimensions.getLength(), itemDimensions.getHeight(), itemDimensions.getThickness()); } } catch (Exception e) { e.printStackTrace(); } return dimension; } @Override public DimensionType unconvert(String s) { DimensionType itemDimension = new DimensionType(); try { if (s != null && s.length() != 0) { String[] data = s.split("x"); itemDimension.setLength(data[0].trim()); itemDimension.setHeight(data[1].trim()); itemDimension.setThickness(data[2].trim()); } } catch (Exception e) { e.printStackTrace(); } return itemDimension; } } } ``` # Contoh Dynamo DBMapper AWS SDK for Java menyediakan `DynamoDBMapper` kelas, memungkinkan Anda untuk memetakan kelas sisi klien Anda ke tabel 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. *Untuk mempelajari lebih lanjut tentang cara menggunakan`DynamoDBMapper`, lihat [Contoh DynamoDB Menggunakan SDK AWS for Java di SDK for Java](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/examples-dynamodb.html) 1.x Panduan AWS Pengembang.*