Oggi parleremo di inserimento bulk in MongoDB. È possibile inserire più documenti contemporaneamente in MongoDB utilizzando l’operazione di inserimento bulk, in cui viene passato un array di documenti al metodo di inserimento come parametro.
Inserimento bulk di MongoDB
L’inserimento bulk di MongoDB effettua un inserimento ordinato di default. Se si verifica un errore durante l’inserimento in un determinato punto, l’inserimento non viene effettuato per i documenti rimanenti. Vediamo un esempio di come inserire più documenti usando l’inserimento bulk di MongoDB tramite la riga di comando.
Inserimento di molti documenti in 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" : [ ]
})
Questa operazione ha inserito cinque documenti. MongoDB crea automaticamente un campo “id” se non specificato dall’utente nella query. La colonna “nInserted” indica all’utente il numero di documenti inseriti. Per visualizzare i documenti inseriti, eseguire la seguente query come mostrato di seguito.
> 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 }
>
Leggi di più sulle operazioni di ricerca (MongoDB find) e inserimento (MongoDB insert) di MongoDB. Durante l’inserimento, non è obbligatorio fornire tutti i campi nella query. Ora vediamo come funziona l’inserimento quando alcuni dei campi non sono specificati.
Inserimento bulk di documenti MongoDB specificando alcuni campi
> 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 questo esempio, per il secondo documento, il campo id non è specificato dall’utente e per il terzo documento vengono forniti solo i campi id, name e speed nella query. La query effettua un inserimento riuscito anche se alcuni campi mancano nei secondi e terzi documenti. La colonna nInserted indica che sono stati inseriti tre documenti. Invoca il metodo find e verifica i documenti inseriti.
> 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 }
>
Nota che l’id è generato automaticamente da MongoDB per l’auto “Santro”. Per l’id 8 – vengono inseriti solo i campi name e speed.
Inserimento di documenti non ordinati
Mentre si effettua l’inserimento non ordinato, se si verifica un errore in un certo punto, MongoDB continua ad inserire i documenti rimanenti in un array. Ad esempio;
> 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" : [ ]
})
>
Viene specificato l’ordered false nella query di inserimento indicando che si tratta di una collezione non ordinata. Esegui 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 }
I documenti vengono inseriti e come puoi vedere, si tratta di un inserimento non ordinato. Se il metodo di inserimento incontra un errore, il risultato include il campo “WriteResult.writeErrors” che indica il messaggio di errore che ha causato il fallimento.
Inserimento di un valore id duplicato
> 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’errore indica che stiamo inserendo un documento per l’id 6, che contiene già un documento, generando così un errore di chiave duplicata per l’id di valore 6.
Metodo MongoDB Bulk.insert()
Questo metodo esegue un’operazione di inserimento in blocco. È introdotto dalla versione 2.6 in poi. La sintassi è Bulk.insert(<documento>). documento: specifica il documento da inserire. Ora vedremo l’esempio per l’inserimento in blocco.
Inserimento non ordinato in blocco
> 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" : [ ]
})
>
Viene creata una lista non ordinata chiamata carbulk e viene specificata una query di inserimento con i campi e i valori da inserire. Nota che è necessario chiamare il metodo execute() dopo l’ultima istruzione di inserimento per garantire che i dati siano effettivamente inseriti nel database.
Inserimento in blocco ordinato di MongoDB
Questo è simile all’inserimento in blocco non ordinato, ma utilizziamo la chiamata 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" : [ ]
})
Prima creiamo una lista ordinata di raccolta di auto chiamata carbulk1 e quindi inseriamo i documenti richiamando il metodo execute().
Programma Java per l’inserimento in blocco di MongoDB
Vediamo un programma Java per diverse operazioni in blocco, che abbiamo visto usando comandi della shell fino ad ora. Di seguito è riportato il programma Java per l’inserimento in blocco utilizzando il driver Java di MongoDB versione 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 {
//metodo che inserisce tutti i documenti
public static void insertmultipledocs() throws UnknownHostException{
//Ottieni una nuova connessione al db assumendo che sia in esecuzione
MongoClient mongoClient = new MongoClient("localhost");
////usa test come database, utilizza il tuo database qui
DB db=mongoClient.getDB("test");
////recupera l'oggetto di raccolta, qui viene utilizzata la macchina, utilizza la tua
DBCollection coll = db.getCollection("car");
//crea un nuovo oggetto
DBObject d1 = new BasicDBObject();
//dati per l'oggetto 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();
//dati per l'oggetto 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();
//dati per l'oggetto 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);
//crea una nuova lista
List docs = new ArrayList<>();
//aggiungi d1, d2 e d3 alla lista docs
docs.add(d1);
docs.add(d2);
docs.add(d3);
//inserisci la lista docs nella raccolta
coll.insert(docs);
//memorizza il risultato nel cursore
DBCursor carmuldocs = coll.find();
//stampare i contenuti del cursore
try {
while(carmuldocs.hasNext()) {
System.out.println(carmuldocs.next());
}
} finally {
carmuldocs.close();//close the cursor
}
}
//metodo che inserisce documenti con alcuni campi
public static void insertsomefieldsformultipledocs() throws UnknownHostException{
//Ottieni una nuova connessione al db assumendo che sia in esecuzione
MongoClient mongoClient = new MongoClient("localhost");
////usa test come database, utilizza il tuo database qui
DB db=mongoClient.getDB("test");
////recupera l'oggetto di raccolta, qui viene utilizzata la macchina, utilizza la tua
DBCollection coll = db.getCollection("car");
//crea l'oggetto d1
DBObject d1 = new BasicDBObject();
//inserisci dati per nome, colore e velocità
d1.put("name","Indica");
d1.put("color", "Silver");
d1.put("cno", "H154");
DBObject d2 = new BasicDBObject();
//inserisci dati per id, nome e velocità
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
}
}
//metodo che controlla i documenti duplicati
public static void insertduplicatedocs() throws UnknownHostException{
//Ottieni una nuova connessione al db assumendo che sia in esecuzione
MongoClient mongoClient = new MongoClient("localhost");
////usa test come database, utilizza il tuo database qui
DB db=mongoClient.getDB("test");
////recupera l'oggetto di raccolta, qui viene utilizzata la macchina, utilizza la tua
DBCollection coll = db.getCollection("car");
DBObject d1 = new BasicDBObject();
//inserisci dati duplicati di 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
}
}
//metodo per eseguire una lista bulk non ordinata
public static void insertbulkunordereddocs() throws UnknownHostException{
//Ottieni una nuova connessione al db assumendo che sia in esecuzione
MongoClient mongoClient = new MongoClient("localhost");
////usa test come database, utilizza il tuo database qui
DB db=mongoClient.getDB("test");
////recupera l'oggetto di raccolta, qui viene utilizzata la macchina, utilizza la tua
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);
//inizializza e crea un bulk non ordinato
BulkWriteOperation b1 = coll.initializeUnorderedBulkOperation();
//inserisci d1 e d2 in bulk b1
b1.insert(d1);
b1.insert(d2);
//esegui il bulk
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
}
}
//metodo che esegue l'inserimento bulk per la lista ordinata
public static void insertbulkordereddocs() throws UnknownHostException{
//Ottieni una nuova connessione al db assumendo che sia in esecuzione
MongoClient mongoClient = new MongoClient("localhost");
////usa test come database, utilizza il tuo database qui
DB db=mongoClient.getDB("test");
////recupera l'oggetto di raccolta, qui viene utilizzata la macchina, utilizza la tua
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);
//inizializza e crea bulk ordinato
BulkWriteOperation b1 = coll.initializeOrderedBulkOperation();
b1.insert(d1);
b1.insert(d2);
//invoca esegui
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{
//invoca tutti i metodi per eseguire l'operazione di inserimento
insertmultipledocs();
insertsomefieldsformultipledocs();
insertbulkunordereddocs();
insertbulkordereddocs();
insertduplicatedocs();
}
}
Di seguito è riportato l’output del programma precedente.
{ "_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)
Se stai utilizzando il driver MongoDB Java 3.x, utilizza il seguente 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 {
// invoca tutti i metodi per eseguire l'operazione di inserimento
insertmultipledocs();
insertsomefieldsformultipledocs();
insertduplicatedocs();
}
// metodo che inserisce tutti i documenti
public static void insertmultipledocs() throws UnknownHostException {
// Ottieni una nuova connessione al database, assumendo che sia in esecuzione
MongoClient mongoClient = new MongoClient("localhost");
//// usa test come database, utilizza il tuo database qui
MongoDatabase db = mongoClient.getDatabase("test");
//// recupera l'oggetto di collezione, qui viene utilizzato 'car', utilizza il tuo
MongoCollection coll = db.getCollection("car");
// crea un nuovo oggetto
Document d1 = new Document();
// dati per l'oggetto 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();
// dati per l'oggetto 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();
// dati per l'oggetto 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);
// crea una nuova lista
List docs = new ArrayList<>();
// aggiungi d1, d2 e d3 alla lista docs
docs.add(d1);
docs.add(d2);
docs.add(d3);
// inserisci la lista docs nella collezione
coll.insertMany(docs);
// memorizza il risultato nel cursore
FindIterable carmuldocs = coll.find();
for (Document d : carmuldocs)
System.out.println(d);
mongoClient.close();
}
// metodo che inserisce documenti con alcuni campi
public static void insertsomefieldsformultipledocs() throws UnknownHostException {
// Ottieni una nuova connessione al database, assumendo che sia in esecuzione
MongoClient mongoClient = new MongoClient("localhost");
//// usa test come database, utilizza il tuo database qui
MongoDatabase db = mongoClient.getDatabase("test");
//// recupera l'oggetto di collezione, qui viene utilizzato 'car', utilizza il tuo
MongoCollection coll = db.getCollection("car");
// crea l'oggetto d1
Document d1 = new Document();
// inserisci i dati per nome, colore e velocità
d1.put("name", "Indica");
d1.put("color", "Silver");
d1.put("cno", "H154");
Document d2 = new Document();
// inserisci i dati per id, nome e velocità
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();
}
// metodo che controlla i documenti duplicati
public static void insertduplicatedocs() throws UnknownHostException {
// Ottieni una nuova connessione al database, assumendo che sia in esecuzione
MongoClient mongoClient = new MongoClient("localhost");
//// usa test come database, utilizza il tuo database qui
MongoDatabase db = mongoClient.getDatabase("test");
//// recupera l'oggetto di collezione, qui viene utilizzato 'car', utilizza il tuo
MongoCollection coll = db.getCollection("car");
Document d1 = new Document();
// inserisci dati duplicati per 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’immagine sottostante mostra un esempio di esecuzione del programma Java di inserimento in blocco di MongoDB sopra descritto. 
Questo è tutto per l’inserimento in blocco in MongoDB utilizzando la shell di Mongo e il driver Java. Ne parleremo di altre operazioni MongoDB nei prossimi articoli.
Source:
https://www.digitalocean.com/community/tutorials/mongodb-bulk-insert-insertmany