本文主要通过批量与非批量对比操作的方式介绍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,也就是批量写操作。在Javadriver中,对应MongoCollection的bulkWrite()方法,先来看下这个方法签名:

这个方法要求传入一个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是唯一的。

  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个参数,第一个是查询条件,第二个参数是要更新的内容,不了解更新操作的可以看下之前的这篇博客http://blog.csdn.net/u014513883/article/details/48312409,第三个参数是可选的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性能对比

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万条数据

  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内存使用情况进行监测,有兴趣的可以尝试下。
 

MongoDB批量操作及与MySQL效率对比的更多相关文章

  1. MongoDB与MySQL效率对比

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

  2. mongodb,redis,mysql 简要对比

    本篇内容大部分不是原创,转载的会贴有链接. 准备学习下数据库,想对目前的主流数据库做一个简单的了解分析,就搜集了资料整理到了一块. 当下主流的要数NoSql数据库了,拥有强大的高并发能力. mongo ...

  3. MongoDB(五)mongo语法和mysql语法对比学习

    我们总是在对比中看到自己的优点和缺点,对于mongodb来说也是一样,对比学习让我们尽快的掌握关于mongodb的基础知识. mongodb与MySQL命令对比 关系型数据库一般是由数据库(datab ...

  4. mongodb与mysql命令对比

    mongodb与mysql命令对比 传统的关系数据库一般由数据库(database).表(table).记录(record)三个层次概念组成,MongoDB是由数据库(database).集合(col ...

  5. MySQL和Mongodb的区别与应用场景对比

    MySQL是关系型数据库 优势: 在不同的引擎上有不同 的存储方式. 查询语句是使用传统的sql语句,拥有较为成熟的体系,成熟度很高. 开源数据库的份额在不断增加,mysql的份额页在持续增长. 缺点 ...

  6. mongodb postgresql mysql jsonb对比

    mongodb pg mysql jsonb对比 http://erthalion.info/2017/12/21/advanced-json-benchmarks/ 使用禁用jsonb列的压缩 AL ...

  7. mongodb为什么比mysql效率高

    首先是内存映射机制,数据不是持久化到存储设备中的,而是暂时存储在内存中,这就提高了在IO上效率以及操作系统对存储介质之间的性能损耗.(毕竟内存读取最快) 其次,NoSQL并不是不使用sql,只是不使用 ...

  8. mongo语法和mysql语法对比学习

    我们总是在对比中看到自己的优点和缺点,对于mongodb来说也是一样,对比学习让我们尽快的掌握关于mongodb的基础知识. mongodb与mysql命令对比 关系型数据库一般是由数据库(datab ...

  9. [原] KVM 环境下MySQL性能对比

    KVM 环境下MySQL性能对比 标签(空格分隔): Cloud2.0 [TOC] 测试目的 对比MySQL在物理机和KVM环境下性能情况 压测标准 压测遵循单一变量原则,所有的对比都是只改变一个变量 ...

随机推荐

  1. 如何优雅地在React项目中使用Redux

    前言 或许你当前的项目还没有到应用Redux的程度,但提前了解一下也没有坏处,本文不会安利大家使用Redux 概念 首先我们会用到哪些框架和工具呢? React UI框架 Redux 状态管理工具,与 ...

  2. Spring(概念)

    在本文中只讲述一些概念性的东西,因为我在开始学习JAVA的时候对这些概念性的东西总是不太理解,总结总结再感悟一下,也方便后人. 理解的不深,用通俗的语言讲一下: 百度百科这样介绍: spring框架主 ...

  3. headfirst设计模式(4)—工厂模式

    开篇 天天逛博客园,就是狠不下心来写篇博客,忙是一方面,但是说忙能有多忙呢,都有时间逛博客园,写篇博客的时间都没有?(这还真不好说) 每次想到写一篇新的设计模式,我总会问自己: 1,自己理解了吗? 2 ...

  4. bzoj 3717: [PA2014]Pakowanie

    Description 你有n个物品和m个包.物品有重量,且不可被分割:包也有各自的容量.要把所有物品装入包中,至少需要几个包? Input 第一行两个整数n,m(1<=n<=24,1&l ...

  5. 微信JS-SDK使用步骤(以微信扫一扫为例)

    概述: 微信JS-SDK是微信公众平台面向网页开发者提供的基于微信内的网页开发工具包. 通过使用微信JS-SDK,网页开发者可借助微信高效地使用拍照.选图.语音.位置等手机系统的能力,同时可以直接使用 ...

  6. C#设计模式之二十二备忘录模式(Memeto Pattern)【行为型】

    一.引言   今天我们开始讲"行为型"设计模式的第十个模式,该模式是[备忘录模式],英文名称是:Memento Pattern.按老规矩,先从名称上来看看这个模式,个人的最初理解就 ...

  7. StreamCQL编写jstorm拓扑任务入门

    一,什么是 StreamCQL StreamCQL(Stream Continuous Query Language)是一个类似SQL的声明式语言, 目的是在流计算平台(目前也就是jstrom)的基础 ...

  8. FPGA 设计总结(1)

    1. set_input_delay和set_output_delay的选项-max和-min的理解 首先 input/output其实是模拟数据在端口外的延时,是一个外部约束条件,目的是为了约束FP ...

  9. Head First设计模式之模板方法模式

    一.定义 在一个方法中定义一个算法的骨架,而将一些步骤延迟到子类中,使得子类可以不改变算法结构的情况下,重定义该算法中的某些特定步骤. 比较通俗的说法,子类决定如何实现算法中的某些步骤,比如两个一连串 ...

  10. MicroPython教程之TPYBoard v102 CAN总线通信

    0x00前言 CAN是控制器局域网络(ControllerAreaNetwork,CAN)的简称,是ISO国际标准化的串行通信协议.CAN总线结构简单,只需2根线与外部相连,并且内部集成了错误探测和管 ...