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

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

Membuat dan menyisipkan dokumen dalam koleksi DocumentDB

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 adalahinsertOne(). 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 iniinsertOne(). Metode ini mengambil BsonDocumentuntuk penyisipan dan mengembalikan InsertOneResultobjek 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 menggunakaninsertOne(), 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 berikutMongoWriteException:

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 InsertManyResultInsertManyResultobjek 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());

bulkWrite()

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:

Saat bekerja dengan bulkWrite() metode ini, ada beberapa kelas penting yang diperlukan. Pertama, WriteModelkelas berfungsi sebagai kelas dasar untuk semua operasi tulis dan dengan implementasi spesifik seperti InsertOneModel,, UpdateOneModelUpdateManyModel, DeleteOneModel, dan DeleteManyModelmenangani berbagai jenis operasi.

BulkWriteOptionsKelas ini diperlukan untuk mengkonfigurasi perilaku operasi massal, seperti pengaturan ordered/unordered eksekusi atau melewati validasi dokumen. BulkWriteResultKelas memberikan informasi rinci tentang hasil eksekusi, termasuk jumlah dokumen yang dimasukkan, diperbarui, dan dihapus.

Untuk penanganan kesalahan, MongoBulkWriteExceptionkelas sangat penting karena berisi informasi tentang kegagalan selama operasi massal, sementara BulkWriteErrorkelas 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 BulkWriteOptionsdan BulkWriteResult, 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 di bawah untuk contoh kode membangun logika coba lagi dengan penanganan kesalahan.

Membaca dan mengambil data dari koleksi DocumentDB

Kueri dokumen di Amazon DocumentDB berkisar pada beberapa komponen utama yang memungkinkan Anda mengambil dan memanipulasi data secara tepat. 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, Filtersdan FindIterabledua komponen fundamental lainnya yang menyediakan blok bangunan untuk operasi query di driver MongoDB Java.

FiltersKelas 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 numerikgte(), 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.

FindIterableadalah 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 menentukanlimit(n), DocumentDB akan berhenti mengembalikan dokumen setelah mengembalikan dokumen 'n', bahkan jika ada lebih banyak kecocokan dalam database.

FindIterablemendukung 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.

FindIterablejuga menyediakan dukungan MongoCursoryang memungkinkan pola kursor digunakan saat bekerja dengan kueri Amazon DocumentDB. MongoCursoradalah 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 untukfind(), Filters danFindIterable.

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 kefind():

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 denganfind():

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 operasisort(),skip(),limit(), dan batchSize() pada FindIterable objek. Urutan bagaimana operasi ini disediakan akan mempengaruhi kinerja kueri Anda. Sebagai praktik terbaik, urutan operasi ini harussort(),, projection()skip(), limit() danbatchSize().

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 padaFindIterable. 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

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 pembaruanupdateOne(): untuk pembaruan dokumen tunggal, untuk beberapa pembaruan dokumenupdateMany(), replaceOne() dan untuk penggantian dokumen lengkap. Selain ketiga metode ini,, UpdatesUpdateOptions, dan UpdateResultmerupakan komponen fundamental lainnya yang menyediakan blok bangunan untuk operasi pembaruan di driver MongoDB Java.

UpdatesKelas 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 sepertiset(),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.

UpdateOptionsadalah 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 melaluiupsert(true), memungkinkan pembuatan dokumen baru ketika tidak ada dokumen yang cocok ditemukan selama operasi pembaruan. MelaluiarrayFilters(), operasi pembaruan dapat secara tepat memperbarui elemen array yang memenuhi kriteria tertentu.

UpdateResultdi 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

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

Ada dua cara untuk memperbarui beberapa dokumen dalam koleksi secara bersamaan. Anda dapat menggunakan updateMany() metode ini atau menggunakan bulkWrite() metode UpdateManyModeldengan. 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

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 DeleteResultobjek 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

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 MongoExceptionsubkelasnya. 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);
    }
}