Vamos a ver la inserción masiva en MongoDB hoy. Se pueden insertar múltiples documentos a la vez en MongoDB utilizando la operación de inserción masiva, donde se pasa un array de documentos al método insert como parámetro.
Inserción masiva en MongoDB
La inserción masiva en MongoDB realiza una inserción ordenada por defecto. Si ocurre un error durante la inserción en cierto punto, la inserción no se realiza para los documentos restantes. Veamos un ejemplo de cómo insertar múltiples documentos utilizando la inserción masiva de MongoDB a través de la línea de comandos.
Insertar muchos documentos en 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" : [ ]
})
Esta operación insertó cinco documentos. MongoDB crea automáticamente un campo id si no es especificado por el usuario en la consulta. La columna “nInserted” le indica al usuario la cantidad de documentos que fueron insertados. Para ver los documentos insertados, realice la siguiente consulta como se muestra a continuación.
> 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 }
>
Lea más sobre las operaciones de buscar en MongoDB e insertar en MongoDB. Durante la inserción no es obligatorio que el usuario proporcione todos los campos en la consulta. Ahora veamos cómo funciona la inserción cuando algunos de los campos no están especificados.
Insertar documentos en bloque en MongoDB especificando algunos de los campos
> 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" : [ ]
})
>
En este ejemplo, para el segundo documento, el campo de identificación (id) no está especificado por el usuario y, para el tercer documento, solo se suministran en la consulta los campos id, nombre y velocidad. La consulta realiza una inserción exitosa incluso si faltan algunos campos en los documentos segundo y tercero. La columna nInserted indica que se insertaron tres documentos. Llama al método find y verifica los documentos insertados.
> 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 }
>
Ten en cuenta que el id se genera automáticamente por MongoDB para el automóvil “Santro”. Para el id 8, solo se insertan los campos de nombre y velocidad.
Insertando documentos desordenados
Al realizar una inserción desordenada, si se produce un error en un punto determinado, MongoDB continúa insertando los documentos restantes en un array. Por ejemplo;
> 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" : [ ]
})
>
El false ordenado se especifica en la consulta de inserción indicando que es una colección desordenada. Ejecuta 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 }
Los documentos se insertan y, como puedes ver, es una inserción desordenada. Si el método de inserción encuentra un error, el resultado incluye el campo “WriteResult.writeErrors” que indica el mensaje de error que causó el fallo.
Insertando valor de id duplicado
> 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 }"
}
})
>
El error indica que estamos insertando un documento para el id 6 que ya contiene un documento, por lo que arroja un error de clave duplicada para el id de valor 6.
Método Bulk.insert() de MongoDB
Este método realiza una operación de inserción en grandes cantidades. Se introdujo a partir de la versión 2.6 en adelante. La sintaxis es Bulk.insert(<documento>). documento: especifica el documento que se va a insertar. Ahora veremos el ejemplo de inserción masiva.
Inserción masiva no ordenada
> 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" : [ ]
})
>
Se crea una lista no ordenada llamada carbulk y se especifica la consulta de inserción con los campos y valores a insertar. Es necesario llamar al método execute() después de la última declaración de inserción para asegurarse de que los datos se inserten realmente en la base de datos.
Inserción Ordenada Masiva de MongoDB
Esto es similar a la inserción masiva desordenada pero usamos la llamada 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" : [ ]
})
Primero creamos una lista ordenada de la colección de coches llamada carbulk1 y luego insertamos los documentos invocando el método execute().
Programa Java para Inserción Masiva de MongoDB
Vamos a ver un programa en Java para diferentes operaciones masivas, que hemos visto utilizando comandos de shell hasta ahora. A continuación se muestra el programa en Java para la inserción masiva utilizando la versión 2.x del controlador de MongoDB para Java.
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étodo que inserta todos los documentos
public static void insertmultipledocs() throws UnknownHostException{
//Obtener una nueva conexión a la base de datos asumiendo que está en funcionamiento
MongoClient mongoClient = new MongoClient("localhost");
////usar test como base de datos, utiliza tu base de datos aquí
DB db=mongoClient.getDB("test");
////obtener el objeto de colección, se usa "car" aquí, utiliza el tuyo propio
DBCollection coll = db.getCollection("car");
//crear un nuevo objeto
DBObject d1 = new BasicDBObject();
//datos para el objeto 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();
//datos para el objeto 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();
//datos para el objeto 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);
//crear una nueva lista
List docs = new ArrayList<>();
//agregar d1, d2 y d3 a la lista docs
docs.add(d1);
docs.add(d2);
docs.add(d3);
//insertar la lista docs en la colección
coll.insert(docs);
//almacena el resultado en el cursor
DBCursor carmuldocs = coll.find();
//imprimir el contenido del cursor
try {
while(carmuldocs.hasNext()) {
System.out.println(carmuldocs.next());
}
} finally {
carmuldocs.close();//close the cursor
}
}
//método que inserta documentos con algunos campos
public static void insertsomefieldsformultipledocs() throws UnknownHostException{
//Obtener una nueva conexión a la base de datos asumiendo que está en funcionamiento
MongoClient mongoClient = new MongoClient("localhost");
////usar test como base de datos, utiliza tu base de datos aquí
DB db=mongoClient.getDB("test");
////obtener el objeto de colección, se usa "car" aquí, utiliza el tuyo propio
DBCollection coll = db.getCollection("car");
//crear objeto d1
DBObject d1 = new BasicDBObject();
//insertar datos para nombre, color y velocidad
d1.put("name","Indica");
d1.put("color", "Silver");
d1.put("cno", "H154");
DBObject d2 = new BasicDBObject();
//insertar datos para id, nombre y velocidad
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étodo que comprueba documentos duplicados
public static void insertduplicatedocs() throws UnknownHostException{
//Obtener una nueva conexión a la base de datos asumiendo que está en funcionamiento
MongoClient mongoClient = new MongoClient("localhost");
////usar test como base de datos, utiliza tu base de datos aquí
DB db=mongoClient.getDB("test");
////obtener el objeto de colección, se usa "car" aquí, utiliza el tuyo propio
DBCollection coll = db.getCollection("car");
DBObject d1 = new BasicDBObject();
//insertar datos duplicados de 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étodo para realizar una lista desordenada a granel
public static void insertbulkunordereddocs() throws UnknownHostException{
//Obtener una nueva conexión a la base de datos asumiendo que está en funcionamiento
MongoClient mongoClient = new MongoClient("localhost");
////usar test como base de datos, utiliza tu base de datos aquí
DB db=mongoClient.getDB("test");
////obtener el objeto de colección, se usa "car" aquí, utiliza el tuyo propio
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);
//inicializar y crear a granel desordenado
BulkWriteOperation b1 = coll.initializeUnorderedBulkOperation();
//insertar d1 y d2 en a granel b1
b1.insert(d1);
b1.insert(d2);
//ejecutar a granel
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étodo que realiza una inserción a granel para una lista ordenada
public static void insertbulkordereddocs() throws UnknownHostException{
//Obtener una nueva conexión a la base de datos asumiendo que está en funcionamiento
MongoClient mongoClient = new MongoClient("localhost");
////usar test como base de datos, utiliza tu base de datos aquí
DB db=mongoClient.getDB("test");
////obtener el objeto de colección, se usa "car" aquí, utiliza el tuyo propio
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);
//inicializar y crear a granel ordenado
BulkWriteOperation b1 = coll.initializeOrderedBulkOperation();
b1.insert(d1);
b1.insert(d2);
//invocar 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{
//invocar todos los métodos para realizar la operación de inserción
insertmultipledocs();
insertsomefieldsformultipledocs();
insertbulkunordereddocs();
insertbulkordereddocs();
insertduplicatedocs();
}
}
A continuación se muestra el resultado del programa anterior.
{ "_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 estás utilizando el controlador de MongoDB para Java 3.x, entonces utiliza el siguiente programa.
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 todos los métodos para realizar la operación de inserción
insertmultipledocs();
insertsomefieldsformultipledocs();
insertduplicatedocs();
}
// método que inserta todos los documentos
public static void insertmultipledocs() throws UnknownHostException {
// Obtén una nueva conexión a la base de datos asumiendo que está en funcionamiento
MongoClient mongoClient = new MongoClient("localhost");
//// usa test como base de datos, usa tu base de datos aquí
MongoDatabase db = mongoClient.getDatabase("test");
//// obtén el objeto de colección, aquí se utiliza "car", usa el tuyo propio
MongoCollection coll = db.getCollection("car");
// crea un nuevo objeto
Document d1 = new Document();
// datos para el objeto 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();
// datos para el objeto 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();
// datos para el objeto 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 nueva lista
List docs = new ArrayList<>();
// agrega d1, d2 y d3 a la lista docs
docs.add(d1);
docs.add(d2);
docs.add(d3);
// inserta la lista docs en la colección
coll.insertMany(docs);
// almacena el resultado en un cursor
FindIterable carmuldocs = coll.find();
for (Document d : carmuldocs)
System.out.println(d);
mongoClient.close();
}
// método que inserta documentos con algunos campos
public static void insertsomefieldsformultipledocs() throws UnknownHostException {
// Obtén una nueva conexión a la base de datos asumiendo que está en funcionamiento
MongoClient mongoClient = new MongoClient("localhost");
//// usa test como base de datos, usa tu base de datos aquí
MongoDatabase db = mongoClient.getDatabase("test");
//// obtén el objeto de colección, aquí se utiliza "car", usa el tuyo propio
MongoCollection coll = db.getCollection("car");
// crea el objeto d1
Document d1 = new Document();
// inserta datos para nombre, color y velocidad
d1.put("name", "Indica");
d1.put("color", "Silver");
d1.put("cno", "H154");
Document d2 = new Document();
// inserta datos para id, nombre y velocidad
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étodo que comprueba documentos duplicados
public static void insertduplicatedocs() throws UnknownHostException {
// Obtén una nueva conexión a la base de datos asumiendo que está en funcionamiento
MongoClient mongoClient = new MongoClient("localhost");
//// usa test como base de datos, usa tu base de datos aquí
MongoDatabase db = mongoClient.getDatabase("test");
//// obtén el objeto de colección, aquí se utiliza "car", usa el tuyo propio
MongoCollection coll = db.getCollection("car");
Document d1 = new Document();
// inserta datos duplicados de 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();
}
}
A continuación se muestra una ejecución de muestra del programa Java de inserción masiva de MongoDB. 
Eso es todo para la inserción masiva en MongoDB usando la terminal de Mongo y el controlador de Java, veremos más operaciones de MongoDB en próximas publicaciones.
Source:
https://www.digitalocean.com/community/tutorials/mongodb-bulk-insert-insertmany