Durchführen von CRUD-Vorgängen in Amazon DocumentDB mit Java

In diesem Abschnitt wird die Durchführung von CRUD-Vorgängen (Create, Read, Update, Delete) in Amazon DocumentDB mithilfe von MongoDB-Java-Treibern beschrieben.

Dokumente in einer DocumentDB-Sammlung erstellen und einfügen

Durch das Einfügen von Dokumenten in Amazon DocumentDB können Sie Ihren Sammlungen neue Daten hinzufügen. Je nach Ihren Bedürfnissen und dem Datenvolumen, mit dem Sie arbeiten, gibt es mehrere Möglichkeiten, Einfügungen durchzuführen. Die einfachste Methode zum Einfügen eines einzelnen Dokuments in die Sammlung ist. insertOne() Um mehrere Dokumente gleichzeitig einzufügen, können Sie die insertMany() Methode verwenden, mit der Sie eine Reihe von Dokumenten in einem einzigen Vorgang hinzufügen können. Eine andere Methode zum Einfügen vieler Dokumente in eine DocumentDB-Sammlung ist. bulkWrite() In diesem Handbuch werden all diese Methoden zum Erstellen von Dokumenten in einer DocumentDB-Sammlung beschrieben.

insertOne()

Lassen Sie uns zunächst untersuchen, wie ein einzelnes Dokument in eine Amazon DocumentDBB-Sammlung eingefügt wird. Das Einfügen eines einzelnen Dokuments erfolgt mithilfe der Methode. insertOne() Diese Methode verwendet BsonDocumentfür das Einfügen einen Wert und gibt ein InsertOneResultObjekt zurück, mit dem die Objekt-ID des neu eingefügten Dokuments abgerufen werden kann. Der folgende Beispielcode zeigt das Einfügen eines Restaurantdokuments in die Sammlung:

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;
}

Achten Sie bei der Verwendung daraufinsertOne(), eine angemessene Fehlerbehandlung einzubeziehen. Im obigen Code hat „restaurantId“ beispielsweise einen eindeutigen Index. Wenn Sie diesen Code erneut ausführen, wird Folgendes ausgelöstMongoWriteException:

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

Die wichtigsten Methoden, die zum Einfügen vieler Dokumente in eine Sammlung verwendet werden, sind insertMany () und. bulkWrite()

Die insertMany() Methode ist die einfachste Methode, mehrere Dokumente in einem einzigen Vorgang einzufügen. Sie akzeptiert eine Liste von Dokumenten und fügt sie in die Sammlung ein. Diese Methode ist ideal, wenn Sie einen Stapel neuer Dokumente einfügen, die unabhängig voneinander sind und keine speziellen Verarbeitungs- oder Mischoperationen erfordern. Der folgende Code zeigt, wie JSON-Dokumente aus einer Datei gelesen und in die Sammlung eingefügt werden. Die insertMany() Funktion gibt ein InsertManyResultInsertManyResultObjekt zurück, mit dem IDs alle eingefügten Dokumente abgerufen werden können.

// 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()

Die bulkWrite() Methode ermöglicht es, mehrere Schreiboperationen (Einfügen, Aktualisieren, Löschen) in einem einzigen Stapel durchzuführen. Sie können bulkWrite() sie verwenden, wenn Sie verschiedene Arten von Vorgängen in einem einzigen Stapel ausführen müssen, z. B. wenn Sie einige Dokumente einfügen und andere aktualisieren müssen. bulkWrite()unterstützt zwei Arten von Batch-Schreibvorgängen, geordnet und ungeordnet:

• Geordnete Operationen — (Standard) Amazon DocumentDB verarbeitet die Schreibvorgänge sequentiell und stoppt beim ersten Fehler, auf den es stößt. Dies ist nützlich, wenn die Reihenfolge der Operationen wichtig ist, z. B. wenn spätere Operationen von früheren Vorgängen abhängen. Geordnete Operationen sind jedoch im Allgemeinen langsamer als ungeordnete Operationen. Bei geordneten Vorgängen müssen Sie den Fall berücksichtigen, dass der Stapel beim ersten Fehler stoppt und einige Operationen möglicherweise unbearbeitet bleiben.

• Ungeordnete Operationen — Ermöglicht Amazon DocumentDB, Einfügungen als einzelne Ausführung in der Datenbank zu verarbeiten. Wenn bei einem Dokument ein Fehler auftritt, wird der Vorgang mit den übrigen Dokumenten fortgesetzt. Dies ist besonders nützlich, wenn Sie große Datenmengen einfügen und einige Fehler tolerieren können, z. B. bei der Datenmigration oder bei Massenimporten, bei denen einige Dokumente aufgrund doppelter Schlüssel fehlschlagen können. Bei ungeordneten Vorgängen müssen Sie teilweise Erfolgsszenarien berücksichtigen, in denen einige Operationen erfolgreich sind, während andere fehlschlagen.

Bei der Arbeit mit der bulkWrite() Methode sind einige wichtige Klassen erforderlich. Erstens dient die WriteModelKlasse als Basisklasse für alle Schreiboperationen und für spezifische Implementierungen wie InsertOneModel,, UpdateOneModelUpdateManyModelDeleteOneModel, und DeleteManyModelbehandelt verschiedene Arten von Operationen.

Die BulkWriteOptionsKlasse ist notwendig, um das Verhalten von Massenoperationen zu konfigurieren, z. B. die ordered/unordered Ausführung festzulegen oder die Dokumentenvalidierung zu umgehen. Die BulkWriteResultKlasse bietet detaillierte Informationen zu den Ausführungsergebnissen, einschließlich der Anzahl der eingefügten, aktualisierten und gelöschten Dokumente.

Für die Fehlerbehandlung ist die MongoBulkWriteExceptionKlasse von entscheidender Bedeutung, da sie Informationen über alle Fehler während des Massenvorgangs enthält, während die BulkWriteErrorKlasse spezifische Details zu einzelnen Vorgangsfehlern enthält. Der folgende Code zeigt ein Beispiel für das Einfügen einer Liste von Dokumenten sowie das Aktualisieren und Löschen eines einzelnen Dokuments, alles innerhalb der Ausführung eines einzigen bulkWrite() Methodenaufrufs. Der Code zeigt auch BulkWriteResult, wie mit BulkWriteOptionsund gearbeitet wird und wie die bulkWrite() Operation korrekt mit Fehlern umgeht.

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

Wiederholbare Schreibvorgänge

Im Gegensatz zu MongoDB unterstützt Amazon DocumentDB keine wiederholbaren Schreibvorgänge. Daher müssen Sie in ihren Anwendungen eine benutzerdefinierte Wiederholungslogik implementieren, insbesondere zur Behandlung von Netzwerkproblemen oder vorübergehender Nichtverfügbarkeit von Diensten. Eine gut implementierte Wiederholungsstrategie besteht in der Regel darin, die Verzögerung zwischen Wiederholungsversuchen zu erhöhen und die Gesamtzahl der Wiederholungsversuche zu begrenzen. Fehlerbehandlung mit WiederholungslogikIm Folgenden finden Sie ein Codebeispiel für die Erstellung einer Wiederholungslogik mit Fehlerbehandlung.

Lesen und Abrufen von Daten aus einer DocumentDB-Sammlung

Das Abfragen von Dokumenten in Amazon DocumentDB basiert auf mehreren Schlüsselkomponenten, mit denen Sie Daten präzise abrufen und bearbeiten können. Die find()Methode ist die grundlegende Abfrage APIs in MongoDB-Java-Treibern. Sie ermöglicht den komplexen Datenabruf mit zahlreichen Optionen zum Filtern, Sortieren und Projizieren von Ergebnissen. Neben der find() Methode FindIterablesind dies zwei weitere grundlegende Komponenten, Filtersdie die Bausteine für Abfrageoperationen in MongoDB-Java-Treibern bereitstellen.

Die Filters Klasse ist eine Hilfsklasse im MongoDB-Java-Treiber, die eine flüssige API zum Erstellen von Abfragefiltern bereitstellt. Diese Klasse bietet statische Factory-Methoden, die Instanzen von Bson Objekten erstellen, die verschiedene Abfragebedingungen repräsentieren. Zu den am häufigsten verwendeten Methoden gehören eq() für Gleichheitsvergleichegt(),lt(),gte(), und lte() für numerische Vergleiche and() und or() für die Kombination mehrerer Bedingungen in() sowie nin() für Array-Zugehörigkeitstests und regex() für den Mustervergleich. Die Klasse ist typsicher konzipiert und bietet im Vergleich zu Abfragen, die auf Rohdokumenten basieren, eine bessere Überprüfung bei der Kompilierung, was sie zum bevorzugten Ansatz für die Erstellung von DocumentDB-Abfragen in Java-Anwendungen macht. Die Fehlerbehandlung ist robust und bei ungültigen Filterkonstruktionen werden eindeutige Ausnahmen ausgelöst.

FindIterableist eine spezielle Schnittstelle, die für die Verarbeitung des Ergebnisses der find() Methode entwickelt wurde. Es bietet eine Vielzahl von Methoden zur Verfeinerung und Steuerung der Abfrageausführung und bietet eine flüssige API für die Methodenverkettung. Die Schnittstelle umfasst grundlegende Methoden zur Änderung von Abfragen, z. B. limit() zur Beschränkung der Anzahl der zurückgegebenen Dokumente, skip() zur Seitennummerierung, zur Reihenfolge der Ergebnisse, sort() zur Auswahl bestimmter Felder und projection() zur Indexauswahl. hint() Die Batch-, Skip- und Limit-Operationen in FindIterable sind wichtige Tools zur Seitennummerierung und Datenverwaltung, mit deren Hilfe gesteuert werden kann, wie Dokumente aus der Datenbank abgerufen und verarbeitet werden.

Batching (batchSize) steuert, wie viele Dokumente DocumentDB in einem einzigen Netzwerk-Roundtrip an den Client zurückgibt. Wenn Sie eine Stapelgröße festlegen, gibt DocumentDB nicht alle passenden Dokumente auf einmal zurück, sondern gibt sie in Gruppen mit der angegebenen Stapelgröße zurück.

Mit Skip können Sie den Startpunkt Ihrer Ergebnisse verschieben und DocumentDB im Wesentlichen anweisen, eine bestimmte Anzahl von Dokumenten zu überspringen, bevor Treffer zurückgegeben werden. Beispielsweise skip(20) werden die ersten 20 übereinstimmenden Dokumente umgangen. Dies wird häufig in Paginierungsszenarien verwendet, in denen Sie nachfolgende Ergebnisseiten abrufen möchten.

Limit schränkt die Gesamtzahl der Dokumente ein, die von einer Abfrage zurückgegeben werden können. Wenn Sie angebenlimit(n), beendet DocumentDB die Rückgabe von Dokumenten, nachdem 'n' Dokumente zurückgegeben wurden, auch wenn es mehr Treffer in der Datenbank gibt.

FindIterableunterstützt sowohl Iterator- als auch Cursormuster beim Abrufen von Dokumenten aus Amazon DocumentDB. Der Vorteil der Verwendung FindIterable als Iterator besteht darin, dass Dokumente verzögert geladen werden können und Dokumente nur abgerufen werden, wenn sie von der Anwendung angefordert werden. Ein weiterer Vorteil der Verwendung von Iterator besteht darin, dass Sie nicht für die Aufrechterhaltung der Verbindung zum Cluster verantwortlich sind und daher kein explizites Schließen der Verbindung erforderlich ist.

FindIterablebietet auch Unterstützung für MongoCursordie Verwendung von Cursormustern bei der Arbeit mit Amazon DocumentDB DocumentDB-Abfragen. MongoCursorist eine mongoDB-Java-Treiberspezifische Implementierung, die die Kontrolle über Datenbankoperationen und Ressourcenmanagement bietet. Sie implementiert die AutoCloseable Schnittstelle und ermöglicht so eine explizite Ressourcenverwaltung über try-with-resources Blöcke, was für das ordnungsgemäße Schließen von Datenbankverbindungen und die Freigabe von Serverressourcen von entscheidender Bedeutung ist. Standardmäßig läuft der Cursor innerhalb von 10 Minuten ab, und DocumentDB bietet Ihnen nicht die Möglichkeit, dieses Timeout-Verhalten zu ändern. Achten Sie bei der Arbeit mit Batchdaten darauf, den nächsten Datenstapel abzurufen, bevor der Cursor das Timeout erreicht. Ein wichtiger Aspekt bei der Verwendung MongoCursor ist, dass ein explizites Schließen erforderlich ist, um Ressourcenlecks zu verhindern.

In diesem Abschnitt werden mehrere Beispiele fürfind(), Filters und vorgestelltFindIterable.

Das folgende Codebeispiel zeigt, wie Sie find() mithilfe des Felds „RestaurantID“ ein einzelnes Dokument abrufen können:

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

Die Verwendung Filters ermöglicht zwar eine bessere Fehlerprüfung bei der Kompilierung, mit dem Java-Treiber können Sie jedoch auch einen Bson Filter direkt in der find() Methode angeben. Der folgende Beispielcode übergibt Bson das Dokument anfind():

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

Der nächste Beispielcode zeigt mehrere Beispiele für die Verwendung der Filters Klasse mitfind():

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

Das folgende Beispiel zeigt, wie die Operationen vonsort(), skip()limit(), und batchSize() an einem FindIterable Objekt verkettet werden. Die Reihenfolge, in der diese Operationen ausgeführt werden, beeinflusst die Leistung Ihrer Abfrage. Als bewährte Methode sollte die Reihenfolge dieser Operationensort(), projection()skip(), limit() und lautenbatchSize().

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

Der folgende Beispielcode zeigt die Erstellung eines Iterators amFindIterable. Es verwendet das forEach Java-Konstrukt, um die Ergebnismenge zu durchlaufen.

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

Im letzten find() Codebeispiel wird gezeigt, wie es zum Abrufen von Dokumenten verwendet cursor() wird. Es erstellt den Cursor im Try-Block, wodurch sichergestellt wird, dass der Cursor geschlossen wird, wenn der Code den Try-Block verlässt.

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

Aktualisieren vorhandener Dokumente in einer DocumentDB-Sammlung

Amazon DocumentDB bietet flexible und leistungsstarke Mechanismen zum Ändern vorhandener Dokumente und zum Einfügen neuer Dokumente, wenn sie nicht existieren. Der MongoDB-Java-Treiber bietet mehrere Methoden für Updates: updateOne() für die Aktualisierung einzelner Dokumente, updateMany() für die Aktualisierung mehrerer Dokumente und replaceOne() für den vollständigen Austausch von Dokumenten. Neben diesen drei Methoden UpdateResultsind, UpdatesUpdateOptions, und weitere grundlegende Komponenten, die die Bausteine für Aktualisierungsvorgänge in MongoDB-Java-Treibern bereitstellen.

Die Updates Klasse im MongoDB-Java-Treiber ist eine Hilfsklasse, die statische Factory-Methoden zum Erstellen von Aktualisierungsoperatoren bereitstellt. Sie dient als primärer Builder für die typsichere und lesbare Konstruktion von Aktualisierungsoperationen. Grundlegende Methoden wie set()unset(), und inc() ermöglichen die direkte Änderung der Dokumente. Die Leistungsfähigkeit dieser Klasse wird deutlich, wenn mehrere Operationen mit der Updates.combine() Methode kombiniert werden, mit der mehrere Aktualisierungsvorgänge atomar ausgeführt werden können, wodurch die Datenkonsistenz gewährleistet wird.

UpdateOptionsist eine leistungsstarke Konfigurationsklasse im Java-Treiber von MongoDB, die grundlegende Anpassungsmöglichkeiten für Dokumentaktualisierungsvorgänge bietet. Zwei wichtige Aspekte dieser Klasse sind die Unterstützung von Upsert- und Array-Filtern für Aktualisierungsvorgänge. Die Upsert-Funktion, aktiviert durchupsert(true), ermöglicht die Erstellung neuer Dokumente, wenn während eines Aktualisierungsvorgangs keine passenden Dokumente gefunden werden. Durch arrayFilters() den Aktualisierungsvorgang können Array-Elemente, die bestimmte Kriterien erfüllen, präzise aktualisiert werden.

UpdateResultDer Java-Treiber von MongoDB bietet den Feedback-Mechanismus, der das Ergebnis eines Aktualisierungsvorgangs detailliert beschreibt. Diese Klasse umfasst drei wichtige Kennzahlen: die Anzahl der Dokumente, die den Aktualisierungskriterien entsprechen (matchedCount), die Anzahl der tatsächlich geänderten Dokumente (modifiedCount) und Informationen über alle geänderten Dokumente (). upsertedId Das Verständnis dieser Metriken ist für die korrekte Fehlerbehandlung, die Überprüfung von Aktualisierungsvorgängen und die Aufrechterhaltung der Datenkonsistenz in Anwendungen unerlässlich.

Aktualisieren und ersetzen Sie ein einzelnes Dokument

In DocumentDB kann die Aktualisierung eines einzelnen Dokuments mit der Methode updateOne () durchgeführt werden. Diese Methode verwendet einen Filterparameter, der normalerweise von der Filters Klasse bereitgestellt wird, um das zu aktualisierende Dokument zu identifizieren, einen Updat e-Parameter, der bestimmt, welche Felder aktualisiert werden sollen, und einen optionalen UpdateOptions Parameter, um verschiedene Optionen für die Aktualisierung festzulegen. Bei Verwendung updateOne() dieser Methode wird nur das erste Dokument aktualisiert, das den Auswahlkriterien entspricht. Der folgende Beispielcode aktualisiert ein einzelnes Feld eines Dokuments:

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

Um mehrere Felder in einem Dokument zu aktualisieren, verwenden Sie updateOne() with Update.combine() wie im folgenden Beispiel gezeigt. Dieses Beispiel zeigt auch, wie ein Element zu einem Array im Dokument hinzugefügt wird.

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

Das folgende Codebeispiel zeigt, wie ein Dokument in der Datenbank aktualisiert wird. Wenn das angegebene Dokument nicht existiert, wird es stattdessen automatisch als neues Dokument eingefügt. Dieser Code zeigt auch, wie die über das UpdateResult Objekt verfügbaren Metriken verwendet werden.

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)");
}

Das folgende Codebeispiel zeigt, wie Sie mithilfe der replaceOne() Methode ein vorhandenes Dokument vollständig durch ein neues Dokument ersetzen können, anstatt einzelne Felder zu aktualisieren. Die replaceOne() Methode überschreibt das gesamte Dokument, wobei nur das _id Feld des Originals beibehalten wird. Wenn mehrere Dokumente den Filterkriterien entsprechen, wird nur das zuerst gefundene Dokument ersetzt.

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

Aktualisieren Sie mehrere Dokumente

Es gibt zwei Möglichkeiten, mehrere Dokumente in einer Sammlung gleichzeitig zu aktualisieren. Sie können die updateMany() Methode oder die UpdateManyModelmit der bulkWrite() Methode verwenden. Die updateMany() Methode verwendet einen Filterparameter, um Dokumente für die Aktualisierung auszuwählen, den Update Parameter zur Identifizierung der zu aktualisierenden Felder und einen optionalen UpdateOptions Parameter zur Angabe von Aktualisierungsoptionen.

Der folgende Beispielcode demonstriert die Verwendung der updateMany() Methode:

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

Der folgende Beispielcode demonstriert die bulkWrite() Methode mit demselben Update:

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

Dokumente aus einer DocumentDB-Sammlung entfernen

Der MongoDB-Java-Treiber bietet deleteOne() die Möglichkeit, ein einzelnes Dokument und mehrere Dokumente deleteMany() zu entfernen, die bestimmten Kriterien entsprechen. Genau wie beim Aktualisieren kann auch der Löschvorgang mit der bulkWrite() Methode verwendet werden. Beides deleteOne() und gibt ein DeleteResultObjekt deleteMany() zurück, das Informationen über das Ergebnis des Vorgangs enthält, einschließlich der Anzahl der gelöschten Dokumente. Im Folgenden finden Sie ein Beispiel für die Verwendung deleteMany() zum Entfernen mehrerer Dokumente:

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

Fehlerbehandlung mit Wiederholungslogik

Eine robuste Strategie zur Fehlerbehandlung für Amazon DocumentDB sollte die Kategorisierung von Fehlern in wiederholbare Fehler (wie Netzwerk-Timeouts, Verbindungsprobleme) und nicht wiederholbare Fehler (wie Authentifizierungsfehler, ungültige Abfragen) implementieren. Bei Betriebsfehlern aufgrund von Fehlern, die wiederholt werden sollten, sollte eine Zeitverzögerung zwischen den einzelnen Wiederholungsversuchen sowie die maximale Anzahl von Wiederholungsversuchen vorgesehen werden. Die CRUD-Operationen sollten sich in einem Try-Catch-Block befinden, der Catches MongoExceptionund seine Unterklassen enthält. Darüber hinaus sollte es die Überwachung und Protokollierung von Fehlern beinhalten, um die betriebliche Transparenz zu gewährleisten. Im Folgenden finden Sie einen Beispielcode, der zeigt, wie die Behandlung von Wiederholungsfehlern implementiert wird:

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