自拍偷在线精品自拍偷,亚洲欧美中文日韩v在线观看不卡

MongoDB vs MySQL，哪個效率更高？

作者：佚名
數(shù)據(jù)庫 MySQL MongoDB
本文主要通過批量與非批量對比操作的方式介紹MongoDB的bulkWrite()方法的使用。順帶與關系型數(shù)據(jù)庫MySQL進行對比，比較這兩種不同類型數(shù)據(jù)庫的效率。

 [[437822]]

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

測試環(huán)境：win7旗艦版、16G內存、i3處理器、MongoDB3.0.2、mysql5.0

一、MongoDB批量操作

MongoDB對數(shù)據(jù)的操作分為Read Operations和Write Operations，Read Operations包含查詢操作，Write Operations包含刪除、插入、替換、更新幾種操作。MongoDB提供客戶端用bulk方式執(zhí)行Write Operations，也就是批量寫操作。在java driver中，對應MongoCollection的bulkWrite()方法，先來看下這個方法簽名： 

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

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

1、插入操作

(1)批量插入

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

  1. public void bulkWriteInsert(List<Document> documents){  
  2.  List<WriteModel<Document>> requests = new ArrayList<WriteModel<Document>>();  
  3.  for (Document document : documents) {  
  4.   //構造插入單個文檔的操作模型  
  5.   InsertOneModel<Document>  iom = new InsertOneModel<Document>(document);  
  6.   requests.add(iom);  
  7.  }  
  8.  BulkWriteResult  bulkWriteResult = collection.bulkWrite(requests);  
  9.  System.out.println(bulkWriteResult.toString());  
  10. } 

測試：下面通過一個main函數(shù)測試下。首先構造10萬個Product實體對象，使用一個工具類將其轉換成json字符串，然后解析成Document對象，保存到一個list集合中，然后調用上面編寫的方法測試10萬個對象插入時間。 

  1. TestMongoDB instance = TestMongoDB.getInstance();  
  2. ArrayList<Document> documents = new ArrayList<Document>();  
  3. for (int i = 0; i < 100000; i++) {  
  4.  Product product = new Product(i,"書籍","追風箏的人",22.5);  
  5.  //將java對象轉換成json字符串  
  6.  String jsonProduct = JsonParseUtil.getJsonString4JavaPOJO(product);  
  7.  //將json字符串解析成Document對象  
  8.  Document docProduct = Document.parse(jsonProduct);  
  9.  documents.add(docProduct);  
  10. }  
  11. System.out.println("開始插入數(shù)據(jù)。。。");  
  12. long startInsert = System.currentTimeMillis();  
  13. instance.bulkWriteInsert(documents);  
  14. System.out.println("插入數(shù)據(jù)完成，共耗時："+(System.currentTimeMillis() - startInsert)+"毫秒"); 

結果：1560毫秒，多次測試基本在1.5秒左右

(2)逐條插入

下面再通過非批量插入10萬個數(shù)據(jù)對比下，方法如下： 

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

測試：10萬條數(shù)據(jù) 

  1. System.out.println("開始插入數(shù)據(jù)。。。");  
  2. long startInsert = System.currentTimeMillis();  
  3. instance.insertOneByOne(documents);  
  4. System.out.println("插入數(shù)據(jù)完成，共耗時："+(System.currentTimeMillis() - startInsert)+"毫秒"); 

結果：12068毫秒，差距非常大。由此可見，MongoDB批量插入比逐條數(shù)據(jù)插入效率提高了非常多。

補充：

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

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

2、刪除操作

(1)批量刪除

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

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

因為隨著collection數(shù)據(jù)量的增大，查找將越耗時，添加索引是為了提高查找效率，進而加快刪除效率。另外，值得一提的是DeleteOneModel表示至多刪除一條匹配條件的記錄，DeleteManyModel表示刪除匹配條件的所有記錄。為了防止一次刪除多條記錄，這里使用DeleteOneModel，保證一個操作只刪除一條記錄。當然這里不可能匹配多條記錄，因為_id是唯一的。

最新 MySQL 面試題整理好了，點擊Java面試庫小程序在線刷題。 

  1. public void bulkWriteDelete(List<Document> documents){  
  2.  List<WriteModel<Document>> requests = new ArrayList<WriteModel<Document>>();  
  3.  for (Document document : documents) {  
  4.   //刪除條件  
  5.   Document queryDocument = new Document("_id",document.get("_id"));  
  6.   //構造刪除單個文檔的操作模型，  
  7.   DeleteOneModel<Document>  dom = new DeleteOneModel<Document>(queryDocument);  
  8.   requests.add(dom);  
  9.  }  
  10.  BulkWriteResult bulkWriteResult = collection.bulkWrite(requests);  
  11.  System.out.println(bulkWriteResult.toString());  
  12. } 

測試：10萬條數(shù)據(jù) 

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

結果：2251毫秒

(2)逐條刪除

來看看在非批量下的刪除 

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

測試：10萬條數(shù)據(jù) 

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

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

3、更新操作

(1)批量更新

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

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

  1. public void bulkWriteUpdate(List<Document> documents){  
  2.  List<WriteModel<Document>> requests = new ArrayList<WriteModel<Document>>();  
  3.  for (Document document : documents) {  
  4.   //更新條件  
  5.   Document queryDocument = new Document("_id",document.get("_id"));  
  6.   //更新內容，改下書的價格 
  7.   Document updateDocument = new Document("$set",new Document("price","30.6"));  
  8.   //構造更新單個文檔的操作模型  
  9.   UpdateOneModel<Document> uom = new UpdateOneModel<Document>(queryDocument,updateDocument,new UpdateOptions().upsert(false));  
  10.   //UpdateOptions代表批量更新操作未匹配到查詢條件時的動作，默認false，什么都不干，true時表示將一個新的Document插入數(shù)據(jù)庫，他是查詢部分和更新部分的結合  
  11.   requests.add(uom);  
  12.  } 
  13.  BulkWriteResult bulkWriteResult = collection.bulkWrite(requests);  
  14.  System.out.println(bulkWriteResult.toString());  
  15. } 

測試：10萬條數(shù)據(jù) 

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

結果：3198毫秒

(2)逐條更新

對比非批量下的更新 

  1. public void updateOneByOne(List<Document> documents){  
  2.  for (Document document : documents) {  
  3.   Document queryDocument = new Document("_id",document.get("_id"));  
  4.   Document updateDocument = new Document("$set",new Document("price","30.6"));  
  5.   UpdateResult UpdateResult = collection.updateOne(queryDocument, updateDocument);  
  6.  }  
  7. } 

測試：10萬條數(shù)據(jù) 

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

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

4、混合批量操作

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

  1. public void bulkWriteMix(){  
  2.  List<WriteModel<Document>> requests = new ArrayList<WriteModel<Document>>();  
  3.   InsertOneModel<Document>  iom = new InsertOneModel<Document>(new Document("name","kobe"));  
  4.   UpdateManyModel<Document> umm = new UpdateManyModel<Document>(new Document("name","kobe"),  
  5.     new Document("$set",new Document("name","James")),new UpdateOptions().upsert(true));  
  6.   DeleteManyModel<Document>  dmm = new DeleteManyModel<Document>(new Document("name","James"));  
  7.   requests.add(iom);  
  8.   requests.add(umm);  
  9.   requests.add(dmm);  
  10.   BulkWriteResult bulkWriteResult = collection.bulkWrite(requests);  
  11.   System.out.println(bulkWriteResult.toString());  
  12. } 

注意：updateMany()、deleteMany()兩個方法和insertMany()不同，它倆不是批量操作，而是代表更新（刪除）匹配條件的所有數(shù)據(jù)。

最新 MySQL 面試題整理好了，點擊Java面試庫小程序在線刷題。

二、與MySQL性能對比

1、插入操作

(1)批處理插入

與MongoDB一樣，也是插入Product實體對象，代碼如下 

  1. public void insertBatch(ArrayList<Product> list) throws Exception{  
  2.  Connection conn = DBUtil.getConnection();  
  3.  try {  
  4.   PreparedStatement pst = conn.prepareStatement("insert into t_product value(?,?,?,?)");  
  5.   int count = 1;  
  6.   for (Product product : list) {  
  7.    pst.setInt(1, product.getProductId());  
  8.    pst.setString(2, product.getCategory());
  9.    pst.setString(3, product.getName());  
  10.    pst.setDouble(4, product.getPrice());  
  11.    pst.addBatch();  
  12.    if(count % 1000 == 0){  
  13.     pst.executeBatch();  
  14.     pst.clearBatch();//每1000條sql批處理一次，然后置空PreparedStatement中的參數(shù)，這樣也能提高效率，防止參數(shù)積累過多事務超時，但實際測試效果不明顯  
  15.    }  
  16.    count++;  
  17.   }  
  18.   conn.commit();  
  19.  } catch (SQLException e) {  
  20.   e.printStackTrace();  
  21.  }  
  22.  DBUtil.closeConnection(conn);  
  23. } 

JDBC默認自動提交事務，切記在獲取連接后添加下面一行代碼，關閉事務自動提交。 

  1. connection.setAutoCommit(false); 

測試：10萬條數(shù)據(jù) 

  1. public static void main(String[] args) throws Exception {  
  2.             TestMysql test = new TestMysql();  
  3.             ArrayList<Product> list = new ArrayList<Product>();  
  4.             for (int i = 0; i < 1000; i++) {  
  5.                 Product product = new Product(i, "書籍", "追風箏的人", 20.5);  
  6.                 list.add(product);  
  7.             } 
  8.             System.out.println("MYSQL開始插入數(shù)據(jù)。。。");  
  9.             long insertStart = System.currentTimeMillis();  
  10.             test.insertBatch(list);  
  11.             System.out.println("MYSQL插入數(shù)據(jù)完成，共耗時："+(System.currentTimeMillis() - insertStart)+"毫秒");  
  12. } 

結果：7389毫秒，多次測試基本7秒左右

(2)逐條插入

再來看看mysql逐條插入,代碼如下： 

  1. public void insertOneByOne(ArrayList<Product> list) throws Exception{  
  2.  Connection conn = DBUtil.getConnection();  
  3.  try {  
  4.   for (Product product : list) {  
  5.    PreparedStatement pst = conn.prepareStatement("insert into t_product value(?,?,?,?)");  
  6.    pst.setInt(1, product.getProductId());  
  7.    pst.setString(2, product.getCategory());  
  8.    pst.setString(3, product.getName());  
  9.    pst.setDouble(4, product.getPrice());  
  10.    pst.executeUpdate();  
  11.    //conn.commit();//加上這句每次插入都提交事務，結果將是非常耗時  
  12.   }  
  13.   conn.commit();  
  14.  } catch (SQLException e) {  
  15.   e.printStackTrace();  
  16.  }  
  17.  DBUtil.closeConnection(conn); 
  18. } 

測試：10萬條記錄 

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

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

2、刪除操作

(1)批處理刪除

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

  1. public void deleteBatch(ArrayList<Product> list) throws Exception{  
  2.   Connection conn = DBUtil.getConnection();  
  3.   try {  
  4.    PreparedStatement pst = conn.prepareStatement("delete from t_product where id = ?");//按主鍵查，否則全表遍歷很慢  
  5.    int count = 1;  
  6.    for (Product product : list) {  
  7.     pst.setInt(1, product.getProductId());  
  8.     pst.addBatch();  
  9.     if(count % 1000 == 0){  
  10.      pst.executeBatch();  
  11.      pst.clearBatch();  
  12.     }  
  13.     count++;  
  14.    }  
  15.    conn.commit();  
  16.   } catch (SQLException e) { 
  17.    e.printStackTrace();  
  18.   }  
  19.   DBUtil.closeConnection(conn);  
  20.  } 

測試：10萬條數(shù)據(jù)。另外，MySQL 系列面試題和答案全部整理好了，微信搜索Java技術棧，在后臺發(fā)送：面試，可以在線閱讀。 

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

結果：7936毫秒

(2)逐條刪除

代碼如下 

  1. public void deleteOneByOne(ArrayList<Product> list) throws Exception{  
  2.  Connection conn = DBUtil.getConnection();  
  3.  PreparedStatement pst = null;  
  4.  try {  
  5.   for (Product product : list) {  
  6.    pst = conn.prepareStatement("delete from t_product where id = ?");  
  7.    pst.setInt(1, product.getProductId());  
  8.    pst.executeUpdate();  
  9.    //conn.commit();//加上這句每次插入都提交事務，結果將是非常耗時  
  10.   }  
  11.   conn.commit(); 
  12.  } catch (SQLException e) {  
  13.   e.printStackTrace();  
  14.  }  
  15.  DBUtil.closeConnection(conn);  
  16. } 

測試：10萬條數(shù)據(jù) 

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

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

3、更新操作

(1)批處理更新

代碼如下 

  1. public void updateBatch(ArrayList<Product> list) throws Exception{  
  2.  Connection conn = DBUtil.getConnection();  
  3.  try {  
  4.   PreparedStatement pst = conn.prepareStatement("update t_product set price=31.5 where id=?");  
  5.   int count = 1;  
  6.   for (Product product : list) {  
  7.    pst.setInt(1, product.getProductId());  
  8.    pst.addBatch(); 
  9.    if(count % 1000 == 0){  
  10.     pst.executeBatch();  
  11.     pst.clearBatch();//每1000條sql批處理一次，然后置空PreparedStatement中的參數(shù)，這樣也能提高效率，防止參數(shù)積累過多事務超時，但實際測試效果不明顯  
  12.    }  
  13.    count++;  
  14.   }  
  15.   conn.commit();  
  16.  } catch (SQLException e) { 
  17.   e.printStackTrace();  
  18.  } 
  19.   DBUtil.closeConnection(conn);  
  20. } 

測試：10萬條數(shù)據(jù) 

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

結果：8611毫秒

(2)逐條更新

代碼如下 

  1. public void updateOneByOne(ArrayList<Product> list) throws Exception{  
  2.   Connection conn = DBUtil.getConnection();  
  3.   try {  
  4.    for (Product product : list) {  
  5.     PreparedStatement pst = conn.prepareStatement("update t_product set price=30.5 where id=?");  
  6.     pst.setInt(1, product.getProductId());  
  7.     pst.executeUpdate();  
  8.     //conn.commit();//加上這句每次插入都提交事務，結果將是非常耗時  
  9.    }  
  10.    conn.commit();  
  11.   } catch (SQLException e) {  
  12.    e.printStackTrace();  
  13.   }  
  14.   DBUtil.closeConnection(conn);  
  15.  } 

測試：10萬條數(shù)據(jù) 

  1. System.out.println("MYSQL開始更新數(shù)據(jù)。。。");  
  2. long updateStart = System.currentTimeMillis();  
  3. test.updateOneByOne(list);  
  4. System.out.println("MYSQL更新數(shù)據(jù)完成，共耗時："+(System.currentTimeMillis() - updateStart)+"毫秒"); 

結果：9430毫秒，比批處理更新慢了1秒左右

三、總結

本文主要是為了介紹bulkWrite()方法的使用，也就是MongoDB的批量寫操作，通過實驗可以看出MongoDB使用bulkWrite()方法進行大量數(shù)據(jù)的寫操作比使用常規(guī)的方法進行寫操作效率要高很多。文章也介紹了mysql幾種寫操作下批量和非批量的對比，可以看出他們批處理方式比非批處理快點，但沒有MongoDB那么明顯。

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

 

責任編輯：龐桂玉 來源： Java編程愛好者
MongoDBMySQL數(shù)據(jù)庫
相關推薦

2020-02-26 10:33:31

邊緣計算云計算

2011-07-15 09:11:39

MySQLMongoDB

2012-09-07 10:09:54

MySQLMongoDB云計算

2021-03-19 11:45:13

云計算邊緣計算

2021-03-10 09:55:38

邊緣計算云計算IT行業(yè)

2014-12-05 09:59:17

程序員

2020-11-03 14:30:02

MySQL5.7MyS8.0數(shù)據(jù)庫

2019-08-05 15:25:22

C語言數(shù)據(jù)庫Linux

2022-01-12 10:29:01

Windows 11Windows微軟

2009-06-08 15:36:21

運維管理自助服務摩卡

2021-04-12 08:01:21

GridFlexbox網格

2024-01-01 18:57:01

Code技巧符號

2024-07-30 09:12:15

2018-12-11 12:38:23

UbuntuMint發(fā)行版

2023-10-18 07:43:55

Redis數(shù)據(jù)存儲

2019-11-25 10:20:54

CSS代碼javascript

2011-11-26 13:42:57

夏普復合一體機

2010-02-06 09:15:15

Power7新安騰

2009-12-21 16:51:50

無線路由器

2012-05-30 15:09:21

愛普生掃描儀
點贊
收藏

51CTO技術棧公眾號