MongoDB與MySQL效率對(duì)比
[導(dǎo)讀]作者：風(fēng)樹(shù)種子來(lái)源：blog.csdn.net/u014513883/article/details/49365987本文主要通過(guò)批量與非批量對(duì)比操作的方式介紹MongoDB的bulkWrite()方法的使用。順帶與關(guān)系型數(shù)據(jù)庫(kù)MySQL進(jìn)行對(duì)比，比較這兩種不同類型數(shù)據(jù)庫(kù)的效率。...
作者：風(fēng)樹(shù)種子
這個(gè)方法要求傳入一個(gè)List集合，集合中的元素類型為WriteModel，它表示一個(gè)可用于批量寫操作的基類模型，它有以下幾個(gè)子類DeleteManyModel、DeleteOneModel、 InsertOneModel、ReplaceOneModel、 UpdateManyModel、UpdateOneModel，從名字可以看出來(lái)它對(duì)應(yīng)了刪除、插入、替換、更新幾種操作。該方法返回一個(gè)BulkWriteResult對(duì)象，代表一個(gè)成功的批量寫操作結(jié)果，封裝了操作結(jié)果的狀態(tài)信息，如插入、更新、刪除記錄數(shù)等。
List requests = new ArrayList();
for (Document document : documents) {
//構(gòu)造插入單個(gè)文檔的操作模型
InsertOneModeliom = new InsertOneModel(document);
requests.add(iom);
}
BulkWriteResult bulkWriteResult = collection.bulkWrite(requests);
System.out.println(bulkWriteResult.toString());
}
測(cè)試：下面通過(guò)一個(gè)main函數(shù)測(cè)試下。首先構(gòu)造10萬(wàn)個(gè)Product實(shí)體對(duì)象，使用一個(gè)工具類將其轉(zhuǎn)換成json字符串，然后解析成Document對(duì)象，保存到一個(gè)list集合中，然后調(diào)用上面編寫的方法測(cè)試10萬(wàn)個(gè)對(duì)象插入時(shí)間。
ArrayListdocuments = new ArrayList();
for (int i = 0; i < 100000; i ) {
Product product = new Product(i,"書籍","追風(fēng)箏的人",22.5);
//將java對(duì)象轉(zhuǎn)換成json字符串
String jsonProduct = JsonParseUtil.getJsonString4JavaPOJO(product);
//將json字符串解析成Document對(duì)象
Document docProduct = Document.parse(jsonProduct);
documents.add(docProduct);
}
System.out.println("開(kāi)始插入數(shù)據(jù)。。。");
long startInsert = System.currentTimeMillis();
instance.bulkWriteInsert(documents);
System.out.println("插入數(shù)據(jù)完成，共耗時(shí)：" (System.currentTimeMillis() - startInsert) "毫秒");
結(jié)果：1560毫秒，多次測(cè)試基本在1.5秒左右
for (Document document : documents){
collection.insertOne(document);
}
}
測(cè)試：10萬(wàn)條數(shù)據(jù)
long startInsert = System.currentTimeMillis();
instance.insertOneByOne(documents);
System.out.println("插入數(shù)據(jù)完成，共耗時(shí)：" (System.currentTimeMillis() - startInsert) "毫秒");
結(jié)果：12068毫秒，差距非常大。由此可見(jiàn)，MongoDB批量插入比逐條數(shù)據(jù)插入效率提高了非常多。
//和bulkWrite()方法等價(jià)
collection.insertMany(documents);
}
因?yàn)殡S著collection數(shù)據(jù)量的增大，查找將越耗時(shí)，添加索引是為了提高查找效率，進(jìn)而加快刪除效率。另外，值得一提的是DeleteOneModel表示至多刪除一條匹配條件的記錄，DeleteManyModel表示刪除匹配條件的所有記錄。為了防止一次刪除多條記錄，這里使用DeleteOneModel，保證一個(gè)操作只刪除一條記錄。當(dāng)然這里不可能匹配多條記錄，因?yàn)開(kāi)id是唯一的。
List requests = new ArrayList();
for (Document document : documents) {
//刪除條件
Document queryDocument = new Document("_id",document.get("_id"));
//構(gòu)造刪除單個(gè)文檔的操作模型，
DeleteOneModeldom = new DeleteOneModel(queryDocument);
requests.add(dom);
}
BulkWriteResult bulkWriteResult = collection.bulkWrite(requests);
System.out.println(bulkWriteResult.toString());
}
測(cè)試：10萬(wàn)條數(shù)據(jù)
long startDelete = System.currentTimeMillis();
instance.bulkWriteDelete(documents);
System.out.println("刪除數(shù)據(jù)完成，共耗時(shí)：" (System.currentTimeMillis() - startDelete) "毫秒");
結(jié)果：2251毫秒
for (Document document : documents) {
Document queryDocument = new Document("_id",document.get("_id"));
DeleteResult deleteResult = collection.deleteOne(queryDocument);
}
}
測(cè)試：10萬(wàn)條數(shù)據(jù)
long startDelete = System.currentTimeMillis();
instance.deleteOneByOne(documents);
System.out.println("刪除數(shù)據(jù)完成，共耗時(shí)：" (System.currentTimeMillis() - startDelete) "毫秒");
結(jié)果：12765毫秒，比批量刪除效率低很多
List requests = new ArrayList();
for (Document document : documents) {
//更新條件
Document queryDocument = new Document("_id",document.get("_id"));
//更新內(nèi)容，改下書的價(jià)格
Document updateDocument = new Document("$set",new Document("price","30.6"));
//構(gòu)造更新單個(gè)文檔的操作模型
UpdateOneModeluom = new UpdateOneModel(queryDocument,updateDocument,new UpdateOptions().upsert(false));
//UpdateOptions代表批量更新操作未匹配到查詢條件時(shí)的動(dòng)作，默認(rèn)false，什么都不干，true時(shí)表示將一個(gè)新的Document插入數(shù)據(jù)庫(kù)，他是查詢部分和更新部分的結(jié)合
requests.add(uom);
}
BulkWriteResult bulkWriteResult = collection.bulkWrite(requests);
System.out.println(bulkWriteResult.toString());
}
測(cè)試：10萬(wàn)條數(shù)據(jù)
long startUpdate = System.currentTimeMillis();
instance.bulkWriteUpdate(documents);
System.out.println("更新數(shù)據(jù)完成，共耗時(shí)：" (System.currentTimeMillis() - startUpdate) "毫秒");
結(jié)果：3198毫秒
for (Document document : documents) {
Document queryDocument = new Document("_id",document.get("_id"));
Document updateDocument = new Document("$set",new Document("price","30.6"));
UpdateResult UpdateResult = collection.updateOne(queryDocument, updateDocument);
}
}
測(cè)試：10萬(wàn)條數(shù)據(jù)
long startUpdate = System.currentTimeMillis();
instance.updateOneByOne(documents);
System.out.println("更新數(shù)據(jù)完成，共耗時(shí)：" (System.currentTimeMillis() - startUpdate) "毫秒");
結(jié)果：13979毫秒，比批量更新效率低很多
List requests = new ArrayList();
InsertOneModeliom = new InsertOneModel(new Document("name","kobe"));
UpdateManyModelumm = new UpdateManyModel(new Document("name","kobe"),
new Document("$set",new Document("name","James")),new UpdateOptions().upsert(true));
DeleteManyModeldmm = new DeleteManyModel(new Document("name","James"));
requests.add(iom);
requests.add(umm);
requests.add(dmm);
BulkWriteResult bulkWriteResult = collection.bulkWrite(requests);
System.out.println(bulkWriteResult.toString());
}
注意：updateMany()、deleteMany()兩個(gè)方法和insertMany()不同，它倆不是批量操作，而是代表更新（刪除）匹配條件的所有數(shù)據(jù)。
Connection conn = DBUtil.getConnection();
try {
PreparedStatement pst = conn.prepareStatement("insert into t_product value(?,?,?,?)");
int count = 1;
for (Product product : list) {
pst.setInt(1, product.getProductId());
pst.setString(2, product.getCategory());
pst.setString(3, product.getName());
pst.setDouble(4, product.getPrice());
pst.addBatch();
if(count % 1000 == 0){
pst.executeBatch();
pst.clearBatch();//每1000條sql批處理一次，然后置空PreparedStatement中的參數(shù)，這樣也能提高效率，防止參數(shù)積累過(guò)多事務(wù)超時(shí)，但實(shí)際測(cè)試效果不明顯
}
count ;
}
conn.commit();
} catch (SQLException e) {
e.printStackTrace();
}
DBUtil.closeConnection(conn);
}
JDBC默認(rèn)自動(dòng)提交事務(wù)，切記在獲取連接后添加下面一行代碼，關(guān)閉事務(wù)自動(dòng)提交。
測(cè)試：10萬(wàn)條數(shù)據(jù)
TestMysql test = new TestMysql();
ArrayListlist = new ArrayList();
for (int i = 0; i < 1000; i ) {
Product product = new Product(i, "書籍", "追風(fēng)箏的人", 20.5);
list.add(product);
}
System.out.println("MYSQL開(kāi)始插入數(shù)據(jù)。。。");
long insertStart = System.currentTimeMillis();
test.insertBatch(list);
System.out.println("MYSQL插入數(shù)據(jù)完成，共耗時(shí)：" (System.currentTimeMillis() - insertStart) "毫秒");
}
結(jié)果：7389毫秒，多次測(cè)試基本7秒左右
Connection conn = DBUtil.getConnection();
try {
for (Product product : list) {
PreparedStatement pst = conn.prepareStatement("insert into t_product value(?,?,?,?)");
pst.setInt(1, product.getProductId());
pst.setString(2, product.getCategory());
pst.setString(3, product.getName());
pst.setDouble(4, product.getPrice());
pst.executeUpdate();
//conn.commit();//加上這句每次插入都提交事務(wù)，結(jié)果將是非常耗時(shí)
}
conn.commit();
} catch (SQLException e) {
e.printStackTrace();
}
DBUtil.closeConnection(conn);
}
測(cè)試：10萬(wàn)條記錄
long insertStart = System.currentTimeMillis();
test.insertOneByOne(list);
System.out.println("MYSQL插入數(shù)據(jù)完成，共耗時(shí)：" (System.currentTimeMillis() - insertStart) "毫秒");
結(jié)果：8921毫秒，基本比批量慢1秒多。
Connection conn = DBUtil.getConnection();
try {
PreparedStatement pst = conn.prepareStatement("delete from t_product where id = ?");//按主鍵查，否則全表遍歷很慢
int count = 1;
for (Product product : list) {
pst.setInt(1, product.getProductId());
pst.addBatch();
if(count % 1000 == 0){
pst.executeBatch();
pst.clearBatch();
}
count ;
}
conn.commit();
} catch (SQLException e) {
e.printStackTrace();
}
DBUtil.closeConnection(conn);
}
測(cè)試：10萬(wàn)條數(shù)據(jù)
long deleteStart = System.currentTimeMillis();
test.deleteBatch(list);
System.out.println("MYSQL刪除數(shù)據(jù)完成，共耗時(shí)：" (System.currentTimeMillis() - deleteStart) "毫秒");
結(jié)果：7936毫秒
(2)、逐條刪除
Connection conn = DBUtil.getConnection();
PreparedStatement pst = null;
try {
for (Product product : list) {
pst = conn.prepareStatement("delete from t_product where id = ?");
pst.setInt(1, product.getProductId());
pst.executeUpdate();
//conn.commit();//加上這句每次插入都提交事務(wù)，結(jié)果將是非常耗時(shí)
}
conn.commit();
} catch (SQLException e) {
e.printStackTrace();
}
DBUtil.closeConnection(conn);
}
測(cè)試：10萬(wàn)條數(shù)據(jù)
long deleteStart = System.currentTimeMillis();
test.deleteOneByOne(list);
System.out.println("MYSQL刪除數(shù)據(jù)完成，共耗時(shí)：" (System.currentTimeMillis() - deleteStart) "毫秒");
結(jié)果：8752毫秒，比批處理刪除慢一秒左右
Connection conn = DBUtil.getConnection();
try {
PreparedStatement pst = conn.prepareStatement("update t_product set price=31.5 where id=?");
int count = 1;
for (Product product : list) {
pst.setInt(1, product.getProductId());
pst.addBatch();
if(count % 1000 == 0){
pst.executeBatch();
pst.clearBatch();//每1000條sql批處理一次，然后置空PreparedStatement中的參數(shù)，這樣也能提高效率，防止參數(shù)積累過(guò)多事務(wù)超時(shí)，但實(shí)際測(cè)試效果不明顯
}
count ;
}
conn.commit();
} catch (SQLException e) {
e.printStackTrace();
}
DBUtil.closeConnection(conn);
}
測(cè)試：10萬(wàn)條數(shù)據(jù)
long updateStart = System.currentTimeMillis();
test.updateBatch(list);
System.out.println("MYSQL更新數(shù)據(jù)完成，共耗時(shí)：" (System.currentTimeMillis() - updateStart) "毫秒");
結(jié)果：8611毫秒
Connection conn = DBUtil.getConnection();
try {
for (Product product : list) {
PreparedStatement pst = conn.prepareStatement("update t_product set price=30.5 where id=?");
pst.setInt(1, product.getProductId());
pst.executeUpdate();
//conn.commit();//加上這句每次插入都提交事務(wù)，結(jié)果將是非常耗時(shí)
}
conn.commit();
} catch (SQLException e) {
e.printStackTrace();
}
DBUtil.closeConnection(conn);
}
測(cè)試：10萬(wàn)條數(shù)據(jù)
long updateStart = System.currentTimeMillis();
test.updateOneByOne(list);
System.out.println("MYSQL更新數(shù)據(jù)完成，共耗時(shí)：" (System.currentTimeMillis() - updateStart) "毫秒");
結(jié)果：9430毫秒，比批處理更新慢了1秒左右
測(cè)試環(huán)境：win7旗艦版、16G內(nèi)存、i3處理器、MongoDB3.0.2、mysql5.0
一、MongoDB批量操作
MongoDB對(duì)數(shù)據(jù)的操作分為Read Operations和Write Operations，Read Operations包含查詢操作，Write Operations包含刪除、插入、替換、更新幾種操作。MongoDB提供客戶端用bulk方式執(zhí)行Write Operations，也就是批量寫操作。在java driver中，對(duì)應(yīng)MongoCollection的bulkWrite()方法，先來(lái)看下這個(gè)方法簽名：
這個(gè)方法要求傳入一個(gè)List集合，集合中的元素類型為WriteModel，它表示一個(gè)可用于批量寫操作的基類模型，它有以下幾個(gè)子類DeleteManyModel、DeleteOneModel、 InsertOneModel、ReplaceOneModel、 UpdateManyModel、UpdateOneModel，從名字可以看出來(lái)它對(duì)應(yīng)了刪除、插入、替換、更新幾種操作。該方法返回一個(gè)BulkWriteResult對(duì)象，代表一個(gè)成功的批量寫操作結(jié)果，封裝了操作結(jié)果的狀態(tài)信息，如插入、更新、刪除記錄數(shù)等。
1、插入操作
(1)、批量插入
List requests = new ArrayList();
for (Document document : documents) {
//構(gòu)造插入單個(gè)文檔的操作模型
InsertOneModeliom = new InsertOneModel(document);
requests.add(iom);
}
BulkWriteResult bulkWriteResult = collection.bulkWrite(requests);
System.out.println(bulkWriteResult.toString());
}
測(cè)試：下面通過(guò)一個(gè)main函數(shù)測(cè)試下。首先構(gòu)造10萬(wàn)個(gè)Product實(shí)體對(duì)象，使用一個(gè)工具類將其轉(zhuǎn)換成json字符串，然后解析成Document對(duì)象，保存到一個(gè)list集合中，然后調(diào)用上面編寫的方法測(cè)試10萬(wàn)個(gè)對(duì)象插入時(shí)間。
ArrayListdocuments = new ArrayList();
for (int i = 0; i < 100000; i ) {
Product product = new Product(i,"書籍","追風(fēng)箏的人",22.5);
//將java對(duì)象轉(zhuǎn)換成json字符串
String jsonProduct = JsonParseUtil.getJsonString4JavaPOJO(product);
//將json字符串解析成Document對(duì)象
Document docProduct = Document.parse(jsonProduct);
documents.add(docProduct);
}
System.out.println("開(kāi)始插入數(shù)據(jù)。。。");
long startInsert = System.currentTimeMillis();
instance.bulkWriteInsert(documents);
System.out.println("插入數(shù)據(jù)完成，共耗時(shí)：" (System.currentTimeMillis() - startInsert) "毫秒");
結(jié)果：1560毫秒，多次測(cè)試基本在1.5秒左右
for (Document document : documents){
collection.insertOne(document);
}
}
測(cè)試：10萬(wàn)條數(shù)據(jù)
long startInsert = System.currentTimeMillis();
instance.insertOneByOne(documents);
System.out.println("插入數(shù)據(jù)完成，共耗時(shí)：" (System.currentTimeMillis() - startInsert) "毫秒");
結(jié)果：12068毫秒，差距非常大。由此可見(jiàn)，MongoDB批量插入比逐條數(shù)據(jù)插入效率提高了非常多。
//和bulkWrite()方法等價(jià)
collection.insertMany(documents);
}
2、刪除操作
(1)、批量刪除
因?yàn)殡S著collection數(shù)據(jù)量的增大，查找將越耗時(shí)，添加索引是為了提高查找效率，進(jìn)而加快刪除效率。另外，值得一提的是DeleteOneModel表示至多刪除一條匹配條件的記錄，DeleteManyModel表示刪除匹配條件的所有記錄。為了防止一次刪除多條記錄，這里使用DeleteOneModel，保證一個(gè)操作只刪除一條記錄。當(dāng)然這里不可能匹配多條記錄，因?yàn)開(kāi)id是唯一的。
List requests = new ArrayList();
for (Document document : documents) {
//刪除條件
Document queryDocument = new Document("_id",document.get("_id"));
//構(gòu)造刪除單個(gè)文檔的操作模型，
DeleteOneModeldom = new DeleteOneModel(queryDocument);
requests.add(dom);
}
BulkWriteResult bulkWriteResult = collection.bulkWrite(requests);
System.out.println(bulkWriteResult.toString());
}
測(cè)試：10萬(wàn)條數(shù)據(jù)
long startDelete = System.currentTimeMillis();
instance.bulkWriteDelete(documents);
System.out.println("刪除數(shù)據(jù)完成，共耗時(shí)：" (System.currentTimeMillis() - startDelete) "毫秒");
結(jié)果：2251毫秒
for (Document document : documents) {
Document queryDocument = new Document("_id",document.get("_id"));
DeleteResult deleteResult = collection.deleteOne(queryDocument);
}
}
測(cè)試：10萬(wàn)條數(shù)據(jù)
long startDelete = System.currentTimeMillis();
instance.deleteOneByOne(documents);
System.out.println("刪除數(shù)據(jù)完成，共耗時(shí)：" (System.currentTimeMillis() - startDelete) "毫秒");
結(jié)果：12765毫秒，比批量刪除效率低很多
3、更新操作
(1)、批量更新
List requests = new ArrayList();
for (Document document : documents) {
//更新條件
Document queryDocument = new Document("_id",document.get("_id"));
//更新內(nèi)容，改下書的價(jià)格
Document updateDocument = new Document("$set",new Document("price","30.6"));
//構(gòu)造更新單個(gè)文檔的操作模型
UpdateOneModeluom = new UpdateOneModel(queryDocument,updateDocument,new UpdateOptions().upsert(false));
//UpdateOptions代表批量更新操作未匹配到查詢條件時(shí)的動(dòng)作，默認(rèn)false，什么都不干，true時(shí)表示將一個(gè)新的Document插入數(shù)據(jù)庫(kù)，他是查詢部分和更新部分的結(jié)合
requests.add(uom);
}
BulkWriteResult bulkWriteResult = collection.bulkWrite(requests);
System.out.println(bulkWriteResult.toString());
}
測(cè)試：10萬(wàn)條數(shù)據(jù)
long startUpdate = System.currentTimeMillis();
instance.bulkWriteUpdate(documents);
System.out.println("更新數(shù)據(jù)完成，共耗時(shí)：" (System.currentTimeMillis() - startUpdate) "毫秒");
結(jié)果：3198毫秒
for (Document document : documents) {
Document queryDocument = new Document("_id",document.get("_id"));
Document updateDocument = new Document("$set",new Document("price","30.6"));
UpdateResult UpdateResult = collection.updateOne(queryDocument, updateDocument);
}
}
測(cè)試：10萬(wàn)條數(shù)據(jù)
long startUpdate = System.currentTimeMillis();
instance.updateOneByOne(documents);
System.out.println("更新數(shù)據(jù)完成，共耗時(shí)：" (System.currentTimeMillis() - startUpdate) "毫秒");
結(jié)果：13979毫秒，比批量更新效率低很多
4、混合批量操作
bulkWrite()方法可以對(duì)不同類型的寫操作進(jìn)行批量處理，代碼如下：
List requests = new ArrayList();
InsertOneModeliom = new InsertOneModel(new Document("name","kobe"));
UpdateManyModelumm = new UpdateManyModel(new Document("name","kobe"),
new Document("$set",new Document("name","James")),new UpdateOptions().upsert(true));
DeleteManyModeldmm = new DeleteManyModel(new Document("name","James"));
requests.add(iom);
requests.add(umm);
requests.add(dmm);
BulkWriteResult bulkWriteResult = collection.bulkWrite(requests);
System.out.println(bulkWriteResult.toString());
}
注意：updateMany()、deleteMany()兩個(gè)方法和insertMany()不同，它倆不是批量操作，而是代表更新（刪除）匹配條件的所有數(shù)據(jù)。
二、與MySQL性能對(duì)比
1、插入操作
(1)、批處理插入
Connection conn = DBUtil.getConnection();
try {
PreparedStatement pst = conn.prepareStatement("insert into t_product value(?,?,?,?)");
int count = 1;
for (Product product : list) {
pst.setInt(1, product.getProductId());
pst.setString(2, product.getCategory());
pst.setString(3, product.getName());
pst.setDouble(4, product.getPrice());
pst.addBatch();
if(count % 1000 == 0){
pst.executeBatch();
pst.clearBatch();//每1000條sql批處理一次，然后置空PreparedStatement中的參數(shù)，這樣也能提高效率，防止參數(shù)積累過(guò)多事務(wù)超時(shí)，但實(shí)際測(cè)試效果不明顯
}
count ;
}
conn.commit();
} catch (SQLException e) {
e.printStackTrace();
}
DBUtil.closeConnection(conn);
}
JDBC默認(rèn)自動(dòng)提交事務(wù)，切記在獲取連接后添加下面一行代碼，關(guān)閉事務(wù)自動(dòng)提交。
測(cè)試：10萬(wàn)條數(shù)據(jù)
TestMysql test = new TestMysql();
ArrayListlist = new ArrayList();
for (int i = 0; i < 1000; i ) {
Product product = new Product(i, "書籍", "追風(fēng)箏的人", 20.5);
list.add(product);
}
System.out.println("MYSQL開(kāi)始插入數(shù)據(jù)。。。");
long insertStart = System.currentTimeMillis();
test.insertBatch(list);
System.out.println("MYSQL插入數(shù)據(jù)完成，共耗時(shí)：" (System.currentTimeMillis() - insertStart) "毫秒");
}
結(jié)果：7389毫秒，多次測(cè)試基本7秒左右
Connection conn = DBUtil.getConnection();
try {
for (Product product : list) {
PreparedStatement pst = conn.prepareStatement("insert into t_product value(?,?,?,?)");
pst.setInt(1, product.getProductId());
pst.setString(2, product.getCategory());
pst.setString(3, product.getName());
pst.setDouble(4, product.getPrice());
pst.executeUpdate();
//conn.commit();//加上這句每次插入都提交事務(wù)，結(jié)果將是非常耗時(shí)
}
conn.commit();
} catch (SQLException e) {
e.printStackTrace();
}
DBUtil.closeConnection(conn);
}
測(cè)試：10萬(wàn)條記錄
long insertStart = System.currentTimeMillis();
test.insertOneByOne(list);
System.out.println("MYSQL插入數(shù)據(jù)完成，共耗時(shí)：" (System.currentTimeMillis() - insertStart) "毫秒");
結(jié)果：8921毫秒，基本比批量慢1秒多。
2、刪除操作
(1)、批處理刪除
Connection conn = DBUtil.getConnection();
try {
PreparedStatement pst = conn.prepareStatement("delete from t_product where id = ?");//按主鍵查，否則全表遍歷很慢
int count = 1;
for (Product product : list) {
pst.setInt(1, product.getProductId());
pst.addBatch();
if(count % 1000 == 0){
pst.executeBatch();
pst.clearBatch();
}
count ;
}
conn.commit();
} catch (SQLException e) {
e.printStackTrace();
}
DBUtil.closeConnection(conn);
}
測(cè)試：10萬(wàn)條數(shù)據(jù)
long deleteStart = System.currentTimeMillis();
test.deleteBatch(list);
System.out.println("MYSQL刪除數(shù)據(jù)完成，共耗時(shí)：" (System.currentTimeMillis() - deleteStart) "毫秒");
結(jié)果：7936毫秒
(2)、逐條刪除
Connection conn = DBUtil.getConnection();
PreparedStatement pst = null;
try {
for (Product product : list) {
pst = conn.prepareStatement("delete from t_product where id = ?");
pst.setInt(1, product.getProductId());
pst.executeUpdate();
//conn.commit();//加上這句每次插入都提交事務(wù)，結(jié)果將是非常耗時(shí)
}
conn.commit();
} catch (SQLException e) {
e.printStackTrace();
}
DBUtil.closeConnection(conn);
}
測(cè)試：10萬(wàn)條數(shù)據(jù)
long deleteStart = System.currentTimeMillis();
test.deleteOneByOne(list);
System.out.println("MYSQL刪除數(shù)據(jù)完成，共耗時(shí)：" (System.currentTimeMillis() - deleteStart) "毫秒");
結(jié)果：8752毫秒，比批處理刪除慢一秒左右
3、更新操作
(1)、批處理更新
Connection conn = DBUtil.getConnection();
try {
PreparedStatement pst = conn.prepareStatement("update t_product set price=31.5 where id=?");
int count = 1;
for (Product product : list) {
pst.setInt(1, product.getProductId());
pst.addBatch();
if(count % 1000 == 0){
pst.executeBatch();
pst.clearBatch();//每1000條sql批處理一次，然后置空PreparedStatement中的參數(shù)，這樣也能提高效率，防止參數(shù)積累過(guò)多事務(wù)超時(shí)，但實(shí)際測(cè)試效果不明顯
}
count ;
}
conn.commit();
} catch (SQLException e) {
e.printStackTrace();
}
DBUtil.closeConnection(conn);
}
測(cè)試：10萬(wàn)條數(shù)據(jù)
long updateStart = System.currentTimeMillis();
test.updateBatch(list);
System.out.println("MYSQL更新數(shù)據(jù)完成，共耗時(shí)：" (System.currentTimeMillis() - updateStart) "毫秒");
結(jié)果：8611毫秒
Connection conn = DBUtil.getConnection();
try {
for (Product product : list) {
PreparedStatement pst = conn.prepareStatement("update t_product set price=30.5 where id=?");
pst.setInt(1, product.getProductId());
pst.executeUpdate();
//conn.commit();//加上這句每次插入都提交事務(wù)，結(jié)果將是非常耗時(shí)
}
conn.commit();
} catch (SQLException e) {
e.printStackTrace();
}
DBUtil.closeConnection(conn);
}
測(cè)試：10萬(wàn)條數(shù)據(jù)
long updateStart = System.currentTimeMillis();
test.updateOneByOne(list);
System.out.println("MYSQL更新數(shù)據(jù)完成，共耗時(shí)：" (System.currentTimeMillis() - updateStart) "毫秒");
結(jié)果：9430毫秒，比批處理更新慢了1秒左右
三、總結(jié)
本文主要是為了介紹bulkWrite()方法的使用，也就是MongoDB的批量寫操作，通過(guò)實(shí)驗(yàn)可以看出MongoDB使用bulkWrite()方法進(jìn)行大量數(shù)據(jù)的寫操作比使用常規(guī)的方法進(jìn)行寫操作效率要高很多。文章也介紹了mysql幾種寫操作下批量和非批量的對(duì)比，可以看出他們批處理方式比非批處理快點(diǎn)，但沒(méi)有MongoDB那么明顯。
下載文檔
