zoukankan      html  css  js  c++  java

  • MongoDB批量操作及与MySQL效率对比

    本文主要通过批量与非批量对比操作的方式介绍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.   
    12. System.out.println("开始插入数据。。。");  
    13. long startInsert = System.currentTimeMillis();  
    14. instance.bulkWriteInsert(documents);  
    15. 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.   
    9.             System.out.println("MYSQL开始插入数据。。。");  
    10.             long insertStart = System.currentTimeMillis();  
    11.             test.insertBatch(list);  
    12.             System.out.println("MYSQL插入数据完成，共耗时："+(System.currentTimeMillis() - insertStart)+"毫秒");  
    13. }  
               结果：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.           
    12.         conn.commit();  
    13.     } catch (SQLException e) {  
    14.         e.printStackTrace();  
    15.     }  
    16.     DBUtil.closeConnection(conn);  
    17. }  
               测试：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内存使用情况进行监测，有兴趣的可以尝试下。
     
  • 相关阅读:
    巧用$.extend
    easyui 表格中combo选择值后显示为valueField而非textField的解决
    jeasyui 造成$.data(...) is undefined报错的原因及解决
    无线路由器+摩托罗拉手机WIFI=能连接，但不能上网
    javascript 复制粘贴功能 各种浏览器兼容
    WriteLiteral与Write的区别
    打印机队列取消不了的解决方法
    js判断字符串长度，中文占两个字符
    针对chrome的css hack
    JS生成26个英文字母
  • 原文地址：https://www.cnblogs.com/sa-dan/p/6836696.html
Copyright © 2011-2022 走看看