文章详情

登录

短信预约-IT技能 免费直播动态提醒

选择考试省份

  • 北京
  • 上海
  • 天津
  • 重庆
  • 河北
  • 山东
  • 辽宁
  • 黑龙江
  • 吉林
  • 甘肃
  • 青海
  • 河南
  • 江苏
  • 湖北
  • 湖南
  • 江西
  • 浙江
  • 广东
  • 云南
  • 福建
  • 海南
  • 山西
  • 四川
  • 陕西
  • 贵州
  • 安徽
  • 广西
  • 内蒙
  • 西藏
  • 新疆
  • 宁夏
  • 兵团

请输入下面的图形验证码

提交验证

短信预约提醒成功

MongoDB vs MySQL，哪个效率更高？

2024-12-02 15:28

关注

本文主要通过批量与非批量对比操作的方式介绍MongoDB的bulkWrite()方法的使用。顺带与关系型数据库MySQL进行对比，比较这两种不同类型数据库的效率。如果只是想学习bulkWrite()的使用的看第一部分就行。

测试环境：win7旗舰版、16G内存、i3处理器、MongoDB3.0.2、mysql5.0

一、MongoDB批量操作

MongoDB对数据的操作分为Read Operations和Write Operations，Read Operations包含查询操作，Write Operations包含删除、插入、替换、更新几种操作。MongoDB提供客户端用bulk方式执行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对象，代表一个成功的批量写操作结果，封装了操作结果的状态信息，如插入、更新、删除记录数等。

1、插入操作

(1)批量插入

代码如下，该方法接收一个包含要进行插入的Document对象的集合参数，遍历集合，使用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函数测试下。首先构造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("开始插入数据。。。");  
  12. long startInsert = System.currentTimeMillis();  
  13. instance.bulkWriteInsert(documents);  
  14. System.out.println("插入数据完成，共耗时："+(System.currentTimeMillis() - startInsert)+"毫秒"); 

结果：1560毫秒，多次测试基本在1.5秒左右

(2)逐条插入

下面再通过非批量插入10万个数据对比下，方法如下： 

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

测试：10万条数据 

  1. System.out.println("开始插入数据。。。");  
  2. long startInsert = System.currentTimeMillis();  
  3. instance.insertOneByOne(documents);  
  4. System.out.println("插入数据完成，共耗时："+(System.currentTimeMillis() - startInsert)+"毫秒"); 

结果：12068毫秒，差距非常大。由此可见，MongoDB批量插入比逐条数据插入效率提高了非常多。

补充：

MongoCollection的insertMany()方法和bulkWrite()方法是等价的，测试时间差不多，不再贴图。 

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

2、删除操作

(1)批量删除

掌握了批量插入，批量删除就是依葫芦画瓢了。构造DeleteOneModel需要一个Bson类型参数，代表一个删除操作，这里使用了Bson类的子类Document。重点来了，这里的删除条件使用文档的_id字段，该字段在文档插入数据库后自动生成，没插入数据库前document.get("_id")为null，如果使用其他条件比如productId，那么要在文档插入到collection后在productId字段上添加索引 

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

因为随着collection数据量的增大，查找将越耗时，添加索引是为了提高查找效率，进而加快删除效率。另外，值得一提的是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万条数据 

  1. System.out.println("开始删除数据。。。");  
  2. long startDelete = System.currentTimeMillis(); 
  3. instance.bulkWriteDelete(documents);  
  4. System.out.println("删除数据完成，共耗时："+(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万条数据 

  1. System.out.println("开始删除数据。。。");  
  2. long startDelete = System.currentTimeMillis();  
  3. instance.deleteOneByOne(documents);  
  4. System.out.println("删除数据完成，共耗时："+(System.currentTimeMillis() - startDelete)+"毫秒"); 

结果：12765毫秒，比批量删除效率低很多

3、更新操作

(1)批量更新

再来看看批量更新，分UpdateOneModel和UpdateManyModel两种，区别是前者更新匹配条件的一条记录，后者更新匹配条件的所有记录。对于ReplaceOneModel，表示替换操作，这里也归为更新，现在以UpdateOneModel为例进行讲解。UpdateOneModel构造方法接收3个参数，第一个是查询条件，第二个参数是要更新的内容，第三个参数是可选的UpdateOptions，不填也会自动帮你new一个，代表批量更新操作未匹配到查询条件时的动作，它的upser属性值默认false，什么都不干，true时表示将一个新的Document插入数据库，这个新的Document是查询Document和更新Document的结合，但如果是替换操作，这个新的Document就是这个替换Document。

这里会有个疑惑：这和匹配到查询条件后执行替换操作结果不一样吗？区别在于_id字段，未匹配查询条件时插入的新的Document的_id是新的，而成功执行替换操作，_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插入数据库，他是查询部分和更新部分的结合  
  11.   requests.add(uom);  
  12.  } 
  13.  BulkWriteResult bulkWriteResult = collection.bulkWrite(requests);  
  14.  System.out.println(bulkWriteResult.toString());  
  15. } 

测试：10万条数据 

  1. System.out.println("开始更新数据。。。");  
  2. long startUpdate = System.currentTimeMillis();  
  3. instance.bulkWriteUpdate(documents);  
  4. System.out.println("更新数据完成，共耗时："+(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万条数据 

  1. System.out.println("开始更新数据。。。");  
  2. long startUpdate = System.currentTimeMillis();  
  3. instance.updateOneByOne(documents);  
  4. System.out.println("更新数据完成，共耗时："+(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()不同，它俩不是批量操作，而是代表更新（删除）匹配条件的所有数据。

最新 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中的参数，这样也能提高效率，防止参数积累过多事务超时，但实际测试效果不明显  
  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万条数据 

  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开始插入数据。。。");  
  9.             long insertStart = System.currentTimeMillis();  
  10.             test.insertBatch(list);  
  11.             System.out.println("MYSQL插入数据完成，共耗时："+(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开始插入数据。。。");  
  2. long insertStart = System.currentTimeMillis();  
  3. test.insertOneByOne(list);  
  4. System.out.println("MYSQL插入数据完成，共耗时："+(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万条数据。另外，MySQL 系列面试题和答案全部整理好了，微信搜索Java技术栈，在后台发送：面试，可以在线阅读。 

  1. System.out.println("MYSQL开始删除数据。。。");  
  2. long deleteStart = System.currentTimeMillis();  
  3. test.deleteBatch(list);  
  4. System.out.println("MYSQL删除数据完成，共耗时："+(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万条数据 

  1. System.out.println("MYSQL开始删除数据。。。"); 
  2. long deleteStart = System.currentTimeMillis();  
  3. test.deleteOneByOne(list);  
  4. System.out.println("MYSQL删除数据完成，共耗时："+(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中的参数，这样也能提高效率，防止参数积累过多事务超时，但实际测试效果不明显  
  12.    }  
  13.    count++;  
  14.   }  
  15.   conn.commit();  
  16.  } catch (SQLException e) { 
  17.   e.printStackTrace();  
  18.  } 
  19.   DBUtil.closeConnection(conn);  
  20. } 

测试：10万条数据 

  1. System.out.println("MYSQL开始更新数据。。。");  
  2. long updateStart = System.currentTimeMillis();  
  3. test.updateBatch(list);  
  4. System.out.println("MYSQL更新数据完成，共耗时："+(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万条数据 

  1. System.out.println("MYSQL开始更新数据。。。");  
  2. long updateStart = System.currentTimeMillis();  
  3. test.updateOneByOne(list);  
  4. System.out.println("MYSQL更新数据完成，共耗时："+(System.currentTimeMillis() - updateStart)+"毫秒"); 

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

三、总结

本文主要是为了介绍bulkWrite()方法的使用，也就是MongoDB的批量写操作，通过实验可以看出MongoDB使用bulkWrite()方法进行大量数据的写操作比使用常规的方法进行写操作效率要高很多。文章也介绍了mysql几种写操作下批量和非批量的对比，可以看出他们批处理方式比非批处理快点，但没有MongoDB那么明显。

对于MongoDB与mysql的比较，批量操作下，MongoDB插入、删除、更新都比mysql快，非批量操作下，MongoDB插入、删除、更新都比mysql慢。当然只是一个初略的结论，文中并没有进行100条、1000条、10000条或更大的这样不同的数据对比，以及CPU内存使用情况进行监测，有兴趣的可以尝试下。 

 

来源：Java编程爱好者内容投诉

免责声明：

① 本站未注明“稿件来源”的信息均来自网络整理。其文字、图片和音视频稿件的所属权归原作者所有。本站收集整理出于非商业性的教育和科研之目的，并不意味着本站赞同其观点或证实其内容的真实性。仅作为临时的测试数据，供内部测试之用。本站并未授权任何人以任何方式主动获取本站任何信息。

② 本站未注明“稿件来源”的临时测试数据将在测试完成后最终做删除处理。有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

软考中级精品资料免费领

  • 历年真题答案解析
  • 备考技巧名师总结
  • 高频考点精准押题

  • 2024年上半年信息系统项目管理师第二批次真题及答案解析（完整版）

    难度     813人已做
    查看

  • 【考后总结】2024年5月26日信息系统项目管理师第2批次考情分析

    难度     354人已做
    查看

  • 【考后总结】2024年5月25日信息系统项目管理师第1批次考情分析

    难度     318人已做
    查看

  • 2024年上半年软考高项第一、二批次真题考点汇总（完整版）

    难度     435人已做
    查看

  • 2024年上半年系统架构设计师考试综合知识真题

    难度     224人已做
    查看

相关文章

发现更多好内容

猜你喜欢

AI推送时光机

MongoDB vs MySQL，哪个效率更高？

后端开发MongoDBMySQL2024-12-02

MongoDB为何比mysql效率高

后端开发2024-04-02

Java 中的 clone( ) 和 new哪个效率更高

后端开发2024-04-02

五个VS Code技巧，开发更快更高效

后端开发Code技巧2024-11-30

Java中clone( ) 和 new效率更高的是哪个

后端开发2023-06-21

哪个 MongoDB 库更有效率："gopkg.in/mgo.v2" 还是 "go.mongodb.org/mongo-driver/mongo"？

哪个 MongoDB 库更有效率：
后端开发2024-04-04

十个提高VS Code工作效率的技巧

后端开发工作效率VS2024-11-30

十个提高Web开发效率的VS Code插件

后端开发插件Postman2024-11-30

10个提高开发效率的 VS Code 快捷键！

后端开发VSCode2024-12-03

MySQL 5.7 vs 8.0，哪个性能更牛？

后端开发MySQL5.7MyS8.02024-12-03

十个极大提高开发效率的 VS Code 技巧！

后端开发VSCode2024-11-30

面试官：MySQL中Count(*)和Count(1)哪个效率高？

后端开发mysqlcount2024-12-02

Linux大文件重定向和管道的效率哪个更高

后端开发2023-06-16

Linux vs Windows：哪个操作系统更适合高效地使用PHP对象？

后端开发2023-08-15

高防云服务器 vs 高防物理机：哪个更好？

后端开发2023-10-27

数据存储效率对决：Redis String vs Hash性能大比拼，哪个更适合你

后端开发Redis数据存储2024-11-30

Python 索引 vs. Windows：哪种异步编程方式更高效？

后端开发2023-06-21

Mysql如何处理重复数据？让你的效率更高效

Mysql如何处理重复数据？让你的效率更高效
后端开发2016-10-12

边缘计算与云计算：哪种效率更高？

后端开发云计算边缘计算2024-12-03

SQL Server vs MySQL：哪个更适合移动应用开发？

后端开发2023-10-22
位置：首页-资讯-后端开发
咦！没有更多了？去看看其它编程学习网 内容吧
首页课程
资料下载问答资讯