Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Bekerja dengan item: Java
Anda dapat menggunakan AWS SDK untuk Java Document API untuk melakukan operasi membuat, membaca, memperbarui, dan menghapus (CRUD) pada item Amazon DynamoDB dalam tabel.
**catatan**
SDK untuk Java juga menyediakan model persistensi objek, memungkinkan Anda memetakan kelas sisi klien ke tabel DynamoDB. Pendekatan ini dapat mengurangi jumlah kode yang harus Anda tulis. Untuk informasi selengkapnya, lihat [Java 1.x: Dinamo DBMapper](DynamoDBMapper.md).
Bagian ini berisi contoh Java untuk melakukan beberapa tindakan item Java Document API dan beberapa contoh kerja yang lengkap.
**Topics**
+ [Menempatkan item](#PutDocumentAPIJava)
+ [Mendapatkan item](#JavaDocumentAPIGetItem)
+ [Penulisan batch: Menempatkan dan menghapus beberapa item](#BatchWriteDocumentAPIJava)
+ [Batch get: Mendapatkan beberapa item](#JavaDocumentAPIBatchGetItem)
+ [Memperbarui Item](#JavaDocumentAPIItemUpdate)
+ [Menghapus item](#DeleteMidLevelJava)
+ [Contoh: Operasi CRUD menggunakan API AWS SDK untuk Java dokumen](JavaDocumentAPICRUDExample.md)
+ [Contoh: Operasi Batch menggunakan API AWS SDK untuk Java dokumen](batch-operation-document-api-java.md)
+ [Contoh: Menangani atribut tipe biner menggunakan API AWS SDK untuk Java dokumen](JavaDocumentAPIBinaryTypeExample.md)
## Menempatkan item
Metode `putItem` menyimpan item dalam tabel. Jika item ada, item tersebut akan menggantikan keseluruhan item. Alih-alih mengganti seluruh item, jika Anda hanya ingin memperbarui atribut tertentu, Anda dapat menggunakan metode `updateItem`. Untuk informasi selengkapnya, lihat [Memperbarui Item](#JavaDocumentAPIItemUpdate).
------
#### [ Java v2 ]
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
import software.amazon.awssdk.services.dynamodb.model.AttributeValue;
import software.amazon.awssdk.services.dynamodb.model.DynamoDbException;
import software.amazon.awssdk.services.dynamodb.model.PutItemRequest;
import software.amazon.awssdk.services.dynamodb.model.PutItemResponse;
import software.amazon.awssdk.services.dynamodb.model.ResourceNotFoundException;
import java.util.HashMap;
/**
* 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 place items into an Amazon DynamoDB table using the AWS SDK for Java V2,
* its better practice to use the
* Enhanced Client. See the EnhancedPutItem example.
*/
public class PutItem {
public static void main(String[] args) {
final String usage = """
Usage:
Where:
tableName - The Amazon DynamoDB table in which an item is placed (for example, Music3).
key - The key used in the Amazon DynamoDB table (for example, Artist).
keyval - The key value that represents the item to get (for example, Famous Band).
albumTitle - The Album title (for example, AlbumTitle).
AlbumTitleValue - The name of the album (for example, Songs About Life ).
Awards - The awards column (for example, Awards).
AwardVal - The value of the awards (for example, 10).
SongTitle - The song title (for example, SongTitle).
SongTitleVal - The value of the song title (for example, Happy Day).
**Warning** This program will place an item that you specify into a table!
""";
if (args.length != 9) {
System.out.println(usage);
System.exit(1);
}
String tableName = args[0];
String key = args[1];
String keyVal = args[2];
String albumTitle = args[3];
String albumTitleValue = args[4];
String awards = args[5];
String awardVal = args[6];
String songTitle = args[7];
String songTitleVal = args[8];
Region region = Region.US_EAST_1;
DynamoDbClient ddb = DynamoDbClient.builder()
.region(region)
.build();
putItemInTable(ddb, tableName, key, keyVal, albumTitle, albumTitleValue, awards, awardVal, songTitle,
songTitleVal);
System.out.println("Done!");
ddb.close();
}
public static void putItemInTable(DynamoDbClient ddb,
String tableName,
String key,
String keyVal,
String albumTitle,
String albumTitleValue,
String awards,
String awardVal,
String songTitle,
String songTitleVal) {
HashMap itemValues = new HashMap<>();
itemValues.put(key, AttributeValue.builder().s(keyVal).build());
itemValues.put(songTitle, AttributeValue.builder().s(songTitleVal).build());
itemValues.put(albumTitle, AttributeValue.builder().s(albumTitleValue).build());
itemValues.put(awards, AttributeValue.builder().s(awardVal).build());
PutItemRequest request = PutItemRequest.builder()
.tableName(tableName)
.item(itemValues)
.build();
try {
PutItemResponse response = ddb.putItem(request);
System.out.println(tableName + " was successfully updated. The request id is "
+ response.responseMetadata().requestId());
} catch (ResourceNotFoundException e) {
System.err.format("Error: The Amazon DynamoDB table \"%s\" can't be found.\n", tableName);
System.err.println("Be sure that it exists and that you've typed its name correctly!");
System.exit(1);
} catch (DynamoDbException e) {
System.err.println(e.getMessage());
System.exit(1);
}
}
}
```
------
#### [ Java v1 ]
Ikuti langkah-langkah ini:
1. Buat instans dari kelas `DynamoDB`.
1. Buat instans dari kelas `Table` untuk mewakili tabel yang ingin Anda gunakan.
1. Buat instans dari kelas `Item` untuk mewakili item baru. Anda harus menentukan kunci primer item baru dan atributnya.
1. Panggil metode `putItem` dari objek `Table` dengan menggunakan `Item` yang Anda buat pada langkah sebelumnya.
Contoh kode Java berikut menunjukkan tugas sebelumnya. Kode tersebut menulis item baru ke tabel `ProductCatalog`.
**Example**
```
AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();
DynamoDB dynamoDB = new DynamoDB(client);
Table table = dynamoDB.getTable("ProductCatalog");
// Build a list of related items
List relatedItems = new ArrayList();
relatedItems.add(341);
relatedItems.add(472);
relatedItems.add(649);
//Build a map of product pictures
Map pictures = new HashMap();
pictures.put("FrontView", "http://example.com/products/123_front.jpg");
pictures.put("RearView", "http://example.com/products/123_rear.jpg");
pictures.put("SideView", "http://example.com/products/123_left_side.jpg");
//Build a map of product reviews
Map> reviews = new HashMap>();
List fiveStarReviews = new ArrayList();
fiveStarReviews.add("Excellent! Can't recommend it highly enough! Buy it!");
fiveStarReviews.add("Do yourself a favor and buy this");
reviews.put("FiveStar", fiveStarReviews);
List oneStarReviews = new ArrayList();
oneStarReviews.add("Terrible product! Do not buy this.");
reviews.put("OneStar", oneStarReviews);
// Build the item
Item item = new Item()
.withPrimaryKey("Id", 123)
.withString("Title", "Bicycle 123")
.withString("Description", "123 description")
.withString("BicycleType", "Hybrid")
.withString("Brand", "Brand-Company C")
.withNumber("Price", 500)
.withStringSet("Color", new HashSet(Arrays.asList("Red", "Black")))
.withString("ProductCategory", "Bicycle")
.withBoolean("InStock", true)
.withNull("QuantityOnHand")
.withList("RelatedItems", relatedItems)
.withMap("Pictures", pictures)
.withMap("Reviews", reviews);
// Write the item to the table
PutItemOutcome outcome = table.putItem(item);
```
Pada contoh sebelumnya, item memiliki atribut berupa skalar (`String`, `Number`, `Boolean`, `Null`), set (`String Set`), dan jenis dokumen (`List`, `Map`).
------
### Menentukan parameter opsional
Selain parameter yang diperlukan, Anda juga dapat menentukan parameter opsional untuk metode `putItem`. Misalnya, contoh kode Java berikut menggunakan parameter opsional untuk menentukan kondisi untuk mengunggah item. Jika kondisi yang Anda tentukan tidak terpenuhi, AWS SDK untuk Java lemparan a`ConditionalCheckFailedException`. Contoh kode menentukan parameter opsional berikut dalam metode `putItem`:
+ `ConditionExpression` yang mendefinisikan kondisi permintaan. Kode tersebut mendefinisikan kondisi bahwa item yang ada dengan kunci primer yang sama diganti hanya jika item tersebut memiliki atribut ISBN yang sama dengan nilai tertentu.
+ Peta untuk `ExpressionAttributeValues` yang digunakan dalam kondisi tersebut. Dalam kasus ini, hanya ada satu substitusi yang diperlukan: placeholder `:val` dalam ekspresi kondisi diganti pada saat runtime dengan nilai ISBN aktual yang akan diperiksa.
Contoh berikut menambahkan item buku baru menggunakan parameter opsional.
**Example**
```
Item item = new Item()
.withPrimaryKey("Id", 104)
.withString("Title", "Book 104 Title")
.withString("ISBN", "444-4444444444")
.withNumber("Price", 20)
.withStringSet("Authors",
new HashSet(Arrays.asList("Author1", "Author2")));
Map expressionAttributeValues = new HashMap();
expressionAttributeValues.put(":val", "444-4444444444");
PutItemOutcome outcome = table.putItem(
item,
"ISBN = :val", // ConditionExpression parameter
null, // ExpressionAttributeNames parameter - we're not using it for this example
expressionAttributeValues);
```
### PutItem dan dokumen JSON
Anda dapat menyimpan dokumen JSON sebagai atribut dalam tabel DynamoDB. Untuk melakukannya, gunakan metode `withJSON` `Item`. Metode ini mengurai dokumen JSON dan memetakan setiap elemen untuk jenis daya DynamoDB asli.
Misalkan Anda ingin menyimpan dokumen JSON berikut, yang berisi vendor yang dapat memenuhi pesanan untuk produk tertentu.
**Example**
```
{
"V01": {
"Name": "Acme Books",
"Offices": [ "Seattle" ]
},
"V02": {
"Name": "New Publishers, Inc.",
"Offices": ["London", "New York"
]
},
"V03": {
"Name": "Better Buy Books",
"Offices": [ "Tokyo", "Los Angeles", "Sydney"
]
}
}
```
Anda dapat menggunakan metode `withJSON` untuk menyimpan ini dalam tabel `ProductCatalog`, dalam atribut `Map` yang disebut `VendorInfo`. Contoh kode Java berikut mendemonstrasikan cara melakukannya.
```
// Convert the document into a String. Must escape all double-quotes.
String vendorDocument = "{"
+ " \"V01\": {"
+ " \"Name\": \"Acme Books\","
+ " \"Offices\": [ \"Seattle\" ]"
+ " },"
+ " \"V02\": {"
+ " \"Name\": \"New Publishers, Inc.\","
+ " \"Offices\": [ \"London\", \"New York\"" + "]" + "},"
+ " \"V03\": {"
+ " \"Name\": \"Better Buy Books\","
+ "\"Offices\": [ \"Tokyo\", \"Los Angeles\", \"Sydney\""
+ " ]"
+ " }"
+ " }";
Item item = new Item()
.withPrimaryKey("Id", 210)
.withString("Title", "Book 210 Title")
.withString("ISBN", "210-2102102102")
.withNumber("Price", 30)
.withJSON("VendorInfo", vendorDocument);
PutItemOutcome outcome = table.putItem(item);
```
## Mendapatkan item
Untuk mengambil satu item, gunakan metode `getItem` dari objek `Table`. Ikuti langkah-langkah ini:
1. Buat instans dari kelas `DynamoDB`.
1. Buat instans dari kelas `Table` untuk mewakili tabel yang ingin Anda gunakan.
1. Panggil metode `getItem` dari instans `Table`. Anda harus menentukan kunci item primer yang ingin Anda ambil.
Contoh kode Java berikut mendemonstrasikan langkah sebelumnya. Kode mendapatkan item yang memiliki kunci partisi yang ditentukan.
```
AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();
DynamoDB dynamoDB = new DynamoDB(client);
Table table = dynamoDB.getTable("ProductCatalog");
Item item = table.getItem("Id", 210);
```
### Menentukan parameter opsional
Selain parameter yang diperlukan, Anda juga dapat menentukan parameter opsional untuk metode `getItem`. Misalnya, contoh kode Java berikut menggunakan metode opsional untuk mengambil hanya daftar atribut tertentu dan menentukan bacaan sangat konsisten. (Untuk mempelajari selengkapnya tentang konsistensi baca, lihat [DynamoDB membaca konsistensi](HowItWorks.ReadConsistency.md).)
Anda dapat menggunakan `ProjectionExpression` untuk mengambil hanya atribut atau elemen tertentu, bukan seluruh item. `ProjectionExpression` dapat menentukan tingkat atas atau atribut bersarang menggunakan jalur dokumen. Untuk informasi selengkapnya, lihat [Menggunakan ekspresi proyeksi di DynamoDB](Expressions.ProjectionExpressions.md).
Parameter dari metode `getItem` tidak membiarkan Anda menentukan konsistensi baca. Namun, Anda dapat membuat `GetItemSpec`, yang menyediakan akses penuh ke semua input ke operasi `GetItem` tingkat rendah. Contoh kode berikut membuat `GetItemSpec` dan menggunakan spesifikasi tersebut sebagai input untuk metode `getItem`.
**Example**
```
GetItemSpec spec = new GetItemSpec()
.withPrimaryKey("Id", 206)
.withProjectionExpression("Id, Title, RelatedItems[0], Reviews.FiveStar")
.withConsistentRead(true);
Item item = table.getItem(spec);
System.out.println(item.toJSONPretty());
```
Untuk mencetak `Item` dalam format yang dapat dibaca manusia, gunakan metode `toJSONPretty`. Output dari contoh sebelumnya terlihat seperti berikut ini.
```
{
"RelatedItems" : [ 341 ],
"Reviews" : {
"FiveStar" : [ "Excellent! Can't recommend it highly enough! Buy it!", "Do yourself a favor and buy this" ]
},
"Id" : 123,
"Title" : "20-Bicycle 123"
}
```
### GetItem dan dokumen JSON
Di bagian [PutItem dan dokumen JSON](#PutItemJavaDocumentAPI.JSON), Anda menyimpan dokumen JSON dalam atribut `Map` yang disebut `VendorInfo`. Anda dapat menggunakan metode `getItem` untuk mengambil seluruh dokumen dalam format JSON. Selain itu, Anda dapat menggunakan notasi jalur dokumen untuk mengambil hanya beberapa elemen dalam dokumen. Contoh kode Java berikut mendemonstrasikan teknik ini.
```
GetItemSpec spec = new GetItemSpec()
.withPrimaryKey("Id", 210);
System.out.println("All vendor info:");
spec.withProjectionExpression("VendorInfo");
System.out.println(table.getItem(spec).toJSON());
System.out.println("A single vendor:");
spec.withProjectionExpression("VendorInfo.V03");
System.out.println(table.getItem(spec).toJSON());
System.out.println("First office location for this vendor:");
spec.withProjectionExpression("VendorInfo.V03.Offices[0]");
System.out.println(table.getItem(spec).toJSON());
```
Output dari contoh sebelumnya terlihat seperti berikut ini.
```
All vendor info:
{"VendorInfo":{"V03":{"Name":"Better Buy Books","Offices":["Tokyo","Los Angeles","Sydney"]},"V02":{"Name":"New Publishers, Inc.","Offices":["London","New York"]},"V01":{"Name":"Acme Books","Offices":["Seattle"]}}}
A single vendor:
{"VendorInfo":{"V03":{"Name":"Better Buy Books","Offices":["Tokyo","Los Angeles","Sydney"]}}}
First office location for a single vendor:
{"VendorInfo":{"V03":{"Offices":["Tokyo"]}}}
```
**catatan**
Anda dapat menggunakan metode `toJSON` untuk mengonversi item apa pun (atau atributnya) ke string berformat JSON. Kode berikut mengambil beberapa atribut tingkat atas dan bertingkat serta mencetak hasilnya sebagai JSON.
```
GetItemSpec spec = new GetItemSpec()
.withPrimaryKey("Id", 210)
.withProjectionExpression("VendorInfo.V01, Title, Price");
Item item = table.getItem(spec);
System.out.println(item.toJSON());
```
Output-nya akan terlihat seperti berikut.
```
{"VendorInfo":{"V01":{"Name":"Acme Books","Offices":["Seattle"]}},"Price":30,"Title":"Book 210 Title"}
```
## Penulisan batch: Menempatkan dan menghapus beberapa item
*Penulisan batch* merujuk pada penempatan dan penghapusan beberapa item dalam satu batch. Metode `batchWriteItem` memungkinkan Anda untuk memasukkan dan menghapus beberapa item dari satu atau lebih tabel dalam satu panggilan. Berikut ini adalah langkah-langkah untuk menempatkan atau menghapus beberapa item menggunakan AWS SDK untuk Java Document API.
1. Buat instans dari kelas `DynamoDB`.
1. Buat instans dari kelas `TableWriteItems` yang menjelaskan semua operasi put dan hapus untuk tabel. Jika Anda ingin menulis ke beberapa tabel dalam satu operasi penulisan batch, Anda harus membuat satu instans `TableWriteItems` per tabel.
1. Jalankan metode `batchWriteItem` dengan menyediakan objek `TableWriteItems` yang Anda buat pada langkah sebelumnya.
1. Proses responsnya. Anda harus memeriksa apakah ada item permintaan yang belum diproses yang dikembalikan sebagai respons. Hal ini dapat terjadi jika Anda mencapai kuota throughput yang disediakan atau kesalahan sementara lainnya. Selain itu, DynamoDB membatasi ukuran permintaan dan jumlah operasi yang dapat Anda tentukan dalam permintaan. Jika Anda melebihi batas ini, DynamoDB menolak permintaan tersebut. Untuk informasi selengkapnya, lihat [Kuota di Amazon DynamoDB](ServiceQuotas.md).
Contoh kode Java berikut mendemonstrasikan langkah sebelumnya. Contoh tersebut melakukan operasi `batchWriteItem` pada dua tabel: `Forum` dan `Thread`. Objek `TableWriteItems` yang sesuai menentukan tindakan berikut:
+ Tempatkan satu item dalam tabel `Forum`.
+ Tempatkan dan hapus satu item dalam tabel `Thread`.
Kode kemudian menjalankan `batchWriteItem` untuk melakukan operasi.
```
AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();
DynamoDB dynamoDB = new DynamoDB(client);
TableWriteItems forumTableWriteItems = new TableWriteItems("Forum")
.withItemsToPut(
new Item()
.withPrimaryKey("Name", "Amazon RDS")
.withNumber("Threads", 0));
TableWriteItems threadTableWriteItems = new TableWriteItems("Thread")
.withItemsToPut(
new Item()
.withPrimaryKey("ForumName","Amazon RDS","Subject","Amazon RDS Thread 1")
.withHashAndRangeKeysToDelete("ForumName","Some partition key value", "Amazon S3", "Some sort key value");
BatchWriteItemOutcome outcome = dynamoDB.batchWriteItem(forumTableWriteItems, threadTableWriteItems);
// Code for checking unprocessed items is omitted in this example
```
Untuk contoh pekerjaan, lihat [Contoh: Operasi penulisan Batch menggunakan API AWS SDK untuk Java dokumen](batch-operation-document-api-java.md#JavaDocumentAPIBatchWrite).
## Batch get: Mendapatkan beberapa item
Metode `batchGetItem` memungkinkan Anda mengambil beberapa item dari satu atau lebih tabel. Untuk mengambil satu item, Anda dapat menggunakan metode `getItem`.
Ikuti langkah-langkah ini:
1. Buat instans dari kelas `DynamoDB`.
1. Buat instans dari kelas `TableKeysAndAttributes` yang menjelaskan daftar nilai kunci primer untuk mengambil dari tabel. Jika Anda ingin membaca dari beberapa tabel dalam satu operasi penulisan batch, Anda harus membuat satu instans `TableKeysAndAttributes` per tabel.
1. Jalankan metode `batchGetItem` dengan menyediakan objek `TableKeysAndAttributes` yang Anda buat pada langkah sebelumnya.
Contoh kode Java berikut mendemonstrasikan langkah sebelumnya. Contoh tersebut mengambil dua item dari tabel `Forum` dan tiga item dari tabel `Thread`.
```
AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();
DynamoDB dynamoDB = new DynamoDB(client);
TableKeysAndAttributes forumTableKeysAndAttributes = new TableKeysAndAttributes(forumTableName);
forumTableKeysAndAttributes.addHashOnlyPrimaryKeys("Name",
"Amazon S3",
"Amazon DynamoDB");
TableKeysAndAttributes threadTableKeysAndAttributes = new TableKeysAndAttributes(threadTableName);
threadTableKeysAndAttributes.addHashAndRangePrimaryKeys("ForumName", "Subject",
"Amazon DynamoDB","DynamoDB Thread 1",
"Amazon DynamoDB","DynamoDB Thread 2",
"Amazon S3","S3 Thread 1");
BatchGetItemOutcome outcome = dynamoDB.batchGetItem(
forumTableKeysAndAttributes, threadTableKeysAndAttributes);
for (String tableName : outcome.getTableItems().keySet()) {
System.out.println("Items in table " + tableName);
List- items = outcome.getTableItems().get(tableName);
for (Item item : items) {
System.out.println(item);
}
}
```
### Menentukan parameter opsional
Bersamaan dengan parameter yang diperlukan, Anda juga dapat menentukan parameter opsional saat menggunakan `batchGetItem`. Misalnya, Anda dapat memberikan `ProjectionExpression` dengan setiap `TableKeysAndAttributes` yang Anda tentukan. Hal ini memungkinkan Anda menentukan atribut yang ingin Anda ambil dari tabel.
Contoh kode berikut mengambil dua item dari tabel `Forum`. Parameter `withProjectionExpression` menentukan bahwa hanya atribut `Threads` yang akan diambil.
**Example**
```
TableKeysAndAttributes forumTableKeysAndAttributes = new TableKeysAndAttributes("Forum")
.withProjectionExpression("Threads");
forumTableKeysAndAttributes.addHashOnlyPrimaryKeys("Name",
"Amazon S3",
"Amazon DynamoDB");
BatchGetItemOutcome outcome = dynamoDB.batchGetItem(forumTableKeysAndAttributes);
```
## Memperbarui Item
Metode `updateItem` dari objek `Table` dapat memperbarui nilai atribut yang ada, menambahkan atribut baru, atau menghapus atribut dari item yang ada.
Metode `updateItem` berperilaku sebagai berikut:
+ Jika item tidak ada (tidak ada item dalam tabel dengan kunci primer yang ditentukan), `updateItem` menambahkan item baru ke tabel.
+ Jika item ada, `updateItem` melakukan pembaruan seperti yang ditentukan oleh parameter `UpdateExpression`.
**catatan**
Hal ini juga memungkinkan untuk "memperbarui" item menggunakan `putItem`. Misalnya, jika Anda memanggil `putItem` untuk menambahkan item ke tabel, tetapi sudah ada item dengan kunci primer yang ditentukan, `putItem` akan menggantikan seluruh item. Jika ada atribut dalam item yang ada yang tidak ditentukan dalam input, `putItem` akan menghapus atribut tersebut dari item.
Secara umum, sebaiknya gunakan `updateItem` setiap kali Anda ingin memodifikasi atribut item. Metode `updateItem` hanya memodifikasi atribut item yang Anda tentukan dalam input, dan atribut lainnya dalam item tidak berubah.
Ikuti langkah-langkah ini:
1. Buat instans dari kelas `Table` untuk mewakili tabel yang ingin Anda gunakan.
1. Panggil metode `updateTable` dari instans `Table`. Anda harus menentukan kunci primer dari item yang ingin Anda ambil, bersama dengan `UpdateExpression` yang menjelaskan atribut untuk memodifikasi dan cara memodifikasinya.
Contoh kode Java berikut menunjukkan tugas sebelumnya. Kode tersebut memperbarui item buku dalam tabel `ProductCatalog`. Contoh tersebut menambahkan penulis baru ke set `Authors`, dan menghapus atribut `ISBN` yang ada. Contoh tersebut juga mengurangi harga sebanyak satu.
Peta `ExpressionAttributeValues` digunakan dalam `UpdateExpression`. Placeholder `:val1` dan `:val2` diganti pada saat runtime dengan nilai aktual untuk `Authors` dan `Price`.
```
AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();
DynamoDB dynamoDB = new DynamoDB(client);
Table table = dynamoDB.getTable("ProductCatalog");
Map expressionAttributeNames = new HashMap();
expressionAttributeNames.put("#A", "Authors");
expressionAttributeNames.put("#P", "Price");
expressionAttributeNames.put("#I", "ISBN");
Map expressionAttributeValues = new HashMap();
expressionAttributeValues.put(":val1",
new HashSet(Arrays.asList("Author YY","Author ZZ")));
expressionAttributeValues.put(":val2", 1); //Price
UpdateItemOutcome outcome = table.updateItem(
"Id", // key attribute name
101, // key attribute value
"add #A :val1 set #P = #P - :val2 remove #I", // UpdateExpression
expressionAttributeNames,
expressionAttributeValues);
```
### Menentukan parameter opsional
Bersamaan dengan parameter yang diperlukan, Anda juga dapat menentukan parameter opsional untuk metode `updateItem`, termasuk kondisi yang harus dipenuhi agar pembaruan bisa terjadi. Jika kondisi yang Anda tentukan tidak terpenuhi, AWS SDK untuk Java lemparan a`ConditionalCheckFailedException`. Misalnya, contoh kode Java berikut memperbarui harga item buku secara kondisional menjadi 25. Ini menentukan pernyataan `ConditionExpression` bahwa harga harus diperbarui hanya jika harga saat ini adalah 20.
**Example**
```
Table table = dynamoDB.getTable("ProductCatalog");
Map expressionAttributeNames = new HashMap();
expressionAttributeNames.put("#P", "Price");
Map expressionAttributeValues = new HashMap();
expressionAttributeValues.put(":val1", 25); // update Price to 25...
expressionAttributeValues.put(":val2", 20); //...but only if existing Price is 20
UpdateItemOutcome outcome = table.updateItem(
new PrimaryKey("Id",101),
"set #P = :val1", // UpdateExpression
"#P = :val2", // ConditionExpression
expressionAttributeNames,
expressionAttributeValues);
```
### Penghitung atom
Anda dapat menggunakan `updateItem` untuk mengimplementasi penghitung atom, di mana Anda menambahkan atau mengurangi nilai atribut yang ada tanpa mengganggu permintaan tulis lainnya. Untuk kenaikan penghitung atom, gunakan `UpdateExpression` dengan tindakan `set` untuk menambahkan nilai numerik ke atribut jenis `Number` yang ada.
Contoh berikut menunjukkan hal ini, menambahkan satu atribut `Quantity`. Hal ini juga menunjukkan penggunaan parameter `ExpressionAttributeNames` dalam `UpdateExpression`.
```
Table table = dynamoDB.getTable("ProductCatalog");
Map expressionAttributeNames = new HashMap();
expressionAttributeNames.put("#p", "PageCount");
Map expressionAttributeValues = new HashMap();
expressionAttributeValues.put(":val", 1);
UpdateItemOutcome outcome = table.updateItem(
"Id", 121,
"set #p = #p + :val",
expressionAttributeNames,
expressionAttributeValues);
```
## Menghapus item
Metode `deleteItem` menghapus item dari tabel. Anda harus menyediakan kunci item primer yang ingin Anda hapus.
Ikuti langkah-langkah ini:
1. Buat instans dari klien `DynamoDB`.
1. Panggil metode `deleteItem` dengan menyediakan kunci item yang ingin Anda hapus.
Contoh Java berikut menunjukkan tugas ini.
**Example**
```
AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();
DynamoDB dynamoDB = new DynamoDB(client);
Table table = dynamoDB.getTable("ProductCatalog");
DeleteItemOutcome outcome = table.deleteItem("Id", 101);
```
### Menentukan parameter opsional
Anda dapat menentukan parameter opsional untuk `deleteItem`. Misalnya, contoh kode Java berikut menentukan `ConditionExpression`, yang menyatakan bahwa item buku dalam `ProductCatalog` hanya dapat dihapus jika buku ini tidak lagi dalam publikasi (atribut `InPublication` adalah salah).
**Example**
```
Map expressionAttributeValues = new HashMap();
expressionAttributeValues.put(":val", false);
DeleteItemOutcome outcome = table.deleteItem("Id",103,
"InPublication = :val",
null, // ExpressionAttributeNames - not used in this example
expressionAttributeValues);
```