Heute werden wir uns mit der Masseneinfügung in MongoDB beschäftigen. Mit der Bulk-Einfügeoperation können mehrere Dokumente gleichzeitig in MongoDB eingefügt werden, indem ein Array von Dokumenten als Parameter an die insert-Methode übergeben wird.
MongoDB Masseneinfügung
Die MongoDB Masseneinfügung führt standardmäßig eine geordnete Einfügung durch. Wenn während der Einfügung an einer bestimmten Stelle ein Fehler auftritt, erfolgt die Einfügung für die verbleibenden Dokumente nicht. Schauen wir uns ein Beispiel dafür an, wie man über die Befehlszeile mehrere Dokumente mit der MongoDB Masseneinfügung einfügt.
MongoDB fügt viele Dokumente ein
> db.car.insert(
... [
... { _id:1,name:"Audi",color:"Red",cno:"H101",mfdcountry:"Germany",speed:75 },
... { _id:2,name:"Swift",color:"Black",cno:"H102",mfdcountry:"Italy",speed:60 },
... { _id:3,name:"Maruthi800",color:"Blue",cno:"H103",mfdcountry:"India",speed:70 },
... { _id:4,name:"Polo",color:"White",cno:"H104",mfdcountry:"Japan",speed:65 },
... { _id:5,name:"Volkswagen",color:"JetBlue",cno:"H105",mfdcountry:"Rome",speed:80 }
... ]
... )
BulkWriteResult({
"writeErrors" : [ ],
"writeConcernErrors" : [ ],
"nInserted" : 5,
"nUpserted" : 0,
"nMatched" : 0,
"nModified" : 0,
"nRemoved" : 0,
"upserted" : [ ]
})
Diese Operation hat fünf Dokumente eingefügt. MongoDB erstellt automatisch ein ID-Feld, wenn es vom Benutzer nicht in der Abfrage angegeben wird. Die Spalte „nInserted“ gibt dem Benutzer die Anzahl der eingefügten Dokumente an. Um die eingefügten Dokumente anzuzeigen, führen Sie die folgende Abfrage wie unten gezeigt aus.
> db.car.find()
{ "_id" : 1, "name" : "Audi", "color" : "Red", "cno" : "H101", "mfdcountry" : "Germany", "speed" : 75 }
{ "_id" : 2, "name" : "Swift", "color" : "Black", "cno" : "H102", "mfdcountry" : "Italy", "speed" : 60 }
{ "_id" : 3, "name" : "Maruthi800", "color" : "Blue", "cno" : "H103", "mfdcountry" : "India", "speed" : 70 }
{ "_id" : 4, "name" : "Polo", "color" : "White", "cno" : "H104", "mfdcountry" : "Japan", "speed" : 65 }
{ "_id" : 5, "name" : "Volkswagen", "color" : "JetBlue", "cno" : "H105", "mfdcountry" : "Rome", "speed" : 80 }
>
Erfahren Sie mehr über die MongoDB find und MongoDB insert Operationen. Beim Einfügen ist es nicht zwingend erforderlich, dass der Benutzer alle Felder in der Abfrage angibt. Schauen wir uns nun an, wie die Einfügung funktioniert, wenn einige Felder nicht angegeben sind.
MongoDB Bulk Insert von Dokumenten unter Angabe einiger Felder
> db.car.insert(
... [
... { _id:6,name:"HondaCity",color:"Grey",cno:"H106",mfdcountry:"Sweden",speed:45 },
... {name:"Santro",color:"Pale Blue",cno:"H107",mfdcountry:"Denmark",speed:55 },
... { _id:8,name:"Zen",speed:54 }
... ]
... )
BulkWriteResult({
"writeErrors" : [ ],
"writeConcernErrors" : [ ],
"nInserted" : 3,
"nUpserted" : 0,
"nMatched" : 0,
"nModified" : 0,
"nRemoved" : 0,
"upserted" : [ ]
})
>
In diesem Beispiel wird für das zweite Dokument das ID-Feld nicht vom Benutzer angegeben, und für das dritte Dokument werden nur die ID-, Name- und Geschwindigkeitsfelder in der Abfrage bereitgestellt. Die Abfrage führt eine erfolgreiche Einfügung durch, obwohl einige Felder im zweiten und dritten Dokument fehlen. Die Spalte „nInserted“ gibt an, dass drei Dokumente eingefügt wurden. Rufen Sie die Methode find auf und überprüfen Sie die eingefügten Dokumente.
> db.car.find()
{ "_id" : 1, "name" : "Audi", "color" : "Red", "cno" : "H101", "mfdcountry" : "Germany", "speed" : 75 }
{ "_id" : 2, "name" : "Swift", "color" : "Black", "cno" : "H102", "mfdcountry" : "Italy", "speed" : 60 }
{ "_id" : 3, "name" : "Maruthi800", "color" : "Blue", "cno" : "H103", "mfdcountry" : "India", "speed" : 70 }
{ "_id" : 4, "name" : "Polo", "color" : "White", "cno" : "H104", "mfdcountry" : "Japan", "speed" : 65 }
{ "_id" : 5, "name" : "Volkswagen", "color" : "JetBlue", "cno" : "H105", "mfdcountry" : "Rome", "speed" : 80 }
{ "_id" : 6, "name" : "HondaCity", "color" : "Grey", "cno" : "H106", "mfdcountry" : "Sweden", "speed" : 45 }
{ "_id" : ObjectId("54885b8e61307aec89441a0b"), "name" : "Santro", "color" : "Pale Blue", "cno" : "H107", "mfdcountry" : "Denmark", "speed" : 55 }
{ "_id" : 8, "name" : "Zen", "speed" : 54 }
>
Beachten Sie, dass die ID von MongoDB automatisch für das Auto „Santro“ generiert wird. Für ID 8 werden nur die Felder Name und Geschwindigkeit eingefügt.
Einfügen von ungeordneten Dokumenten
Bei ungeordneter Einfügung setzt MongoDB die Einfügung der verbleibenden Dokumente im Array fort, wenn an einer bestimmten Stelle ein Fehler auftritt. Zum Beispiel;
> db.car.insert(
... [
... { _id:9,name:"SwiftDezire",color:"Maroon",cno:"H108",mfdcountry:"New York",speed:40 },
... { name:"Punto",color:"Wine Red",cno:"H109",mfdcountry:"Paris",speed:45 },
... ],
... { ordered: false }
... )
BulkWriteResult({
"writeErrors" : [ ],
"writeConcernErrors" : [ ],
"nInserted" : 2,
"nUpserted" : 0,
"nMatched" : 0,
"nModified" : 0,
"nRemoved" : 0,
"upserted" : [ ]
})
>
Im Insert-Query wird „ordered false“ angegeben, was darauf hinweist, dass es sich um eine ungeordnete Sammlung handelt. Führen Sie db.car.find() aus.
{ "_id" : 1, "name" : "Audi", "color" : "Red", "cno" : "H101", "mfdcountry" : "Germany", "speed" : 75 }
{ "_id" : 2, "name" : "Swift", "color" : "Black", "cno" : "H102", "mfdcountry" : "Italy", "speed" : 60 }
{ "_id" : 3, "name" : "Maruthi800", "color" : "Blue", "cno" : "H103", "mfdcountry" : "India", "speed" : 70 }
{ "_id" : 4, "name" : "Polo", "color" : "White", "cno" : "H104", "mfdcountry" : "Japan", "speed" : 65 }
{ "_id" : 5, "name" : "Volkswagen", "color" : "JetBlue", "cno" : "H105", "mfdcountry" : "Rome", "speed" : 80 }
{ "_id" : 6, "name" : "HondaCity", "color" : "Grey", "cno" : "H106", "mfdcountry" : "Sweden", "speed" : 45 }
{ "_id" : ObjectId("54746407d785e3a05a1808a6"), "name" : "Santro", "color" : "Pale Blue", "cno" : "H107", "mfdcountry" : "Denmark", "speed" : 55 }
{ "_id" : 8, "name" : "Zen", "speed" : 54 }
{ "_id" : 9, "name" : "SwiftDezire", "color" : "Maroon", "cno" : "H108", "mfdcountry" : "New York", "speed" : 40 }
{ "_id" : ObjectId("5474642dd785e3a05a1808a7"), "name" : "Punto", "color" : "Wine Red", "cno" : "H109", "mfdcountry" : "Paris", "speed" : 45 }
Die Dokumente werden eingefügt, und wie Sie sehen können, handelt es sich um eine ungeordnete Einfügung. Wenn die Insert-Methode auf einen Fehler stößt, enthält das Ergebnis das Feld „WriteResult.writeErrors“, das die Fehlermeldung angibt, die das Scheitern verursacht hat.
Einfügen des doppelten ID-Werts
> db.car.insert({_id:6,name:"Innova"})
WriteResult({
"nInserted" : 0,
"writeError" : {
"code" : 11000,
"errmsg" : "insertDocument :: caused by :: 11000 E11000 duplicate key error index: journaldev.car.$_id_ dup key: { : 6.0 }"
}
})
>
Der Fehler deutet darauf hin, dass wir ein Dokument für die ID 6 einfügen, das bereits ein Dokument enthält, und wirft daher einen Fehler für den doppelten Schlüsselwert für die ID 6.
MongoDB Bulk.insert() Methode
Diese Methode führt eine Massen-Einfügeoperation durch. Sie wurde ab Version 2.6 eingeführt. Die Syntax lautet Bulk.insert(<Dokument>). Dokument: gibt das einzufügende Dokument an. Nun werden wir das Beispiel für die Masseneinfügung sehen.
Massen-Ungeordnete Einfügung
> var carbulk = db.car.initializeUnorderedBulkOp();
> carbulk.insert({ name:"Ritz", color:"Grey",cno:"H109",mfdcountry:"Mexico",speed:62});
> carbulk.insert({ name:"Versa", color:"Magenta",cno:"H110",mfdcountry:"France",speed:68});
> carbulk.insert({ name:"Innova", color:"JetRed",cno:"H111",mfdcountry:"Dubai",speed:72});
> carbulk.execute();
BulkWriteResult({
"writeErrors" : [ ],
"writeConcernErrors" : [ ],
"nInserted" : 3,
"nUpserted" : 0,
"nMatched" : 0,
"nModified" : 0,
"nRemoved" : 0,
"upserted" : [ ]
})
>
Eine ungeordnete Liste namens carbulk wird erstellt und eine Einfügeabfrage wird mit den Feldern und Werten angegeben, die eingefügt werden sollen. Beachten Sie, dass es erforderlich ist, die Methode execute() nach der letzten Einfügeanweisung aufzurufen, um sicherzustellen, dass die Daten tatsächlich in die Datenbank eingefügt werden.
MongoDB Bulk Ordered Insert
Dies ist ähnlich wie ein ungeordneter Masseneinfügevorgang, aber wir verwenden den initializeOrderedBulkOp-Aufruf.
>var car1bulk = db.car.initializeOrderedBulkOp();
>car1bulk.insert({ name:"Ertiga", color:"Red",cno:"H112",mfdcountry:"America",speed:65});
>car1bulk.insert({ name:"Quanta", color:"Maroon",cno:"H113",mfdcountry:"Rome",speed:78});
>car1bulk.execute();
BulkWriteResult({
"writeErrors" : [ ],
"writeConcernErrors" : [ ],
"nInserted" : 2,
"nUpserted" : 0,
"nMatched" : 0,
"nModified" : 0,
"nRemoved" : 0,
"upserted" : [ ]
})
Zuerst erstellen wir eine geordnete Liste der Autosammlung namens carbulk1 und fügen dann die Dokumente ein, indem wir die execute() Methode aufrufen.
MongoDB Bulk Insert Java Programm
Lassen Sie uns ein Java-Programm für verschiedene Massenoperationen sehen, die wir bisher mit Shell-Befehlen gesehen haben. Unten ist das Java-Programm für die Masseneinfügung unter Verwendung des MongoDB-Java-Treibers Version 2.x.
package com.journaldev.mongodb;
import com.mongodb.BasicDBObject;
import com.mongodb.BulkWriteOperation;
import com.mongodb.BulkWriteResult;
import com.mongodb.DB;
import com.mongodb.DBCollection;
import com.mongodb.DBCursor;
import com.mongodb.DBObject;
import com.mongodb.MongoClient;
import java.net.UnknownHostException;
import java.util.ArrayList;
import java.util.List;
public class MongoDBBulkInsert {
// Methode, die alle Dokumente einfügt
public static void insertmultipledocs() throws UnknownHostException{
// Erhalte eine neue Verbindung zur Datenbank, vorausgesetzt sie läuft
MongoClient mongoClient = new MongoClient("localhost");
//// Verwende "test" als Datenbank, setze hier deine eigene Datenbank ein
DB db=mongoClient.getDB("test");
//// Hol das Collection-Objekt, "car" wird hier verwendet, nutze dein eigenes
DBCollection coll = db.getCollection("car");
// Erstelle ein neues Objekt
DBObject d1 = new BasicDBObject();
// Daten für Objekt d1
d1.put("_id", 11);
d1.put("name","WagonR");
d1.put("color", "MetallicSilver");
d1.put("cno", "H141");
d1.put("mfdcountry","Australia");
d1.put("speed",66);
DBObject d2 = new BasicDBObject();
// Daten für Objekt d2
d2.put("_id", 12);
d2.put("name","Xylo");
d2.put("color", "JetBlue");
d2.put("cno", "H142");
d2.put("mfdcountry","Europe");
d2.put("speed",69);
DBObject d3 = new BasicDBObject();
// Daten für Objekt d3
d3.put("_id", 13);
d3.put("name","Alto800");
d3.put("color", "JetGrey");
d3.put("cno", "H143");
d3.put("mfdcountry","Austria");
d3.put("speed",74);
// Erstelle eine neue Liste
List docs = new ArrayList<>();
// Füge d1, d2 und d3 der Liste "docs" hinzu
docs.add(d1);
docs.add(d2);
docs.add(d3);
// Füge die Liste "docs" der Collection hinzu
coll.insert(docs);
// Speichere das Ergebnis im Cursor
DBCursor carmuldocs = coll.find();
// Gib den Inhalt des Cursors aus
try {
while(carmuldocs.hasNext()) {
System.out.println(carmuldocs.next());
}
} finally {
carmuldocs.close();//close the cursor
}
}
// Methode, die Dokumente mit bestimmten Feldern einfügt
public static void insertsomefieldsformultipledocs() throws UnknownHostException{
// Erhalte eine neue Verbindung zur Datenbank, vorausgesetzt sie läuft
MongoClient mongoClient = new MongoClient("localhost");
//// Verwende "test" als Datenbank, setze hier deine eigene Datenbank ein
DB db=mongoClient.getDB("test");
//// Hol das Collection-Objekt, "car" wird hier verwendet, nutze dein eigenes
DBCollection coll = db.getCollection("car");
// Erstelle Objekt d1
DBObject d1 = new BasicDBObject();
// Füge Daten für Name, Farbe und Geschwindigkeit ein
d1.put("name","Indica");
d1.put("color", "Silver");
d1.put("cno", "H154");
DBObject d2 = new BasicDBObject();
// Füge Daten für ID, Name und Geschwindigkeit ein
d2.put("_id", 43);
d2.put("name","Astar");
d2.put("speed",79);
List docs = new ArrayList<>();
docs.add(d1);
docs.add(d2);
coll.insert(docs);
DBCursor carmuldocs = coll.find();
System.out.println("-----------------------------------------------");
try {
while(carmuldocs.hasNext()) {
System.out.println(carmuldocs.next());
}
} finally {
carmuldocs.close();//close the cursor
}
}
// Methode, die auf doppelte Dokumente prüft
public static void insertduplicatedocs() throws UnknownHostException{
// Erhalte eine neue Verbindung zur Datenbank, vorausgesetzt sie läuft
MongoClient mongoClient = new MongoClient("localhost");
//// Verwende "test" als Datenbank, setze hier deine eigene Datenbank ein
DB db=mongoClient.getDB("test");
//// Hol das Collection-Objekt, "car" wird hier verwendet, nutze dein eigenes
DBCollection coll = db.getCollection("car");
DBObject d1 = new BasicDBObject();
// Füge doppelte Daten von ID 11 ein
d1.put("_id", 11);
d1.put("name","WagonR-Lxi");
coll.insert(d1);
DBCursor carmuldocs = coll.find();
System.out.println("-----------------------------------------------");
try {
while(carmuldocs.hasNext()) {
System.out.println(carmuldocs.next());
}
} finally {
carmuldocs.close();//close the cursor
}
}
// Methode zum Durchführen von Masseneinfügungen in ungeordneter Liste
public static void insertbulkunordereddocs() throws UnknownHostException{
// Erhalte eine neue Verbindung zur Datenbank, vorausgesetzt sie läuft
MongoClient mongoClient = new MongoClient("localhost");
//// Verwende "test" als Datenbank, setze hier deine eigene Datenbank ein
DB db=mongoClient.getDB("test");
//// Hol das Collection-Objekt, "car" wird hier verwendet, nutze dein eigenes
DBCollection coll = db.getCollection("car");
DBObject d1 = new BasicDBObject();
d1.put("name","Suzuki S-4");
d1.put("color", "Yellow");
d1.put("cno", "H167");
d1.put("mfdcountry","Italy");
d1.put("speed",54);
DBObject d2 = new BasicDBObject();
d2.put("name","Santro-Xing");
d2.put("color", "Cyan");
d2.put("cno", "H164");
d2.put("mfdcountry","Holand");
d2.put("speed",76);
// Initialisiere und erstelle eine ungeordnete Masseneinfügung
BulkWriteOperation b1 = coll.initializeUnorderedBulkOperation();
// Füge d1 und d2 zu Masse b1 hinzu
b1.insert(d1);
b1.insert(d2);
// Führe die Masseneinfügung aus
BulkWriteResult r1 = b1.execute();
DBCursor carmuldocs = coll.find();
System.out.println("-----------------------------------------------");
try {
while(carmuldocs.hasNext()) {
System.out.println(carmuldocs.next());
}
} finally {
carmuldocs.close();//close the cursor
}
}
// Methode, die Masseneinfügungen für geordnete Liste durchführt
public static void insertbulkordereddocs() throws UnknownHostException{
// Erhalte eine neue Verbindung zur Datenbank, vorausgesetzt sie läuft
MongoClient mongoClient = new MongoClient("localhost");
//// Verwende "test" als Datenbank, setze hier deine eigene Datenbank ein
DB db=mongoClient.getDB("test");
//// Hol das Collection-Objekt, "car" wird hier verwendet, nutze dein eigenes
DBCollection coll = db.getCollection("car");
DBObject d1 = new BasicDBObject();
d1.put("name","Palio");
d1.put("color", "Purple");
d1.put("cno", "H183");
d1.put("mfdcountry","Venice");
d1.put("speed",82);
DBObject d2 = new BasicDBObject();
d2.put("name","Micra");
d2.put("color", "Lime");
d2.put("cno", "H186");
d2.put("mfdcountry","Ethopia");
d2.put("speed",84);
// Initialisiere und erstelle geordnete Masse
BulkWriteOperation b1 = coll.initializeOrderedBulkOperation();
b1.insert(d1);
b1.insert(d2);
// Rufe "execute" auf
BulkWriteResult r1 = b1.execute();
DBCursor carmuldocs = coll.find();
System.out.println("-----------------------------------");
try {
while(carmuldocs.hasNext()) {
System.out.println(carmuldocs.next());
}
} finally {
carmuldocs.close();//close the cursor
}
}
public static void main(String[] args) throws UnknownHostException{
// Rufe alle Methoden auf, um die Einfügeoperation durchzuführen
insertmultipledocs();
insertsomefieldsformultipledocs();
insertbulkunordereddocs();
insertbulkordereddocs();
insertduplicatedocs();
}
}
Unten finden Sie die Ausgabe des obigen Programms.
{ "_id" : 11 , "name" : "WagonR" , "color" : "MetallicSilver" , "cno" : "H141" , "mfdcountry" : "Australia" , "speed" : 66}
{ "_id" : 12 , "name" : "Xylo" , "color" : "JetBlue" , "cno" : "H142" , "mfdcountry" : "Europe" , "speed" : 69}
{ "_id" : 13 , "name" : "Alto800" , "color" : "JetGrey" , "cno" : "H143" , "mfdcountry" : "Austria" , "speed" : 74}
-----------------------------------------------
{ "_id" : 11 , "name" : "WagonR" , "color" : "MetallicSilver" , "cno" : "H141" , "mfdcountry" : "Australia" , "speed" : 66}
{ "_id" : 12 , "name" : "Xylo" , "color" : "JetBlue" , "cno" : "H142" , "mfdcountry" : "Europe" , "speed" : 69}
{ "_id" : 13 , "name" : "Alto800" , "color" : "JetGrey" , "cno" : "H143" , "mfdcountry" : "Austria" , "speed" : 74}
{ "_id" : { "$oid" : "548860e803649b8efac5a1d7"} , "name" : "Indica" , "color" : "Silver" , "cno" : "H154"}
{ "_id" : 43 , "name" : "Astar" , "speed" : 79}
-----------------------------------------------
{ "_id" : 11 , "name" : "WagonR" , "color" : "MetallicSilver" , "cno" : "H141" , "mfdcountry" : "Australia" , "speed" : 66}
{ "_id" : 12 , "name" : "Xylo" , "color" : "JetBlue" , "cno" : "H142" , "mfdcountry" : "Europe" , "speed" : 69}
{ "_id" : 13 , "name" : "Alto800" , "color" : "JetGrey" , "cno" : "H143" , "mfdcountry" : "Austria" , "speed" : 74}
{ "_id" : { "$oid" : "548860e803649b8efac5a1d7"} , "name" : "Indica" , "color" : "Silver" , "cno" : "H154"}
{ "_id" : 43 , "name" : "Astar" , "speed" : 79}
{ "_id" : { "$oid" : "548860e803649b8efac5a1d8"} , "name" : "Suzuki S-4" , "color" : "Yellow" , "cno" : "H167" , "mfdcountry" : "Italy" , "speed" : 54}
{ "_id" : { "$oid" : "548860e803649b8efac5a1d9"} , "name" : "Santro-Xing" , "color" : "Cyan" , "cno" : "H164" , "mfdcountry" : "Holand" , "speed" : 76}
-----------------------------------
{ "_id" : 11 , "name" : "WagonR" , "color" : "MetallicSilver" , "cno" : "H141" , "mfdcountry" : "Australia" , "speed" : 66}
{ "_id" : 12 , "name" : "Xylo" , "color" : "JetBlue" , "cno" : "H142" , "mfdcountry" : "Europe" , "speed" : 69}
{ "_id" : 13 , "name" : "Alto800" , "color" : "JetGrey" , "cno" : "H143" , "mfdcountry" : "Austria" , "speed" : 74}
{ "_id" : { "$oid" : "548860e803649b8efac5a1d7"} , "name" : "Indica" , "color" : "Silver" , "cno" : "H154"}
{ "_id" : 43 , "name" : "Astar" , "speed" : 79}
{ "_id" : { "$oid" : "548860e803649b8efac5a1d8"} , "name" : "Suzuki S-4" , "color" : "Yellow" , "cno" : "H167" , "mfdcountry" : "Italy" , "speed" : 54}
{ "_id" : { "$oid" : "548860e803649b8efac5a1d9"} , "name" : "Santro-Xing" , "color" : "Cyan" , "cno" : "H164" , "mfdcountry" : "Holand" , "speed" : 76}
{ "_id" : { "$oid" : "548860e803649b8efac5a1da"} , "name" : "Palio" , "color" : "Purple" , "cno" : "H183" , "mfdcountry" : "Venice" , "speed" : 82}
{ "_id" : { "$oid" : "548860e803649b8efac5a1db"} , "name" : "Micra" , "color" : "Lime" , "cno" : "H186" , "mfdcountry" : "Ethopia" , "speed" : 84}
Exception in thread "main" com.mongodb.MongoException$DuplicateKey: { "serverUsed" : "localhost:27017" , "ok" : 1 , "n" : 0 , "err" : "insertDocument :: caused by :: 11000 E11000 duplicate key error index: test.car.$_id_ dup key: { : 11 }" , "code" : 11000}
at com.mongodb.CommandResult.getWriteException(CommandResult.java:88)
at com.mongodb.CommandResult.getException(CommandResult.java:79)
at com.mongodb.DBCollectionImpl.translateBulkWriteException(DBCollectionImpl.java:314)
at com.mongodb.DBCollectionImpl.insert(DBCollectionImpl.java:189)
at com.mongodb.DBCollectionImpl.insert(DBCollectionImpl.java:165)
at com.mongodb.DBCollection.insert(DBCollection.java:93)
at com.mongodb.DBCollection.insert(DBCollection.java:78)
at com.mongodb.DBCollection.insert(DBCollection.java:120)
at com.journaldev.mongodb.MongoDBBulkInsert.insertduplicatedocs(MongoDBBulkInsert.java:163)
at com.journaldev.mongodb.MongoDBBulkInsert.main(MongoDBBulkInsert.java:304)
Wenn Sie den MongoDB Java-Treiber 3.x verwenden, verwenden Sie das folgende Programm.
package com.journaldev.mongodb.main;
import java.net.UnknownHostException;
import java.util.ArrayList;
import java.util.List;
import org.bson.Document;
import com.mongodb.MongoClient;
import com.mongodb.client.FindIterable;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
public class MongoDBBulkInsert {
public static void main(String[] args) throws UnknownHostException {
//Rufen Sie alle Methoden auf, um den Einfügevorgang durchzuführen
insertmultipledocs();
insertsomefieldsformultipledocs();
insertduplicatedocs();
}
//Methode, die alle Dokumente einfügt
public static void insertmultipledocs() throws UnknownHostException {
//Holen Sie sich eine neue Verbindung zur Datenbank, vorausgesetzt sie läuft
MongoClient mongoClient = new MongoClient("localhost");
////Verwenden Sie test als Datenbank, verwenden Sie hier Ihre eigene
MongoDatabase db = mongoClient.getDatabase("test");
////Rufen Sie das Collection-Objekt ab, hier wird car verwendet, verwenden Sie Ihr eigenes
MongoCollection coll = db.getCollection("car");
//Erstellen Sie ein neues Objekt
Document d1 = new Document();
//Daten für Objekt d1
d1.put("_id", 11);
d1.put("name", "WagonR");
d1.put("color", "MetallicSilver");
d1.put("cno", "H141");
d1.put("mfdcountry", "Australia");
d1.put("speed", 66);
Document d2 = new Document();
//Daten für Objekt d2
d2.put("_id", 12);
d2.put("name", "Xylo");
d2.put("color", "JetBlue");
d2.put("cno", "H142");
d2.put("mfdcountry", "Europe");
d2.put("speed", 69);
Document d3 = new Document();
//Daten für Objekt d3
d3.put("_id", 13);
d3.put("name", "Alto800");
d3.put("color", "JetGrey");
d3.put("cno", "H143");
d3.put("mfdcountry", "Austria");
d3.put("speed", 74);
//Erstellen Sie eine neue Liste
List docs = new ArrayList<>();
//Fügen Sie d1, d2 und d3 zu Liste docs hinzu
docs.add(d1);
docs.add(d2);
docs.add(d3);
//Fügen Sie die Liste docs in die Collection ein
coll.insertMany(docs);
//Speichert das Ergebnis im Cursor
FindIterable carmuldocs = coll.find();
for (Document d : carmuldocs)
System.out.println(d);
mongoClient.close();
}
//Methode, die Dokumente mit einigen Feldern einfügt
public static void insertsomefieldsformultipledocs() throws UnknownHostException {
//Holen Sie sich eine neue Verbindung zur Datenbank, vorausgesetzt sie läuft
MongoClient mongoClient = new MongoClient("localhost");
////Verwenden Sie test als Datenbank, verwenden Sie hier Ihre eigene
MongoDatabase db = mongoClient.getDatabase("test");
////Rufen Sie das Collection-Objekt ab, hier wird car verwendet, verwenden Sie Ihr eigenes
MongoCollection coll = db.getCollection("car");
//Erstellen Sie Objekt d1
Document d1 = new Document();
//Fügen Sie Daten für name, color und speed ein
d1.put("name", "Indica");
d1.put("color", "Silver");
d1.put("cno", "H154");
Document d2 = new Document();
//Fügen Sie Daten für id, name und speed ein
d2.put("_id", 43);
d2.put("name", "Astar");
d2.put("speed", 79);
List docs = new ArrayList<>();
docs.add(d1);
docs.add(d2);
coll.insertMany(docs);
FindIterable carmuldocs = coll.find();
System.out.println("-----------------------------------------------");
for (Document d : carmuldocs)
System.out.println(d);
mongoClient.close();
}
//Methode, die auf doppelte Dokumente prüft
public static void insertduplicatedocs() throws UnknownHostException {
//Holen Sie sich eine neue Verbindung zur Datenbank, vorausgesetzt sie läuft
MongoClient mongoClient = new MongoClient("localhost");
////Verwenden Sie test als Datenbank, verwenden Sie hier Ihre eigene
MongoDatabase db = mongoClient.getDatabase("test");
////Rufen Sie das Collection-Objekt ab, hier wird car verwendet, verwenden Sie Ihr eigenes
MongoCollection coll = db.getCollection("car");
Document d1 = new Document();
//Fügen Sie doppelte Daten von id11 ein
d1.put("_id", 11);
d1.put("name", "WagonR-Lxi");
coll.insertOne(d1);
FindIterable carmuldocs = coll.find();
System.out.println("-----------------------------------------------");
for (Document d : carmuldocs)
System.out.println(d);
mongoClient.close();
}
}
Unter dem Bild wird der Beispielablauf des oben genannten MongoDB-Bulk-Insert-Java-Programms gezeigt. 
Das ist alles für den Bulk-Insert in MongoDB mithilfe der Mongo-Shell und des Java-Treibers. Wir werden in den kommenden Beiträgen weitere MongoDB-Operationen betrachten.
Source:
https://www.digitalocean.com/community/tutorials/mongodb-bulk-insert-insertmany