We zullen vandaag kijken naar MongoDB bulk insert. Meerdere documenten kunnen tegelijkertijd worden ingevoegd in MongoDB met behulp van de bulk insert-operatie, waarbij een array van documenten wordt doorgegeven aan de insert-methode als parameter.
MongoDB bulk insert
MongoDB bulk insert voert standaard een geordende invoeging uit. Als er een fout optreedt tijdens de invoeging op een bepaald punt, vindt de invoeging niet plaats voor de overgebleven documenten. Laten we een voorbeeld bekijken van hoe we meerdere documenten kunnen invoegen met behulp van MongoDB bulk insert via de opdrachtregel.
MongoDB insert meerdere documenten
> 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" : [ ]
})
Deze bewerking heeft vijf documenten ingevoegd. MongoDB maakt automatisch een id-veld aan als dit niet is gespecificeerd door de gebruiker in de query. De kolom “nInserted” geeft de gebruiker het aantal ingevoegde documenten aan. Om de ingevoegde documenten te bekijken, voert u de volgende query uit zoals hieronder weergegeven.
> 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 }
>
Lees meer over MongoDB find en MongoDB insert bewerkingen. Bij het invoegen is het niet verplicht voor de gebruiker om alle velden in de query op te geven. Laten we nu bekijken hoe de invoeging werkt wanneer sommige velden niet zijn gespecificeerd.
MongoDB Bulk Insert documenten specificeren enkele van de velden
> 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 dit voorbeeld wordt voor het tweede document het id-veld niet door de gebruiker gespecificeerd en voor het derde document worden alleen id-, naam- en snelheidsvelden geleverd in de query. De query voert een succesvolle invoeging uit, ook al ontbreken sommige velden in de tweede en derde documenten. In de kolom nInserted staat dat drie documenten zijn ingevoegd. Roep de find-methode aan en controleer de ingevoegde documenten.
> 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 }
>
Merk op dat het id automatisch wordt gegenereerd door MongoDB voor de auto “Santro”. Voor id 8 – worden alleen de naam- en snelheidsvelden ingevoegd.
Het invoegen van ongeordende documenten
Tijdens het uitvoeren van ongeordende invoegingen, als er een fout optreedt op een bepaald punt, blijft MongoDB de resterende documenten invoegen in een array. Bijvoorbeeld;
> 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" : [ ]
})
>
De parameter ordered false is gespecificeerd in de invoegquery, wat aangeeft dat het een ongeordende verzameling is. Voer db.car.find() uit
{ "_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 }
De documenten worden ingevoegd en zoals u kunt zien, is het een ongeordende invoeging. Als de invoegmethode een fout tegenkomt, bevat het resultaat het veld “WriteResult.writeErrors” met de foutmelding die de mislukking heeft veroorzaakt.
Dubbele id-waarde invoegen
> 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 }"
}
})
>
Het foutmelding geeft aan dat we een document invoegen voor id 6 dat al een document bevat en werpt daarom een fout op voor een duplicaat id-waarde 6.
MongoDB Bulk.insert() methode
Deze methode voert een invoegbewerking uit in bulkhoeveelheden. Het is geïntroduceerd vanaf versie 2.6 en hoger. De syntaxis is Bulk.insert(<document>). document: geeft het document aan dat moet worden ingevoegd. Nu zullen we het voorbeeld zien van bulkinvoeging.
Bulk Ongesorteerde invoeging
> 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" : [ ]
})
>
Een ongesorteerde lijst met de naam carbulk wordt aangemaakt en de invoegquery wordt gespecificeerd met de velden, waarden die moeten worden ingevoegd. Let op dat het noodzakelijk is om de execute() methode aan te roepen na de laatste invoegverklaring om ervoor te zorgen dat de gegevens daadwerkelijk in de database worden ingevoegd.
MongoDB Bulk Ordered Insert
Dit is vergelijkbaar met ongeordende bulkinvoeging, maar we gebruiken de initializeOrderedBulkOp-aanroep.
>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" : [ ]
})
Eerst maken we een geordende lijst van de autocollectie genaamd carbulk1 en vervolgens voegen we de documenten in door de execute() methode aan te roepen.
MongoDB Bulk Insert Java-programma
Laten we een Java-programma bekijken voor verschillende bulkbewerkingen, die we tot nu toe hebben gezien met behulp van shell-opdrachten. Hieronder staat het Java-programma voor bulkinvoeging met behulp van de MongoDB Java-driver versie 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 documenten invoegt
public static void insertmultipledocs() throws UnknownHostException{
//Maak een nieuwe verbinding met de db, ervan uitgaande dat deze actief is
MongoClient mongoClient = new MongoClient("localhost");
////gebruik test als database, gebruik hier je eigen database
DB db=mongoClient.getDB("test");
////haal het collectieobject op, hier wordt auto gebruikt, gebruik je eigen
DBCollection coll = db.getCollection("car");
//maak een nieuw object aan
DBObject d1 = new BasicDBObject();
//gegevens voor object 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();
//gegevens voor object 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();
//gegevens voor object 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);
//maak een nieuwe lijst aan
List docs = new ArrayList<>();
//voeg d1, d2 en d3 toe aan lijst docs
docs.add(d1);
docs.add(d2);
docs.add(d3);
//voeg lijst docs toe aan collectie
coll.insert(docs);
//sla het resultaat op in cursor
DBCursor carmuldocs = coll.find();
//druk de inhoud van de cursor af
try {
while(carmuldocs.hasNext()) {
System.out.println(carmuldocs.next());
}
} finally {
carmuldocs.close();//close the cursor
}
}
//methode die documenten invoegt met enkele velden
public static void insertsomefieldsformultipledocs() throws UnknownHostException{
//Maak een nieuwe verbinding met de db, ervan uitgaande dat deze actief is
MongoClient mongoClient = new MongoClient("localhost");
////gebruik test als database, gebruik hier je eigen database
DB db=mongoClient.getDB("test");
////haal het collectieobject op, hier wordt auto gebruikt, gebruik je eigen
DBCollection coll = db.getCollection("car");
//maak object d1 aan
DBObject d1 = new BasicDBObject();
//voeg gegevens toe voor naam, kleur en snelheid
d1.put("name","Indica");
d1.put("color", "Silver");
d1.put("cno", "H154");
DBObject d2 = new BasicDBObject();
//voeg gegevens toe voor id, naam en snelheid
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 controleert op dubbele documenten
public static void insertduplicatedocs() throws UnknownHostException{
//Maak een nieuwe verbinding met de db, ervan uitgaande dat deze actief is
MongoClient mongoClient = new MongoClient("localhost");
////gebruik test als database, gebruik hier je eigen database
DB db=mongoClient.getDB("test");
////haal het collectieobject op, hier wordt auto gebruikt, gebruik je eigen
DBCollection coll = db.getCollection("car");
DBObject d1 = new BasicDBObject();
//voeg duplicaatgegevens van id11 toe
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 om bulk ongeordende lijst uit te voeren
public static void insertbulkunordereddocs() throws UnknownHostException{
//Maak een nieuwe verbinding met de db, ervan uitgaande dat deze actief is
MongoClient mongoClient = new MongoClient("localhost");
////gebruik test als database, gebruik hier je eigen database
DB db=mongoClient.getDB("test");
////haal het collectieobject op, hier wordt auto gebruikt, gebruik je eigen
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);
//initialiseer en maak een ongeordende bulk aan
BulkWriteOperation b1 = coll.initializeUnorderedBulkOperation();
//voeg d1 en d2 toe aan bulk b1
b1.insert(d1);
b1.insert(d2);
//voer de bulk uit
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 bulkinvoer voor geordende lijst uitvoert
public static void insertbulkordereddocs() throws UnknownHostException{
//Maak een nieuwe verbinding met de db, ervan uitgaande dat deze actief is
MongoClient mongoClient = new MongoClient("localhost");
////gebruik test als database, gebruik hier je eigen database
DB db=mongoClient.getDB("test");
////haal het collectieobject op, hier wordt auto gebruikt, gebruik je eigen
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);
//initialiseer en maak geordende bulk aan
BulkWriteOperation b1 = coll.initializeOrderedBulkOperation();
b1.insert(d1);
b1.insert(d2);
//roep execute aan
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{
//roep alle methoden aan om invoeroperatie uit te voeren
insertmultipledocs();
insertsomefieldsformultipledocs();
insertbulkunordereddocs();
insertbulkordereddocs();
insertduplicatedocs();
}
}
Hier is de uitvoer van het bovenstaande programma.
{ "_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)
Als je de MongoDB Java-driver 3.x gebruikt, gebruik dan het onderstaande programma.
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 {
// roep alle methoden aan om de invoeroperatie uit te voeren
insertmultipledocs();
insertsomefieldsformultipledocs();
insertduplicatedocs();
}
// methode die alle documenten invoegt
public static void insertmultipledocs() throws UnknownHostException {
// Krijg een nieuwe verbinding met de database, ga ervan uit dat deze draait
MongoClient mongoClient = new MongoClient("localhost");
//// gebruik test als database, gebruik hier je eigen database
MongoDatabase db = mongoClient.getDatabase("test");
//// haal het collectieobject op, hier wordt 'car' gebruikt, gebruik je eigen naam
MongoCollection coll = db.getCollection("car");
// maak een nieuw object aan
Document d1 = new Document();
// gegevens voor object 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();
// gegevens voor object 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();
// gegevens voor object 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);
// maak een nieuwe lijst aan
List docs = new ArrayList<>();
// voeg d1, d2 en d3 toe aan de lijst docs
docs.add(d1);
docs.add(d2);
docs.add(d3);
// voeg de lijst docs in bij de collectie
coll.insertMany(docs);
// sla het resultaat op in de cursor
FindIterable carmuldocs = coll.find();
for (Document d : carmuldocs)
System.out.println(d);
mongoClient.close();
}
// methode die documenten invoegt met enkele velden
public static void insertsomefieldsformultipledocs() throws UnknownHostException {
// Krijg een nieuwe verbinding met de database, ga ervan uit dat deze draait
MongoClient mongoClient = new MongoClient("localhost");
//// gebruik test als database, gebruik hier je eigen database
MongoDatabase db = mongoClient.getDatabase("test");
//// haal het collectieobject op, hier wordt 'car' gebruikt, gebruik je eigen naam
MongoCollection coll = db.getCollection("car");
// maak object d1 aan
Document d1 = new Document();
// voeg gegevens toe voor naam, kleur en snelheid
d1.put("name", "Indica");
d1.put("color", "Silver");
d1.put("cno", "H154");
Document d2 = new Document();
// voeg gegevens toe voor id, naam en snelheid
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 controleert op dubbele documenten
public static void insertduplicatedocs() throws UnknownHostException {
// Krijg een nieuwe verbinding met de database, ga ervan uit dat deze draait
MongoClient mongoClient = new MongoClient("localhost");
//// gebruik test als database, gebruik hier je eigen database
MongoDatabase db = mongoClient.getDatabase("test");
//// haal het collectieobject op, hier wordt 'car' gebruikt, gebruik je eigen naam
MongoCollection coll = db.getCollection("car");
Document d1 = new Document();
// voeg duplicaatgegevens van id11 in
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();
}
}
Onderstaande afbeelding toont een voorbeelduitvoering van het bovenstaande MongoDB bulk-insert Java-programma. 
Dat is alles voor bulk-insert in MongoDB met behulp van de Mongo-shell en Java-driver. We zullen meer MongoDB-bewerkingen bekijken in komende berichten.
Source:
https://www.digitalocean.com/community/tutorials/mongodb-bulk-insert-insertmany