MongoDB vs MySQL，哪個(gè)效率更高？

點(diǎn)擊關(guān)注公眾號(hào)，回復(fù)“2T”獲取2TB學(xué)習(xí)資源！

互聯(lián)網(wǎng)架構(gòu)師后臺(tái)回復(fù) 2T 有特別禮包

上一篇：Docker 大勢(shì)已去，Podman 崛起

本文主要通過(guò)批量與非批量對(duì)比操作的方式介紹MongoDB的bulkWrite()方法的使用。順帶與關(guān)系型數(shù)據(jù)庫(kù)MySQL進(jìn)行對(duì)比，比較這兩種不同類型數(shù)據(jù)庫(kù)的效率。如果只是想學(xué)習(xí)bulkWrite()的使用的看第一部分就行。

測(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，也就是批量寫(xiě)操作。在java driver中，對(duì)應(yīng)MongoCollection的bulkWrite()方法，先來(lái)看下這個(gè)方法簽名：

BulkWriteResult  com.mongodb.client.MongoCollection.bulkWrite(List<? extends WriteModel<? extends Document>> requests)

這個(gè)方法要求傳入一個(gè)List集合，集合中的元素類型為WriteModel，它表示一個(gè)可用于批量寫(xiě)操作的基類模型，它有以下幾個(gè)子類DeleteManyModel、DeleteOneModel、 InsertOneModel、ReplaceOneModel、 UpdateManyModel、UpdateOneModel，從名字可以看出來(lái)它對(duì)應(yīng)了刪除、插入、替換、更新幾種操作。該方法返回一個(gè)BulkWriteResult對(duì)象，代表一個(gè)成功的批量寫(xiě)操作結(jié)果，封裝了操作結(jié)果的狀態(tài)信息，如插入、更新、刪除記錄數(shù)等。

1、插入操作

(1)、批量插入

代碼如下，該方法接收一個(gè)包含要進(jìn)行插入的Document對(duì)象的集合參數(shù)，遍歷集合，使用Document構(gòu)造InsertOneModel對(duì)象，每個(gè)InsertOneModel實(shí)例代表一個(gè)插入單個(gè)Document的操作，然后將該實(shí)例添加List集合中，調(diào)用bulkWrite()方法，傳入存儲(chǔ)所有插入操作的List集合完成批量插入。

public void bulkWriteInsert(List<Document> documents){
 List<WriteModel<Document>> requests = new ArrayList<WriteModel<Document>>();
 for (Document document : documents) {
  //構(gòu)造插入單個(gè)文檔的操作模型
  InsertOneModel<Document>  iom = new InsertOneModel<Document>(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)用上面編寫(xiě)的方法測(cè)試10萬(wàn)個(gè)對(duì)象插入時(shí)間。

TestMongoDB instance = TestMongoDB.getInstance();
ArrayList<Document> documents = new ArrayList<Document>();
for (int i = 0; i < 100000; i++) {
 Product product = new Product(i,"書(shū)籍","追風(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秒左右

(2)、逐條插入

下面再通過(guò)非批量插入10萬(wàn)個(gè)數(shù)據(jù)對(duì)比下，方法如下：

 public void insertOneByOne(List<Document> documents) throws ParseException{
  for (Document document : documents){
   collection.insertOne(document);
  }
 }

測(cè)試：10萬(wàn)條數(shù)據(jù)

System.out.println("開(kāi)始插入數(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ù)插入效率提高了非常多。

補(bǔ)充：

MongoCollection的insertMany()方法和bulkWrite()方法是等價(jià)的，測(cè)試時(shí)間差不多，不再貼圖。

 public void insertMany(List<Document> documents) throws ParseException{
  //和bulkWrite()方法等價(jià)
  collection.insertMany(documents);
 }

2、刪除操作

(1)、批量刪除

掌握了批量插入，批量刪除就是依葫蘆畫(huà)瓢了。構(gòu)造DeleteOneModel需要一個(gè)Bson類型參數(shù)，代表一個(gè)刪除操作，這里使用了Bson類的子類Document。重點(diǎn)來(lái)了，這里的刪除條件使用文檔的_id字段，該字段在文檔插入數(shù)據(jù)庫(kù)后自動(dòng)生成，沒(méi)插入數(shù)據(jù)庫(kù)前document.get("_id")為null，如果使用其他條件比如productId，那么要在文檔插入到collection后在productId字段上添加索引

collection.createIndex(new Document("productId", 1));

因?yàn)殡S著collection數(shù)據(jù)量的增大，查找將越耗時(shí)，添加索引是為了提高查找效率，進(jìn)而加快刪除效率。另外，值得一提的是DeleteOneModel表示至多刪除一條匹配條件的記錄，DeleteManyModel表示刪除匹配條件的所有記錄。為了防止一次刪除多條記錄，這里使用DeleteOneModel，保證一個(gè)操作只刪除一條記錄。當(dāng)然這里不可能匹配多條記錄，因?yàn)開(kāi)id是唯一的。搜索公眾號(hào)互聯(lián)網(wǎng)架構(gòu)師后臺(tái)回復(fù)“2T”，獲取一份驚喜禮包。

public void bulkWriteDelete(List<Document> documents){
 List<WriteModel<Document>> requests = new ArrayList<WriteModel<Document>>();
 for (Document document : documents) {
  //刪除條件
  Document queryDocument = new Document("_id",document.get("_id"));
  //構(gòu)造刪除單個(gè)文檔的操作模型，
  DeleteOneModel<Document>  dom = new DeleteOneModel<Document>(queryDocument);
  requests.add(dom);
 }
 BulkWriteResult bulkWriteResult = collection.bulkWrite(requests);
 System.out.println(bulkWriteResult.toString());
}

測(cè)試：10萬(wàn)條數(shù)據(jù)

System.out.println("開(kāi)始刪除數(shù)據(jù)。。。");
long startDelete = System.currentTimeMillis();
instance.bulkWriteDelete(documents);
System.out.println("刪除數(shù)據(jù)完成，共耗時(shí)："+(System.currentTimeMillis() - startDelete)+"毫秒");

結(jié)果：2251毫秒

(2)、逐條刪

來(lái)看看在非批量下的刪除

 public void deleteOneByOne(List<Document> documents){
  for (Document document : documents) {
   Document queryDocument = new Document("_id",document.get("_id"));
   DeleteResult deleteResult = collection.deleteOne(queryDocument);
  }
 }

測(cè)試：10萬(wàn)條數(shù)據(jù)

System.out.println("開(kāi)始刪除數(shù)據(jù)。。。");
long startDelete = System.currentTimeMillis();
instance.deleteOneByOne(documents);
System.out.println("刪除數(shù)據(jù)完成，共耗時(shí)："+(System.currentTimeMillis() - startDelete)+"毫秒");

結(jié)果：12765毫秒，比批量刪除效率低很多

3、更新操作

(1)、批量更新

再來(lái)看看批量更新，分UpdateOneModel和UpdateManyModel兩種，區(qū)別是前者更新匹配條件的一條記錄，后者更新匹配條件的所有記錄。對(duì)于ReplaceOneModel，表示替換操作，這里也歸為更新，現(xiàn)在以UpdateOneModel為例進(jìn)行講解。UpdateOneModel構(gòu)造方法接收3個(gè)參數(shù)，第一個(gè)是查詢條件，第二個(gè)參數(shù)是要更新的內(nèi)容，第三個(gè)參數(shù)是可選的UpdateOptions，不填也會(huì)自動(dòng)幫你new一個(gè)，代表批量更新操作未匹配到查詢條件時(shí)的動(dòng)作，它的upser屬性值默認(rèn)false，什么都不干，true時(shí)表示將一個(gè)新的Document插入數(shù)據(jù)庫(kù)，這個(gè)新的Document是查詢Document和更新Document的結(jié)合，但如果是替換操作，這個(gè)新的Document就是這個(gè)替換Document。

這里會(huì)有個(gè)疑惑：這和匹配到查詢條件后執(zhí)行替換操作結(jié)果不一樣嗎？區(qū)別在于_id字段，未匹配查詢條件時(shí)插入的新的Document的_id是新的，而成功執(zhí)行替換操作，_id是原先舊的。

 public void bulkWriteUpdate(List<Document> documents){
  List<WriteModel<Document>> requests = new ArrayList<WriteModel<Document>>();
  for (Document document : documents) {
   //更新條件
   Document queryDocument = new Document("_id",document.get("_id"));
   //更新內(nèi)容，改下書(shū)的價(jià)格
   Document updateDocument = new Document("$set",new Document("price","30.6"));
   //構(gòu)造更新單個(gè)文檔的操作模型
   UpdateOneModel<Document> uom = new UpdateOneModel<Document>(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ù)

System.out.println("開(kāi)始更新數(shù)據(jù)。。。");
long startUpdate = System.currentTimeMillis();
instance.bulkWriteUpdate(documents);
System.out.println("更新數(shù)據(jù)完成，共耗時(shí)："+(System.currentTimeMillis() - startUpdate)+"毫秒");

結(jié)果：3198毫秒

(2)、逐條更新

對(duì)比非批量下的更新

 public void updateOneByOne(List<Document> documents){
  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ù)

System.out.println("開(kāi)始更新數(shù)據(jù)。。。");
long startUpdate = System.currentTimeMillis();
instance.updateOneByOne(documents);
System.out.println("更新數(shù)據(jù)完成，共耗時(shí)："+(System.currentTimeMillis() - startUpdate)+"毫秒");

結(jié)果：13979毫秒，比批量更新效率低很多

4、混合批量操作

bulkWrite()方法可以對(duì)不同類型的寫(xiě)操作進(jìn)行批量處理，代碼如下：

 public void bulkWriteMix(){
  List<WriteModel<Document>> requests = new ArrayList<WriteModel<Document>>();
   InsertOneModel<Document>  iom = new InsertOneModel<Document>(new Document("name","kobe"));
   UpdateManyModel<Document> umm = new UpdateManyModel<Document>(new Document("name","kobe"),
     new Document("$set",new Document("name","James")),new UpdateOptions().upsert(true));
   DeleteManyModel<Document>  dmm = new DeleteManyModel<Document>(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)、批處理插入

與MongoDB一樣，也是插入Product實(shí)體對(duì)象，代碼如下

 public void insertBatch(ArrayList<Product> list) throws Exception{
  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)提交。

connection.setAutoCommit(false);

測(cè)試：10萬(wàn)條數(shù)據(jù)

public static void main(String[] args) throws Exception {
            TestMysql test = new TestMysql();
            ArrayList<Product> list = new ArrayList<Product>();
            for (int i = 0; i < 1000; i++) {
                Product product = new Product(i, "書(shū)籍", "追風(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秒左右

(2)、逐條插入

再來(lái)看看mysql逐條插入,代碼如下：

 public void insertOneByOne(ArrayList<Product> list) throws Exception{
  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)條記錄

System.out.println("MYSQL開(kāi)始插入數(shù)據(jù)。。。");
long insertStart = System.currentTimeMillis();
test.insertOneByOne(list);
System.out.println("MYSQL插入數(shù)據(jù)完成，共耗時(shí)："+(System.currentTimeMillis() - insertStart)+"毫秒");

結(jié)果：8921毫秒，基本比批量慢1秒多。

2、刪除操作

(1)、批處理刪除

刪除的where條件是productId，這里在建表的時(shí)候沒(méi)有添加主鍵，刪除異常的慢，查了半天不知道什么原因。切記添加主鍵，主鍵默認(rèn)有索引，所有能更快匹配到記錄。

 public void deleteBatch(ArrayList<Product> list) throws Exception{
  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ù)。另外，MySQL 系列面試題和答案全部整理好了，微信搜索互聯(lián)網(wǎng)架構(gòu)師，在后臺(tái)發(fā)送：2T，可以在線閱讀。

System.out.println("MYSQL開(kāi)始刪除數(shù)據(jù)。。。");
long deleteStart = System.currentTimeMillis();
test.deleteBatch(list);
System.out.println("MYSQL刪除數(shù)據(jù)完成，共耗時(shí)："+(System.currentTimeMillis() - deleteStart)+"毫秒");

結(jié)果：7936毫秒

(2)、逐條刪除

代碼如下

 public void deleteOneByOne(ArrayList<Product> list) throws Exception{
  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ù)

System.out.println("MYSQL開(kāi)始刪除數(shù)據(jù)。。。");
long deleteStart = System.currentTimeMillis();
test.deleteOneByOne(list);
System.out.println("MYSQL刪除數(shù)據(jù)完成，共耗時(shí)："+(System.currentTimeMillis() - deleteStart)+"毫秒");

結(jié)果：8752毫秒，比批處理刪除慢一秒左右。

3、更新操作

(1)、批處理更新

代碼如下

 public void updateBatch(ArrayList<Product> list) throws Exception{
  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ù)

System.out.println("MYSQL開(kāi)始更新數(shù)據(jù)。。。");
long updateStart = System.currentTimeMillis();
test.updateBatch(list);
System.out.println("MYSQL更新數(shù)據(jù)完成，共耗時(shí)："+(System.currentTimeMillis() - updateStart)+"毫秒");

結(jié)果：8611毫秒

(2)、逐條更新

代碼如下

public void updateOneByOne(ArrayList<Product> list) throws Exception{
  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ù)

System.out.println("MYSQL開(kāi)始更新數(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的批量寫(xiě)操作，通過(guò)實(shí)驗(yàn)可以看出MongoDB使用bulkWrite()方法進(jìn)行大量數(shù)據(jù)的寫(xiě)操作比使用常規(guī)的方法進(jìn)行寫(xiě)操作效率要高很多。文章也介紹了mysql幾種寫(xiě)操作下批量和非批量的對(duì)比，可以看出他們批處理方式比非批處理快點(diǎn)，但沒(méi)有MongoDB那么明顯。

對(duì)于MongoDB與mysql的比較，批量操作下，MongoDB插入、刪除、更新都比mysql快，非批量操作下，MongoDB插入、刪除、更新都比mysql慢。當(dāng)然只是一個(gè)初略的結(jié)論，文中并沒(méi)有進(jìn)行100條、1000條、10000條或更大的這樣不同的數(shù)據(jù)對(duì)比，以及CPU內(nèi)存使用情況進(jìn)行監(jiān)測(cè)，有興趣的可以嘗試下。

原文鏈接：https://blog.csdn.net/u014513883/article/details/49365987

最后，關(guān)注公眾號(hào)互聯(lián)網(wǎng)架構(gòu)師，在后臺(tái)回復(fù)：2T，可以獲取我整理的 Java 系列面試題和答案，非常齊全。

正文結(jié)束

推薦閱讀 ↓↓↓

1.心態(tài)崩了！稅前2萬(wàn)4，到手1萬(wàn)4，年終獎(jiǎng)扣稅方式1月1日起施行~

2.深圳一普通中學(xué)老師工資單曝光，秒殺程序員，網(wǎng)友：敢問(wèn)是哪個(gè)學(xué)校畢業(yè)的？

3.從零開(kāi)始搭建創(chuàng)業(yè)公司后臺(tái)技術(shù)棧

4.程序員一般可以從什么平臺(tái)接私活？

5.清華大學(xué)：2021 元宇宙研究報(bào)告！

6.為什么國(guó)內(nèi) 996 干不過(guò)國(guó)外的 955呢？

7.這封“領(lǐng)導(dǎo)痛批95后下屬”的郵件，句句扎心！

8.15張圖看懂瞎忙和高效的區(qū)別！