Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

Durchführung 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 erstellen und in eine DocumentDB-Sammlung 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 grundlegendste 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 besprechen wir all diese Methoden zum Erstellen von Dokumenten in einer DocumentDB-Sammlung.

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 ein Formular BsonDocument zum Einfügen und gibt ein InsertOneResult Objekt zurück, das verwendet werden kann, um die Objekt-ID des neu eingefügten Dokuments abzurufen. 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 beispielsweise „restaurantId“ einen eindeutigen Index. Wenn Sie diesen Code erneut ausführen, wird daher 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={}}.

Fügt viele ein ()

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

Die insertMany() Methode ist die einfachste Methode, um 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 Verarbeitungen oder gemischten Operationen erfordern. Der folgende Code zeigt, wie JSON-Dokumente aus einer Datei gelesen und in die Sammlung eingefügt werden. Die insertMany() Funktion gibt ein InsertManyResult InsertManyResult Objekt zurück, mit dem die IDs aller 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 die Ausführung mehrerer Schreibvorgänge (Einfügen, Aktualisieren, Löschen) in einem einzigen Stapel. Sie können es verwendenbulkWrite(), 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:

Bei der Arbeit mit der bulkWrite() Methode sind einige wichtige Klassen erforderlich. Erstens dient die WriteModel Klasse als Basisklasse für alle Schreiboperationen und für spezifische Implementierungen wie InsertOneModel, UpdateOneModel UpdateManyModel DeleteOneModel, und für die DeleteManyModel Behandlung verschiedener Arten von Operationen.

Die BulkWriteOptions Klasse ist erforderlich, um das Verhalten von Massenoperationen zu konfigurieren, z. B. um die ordered/unordered Ausführung festzulegen oder die Dokumentvalidierung zu umgehen. Die BulkWriteResult Klasse 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 MongoBulkWriteException Klasse von entscheidender Bedeutung, da sie Informationen über alle Fehler während des Massenvorgangs enthält, während die BulkWriteError Klasse spezifische Details zu einzelnen Betriebsfehlern 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, und das alles im Rahmen eines einzelnen bulkWrite() Methodenaufrufs. Der Code zeigt auch, wie mit BulkWriteOptions und gearbeitet wird BulkWriteResult, sowie die korrekte Fehlerbehandlung der bulkWrite() Operation.

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 Schreibversuche. Daher müssen Sie in ihren Anwendungen eine benutzerdefinierte Wiederholungslogik implementieren, insbesondere zur Behandlung von Netzwerkproblemen oder vorübergehenden Dienstausfällen. Eine gut implementierte Wiederholungsstrategie besteht in der Regel darin, die Verzögerung zwischen Wiederholungsversuchen zu erhöhen und die Gesamtzahl der Wiederholungen 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-API in MongoDB-Java-Treibern. Sie ermöglicht das Abrufen komplexer Daten mit zahlreichen Optionen zum Filtern, Sortieren und Projizieren von Ergebnissen. Neben der find() Methode FindIterable gibt es zwei weitere grundlegende Komponenten, Filters die 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 für die Erstellung 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() Gleichheitsvergleiche,gt(), lt()gte(), und lte() für numerische Vergleiche and() sowie or() für das Kombinieren mehrerer Bedingungen in() sowie nin() für Tests der Array-Zugehörigkeit und regex() für den Mustervergleich. Die Klasse ist typsicher konzipiert und bietet im Vergleich zu dokumentbasierten Rohabfragen eine bessere Überprüfung bei der Kompilierung. Daher ist sie der bevorzugte Ansatz für die Erstellung von DocumentDB-Abfragen in Java-Anwendungen. Die Fehlerbehandlung ist robust, und es werden klare Ausnahmen für ungültige Filterkonstruktionen ausgelöst.

FindIterableist eine spezielle Schnittstelle, die entwickelt wurde, um das Ergebnis der find() Methode zu verarbeiten. 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 wichtige Methoden zur Änderung von Abfragen, z. B. limit() zur Beschränkung der Anzahl der zurückgegebenen Dokumente, skip() zur Seitennummerierung, zur Sortierung von Ergebnissen, sort() zur Auswahl bestimmter Felder und projection() zur Indexauswahl. hint() Die Batch-, Skip- und Limit-Operationen in FindIterable sind wichtige Paginierungs- und Datenmanagement-Tools, mit denen Sie kontrollieren können, 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 stattdessen in Gruppen 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 passenden 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 es 'n' Dokumente zurückgegeben hat, auch wenn die Datenbank mehr Treffer enthält.

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 des Iterators besteht darin, dass Sie nicht für die Aufrechterhaltung der Verbindung zum Cluster verantwortlich sind und daher kein ausdrückliches Schließen der Verbindung erforderlich ist.

FindIterablebieten auch Unterstützung MongoCursor, die die Verwendung von Cursormustern bei der Arbeit mit Amazon DocumentDB-Abfragen ermöglicht. MongoCursorist eine für den MongoDB-Java-Treiber spezifische Implementierung, die die Kontrolle über Datenbankoperationen und Ressourcenmanagement bietet. Sie implementiert die AutoCloseable Schnittstelle und ermöglicht eine explizite Ressourcenverwaltung durch Try-with-Resources-Blöcke. Dies ist entscheidend für das ordnungsgemäße Schließen von Datenbankverbindungen und das Freigeben von Serverressourcen. Standardmäßig läuft das Timeout des Cursors nach 10 Minuten ab, und DocumentDB bietet Ihnen nicht die Möglichkeit, dieses Timeout-Verhalten zu ändern. Wenn Sie mit Stapeldaten arbeiten, stellen Sie sicher, dass Sie den nächsten Datenstapel abrufen, bevor das Zeitlimit für den Cursor überschritten wird. Eine wichtige Überlegung bei der Verwendung MongoCursor ist, dass ein explizites Schließen erforderlich ist, um Ressourcenlecks zu verhindern.

In diesem Abschnitt werden mehrere Beispiele für find() Filters und FindIterable vorgestellt.

Das folgende Codebeispiel zeigt, wie ein einzelnes Dokument mithilfe des Felds „RestaurantID“ abgerufen wird: find()

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

Obwohl die Verwendung Filters eine bessere Überprüfung von Fehlern bei der Kompilierung ermöglicht, können Sie mit dem Java-Treiber auch direkt in der find() Methode einen Bson Filter 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 für ein FindIterable Objekt batchSize() verkettet werden. Die Reihenfolge, in der diese Operationen bereitgestellt werden, wirkt sich auf die Leistung Ihrer Abfrage aus. 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 das Erstellen eines Iterators aufFindIterable. 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 cursor() für das Abrufen von Dokumenten verwendet 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

Aktualisierung 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 Aktualisierungen: updateOne() für einzelne Dokumentaktualisierungen, updateMany() für mehrere Dokumentaktualisierungen und replaceOne() für den vollständigen Austausch von Dokumenten. Neben diesen drei Methoden UpdateResult gibt es noch weitere grundlegende Komponenten Updates UpdateOptions, die die Bausteine für Aktualisierungsvorgänge in MongoDB-Java-Treibern bilden.

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 Stärke dieser Klasse wird deutlich, wenn mehrere Operationen mithilfe 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 wichtige Anpassungsfunktionen 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, die durch aktiviert wirdupsert(true), ermöglicht die Erstellung neuer Dokumente, wenn bei einem Aktualisierungsvorgang 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 fehlerhaften Dokumente (). upsertedId Das Verständnis dieser Metriken ist für eine korrekte Fehlerbehandlung, die Überprüfung von Aktualisierungsvorgängen und die Aufrechterhaltung der Datenkonsistenz in Anwendungen unerlässlich.

Ein einzelnes Dokument aktualisieren und ersetzen

In DocumentDB kann das Aktualisieren eines einzelnen Dokuments mit der updateOne () -Methode 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 der updateOne() 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, fügt der Vorgang es stattdessen automatisch als neues Dokument ein. 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 ein vorhandenes Dokument mithilfe der replaceOne() Methode vollständig durch ein neues Dokument ersetzt wird, anstatt einzelne Felder zu aktualisieren. Die replaceOne() Methode überschreibt das gesamte Dokument und behält nur das _id Feld des Originals bei. 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());

Aktualisiere mehrere Dokumente

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

Der folgende Beispielcode veranschaulicht 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 zu entfernen und deleteMany() mehrere Dokumente zu entfernen, die bestimmten Kriterien entsprechen. Genau wie beim Aktualisieren kann auch der Löschvorgang mit der bulkWrite() Methode verwendet werden. Beide deleteOne() und deleteMany() geben ein DeleteResult Objekt zurück, das Informationen über das Ergebnis des Vorgangs liefert, einschließlich der Anzahl der gelöschten Dokumente. Das Folgende ist 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 Fehlerbehandlungsstrategie für Amazon DocumentDB sollte die Kategorisierung von Fehlern in wiederholbare Fehler (wie Netzwerk-Timeouts, Verbindungsprobleme) und Fehler, die nicht wiederholt werden können (wie Authentifizierungsfehler, ungültige Abfragen), beinhalten. Bei Betriebsausfällen aufgrund von Fehlern, die erneut versucht werden sollten, sollte eine Zeitverzögerung zwischen den einzelnen Wiederholungsversuchen sowie die maximale Anzahl der Wiederholungsversuche eingeführt werden. Die CRUD-Operationen sollten sich in einem Try-Catch-Block befinden, der Catches und seine Unterklassen abfängt. MongoException Darüber hinaus sollte es die Überwachung und Protokollierung von Fehlern beinhalten, um die betriebliche Sichtbarkeit 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);
    }
}