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

# Melakukan operasi CRUD di Amazon DocumentDB dengan Java
<a name="java-crud-operations"></a>

Bagian ini membahas melakukan operasi CRUD (membuat, membaca, memperbarui, menghapus) di Amazon DocumentDB menggunakan driver MongoDB Java.

**Topics**
+ [Membuat dan menyisipkan dokumen dalam koleksi DocumentDB](#creating-inserting)
+ [Membaca dan mengambil data dari koleksi DocumentDB](#reading-retrieving)
+ [Memperbarui dokumen yang ada dalam koleksi DocumentDB](#updating-documents)
+ [Menghapus dokumen dari koleksi DocumentDB](#deleting-documents)
+ [Penanganan kesalahan dengan logika coba lagi](#error-handling)

## Membuat dan menyisipkan dokumen dalam koleksi DocumentDB
<a name="creating-inserting"></a>

Memasukkan dokumen ke Amazon DocumentDB memungkinkan Anda menambahkan data baru ke koleksi Anda. Ada beberapa cara untuk melakukan penyisipan, tergantung pada kebutuhan Anda dan volume data yang Anda kerjakan. Metode paling dasar untuk memasukkan dokumen individual ke koleksi adalah`insertOne()`. Untuk memasukkan beberapa dokumen sekaligus, Anda dapat menggunakan `insertMany()` metode ini, yang memungkinkan Anda menambahkan array dokumen dalam satu operasi. Metode lain untuk memasukkan banyak dokumen dalam koleksi DocumentDB adalah. `bulkWrite()` Dalam panduan ini, kami membahas semua metode ini untuk membuat dokumen dalam koleksi DocumentDB.

**`insertOne()`**

Mari kita mulai dengan memeriksa cara memasukkan dokumen individual ke dalam koleksi Amazon DocumentDBB. Menyisipkan satu dokumen dilakukan dengan menggunakan metode ini`insertOne()`. Metode ini mengambil [BsonDocument](https://mongodb.github.io/mongo-java-driver/5.3/apidocs/bson/org/bson/BsonDocument.html)untuk penyisipan dan mengembalikan [https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/client/result/InsertOneResult.html](https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/client/result/InsertOneResult.html)objek yang dapat digunakan untuk mendapatkan id objek dari dokumen baru dimasukkan. Contoh kode di bawah ini menunjukkan memasukkan satu dokumen restoran ke dalam koleksi:

```
Document article = new Document()
    .append("restaurantId", "REST-21G145")
    .append("name", "Future-proofed Intelligent Bronze Hat")
    .append("cuisine", "International")
    .append("rating", new Document()
        .append("average", 1.8)
        .append("totalReviews", 267))
    .append("features", Arrays.asList("Outdoor Seating", "Live Music"));

try {
    InsertOneResult result = collection.insertOne(article);
    System.out.println("Inserted document with the following id: " + result.getInsertedId());
} catch (MongoWriteException e) {
    // Handle duplicate key or other write errors
    System.err.println("Failed to insert document: " + e.getMessage());
    throw e;
} catch (MongoException e) {
    // Handle other MongoDB errors
    System.err.println("MongoDB error: " + e.getMessage());
    throw e;
}
```

Saat menggunakan`insertOne()`, pastikan untuk menyertakan penanganan kesalahan yang sesuai. Misalnya, dalam kode di atas, “`restaurantId`” memiliki indeks unik dan oleh karena itu menjalankan kode ini lagi akan memunculkan yang berikut`MongoWriteException`:

```
Failed to insert document: Write operation error on server docdbCluster.docdb.amazonaws.com:27017. 
Write error: WriteError{code=11000, message='E11000 duplicate key error collection: Restaurants index: restaurantId_1', details={}}.
```

**InsertMany ()**

Metode utama yang digunakan untuk memasukkan banyak dokumen ke dalam koleksi adalah insertMany () dan. `bulkWrite()` 

`insertMany()`Metode ini adalah cara paling sederhana untuk memasukkan beberapa dokumen dalam satu operasi. Ini menerima daftar dokumen dan memasukkannya ke dalam koleksi. Metode ini sangat ideal ketika Anda memasukkan sekumpulan dokumen baru yang independen satu sama lain dan tidak memerlukan pemrosesan khusus atau operasi campuran. Kode berikut menunjukkan membaca dokumen JSON dari file dan memasukkannya ke dalam koleksi. `insertMany()`Fungsi mengembalikan [https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/client/result/InsertManyResult.html](https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/client/result/InsertManyResult.html)`InsertManyResult`objek yang dapat digunakan untuk mendapatkan semua dokumen yang dimasukkan. IDs 

```
// Read JSON file content
String content = new String(Files.readAllBytes(Paths.get(jsonFileName)));
JSONArray jsonArray = new JSONArray(content);

// Convert JSON articles to Documents
List < Document > restaurants = new ArrayList < > ();
for (int i = 0; i < jsonArray.length(); i++) {
    JSONObject jsonObject = jsonArray.getJSONObject(i);
    Document doc = Document.parse(jsonObject.toString());
    restaurants.add(doc);
}
//insert documents in collection
InsertManyResult result = collection.insertMany(restaurants);

System.out.println("Count of inserted documents: " + result.getInsertedIds().size());
```

**[https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/bulk/package-summary.html](https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/bulk/package-summary.html)**

`bulkWrite()`Metode ini memungkinkan untuk melakukan beberapa operasi tulis (menyisipkan, memperbarui, menghapus) dalam satu batch. Anda dapat menggunakan `bulkWrite()` ketika Anda perlu melakukan berbagai jenis operasi dalam satu batch, seperti memasukkan beberapa dokumen sambil memperbarui yang lain. `bulkWrite()`mendukung dua jenis batch write, ordered dan unordered:
+ *Operasi yang dipesan* — (default) Amazon DocumentDB memproses operasi penulisan secara berurutan, dan berhenti pada kesalahan pertama yang ditemuinya. Ini berguna ketika urutan operasi penting, seperti ketika operasi nanti bergantung pada yang sebelumnya. Namun, operasi yang diperintahkan umumnya lebih lambat daripada operasi yang tidak teratur. Dengan operasi yang dipesan, Anda harus mengatasi kasus di mana batch berhenti pada kesalahan pertama, yang berpotensi membuat beberapa operasi tidak diproses.
+ *Operasi tidak teratur* - Memungkinkan Amazon DocumentDB memproses sisipan sebagai eksekusi tunggal dalam database. Jika terjadi kesalahan dengan satu dokumen, operasi berlanjut dengan dokumen yang tersisa. Ini sangat berguna ketika Anda memasukkan data dalam jumlah besar dan dapat mentolerir beberapa kegagalan, seperti selama migrasi data atau impor massal di mana beberapa dokumen mungkin gagal karena kunci duplikat. Dengan operasi yang tidak teratur, Anda harus mengatasi skenario keberhasilan sebagian di mana beberapa operasi berhasil sementara yang lain gagal.

Saat bekerja dengan `bulkWrite()` metode ini, ada beberapa kelas penting yang diperlukan. Pertama, [https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/client/model/WriteModel.html](https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/client/model/WriteModel.html)kelas berfungsi sebagai kelas dasar untuk semua operasi tulis dan dengan implementasi spesifik seperti [https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/client/model/InsertOneModel.html](https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/client/model/InsertOneModel.html),, [https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/client/model/UpdateOneModel.html](https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/client/model/UpdateOneModel.html), [https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/client/model/DeleteOneModel.html](https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/client/model/DeleteOneModel.html), dan [https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/client/model/DeleteManyModel.html](https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/client/model/DeleteManyModel.html)menangani berbagai jenis operasi.

[https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/client/model/BulkWriteOptions.html](https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/client/model/BulkWriteOptions.html)Kelas ini diperlukan untuk mengkonfigurasi perilaku operasi massal, seperti pengaturan ordered/unordered eksekusi atau melewati validasi dokumen. [https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/bulk/BulkWriteResult.html](https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/bulk/BulkWriteResult.html)Kelas memberikan informasi rinci tentang hasil eksekusi, termasuk jumlah dokumen yang dimasukkan, diperbarui, dan dihapus.

Untuk penanganan kesalahan, [https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/MongoBulkWriteException.html](https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/MongoBulkWriteException.html)kelas sangat penting karena berisi informasi tentang kegagalan selama operasi massal, sementara [https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/bulk/BulkWriteError.html](https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/bulk/BulkWriteError.html)kelas memberikan rincian spesifik tentang kegagalan operasi individu. Kode berikut menunjukkan contoh memasukkan daftar dokumen, serta memperbarui dan menghapus satu dokumen, semua dalam pelaksanaan panggilan `bulkWrite()` metode tunggal. Kode ini juga menunjukkan cara bekerja dengan [https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/client/model/BulkWriteOptions.html](https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/client/model/BulkWriteOptions.html)dan [https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/bulk/BulkWriteResult.html](https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/bulk/BulkWriteResult.html), serta penanganan kesalahan yang tepat dari `bulkWrite()` operasi. 

```
List < WriteModel < Document >> bulkOperations = new ArrayList < > ();
// get list of 10 documents representing 10 restaurants
List < Document > restaurantsToInsert = getSampleData();

for (Document doc: restaurantsToInsert) {
    bulkOperations.add(new InsertOneModel < > (doc));
}
// Update operation
bulkOperations.add(new UpdateOneModel < > (
    new Document("restaurantId", "REST-Y2E9H5"),
    new Document("", new Document("stats.likes", 20))
    .append("", new Document("rating.average", 4.5))));
// Delete operation
bulkOperations.add(new DeleteOneModel < > (new Document("restaurantId", "REST-D2L431")));

// Perform bulkWrite operation
try {
    BulkWriteOptions options = new BulkWriteOptions()
        .ordered(false); // Allow unordered inserts

    BulkWriteResult result = collection.bulkWrite(bulkOperations, options);

    System.out.println("Inserted: " + result.getInsertedCount());
    System.out.println("Updated: " + result.getModifiedCount());
    System.out.println("Deleted: " + result.getDeletedCount());
} catch (MongoBulkWriteException e) {
    System.err.println("Bulk write error occurred: " + e.getMessage());
    // Log individual write errors
    for (BulkWriteError error: e.getWriteErrors()) {
        System.err.printf("Error at index %d: %s (Code: %d)%n", error.getIndex(), error.getMessage(),
            error.getCode());

        // Log the problematic document
        Document errorDoc = new Document(error.getDetails());
        if (errorDoc != null) {
            System.err.println("Problematic document: " + errorDoc);
        }
    }
} catch (Exception e) {
    System.err.println("Error during bulkWrite: " + e.getMessage());
}
```

**Retryable menulis**

Tidak seperti MongoDB, Amazon DocumentDB tidak mendukung penulisan yang dapat dicoba ulang. Akibatnya, Anda harus menerapkan logika coba ulang khusus dalam aplikasi mereka, terutama untuk menangani masalah jaringan atau tidak tersedianya layanan sementara. Strategi coba ulang yang diimplementasikan dengan baik, biasanya, melibatkan peningkatan penundaan antara upaya coba lagi dan membatasi jumlah total percobaan ulang. Lihat [Penanganan kesalahan dengan logika coba lagi](#error-handling) di bawah untuk contoh kode membangun logika coba lagi dengan penanganan kesalahan.

## Membaca dan mengambil data dari koleksi DocumentDB
<a name="reading-retrieving"></a>

Kueri dokumen di Amazon DocumentDB berkisar pada beberapa komponen utama yang memungkinkan Anda mengambil dan memanipulasi data secara tepat. [https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-sync/com/mongodb/client/MongoCollection.html#find()](https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-sync/com/mongodb/client/MongoCollection.html#find())Metode ini adalah query mendasar APIs dalam driver MongoDB Java. Ini memungkinkan pengambilan data yang kompleks dengan banyak opsi untuk memfilter, menyortir, dan memproyeksikan hasil. Selain `find()` metode, [https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/client/model/Filters.html](https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/client/model/Filters.html)dan [https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-sync/com/mongodb/client/FindIterable.html](https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-sync/com/mongodb/client/FindIterable.html)dua komponen fundamental lainnya yang menyediakan blok bangunan untuk operasi query di driver MongoDB Java.

`Filters`Kelas ini adalah kelas utilitas dalam driver MongoDB Java yang menyediakan API lancar untuk membangun filter query. Kelas ini menawarkan metode pabrik statis yang membuat instance `Bson` objek yang mewakili berbagai kondisi kueri. Metode yang paling umum digunakan termasuk `eq()` untuk perbandingan kesetaraan,,,, `gt()``lt()`, dan untuk perbandingan numerik`gte()`, dan `lte()` untuk menggabungkan beberapa kondisi, `and()` dan `or()` untuk tes keanggotaan array, `in()` dan `nin()` untuk pencocokan pola. `regex()` Kelas ini dirancang untuk menjadi type-safe dan menyediakan pemeriksaan waktu kompilasi yang lebih baik dibandingkan dengan query berbasis dokumen mentah, menjadikannya pendekatan yang disukai untuk membangun kueri DocumentDB dalam aplikasi Java. Penanganan kesalahan kuat, dengan pengecualian yang jelas dilemparkan untuk konstruksi filter yang tidak valid.

`FindIterable`adalah antarmuka khusus yang dirancang untuk menangani hasil `find()` metode. Ini menyediakan serangkaian metode yang kaya untuk menyempurnakan dan mengendalikan eksekusi kueri, menawarkan API yang lancar untuk rantai metode. Antarmuka mencakup metode modifikasi kueri penting seperti `limit()` untuk membatasi jumlah dokumen yang dikembalikan, `skip()` untuk pagination, `sort()` untuk memesan hasil, `projection()` untuk memilih bidang tertentu, dan `hint()` untuk pemilihan indeks. Operasi batch, skip, dan limit di `FindIterable` adalah pagination penting dan alat manajemen data yang membantu mengontrol bagaimana dokumen diambil dan diproses dari database.

Batching (`batchSize`) mengontrol berapa banyak dokumen yang dikembalikan DocumentDB ke klien dalam satu perjalanan pulang-pergi jaringan. Saat Anda menetapkan ukuran batch, DocumentDB tidak mengembalikan semua dokumen yang cocok sekaligus, melainkan mengembalikannya dalam grup dengan ukuran batch yang ditentukan. 

Skip memungkinkan Anda untuk mengimbangi titik awal hasil Anda, pada dasarnya memberi tahu DocumentDB untuk melewati sejumlah dokumen tertentu sebelum mulai mengembalikan kecocokan. Misalnya, `skip(20)` akan mem-bypass 20 dokumen pertama yang cocok. Ini biasanya digunakan dalam skenario pagination di mana Anda ingin mengambil halaman hasil berikutnya. 

Batas membatasi jumlah total dokumen yang dapat dikembalikan dari kueri. Saat Anda menentukan`limit(n)`, DocumentDB akan berhenti mengembalikan dokumen setelah mengembalikan dokumen 'n', bahkan jika ada lebih banyak kecocokan dalam database. 

`FindIterable`mendukung pola iterator dan kursor saat mengambil dokumen dari Amazon DocumentDB. Manfaat menggunakan `FindIterable` sebagai iterator adalah memungkinkan pemuatan dokumen yang lambat dan hanya mengambil dokumen saat diminta oleh aplikasi. Manfaat lain menggunakan iterator adalah Anda tidak bertanggung jawab untuk menjaga koneksi ke cluster dan dengan demikian tidak diperlukan penutupan koneksi secara eksplisit. 

`FindIterable`juga menyediakan dukungan [https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-sync/com/mongodb/client/MongoCursor.html](https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-sync/com/mongodb/client/MongoCursor.html)yang memungkinkan pola kursor digunakan saat bekerja dengan kueri Amazon DocumentDB. `MongoCursor`adalah implementasi khusus driver MongoDB Java yang menyediakan kontrol atas operasi database dan manajemen sumber daya. Ini mengimplementasikan `AutoCloseable` antarmuka, memungkinkan manajemen sumber daya eksplisit melalui try-with-resources blok, yang sangat penting untuk menutup koneksi database dengan benar dan membebaskan sumber daya server. Secara default, waktu kursor habis dalam 10 menit dan DocumentDB tidak memberi Anda opsi untuk mengubah perilaku time out ini. Saat bekerja dengan data batch, pastikan untuk mengambil kumpulan data berikutnya sebelum waktu kursor habis. Salah satu pertimbangan utama saat menggunakan `MongoCursor` adalah bahwa hal itu memerlukan penutupan eksplisit untuk mencegah kebocoran sumber daya.

Pada bagian ini, beberapa contoh disajikan untuk`find()`, `Filters` dan`FindIterable`.

Contoh kode berikut menunjukkan cara menggunakan `find()` untuk mengambil satu dokumen menggunakan bidang “Restaurantid” -nya:

```
Document filter = new Document("restaurantId", "REST-21G145");
Document result = collection.find(filter).first();
```

Meskipun menggunakan `Filters` memungkinkan untuk pemeriksaan kesalahan waktu kompilasi yang lebih baik, driver java juga memungkinkan Anda untuk menentukan `Bson` filter secara langsung dalam `find()` metode. Kode contoh berikut meneruskan `Bson` dokumen ke`find()`:

```
result = collection.find(new Document("$and", Arrays.asList(
    new Document("rating.totalReviews", new Document("$gt", 1000)),
    new Document("priceRange", "$$"))))
```

Contoh kode berikutnya menunjukkan beberapa contoh menggunakan `Filters` kelas dengan`find()`:

```
FindIterable < Document > results;

// Exact match
results = collection.find(Filters.eq("name", "Thai Curry Palace"));

// Not equal
results = collection.find(Filters.ne("cuisine", "Thai"));

// find an element in an array
results = collection.find(Filters.in("features", Arrays.asList("Private Dining")));

// Greater than
results = collection.find(Filters.gt("rating.average", 3.5));

// Between (inclusive)
results = collection.find(Filters.and(
    Filters.gte("rating.totalReviews", 100),
    Filters.lte("rating.totalReviews", 200)));
// AND
results = collection.find(Filters.and(
    Filters.eq("cuisine", "Thai"),
    Filters.gt("rating.average", 4.5)));

// OR
results = collection.find(Filters.or(
    Filters.eq("cuisine", "Thai"),
    Filters.eq("cuisine", "American")));


// All document where the Field exists
results = collection.find(Filters.exists("michelin"));

// Regex
results = collection.find(Filters.regex("name", Pattern.compile("Curry", Pattern.CASE_INSENSITIVE)));

// Find all document where the array contain the list of value regardless of its order
results = collection.find(Filters.all("features", Arrays.asList("Private Dining", "Parking")));

// Array size
results = collection.find(Filters.size("features", 4));
```

Contoh berikut menunjukkan bagaimana untuk rantai operasi`sort()`,`skip()`,`limit()`, dan `batchSize()` pada `FindIterable` objek. Urutan bagaimana operasi ini disediakan akan mempengaruhi kinerja kueri Anda. Sebagai praktik terbaik, urutan operasi ini harus`sort()`,, `projection()``skip()`, `limit()` dan`batchSize()`.

```
FindIterable < Document > results = collection.find(Filters.gt("rating.totalReviews", 1000))
    // Sorting
    .sort(Sorts.orderBy(
        Sorts.descending("address.city"),
        Sorts.ascending("cuisine")))
    // Field selection
    .projection(Projections.fields(
        Projections.include("name", "cuisine", "priceRange"),
        Projections.excludeId()))

    // Pagination
    .skip(20)
    .limit(10)
    .batchSize(2);
```

Kode contoh berikut menunjukkan membuat iterator pada`FindIterable`. Ini menggunakan `forEach` konstruksi Java untuk melintasi set hasil.

```
collection.find(Filters.eq("cuisine", "American")).forEach(doc -> System.out.println(doc.toJson()));
```

Dalam contoh `find()` kode terakhir, ini menunjukkan bagaimana menggunakan `cursor()` untuk pengambilan dokumen. Ini menciptakan kursor di blok try yang memastikan bahwa kursor akan ditutup ketika kode keluar dari blok try.

```
try (MongoCursor < Document > cursor = collection.find(Filters.eq("cuisine", "American"))
    .batchSize(25)
    .cursor()) {
    while (cursor.hasNext()) {
        Document doc = cursor.next();
        System.out.println(doc.toJson());
    }
} // Cursor automatically closed
```

## Memperbarui dokumen yang ada dalam koleksi DocumentDB
<a name="updating-documents"></a>

Amazon DocumentDB menyediakan mekanisme yang fleksibel dan kuat untuk memodifikasi dokumen yang ada dan memasukkan yang baru ketika tidak ada. Driver MongoDB Java menawarkan beberapa metode untuk pembaruan`updateOne()`: untuk pembaruan dokumen tunggal, untuk beberapa pembaruan dokumen`updateMany()`, `replaceOne()` dan untuk penggantian dokumen lengkap. Selain ketiga metode ini,, [https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/client/model/Updates.html](https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/client/model/Updates.html), dan [https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/client/result/UpdateResult.html](https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/client/result/UpdateResult.html)merupakan komponen fundamental lainnya yang menyediakan blok bangunan untuk operasi pembaruan di driver MongoDB Java. 

`Updates`Kelas dalam driver MongoDB Java adalah kelas utilitas yang menyediakan metode pabrik statis untuk membuat operator pembaruan. Ini berfungsi sebagai pembangun utama untuk membangun operasi pembaruan dengan cara yang aman dan mudah dibaca. Metode dasar seperti`set()`,`unset()`, dan `inc()` memungkinkan modifikasi langsung dari dokumen. Kekuatan kelas ini menjadi jelas ketika menggabungkan beberapa operasi menggunakan `Updates.combine()` metode yang memungkinkan beberapa operasi pembaruan dijalankan secara atom, memastikan konsistensi data.

`UpdateOptions`adalah kelas konfigurasi yang kuat di driver Java MongoDB yang menyediakan kemampuan kustomisasi penting untuk operasi pembaruan dokumen. Dua aspek penting dari kelas ini adalah menyediakan dukungan filter upsert dan array untuk operasi pembaruan. Fitur upsert, diaktifkan melalui`upsert(true)`, memungkinkan pembuatan dokumen baru ketika tidak ada dokumen yang cocok ditemukan selama operasi pembaruan. Melalui`arrayFilters()`, operasi pembaruan dapat secara tepat memperbarui elemen array yang memenuhi kriteria tertentu.

`UpdateResult`di driver Java MongoDB menyediakan mekanisme umpan balik yang merinci hasil operasi pembaruan. Kelas ini merangkum tiga metrik utama: jumlah dokumen yang cocok dengan kriteria pembaruan (), jumlah dokumen yang benar-benar dimodifikasi (`matchedCount`), dan informasi tentang dokumen yang diperbarui (`modifiedCount`). `upsertedId` Memahami metrik ini sangat penting untuk penanganan kesalahan yang tepat, verifikasi operasi pembaruan, dan menjaga konsistensi data dalam aplikasi.

### Perbarui dan ganti satu dokumen
<a name="update-single-doc"></a>

Di DocumentDB, memperbarui satu dokumen dapat dilakukan dengan menggunakan metode updateOne (). Metode ini mengambil parameter filter, biasanya disediakan oleh `Filters` kelas, untuk mengidentifikasi dokumen yang akan diperbarui, parameter `Updat` e yang menentukan bidang mana yang akan diperbarui, dan `UpdateOptions` parameter opsional untuk mengatur opsi yang berbeda untuk pembaruan. Menggunakan `updateOne()` metode ini hanya akan memperbarui dokumen pertama yang cocok dengan kriteria pemilihan. Kode contoh berikut memperbarui satu bidang dari satu dokumen:

```
collection.updateOne(Filters.eq("restaurantId", "REST-Y2E9H5"),
    Updates.set("name", "Amazing Japanese sushi"));
```

Untuk memperbarui beberapa bidang dalam satu dokumen, gunakan `updateOne()` dengan `Update.combine()` seperti yang ditunjukkan pada contoh berikut. Contoh ini juga menunjukkan cara menambahkan item ke array dalam dokumen.

```
List<Bson> updates = new ArrayList<>();
// Basic field updates
updates.add(Updates.set("name", "Shanghai Best"));
// Array operations
updates.add(Updates.addEachToSet("features", Arrays.asList("Live Music")));
// Counter updates
updates.add(Updates.inc("rating.totalReviews", 10));
// Combine all updates
Bson combinedUpdates = Updates.combine(updates);
// Execute automic update with one call
collection.updateOne(Filters.eq("restaurantId","REST-1J83NH"), combinedUpdates);
```

Contoh kode berikut menunjukkan cara memperbarui dokumen dalam database. Jika dokumen yang ditentukan tidak ada, operasi akan secara otomatis menyisipkannya sebagai dokumen baru. Kode ini juga menunjukkan cara menggunakan metrik yang tersedia melalui `UpdateResult` objek.

```
Bson filter = Filters.eq("restaurantId", "REST-0Y9GL0");
Bson update = Updates.set("cuisine", "Indian");
// Upsert operation
UpdateOptions options = new UpdateOptions().upsert(true);
UpdateResult result = collection.updateOne(filter, update, options);

if (result.getUpsertedId() != null) {
   	System.out.println("Inserted document with _id: " + result.getUpsertedId());
} else {
    	System.out.println("Updated " + result.getModifiedCount() + " document(s)");
}
```

Contoh kode berikut menunjukkan bagaimana untuk sepenuhnya mengganti dokumen yang ada dengan dokumen baru menggunakan `replaceOne()` metode, daripada memperbarui bidang individual. `replaceOne()`Metode ini menimpa seluruh dokumen, hanya mempertahankan `_id` bidang aslinya. Jika beberapa dokumen cocok dengan kriteria filter, hanya dokumen yang ditemui pertama yang diganti.

```
Document newDocument = new Document()
                .append("restaurantId", "REST-0Y9GL0")
                .append("name", "Bhiryani Adda")
                .append("cuisine", "Indian")
                .append("rating", new Document()
                        .append("average", 4.8)
                        .append("totalReviews", 267))
                .append("features", Arrays.asList("Outdoor Seating", "Live Music"));

UpdateResult result = collection.replaceOne(
                    Filters.eq("restaurantId", "REST-0Y9GL0"),
                    newDocument);
System.out.printf("Modified %d document%n", result.getModifiedCount());
```

### Perbarui beberapa dokumen
<a name="update-multiple-docs"></a>

Ada dua cara untuk memperbarui beberapa dokumen dalam koleksi secara bersamaan. Anda dapat menggunakan `updateMany()` metode ini atau menggunakan `bulkWrite()` metode [https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/client/model/UpdateManyModel.html](https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/client/model/UpdateManyModel.html)dengan. `updateMany()`Metode ini menggunakan parameter filter untuk memilih dokumen untuk pembaruan, `Update` parameter untuk mengidentifikasi bidang yang akan diperbarui, dan `UpdateOptions` parameter opsional untuk menentukan opsi pembaruan.

Kode contoh berikut menunjukkan penggunaan `updateMany()` metode:

```
Bson filter = Filters.and(
    Filters.in("features", Arrays.asList("Private Dining")),
    Filters.eq("cuisine", "Thai"));
UpdateResult result1 = collection.updateMany(filter, Updates.set("priceRange", "$$$"));
```

Contoh kode berikut menunjukkan `bulkWrite()` metode menggunakan update yang sama:

```
BulkWriteOptions options = new BulkWriteOptions().ordered(false);
List < WriteModel < Document >> updates = new ArrayList < > ();
Bson filter = Filters.and(
    Filters.in("features", Arrays.asList("Private Dining")),
    Filters.eq("cuisine", "Indian"));
Bson updateField = Updates.set("priceRange", "$$$");
updates.add(new UpdateManyModel < > (filter, updateField));
BulkWriteResult result = collection.bulkWrite(updates, options);
System.out.printf("Modified %d document%n", result.getModifiedCount());
```

## Menghapus dokumen dari koleksi DocumentDB
<a name="deleting-documents"></a>

Driver MongoDB Java `deleteOne()` menawarkan untuk menghapus satu dokumen `deleteMany()` dan untuk menghapus beberapa dokumen yang sesuai dengan kriteria tertentu. Sama seperti pembaruan, operasi hapus juga dapat digunakan dengan `bulkWrite()` metode ini. Keduanya `deleteOne()` dan `deleteMany()` mengembalikan [https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/client/result/DeleteResult.html](https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/client/result/DeleteResult.html)objek yang memberikan informasi tentang hasil operasi, termasuk jumlah dokumen yang dihapus. Berikut ini adalah contoh penggunaan `deleteMany()` untuk menghapus beberapa dokumen:

```
Bson filter = Filters.and(
    Filters.eq("cuisine", "Thai"),
    Filters.lt("rating.totalReviews", 50));
DeleteResult result = collection.deleteMany(filter);
System.out.printf("Deleted %d document%n", result.getDeletedCount());
```

## Penanganan kesalahan dengan logika coba lagi
<a name="error-handling"></a>

Strategi penanganan kesalahan yang kuat untuk Amazon DocumentDB harus menerapkan kategorisasi kesalahan menjadi dapat dicoba ulang (seperti batas waktu jaringan, masalah koneksi) dan tidak dapat dicoba ulang (seperti kegagalan otentikasi, kueri tidak valid). Untuk kegagalan operasi karena kesalahan yang harus dicoba lagi, itu harus menerapkan penundaan waktu antara setiap percobaan ulang serta upaya percobaan ulang maksimal. Operasi CRUD harus berada di blok try-catch yang menangkap dan [https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/MongoException.html](https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/MongoException.html)subkelasnya. Selain itu, harus mencakup pemantauan dan pencatatan kesalahan untuk visibilitas operasional. Berikut ini adalah contoh kode yang menunjukkan bagaimana menerapkan penanganan kesalahan coba lagi:

```
int MAX_RETRIES = 3;
int INITIAL_DELAY_MS = 1000;
int retryCount = 0;

while (true) {
    try {
        crud_operation(); //perform crud that will throw MongoException or one of its subclass
        break;
    } catch (MongoException e) {
        if (retryCount < MAX_RETRIES) {
            retryCount++;
            long delayMs = INITIAL_DELAY_MS * (long) Math.pow(2, retryCount - 1);
            try {
                TimeUnit.MILLISECONDS.sleep(delayMs);
            } catch (InterruptedException t) {
                Thread.currentThread().interrupt();
                throw new RuntimeException("Retry interrupted", t);
            }
            continue;
        } else
            throw new RuntimeException("Crud operation failed", e);
    }
}
```