Vamos analisar hoje a inserção em massa no MongoDB. Múltiplos documentos podem ser inseridos de uma vez no MongoDB usando a operação de inserção em massa, onde um array de documentos é passado como parâmetro para o método de inserção.
Inserção em massa no MongoDB
A inserção em massa no MongoDB realiza uma inserção ordenada por padrão. Se ocorrer um erro durante a inserção em um determinado ponto, a inserção não ocorre para os documentos restantes. Vamos ver um exemplo de como inserir vários documentos usando a inserção em massa no MongoDB por meio da linha de comando.
Inserir muitos documentos no 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 operação inseriu cinco documentos. O MongoDB cria automaticamente um campo de id se não for especificado pelo usuário na consulta. A coluna “nInseridos” informa ao usuário o número de documentos que foram inseridos. Para visualizar os documentos inseridos, execute a seguinte consulta, conforme mostrado abaixo.
> 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 }
>
Saiba mais sobre as operações localizar no MongoDB e inserir no MongoDB. Ao inserir, não é obrigatório fornecer todos os campos na consulta. Agora, vamos ver como a inserção funciona quando alguns dos campos não são especificados.
Insertar em Massa no MongoDB documentos especificando alguns dos 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" : [ ]
})
>
Neste exemplo, para o segundo documento, o campo id não é especificado pelo usuário e para o terceiro documento apenas os campos id, nome e velocidade são fornecidos na consulta. A consulta faz uma inserção bem-sucedida mesmo que alguns campos estejam ausentes nos segundo e terceiro documentos. A coluna nInserted indica que três documentos foram inseridos. Chame o método find e verifique os documentos inseridos.
> 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 }
>
Observe que o id é gerado automaticamente pelo MongoDB para o carro “Santro”. Para o id 8 – apenas os campos nome e velocidade são inseridos.
Inserindo documentos desordenados
Ao realizar uma inserção desordenada, se ocorrer um erro em certo ponto, o MongoDB continua a inserir os documentos restantes em um array. Por exemplo;
> 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" : [ ]
})
>
O ordered false é especificado na consulta de inserção indicando que é uma coleção desordenada. Execute 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 }
Os documentos são inseridos e, como você pode ver, é uma inserção desordenada. Se o método de inserção encontrar um erro, o resultado inclui o campo “WriteResult.writeErrors” indicando a mensagem de erro que causou a falha.
Inserindo valor duplicado de ID
> 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 }"
}
})
>
O erro indica que estamos inserindo um documento para o ID 6, que já contém um documento, resultando em um erro de chave duplicada para o ID de valor 6.
Método Bulk.insert() do MongoDB
Este método realiza uma operação de inserção em grandes quantidades. Foi introduzido a partir da versão 2.6 em diante. A sintaxe é Bulk.insert(<documento>). documento: especifica o documento a ser inserido. Agora veremos o exemplo de inserção em massa.
Inserção em Massa não 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" : [ ]
})
>
Uma lista não ordenada chamada carbulk é criada e a consulta de inserção é especificada com os campos e valores a serem inseridos. Note que é necessário chamar o método execute() após a última instrução de inserção para garantir que os dados sejam realmente inseridos no banco de dados.
Inserção em Massa Ordenada no MongoDB
Isso é semelhante à inserção em massa não ordenada, mas usamos a chamada 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" : [ ]
})
Primeiro, criamos uma lista ordenada da coleção de carros chamada carbulk1 e depois inserimos os documentos invocando o método execute().
Programa Java para Inserção em Massa no MongoDB
Vamos ver um programa em Java para diferentes operações em massa, que já vimos usando comandos de shell até agora. Abaixo está o programa em Java para inserção em massa usando o driver java do MongoDB versão 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étodo que insere todos os documentos
public static void insertmultipledocs() throws UnknownHostException{
//Obtenha uma nova conexão com o banco de dados assumindo que esteja em execução
MongoClient mongoClient = new MongoClient("localhost");
////use test como banco de dados, use seu banco de dados aqui
DB db=mongoClient.getDB("test");
////obtenha o objeto de coleção, car é usado aqui, use o seu
DBCollection coll = db.getCollection("car");
//crie um novo objeto
DBObject d1 = new BasicDBObject();
//dados para o 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();
//dados para o 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();
//dados para o 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);
//crie uma nova lista
List docs = new ArrayList<>();
//adicione d1, d2 e d3 à lista docs
docs.add(d1);
docs.add(d2);
docs.add(d3);
//insira a lista docs na coleção
coll.insert(docs);
//armazena o resultado no cursor
DBCursor carmuldocs = coll.find();
//imprima o conteúdo do cursor
try {
while(carmuldocs.hasNext()) {
System.out.println(carmuldocs.next());
}
} finally {
carmuldocs.close();//close the cursor
}
}
//método que insere documentos com alguns campos
public static void insertsomefieldsformultipledocs() throws UnknownHostException{
//Obtenha uma nova conexão com o banco de dados assumindo que esteja em execução
MongoClient mongoClient = new MongoClient("localhost");
////use test como banco de dados, use seu banco de dados aqui
DB db=mongoClient.getDB("test");
////obtenha o objeto de coleção, car é usado aqui, use o seu
DBCollection coll = db.getCollection("car");
//crie o objeto d1
DBObject d1 = new BasicDBObject();
//insira dados para nome, cor e velocidade
d1.put("name","Indica");
d1.put("color", "Silver");
d1.put("cno", "H154");
DBObject d2 = new BasicDBObject();
//insira dados para id, nome e velocidade
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 verifica documentos duplicados
public static void insertduplicatedocs() throws UnknownHostException{
//Obtenha uma nova conexão com o banco de dados assumindo que esteja em execução
MongoClient mongoClient = new MongoClient("localhost");
////use test como banco de dados, use seu banco de dados aqui
DB db=mongoClient.getDB("test");
////obtenha o objeto de coleção, car é usado aqui, use o seu
DBCollection coll = db.getCollection("car");
DBObject d1 = new BasicDBObject();
//insira dados 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 uma lista desordenada em massa
public static void insertbulkunordereddocs() throws UnknownHostException{
//Obtenha uma nova conexão com o banco de dados assumindo que esteja em execução
MongoClient mongoClient = new MongoClient("localhost");
////use test como banco de dados, use seu banco de dados aqui
DB db=mongoClient.getDB("test");
////obtenha o objeto de coleção, car é usado aqui, use o seu
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);
//inicialize e crie um bulk desordenado
BulkWriteOperation b1 = coll.initializeUnorderedBulkOperation();
//insira d1 e d2 no bulk b1
b1.insert(d1);
b1.insert(d2);
//execute o 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
}
}
//método que executa a inserção em massa para lista ordenada
public static void insertbulkordereddocs() throws UnknownHostException{
//Obtenha uma nova conexão com o banco de dados assumindo que esteja em execução
MongoClient mongoClient = new MongoClient("localhost");
////use test como banco de dados, use seu banco de dados aqui
DB db=mongoClient.getDB("test");
////obtenha o objeto de coleção, car é usado aqui, use o seu
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);
//inicialize e crie bulk ordenado
BulkWriteOperation b1 = coll.initializeOrderedBulkOperation();
b1.insert(d1);
b1.insert(d2);
//invocando 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{
//chame todos os métodos para executar a operação de inserção
insertmultipledocs();
insertsomefieldsformultipledocs();
insertbulkunordereddocs();
insertbulkordereddocs();
insertduplicatedocs();
}
}
Abaixo está a saída do programa acima.
{ "_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 você estiver usando o driver Java do MongoDB 3.x, use o programa abaixo.
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 os métodos para realizar a operação de inserção
insertmultipledocs();
insertsomefieldsformultipledocs();
insertduplicatedocs();
}
// método que insere todos os documentos
public static void insertmultipledocs() throws UnknownHostException {
// Obtenha uma nova conexão com o banco de dados supondo que ele esteja em execução
MongoClient mongoClient = new MongoClient("localhost");
//// use test como um banco de dados, use seu banco de dados aqui
MongoDatabase db = mongoClient.getDatabase("test");
//// recupere o objeto de coleção, car é usado aqui, use o seu próprio
MongoCollection coll = db.getCollection("car");
// crie um novo objeto
Document d1 = new Document();
// dados para o 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();
// dados para o 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();
// dados para o 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);
// crie uma nova lista
List docs = new ArrayList<>();
// adicione d1, d2 e d3 à lista de documentos
docs.add(d1);
docs.add(d2);
docs.add(d3);
// insira a lista de documentos na coleção
coll.insertMany(docs);
// armazena o resultado no cursor
FindIterable carmuldocs = coll.find();
for (Document d : carmuldocs)
System.out.println(d);
mongoClient.close();
}
// método que insere documentos com alguns campos
public static void insertsomefieldsformultipledocs() throws UnknownHostException {
// Obtenha uma nova conexão com o banco de dados supondo que ele esteja em execução
MongoClient mongoClient = new MongoClient("localhost");
//// use test como um banco de dados, use seu banco de dados aqui
MongoDatabase db = mongoClient.getDatabase("test");
//// recupere o objeto de coleção, car é usado aqui, use o seu próprio
MongoCollection coll = db.getCollection("car");
// crie o objeto d1
Document d1 = new Document();
// insira os dados para nome, cor e velocidade
d1.put("name", "Indica");
d1.put("color", "Silver");
d1.put("cno", "H154");
Document d2 = new Document();
// insira os dados para id, nome e velocidade
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 verifica duplicatas de documentos
public static void insertduplicatedocs() throws UnknownHostException {
// Obtenha uma nova conexão com o banco de dados supondo que ele esteja em execução
MongoClient mongoClient = new MongoClient("localhost");
//// use test como um banco de dados, use seu banco de dados aqui
MongoDatabase db = mongoClient.getDatabase("test");
//// recupere o objeto de coleção, car é usado aqui, use o seu próprio
MongoCollection coll = db.getCollection("car");
Document d1 = new Document();
// insira dados 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();
}
}
Abaixo, a imagem mostra uma execução de exemplo do programa de inserção em massa do MongoDB em Java. 
Isso é tudo para a inserção em massa no MongoDB usando o shell do Mongo e o driver Java. Vamos explorar mais operações do MongoDB em postagens futuras.
Source:
https://www.digitalocean.com/community/tutorials/mongodb-bulk-insert-insertmany