Nous allons nous pencher aujourd’hui sur l’insertion en vrac dans MongoDB. Plusieurs documents peuvent être insérés en une seule fois dans MongoDB à l’aide de l’opération d’insertion en vrac, où un tableau de documents est passé en paramètre à la méthode d’insertion.
Insertion en vrac dans MongoDB
L’insertion en vrac dans MongoDB effectue une insertion ordonnée par défaut. Si une erreur se produit lors de l’insertion à un certain point, l’insertion ne se produit pas pour les documents restants. Voyons un exemple de comment insérer plusieurs documents en utilisant l’insertion en vrac de MongoDB via la ligne de commande.
Insérer de nombreux documents dans MongoDB
> 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" : [ ]
})
Cette opération a inséré cinq documents. MongoDB crée automatiquement un champ « id » s’il n’est pas spécifié par l’utilisateur dans la requête. La colonne « nInserted » indique à l’utilisateur le nombre de documents insérés. Pour afficher les documents insérés, exécutez la requête suivante comme indiqué ci-dessous.
> 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 }
>
En savoir plus sur les opérations recherche MongoDB et insertion MongoDB. Lors de l’insertion, il n’est pas obligatoire pour l’utilisateur de fournir tous les champs dans la requête. Voyons maintenant comment fonctionne l’insertion lorsque certains champs ne sont pas spécifiés.
Insertion en bloc de documents MongoDB en spécifiant certains champs
> 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" : [ ]
})
>
Dans cet exemple, pour le deuxième document, le champ id n’est pas spécifié par l’utilisateur et pour le troisième document, seuls les champs id, nom et vitesse sont fournis dans la requête. La requête effectue une insertion réussie même si certains champs sont manquants dans les deuxième et troisième documents. La colonne nInserted indique que trois documents ont été insérés. Invoquez la méthode find et vérifiez les documents insérés.
> 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 }
>
Notez que l’id est automatiquement généré par MongoDB pour la voiture « Santro ». Pour l’id 8, seuls les champs nom et vitesse sont insérés.
Insertion de documents non ordonnés
Lors de l’insertion non ordonnée, si une erreur se produit à un certain point, MongoDB continue d’insérer les documents restants dans un tableau. Par exemple;
> 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" : [ ]
})
>
L’option ordered false est spécifiée dans la requête d’insertion, indiquant qu’il s’agit d’une collection non ordonnée. Exécutez 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("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 }
Les documents sont insérés et comme vous pouvez le voir, il s’agit d’une insertion non ordonnée. Si la méthode d’insertion rencontre une erreur, le résultat inclut le champ « WriteResult.writeErrors » indiquant le message d’erreur qui a causé l’échec.
Insertion de valeur d’id en double
> 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 }"
}
})
>
L’erreur indique que nous insérons un document pour l’id 6 qui contient déjà un document et lance donc une erreur de clé en double pour une valeur d’id de 6.
Méthode Bulk.insert() de MongoDB
Cette méthode effectue une opération d’insertion en gros. Elle est introduite à partir de la version 2.6. La syntaxe est Bulk.insert(<document>). document : spécifie le document à insérer. Nous allons maintenant voir l’exemple d’insertion en vrac.
Insertion en vrac non ordonnée
> 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" : [ ]
})
>
Une liste non ordonnée nommée carbulk est créée et une requête d’insertion est spécifiée avec les champs et les valeurs à insérer. Notez qu’il est nécessaire d’appeler la méthode execute() après la dernière instruction d’insertion pour s’assurer que les données sont réellement insérées dans la base de données.
Insertion groupée ordonnée de MongoDB
Ceci est similaire à l’insertion groupée non triée, mais nous utilisons l’appel initializeOrderedBulkOp.
>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" : [ ]
})
Tout d’abord, nous créons une liste ordonnée de la collection de voitures appelée « carbulk1 », puis nous insérons les documents en invoquant la méthode execute().
Programme Java pour l’insertion groupée de MongoDB
Voyons un programme Java pour différentes opérations groupées, que nous avons vues jusqu’à présent en utilisant des commandes shell. Voici le programme Java pour l’insertion groupée en utilisant le pilote Java MongoDB 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 {
//méthode qui insère tous les documents
public static void insertmultipledocs() throws UnknownHostException{
//Obtenir une nouvelle connexion à la base de données en supposant qu'elle fonctionne
MongoClient mongoClient = new MongoClient("localhost");
////utiliser test comme base de données, utiliser votre base de données ici
DB db=mongoClient.getDB("test");
////récupérer l'objet collection, car est utilisé ici, utilisez le vôtre
DBCollection coll = db.getCollection("car");
//créer un nouvel objet
DBObject d1 = new BasicDBObject();
//données pour l'objet 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();
//données pour l'objet 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();
//données pour l'objet 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);
//créer une nouvelle liste
List docs = new ArrayList<>();
//ajouter d1, d2 et d3 à la liste docs
docs.add(d1);
docs.add(d2);
docs.add(d3);
//insérer la liste docs dans la collection
coll.insert(docs);
//stocke le résultat dans le curseur
DBCursor carmuldocs = coll.find();
//afficher le contenu du curseur
try {
while(carmuldocs.hasNext()) {
System.out.println(carmuldocs.next());
}
} finally {
carmuldocs.close();//close the cursor
}
}
//méthode qui insère des documents avec certains champs
public static void insertsomefieldsformultipledocs() throws UnknownHostException{
//Obtenir une nouvelle connexion à la base de données en supposant qu'elle fonctionne
MongoClient mongoClient = new MongoClient("localhost");
////utiliser test comme base de données, utiliser votre base de données ici
DB db=mongoClient.getDB("test");
////récupérer l'objet collection, car est utilisé ici, utilisez le vôtre
DBCollection coll = db.getCollection("car");
//créer l'objet d1
DBObject d1 = new BasicDBObject();
//insérer les données pour le nom, la couleur et la vitesse
d1.put("name","Indica");
d1.put("color", "Silver");
d1.put("cno", "H154");
DBObject d2 = new BasicDBObject();
//insérer les données pour l'id, le nom et la vitesse
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
}
}
//méthode qui vérifie les documents en double
public static void insertduplicatedocs() throws UnknownHostException{
//Obtenir une nouvelle connexion à la base de données en supposant qu'elle fonctionne
MongoClient mongoClient = new MongoClient("localhost");
////utiliser test comme base de données, utiliser votre base de données ici
DB db=mongoClient.getDB("test");
////récupérer l'objet collection, car est utilisé ici, utilisez le vôtre
DBCollection coll = db.getCollection("car");
DBObject d1 = new BasicDBObject();
//insérer les données en double de l'id11
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
}
}
//méthode pour effectuer une liste non ordonnée en vrac
public static void insertbulkunordereddocs() throws UnknownHostException{
//Obtenir une nouvelle connexion à la base de données en supposant qu'elle fonctionne
MongoClient mongoClient = new MongoClient("localhost");
////utiliser test comme base de données, utiliser votre base de données ici
DB db=mongoClient.getDB("test");
////récupérer l'objet collection, car est utilisé ici, utilisez le vôtre
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);
//initialiser et créer un bloc en vrac non ordonné
BulkWriteOperation b1 = coll.initializeUnorderedBulkOperation();
//insérer d1 et d2 dans le bloc b1
b1.insert(d1);
b1.insert(d2);
//exécuter le bloc en vrac
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
}
}
//méthode qui effectue une insertion en vrac pour une liste ordonnée
public static void insertbulkordereddocs() throws UnknownHostException{
//Obtenir une nouvelle connexion à la base de données en supposant qu'elle fonctionne
MongoClient mongoClient = new MongoClient("localhost");
////utiliser test comme base de données, utiliser votre base de données ici
DB db=mongoClient.getDB("test");
////récupérer l'objet collection, car est utilisé ici, utilisez le vôtre
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);
//initialiser et créer un bloc en vrac ordonné
BulkWriteOperation b1 = coll.initializeOrderedBulkOperation();
b1.insert(d1);
b1.insert(d2);
//appeler execute
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{
//appeler toutes les méthodes pour effectuer l'opération d'insertion
insertmultipledocs();
insertsomefieldsformultipledocs();
insertbulkunordereddocs();
insertbulkordereddocs();
insertduplicatedocs();
}
}
Voici la sortie du programme ci-dessus.
{ "_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)
Si vous utilisez le pilote Java MongoDB 3.x, utilisez le programme suivant.
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 {
// invoquer toutes les méthodes pour effectuer une opération d'insertion
insertmultipledocs();
insertsomefieldsformultipledocs();
insertduplicatedocs();
}
// méthode qui insère tous les documents
public static void insertmultipledocs() throws UnknownHostException {
// Obtenir une nouvelle connexion à la base de données en supposant qu'elle soit en cours d'exécution
MongoClient mongoClient = new MongoClient("localhost");
//// utiliser test comme base de données, utilisez votre base de données ici
MongoDatabase db = mongoClient.getDatabase("test");
//// récupérer l'objet de collection, "car" est utilisé ici, utilisez le vôtre
MongoCollection coll = db.getCollection("car");
// créer un nouvel objet
Document d1 = new Document();
// données de l'objet 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();
// données de l'objet 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();
// données de l'objet 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);
// créer une nouvelle liste
List docs = new ArrayList<>();
// ajouter d1, d2 et d3 à la liste docs
docs.add(d1);
docs.add(d2);
docs.add(d3);
// insérer la liste docs dans la collection
coll.insertMany(docs);
// stocke le résultat dans un curseur
FindIterable carmuldocs = coll.find();
for (Document d : carmuldocs)
System.out.println(d);
mongoClient.close();
}
// méthode qui insère des documents avec certains champs
public static void insertsomefieldsformultipledocs() throws UnknownHostException {
// Obtenir une nouvelle connexion à la base de données en supposant qu'elle soit en cours d'exécution
MongoClient mongoClient = new MongoClient("localhost");
//// utiliser test comme base de données, utilisez votre base de données ici
MongoDatabase db = mongoClient.getDatabase("test");
//// récupérer l'objet de collection, "car" est utilisé ici, utilisez le vôtre
MongoCollection coll = db.getCollection("car");
// créer l'objet d1
Document d1 = new Document();
// insérer les données pour le nom, la couleur et la vitesse
d1.put("name", "Indica");
d1.put("color", "Silver");
d1.put("cno", "H154");
Document d2 = new Document();
// insérer les données pour l'id, le nom et la vitesse
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();
}
// méthode qui vérifie les documents en double
public static void insertduplicatedocs() throws UnknownHostException {
// Obtenir une nouvelle connexion à la base de données en supposant qu'elle soit en cours d'exécution
MongoClient mongoClient = new MongoClient("localhost");
//// utiliser test comme base de données, utilisez votre base de données ici
MongoDatabase db = mongoClient.getDatabase("test");
//// récupérer l'objet de collection, "car" est utilisé ici, utilisez le vôtre
MongoCollection coll = db.getCollection("car");
Document d1 = new Document();
// insérer des données en double pour id11
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();
}
}
L’image ci-dessous montre un exemple d’exécution du programme Java d’insertion en masse de MongoDB ci-dessus. 
C’est tout pour l’insertion en masse dans MongoDB en utilisant le shell Mongo et le pilote Java, nous examinerons d’autres opérations MongoDB dans les prochains articles.
Source:
https://www.digitalocean.com/community/tutorials/mongodb-bulk-insert-insertmany