Massenaktualisierung von Dokumenten in MongoDB mit Java

  2. How-To's
  3. MongoDB-Howtos
  4. Massenaktualisierung von Dokumenten in …
Mehvish Ashiq 12 Oktober 2023
MongoDB MongoDB Java
  1. Voraussetzungen
  2. Massenaktualisierung von Dokumenten in MongoDB mit Java
  3. Verwenden Sie updateMany(), um eine Massenaktualisierung durchzuführen, indem Sie den vorhandenen Dokumenten ein neues Feld hinzufügen
  4. Verwenden Sie updateMany(), um eine Massenaktualisierung bestehender Felder in mehreren Dokumenten durchzuführen, die dem Filter entsprechen
  5. Verwenden Sie updateMany(), um eine Massenaktualisierung für eingebettete Dokumente durchzuführen, die dem Filter entsprechen
  6. Verwenden Sie die bulkWrite()-API, um vorhandene Dokumente zu aktualisieren, die der Filterabfrage entsprechen
Massenaktualisierung von Dokumenten in MongoDB mit Java

In diesem Tutorial geht es um die Durchführung einer Massenaktualisierung von Dokumenten in MongoDB mit dem Java-Treiber. Wir werden auch lernen, wie man aktualisiert, indem man ein neues Feld hinzufügt, den Wert des vorhandenen Felds oder Arrays ändert oder Dokumente löscht.

Voraussetzungen

Für dieses Tutorial verwenden wir die folgenden Tools, die Sie unbedingt befolgen müssen.

  1. Java (wir verwenden Java 18.0.1.1)
  2. MongoDB Server (wir verwenden MongoDB 5.0.8)
  3. Code-Editor oder eine beliebige Java-IDE (wir verwenden Apache NetBeans IDE 13)
  4. Mongo Java-Treiberabhängigkeiten mit Maven oder Gradle; wir verwenden es mit Maven.

Massenaktualisierung von Dokumenten in MongoDB mit Java

Die Massenaktualisierung ist vorteilhaft, wenn wir mehrere Dokumente in der Datenbank aktualisieren müssen. Nun stellt sich die Frage, wie wollen wir die Dokumente aktualisieren?

Möchten wir aktualisieren, indem wir ein neues Feld hinzufügen, den Wert eines vorhandenen Felds oder eines Arrays aktualisieren oder Dokumente löschen? Um all diese Szenarien kennenzulernen, erstellen wir eine Sammlung und fügen zwei Dokumente ein.

Sammlung erstellen:

db.createCollection('supervisor');

Erstes Dokument einfügen:

db.supervisor.insertOne(
    {
          "firstname": "Mehvish",
          "lastname": "Ashiq",
          "gender": "Female",
          "contact" : {
              "email":"mehvishofficial@gmail.com",
              "phone" : [
                  {
                      "type" : "official",
                      "number" : "123456789"
                  },
                  {
                       "type" : "personal",
                       "number" : "124578369"
                  },
               ]
          },
          "entries" : [
              { "_id" : 1, "itemsperday" : [ 1,3,4,5,6,7 ] },
              { "_id" : 2, "itemperday" : [ 2,3,4,5,2,7 ] },
              { "_id" : 3, "itemperday" : [ 5,0,0,4,0,1 ] }
           ]
    }
);

Zweites Dokument einfügen:

db.supervisor.insertOne(
    {
          "firstname": "Tahir",
          "lastname": "Raza",
          "gender": "Male",
          "contact" : {
              "email":"tahirraza@gmail.com",
              "phone" : [
                  {
                      "type" : "official",
                      "number" : "123478789"
                  },
                  {
                       "type" : "personal",
                       "number" : "122378369"
                  },
               ]
          },
          "entries" : [
              { "_id" : 1, "itemsperday" : [ 4,5,6,7,4,6 ] },
              { "_id" : 2, "itemperday" : [ 2,3,2,7,5,2 ] },
              { "_id" : 3, "itemperday" : [ 5,0,0,1,0,0 ] }
           ]
    }
);

Sobald Sie die Sammlung gefüllt haben, können Sie db.supervisor.find().pretty(); um die eingefügten Dokumente anzusehen. Wir beginnen mit einfachen Lösungen und bewegen uns zu etwas kniffligen, aber interessanten Lösungen.

Verwenden Sie updateMany(), um eine Massenaktualisierung durchzuführen, indem Sie den vorhandenen Dokumenten ein neues Feld hinzufügen

Beispielcode:

// write your package where you want to save your source file
package com.voidtesting.javamongobulkupdateexample;

// import necessary libraries
import com.mongodb.BasicDBObject;
import com.mongodb.MongoException;
import com.mongodb.client.MongoClient;
import com.mongodb.client.MongoClients;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
import org.bson.Document;

// Example_1
public class Example_1 {
  // main method
  public static void main(String[] args) {
    // Replace the connection string with your own connection string
    var uri = "mongodb://localhost:27017";

    // try block
    try (MongoClient mongoClient = MongoClients.create(uri)) {
      // print message if connection is successfully established
      System.out.println("Connected successfully to server.");

      // get the specified database from the MongoDB server
      MongoDatabase database = mongoClient.getDatabase("bulkUpdate");

      // get the specified collection from the selected database
      MongoCollection<Document> collection = database.getCollection("supervisor");

      // update documents by adding a new field and its value
      collection.updateMany(
          new BasicDBObject(), new BasicDBObject("$set", new BasicDBObject("status", "Good")));

      // print a new line
      System.out.println();

      // iterate over all documents of the selected collection
      // to print in Java IDE
      collection.find().forEach(doc -> {
        System.out.println(doc.toBsonDocument());
        System.out.println();
      }); // end forEach

    } // end try block

    // print error if unable to execute a command
    catch (MongoException error) {
      System.err.println("An error occurred while running a command: " + error);
    } // end catch block

  } // end main method
} // end Example_1

Ausgabe:

{
    "_id": {"$oid": "62a866e592fd89ad9c4932ed"},
    "firstname": "Mehvish",
    "lastname": "Ashiq",
    "gender": "Female",
    "contact": {
        "email": "mehvishofficial@gmail.com",
        "phone": [
            { "type": "official", "number": "123456789"},
            {"type": "personal", "number": "124578369"}
         ]
     },
     "entries": [
         {"_id": 1.0, "itemsperday": [1.0, 3.0, 4.0, 5.0, 6.0, 7.0]},
         {"_id": 2.0, "itemperday": [2.0, 3.0, 4.0, 5.0, 2.0, 7.0]},
         {"_id": 3.0, "itemperday": [5.0, 0.0, 0.0, 4.0, 0.0, 1.0]}
     ],
     "status": "Good"
}

{
    "_id": {"$oid": "62a8670192fd89ad9c4932ee"},
    "firstname": "Tahir",
    "lastname": "Raza",
    "gender": "Male",
    "contact": {
        "email": "tahirraza@gmail.com",
        "phone": [
            {"type": "official", "number": "123478789"},
            {"type": "personal", "number": "122378369"}
         ]
     },
     "entries": [
         {"_id": 1.0, "itemsperday": [4.0, 5.0, 6.0, 7.0, 4.0, 6.0]},
         {"_id": 2.0, "itemperday": [2.0, 3.0, 2.0, 7.0, 5.0, 2.0]},
         {"_id": 3.0, "itemperday": [5.0, 0.0, 0.0, 1.0, 0.0, 0.0]}
     ],
     "status": "Good"
}

Wir haben die Ausgabe für Sie formatiert (siehe oben), aber in der IDE sehen Sie ein Dokument pro Zeile. Wir können auch db.supervisor.find().pretty(); auf Mongo Shell, um dort die aktualisierten Dokumente anzuzeigen.

Für diesen Beispielcode verwenden wir die updateMany()-Methode eines Mongo-Erfassungsobjekts, das die filter-Abfrage und eine update-Anweisung verwendet, um die übereinstimmenden Dokumente zu aktualisieren. Hier filtern wir die Dokumente nicht, sondern fügen allen vorhandenen Dokumenten ein neues Feld namens status hinzu (siehe die oben angegebene Ausgabe).

Verwenden Sie updateMany(), um eine Massenaktualisierung bestehender Felder in mehreren Dokumenten durchzuführen, die dem Filter entsprechen

Beispielcode:

// write your package where you want to save your source file
package com.voidtesting.javamongobulkupdateexample;

// import necessary libraries
import static com.mongodb.client.model.Filters.eq;
import static com.mongodb.client.model.Updates.combine;
import static com.mongodb.client.model.Updates.set;

import com.mongodb.MongoException;
import com.mongodb.client.MongoClient;
import com.mongodb.client.MongoClients;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
import org.bson.Document;

// Example_2
public class Example_2 {
  // main method
  public static void main(String[] args) {
    // Replace the connection string with your own connection string
    var uri = "mongodb://localhost:27017";

    // try block
    try (MongoClient mongoClient = MongoClients.create(uri)) {
      // print message if connection is successfully established
      System.out.println("Connected successfully to server.");

      // get the specified database from the MongoDB server
      MongoDatabase database = mongoClient.getDatabase("bulkUpdate");

      // get the specified collection from the selected database
      MongoCollection<Document> collection = database.getCollection("supervisor");

      // update the filtered documents by updating the existing field
      collection.updateMany(eq("gender", "Female"), combine(set("gender", "F")));
      collection.updateMany(eq("gender", "Male"), combine(set("gender", "M")));

      System.out.println();
      // iterate over all documents of the selected collection
      // to print in Java IDE
      collection.find().forEach(doc -> {
        System.out.println(doc.toBsonDocument());
        System.out.println();
      }); // end forEach

    } // end try block

    // print error if unable to execute a command
    catch (MongoException error) {
      System.err.println("An error occurred while running a command: " + error);
    } // end catch block

  } // end main method
} // end Example_2

Ausgabe:

{
    "_id": {"$oid": "62a866e592fd89ad9c4932ed"},
    "firstname": "Mehvish",
    "lastname": "Ashiq",
    "gender": "F",
    "contact": {
        "email": "mehvishofficial@gmail.com",
        "phone": [
            { "type": "official", "number": "123456789"},
            {"type": "personal", "number": "124578369"}
         ]
     },
     "entries": [
         {"_id": 1.0, "itemsperday": [1.0, 3.0, 4.0, 5.0, 6.0, 7.0]},
         {"_id": 2.0, "itemperday": [2.0, 3.0, 4.0, 5.0, 2.0, 7.0]},
         {"_id": 3.0, "itemperday": [5.0, 0.0, 0.0, 4.0, 0.0, 1.0]}
     ],
     "status": "Good"
}

{
    "_id": {"$oid": "62a8670192fd89ad9c4932ee"},
    "firstname": "Tahir",
    "lastname": "Raza",
    "gender": "M",
    "contact": {
        "email": "tahirraza@gmail.com",
        "phone": [
            {"type": "official", "number": "123478789"},
            {"type": "personal", "number": "122378369"}
         ]
     },
     "entries": [
         {"_id": 1.0, "itemsperday": [4.0, 5.0, 6.0, 7.0, 4.0, 6.0]},
         {"_id": 2.0, "itemperday": [2.0, 3.0, 2.0, 7.0, 5.0, 2.0]},
         {"_id": 3.0, "itemperday": [5.0, 0.0, 0.0, 1.0, 0.0, 0.0]}
     ],
     "status": "Good"
}

Dieses Codebeispiel ähnelt dem vorherigen, aber wir aktualisieren den Wert eines bestimmten Felds in allen Dokumenten, die dem Filter entsprechen.

Wir verwenden updateMany(), um Massenaktualisierungen für alle Dokumente durchzuführen, bei denen gender gleich Female und gender gleich Male ist. Wir ändern das "gender": "Female" und das "gender": "Male" in "gender": "F" bzw. "gender":"M".

Bisher haben wir gesehen, wie man die Methode updateMany() verwendet, um ein neues Feld hinzuzufügen oder den Wert eines bestehenden Felds auf der ersten Ebene zu aktualisieren. Als nächstes werden wir lernen, wie man updateMany() verwendet, um eine Massenaktualisierung eingebetteter Dokumente durchzuführen, die die Filterabfrage erfüllen.

Verwenden Sie updateMany(), um eine Massenaktualisierung für eingebettete Dokumente durchzuführen, die dem Filter entsprechen

Beispielcode:

// write your package where you want to save your source file
package com.voidtesting.javamongobulkupdateexample;

// import necessary libraries
import com.mongodb.MongoException;
import com.mongodb.client.MongoClient;
import com.mongodb.client.MongoClients;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
import com.mongodb.client.model.UpdateOptions;
import org.bson.Document;
import org.bson.conversions.Bson;

// Example_3
public class Example_3 {
  // main method
  public static void main(String[] args) {
    // Replace the connection string with your own connection string
    var uri = "mongodb://localhost:27017";

    // try block
    try (MongoClient mongoClient = MongoClients.create(uri)) {
      // print message if connection is successfully established
      System.out.println("Connected successfully to server.");

      // get the specified database from the MongoDB server
      MongoDatabase database = mongoClient.getDatabase("bulkUpdate");

      // get the specified collection from the selected database
      MongoCollection<Document> collection = database.getCollection("supervisor");
      // filter
      Bson where = new Document().append("contact.phone.type", "official");
      // update
      Bson update = new Document().append("contact.phone.$.type", "assistant");
      // set
      Bson set = new Document().append("$set", update);

      // update collection
      collection.updateMany(where, set, new UpdateOptions());

      // iterate over all documents of the selected collection
      // to print in Java IDE
      collection.find().forEach(doc -> {
        System.out.println(doc.toBsonDocument());
        System.out.println();
      }); // end forEach

    } // end try block

    // print error if unable to execute a command
    catch (MongoException error) {
      System.err.println("An error occurred while running a command: " + error);
    } // end catch block

  } // end main method
} // end Example_3

Ausgabe:

{
    "_id": {"$oid": "62a866e592fd89ad9c4932ed"},
    "firstname": "Mehvish",
    "lastname": "Ashiq",
    "gender": "F",
    "contact": {
        "email": "mehvishofficial@gmail.com",
        "phone": [
            { "type": "assistant", "number": "123456789"},
            {"type": "personal", "number": "124578369"}
         ]
     },
     "entries": [
         {"_id": 1.0, "itemsperday": [1.0, 3.0, 4.0, 5.0, 6.0, 7.0]},
         {"_id": 2.0, "itemperday": [2.0, 3.0, 4.0, 5.0, 2.0, 7.0]},
         {"_id": 3.0, "itemperday": [5.0, 0.0, 0.0, 4.0, 0.0, 1.0]}
     ],
     "status": "Good"
}

{
    "_id": {"$oid": "62a8670192fd89ad9c4932ee"},
    "firstname": "Tahir",
    "lastname": "Raza",
    "gender": "M",
    "contact": {
        "email": "tahirraza@gmail.com",
        "phone": [
            {"type": "assistant", "number": "123478789"},
            {"type": "personal", "number": "122378369"}
         ]
     },
     "entries": [
         {"_id": 1.0, "itemsperday": [4.0, 5.0, 6.0, 7.0, 4.0, 6.0]},
         {"_id": 2.0, "itemperday": [2.0, 3.0, 2.0, 7.0, 5.0, 2.0]},
         {"_id": 3.0, "itemperday": [5.0, 0.0, 0.0, 1.0, 0.0, 0.0]}
     ],
     "status": "Good"
}

In diesem Java-Programm verwenden wir die Methode updateMany(), um eine Massenaktualisierung für eingebettete Dokumente durchzuführen, die der Filterabfrage entsprechen.

Hier aktualisieren wir den Wert des contact.phone.type von official auf assistant. Um auf ein Array von Dokumenten zuzugreifen, verwenden wir den Positionsoperator ($), um den ersten Array-Wert zu aktualisieren, der der Filterabfrage entspricht.

Bei Verwendung des Positionsoperators können wir auch angeben, welche Array-Elemente aktualisiert werden sollen. Wir können das erste, alle oder bestimmte zu aktualisierende Array-Elemente angeben.

Um die Array-Elemente per Positionsoperator anzugeben, verwenden wir die Punktnotation, eine Eigenschaftszugriffssyntax zum Navigieren durch BSON-Objekte. Wir verwenden den Positionsoperator auf folgende Weise, um zuerst, alle oder bestimmte Array-Elemente zu aktualisieren.

  1. Wir verwenden den Positionsoperator ($), um das erste Element des Arrays zu aktualisieren, das die Filterabfrage erfüllt, während das Array-Feld Teil der Filterabfrage sein muss, um den Positionsoperator zu verwenden.

  2. Wir verwenden alle Positionsoperatoren ($[]), um alle Elemente (Elemente) eines Arrays zu aktualisieren.

  3. Der gefilterte Positionsoperator ($[<identifier>]) wird verwendet, um die Elemente des Arrays zu aktualisieren, die der Filterabfrage entsprechen. Hier müssen wir den Array-Filter in unseren Aktualisierungsvorgang einbeziehen, um mitzuteilen, welche Array-Elemente aktualisiert werden müssen.

    Denken Sie daran, dass <identifier> ein Name ist, den wir unserem Array-Filter geben. Dieser Wert muss mit einem Kleinbuchstaben beginnen und darf nur alphanumerische Zeichen enthalten.

Verwenden Sie die bulkWrite()-API, um vorhandene Dokumente zu aktualisieren, die der Filterabfrage entsprechen

Beispielcode:

// write your package where you want to save your source file
package com.voidtesting.javamongobulkupdateexample;

// import necessary libraries
import com.mongodb.MongoException;
import com.mongodb.client.MongoClient;
import com.mongodb.client.MongoClients;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
import com.mongodb.client.model.DeleteOneModel;
import com.mongodb.client.model.UpdateManyModel;
import com.mongodb.client.model.WriteModel;
import java.util.ArrayList;
import java.util.List;
import org.bson.Document;

// Example_4
public class Example_4 {
  // main method
  public static void main(String[] args) {
    // Replace the connection string with your own connection string
    var uri = "mongodb://localhost:27017";

    // try block
    try (MongoClient mongoClient = MongoClients.create(uri)) {
      // print message if connection is successfully established
      System.out.println("Connected successfully to server.");

      // get the specified database from the MongoDB server
      MongoDatabase database = mongoClient.getDatabase("bulkUpdate");

      // get the specified collection from the selected database
      MongoCollection<Document> collection = database.getCollection("supervisor");

      // create object
      List<WriteModel<Document>> writes = new ArrayList<>();

      // delete the document matching the filter
      writes.add(new DeleteOneModel<>(new Document("firstname", "Tahir")));

      // update document matching the filter
      writes.add(new UpdateManyModel<>(new Document("status", "Good"), // filter
          new Document("$set", new Document("status", "Excellent")) // update
          ));

      // bulk write
      collection.bulkWrite(writes);

      // iterate over all documents of the selected collection
      // to print in Java IDE
      collection.find().forEach(doc -> {
        System.out.println(doc.toBsonDocument());
        System.out.println();
      }); // end forEach

    } // end try block
    catch (MongoException me) {
      System.err.println("An error occurred while running a command: " + me);
    } // end catch block
  } // end main method

} // end Example_4

Ausgabe:

{
    "_id": {"$oid": "62a866e592fd89ad9c4932ed"},
    "firstname": "Mehvish",
    "lastname": "Ashiq",
    "gender": "F",
    "contact": {
        "email": "mehvishofficial@gmail.com",
        "phone": [
            {"type": "assistant", "number": "123456789"},
            {"type": "personal", "number": "124578369"}
        ]
     },
     "entries": [
         {"_id": 1.0, "itemsperday": [1.0, 3.0, 4.0, 5.0, 6.0, 7.0]},
         {"_id": 2.0, "itemperday": [2.0, 3.0, 4.0, 5.0, 2.0, 7.0]},
         {"_id": 3.0, "itemperday": [5.0, 0.0, 0.0, 4.0, 0.0, 1.0]}
     ],
     "status": "Excellent"
}

In diesem Beispiel führen wir mehrere Operationen (Löschen und Aktualisieren) gleichzeitig mit der bulkWrite() API aus. Das DeleteOneModel() wird verwendet, um ein Dokument zu löschen, das dem Filter entspricht, während wir UpdateManyModel() verwenden, um den Wert eines bereits vorhandenen Felds in allen Dokumenten zu aktualisieren, die dem Filter entsprechen.

Autor: Mehvish Ashiq
Mehvish Ashiq avatar Mehvish Ashiq avatar

Mehvish Ashiq is a former Java Programmer and a Data Science enthusiast who leverages her expertise to help others to learn and grow by creating interesting, useful, and reader-friendly content in Computer Programming, Data Science, and Technology.

LinkedIn GitHub Facebook

Verwandter Artikel - MongoDB Java