关于mongodb:MongoDB-vs-MySQL哪个效率更高

一、MongoDB 批量操作
MongoDB 对数据的操作分为 Read Operations 和 Write Operations，Read Operations 蕴含查问操作，Write Operations 蕴含删除、插入、替换、更新几种操作。MongoDB 提供客户端用 bulk 形式执行 Write Operations，也就是批量写操作。在 java driver 中，对应 MongoCollection 的 bulkWrite() 办法，先来看下这个办法签名：

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 汇合实现批量插入。

public void bulkWriteInsert(List<Document> documents){
List<WriteModel<Document>> requests = new ArrayList<WriteModel<Document>>();
for (Document document : documents) {
// 结构插入单个文档的操作模型
InsertOneModel<Document> iom = new InsertOneModel<Document>(document);
requests.add(iom);
}
BulkWriteResult bulkWriteResult = collection.bulkWrite(requests);
System.out.println(bulkWriteResult.toString());
}
测试：上面通过一个 main 函数测试下。首先结构 10 万个 Product 实体对象，应用一个工具类将其转换成 json 字符串，而后解析成 Document 对象，保留到一个 list 汇合中，而后调用下面编写的办法测试 10 万个对象插入工夫。

TestMongoDB instance = TestMongoDB.getInstance();
ArrayList<Document> documents = new ArrayList<Document>();
for (int i = 0; i < 100000; i++) {
Product product = new Product(i,” 书籍 ”,” 追风筝的人 ”,22.5);
// 将 java 对象转换成 json 字符串
String jsonProduct = JsonParseUtil.getJsonString4JavaPOJO(product);
// 将 json 字符串解析成 Document 对象
Document docProduct = Document.parse(jsonProduct);
documents.add(docProduct);
}

System.out.println(“ 开始插入数据。。。”);
long startInsert = System.currentTimeMillis();
instance.bulkWriteInsert(documents);
System.out.println(“ 插入数据实现，共耗时：”+(System.currentTimeMillis() – startInsert)+” 毫秒 ”);
后果：1560 毫秒，屡次测试根本在 1.5 秒左右

(2)、逐条插入

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

public void insertOneByOne(List<Document> documents) throws ParseException{
for (Document document : documents){
collection.insertOne(document);
}
}
测试：10 万条数据

System.out.println(“ 开始插入数据。。。”);
long startInsert = System.currentTimeMillis();
instance.insertOneByOne(documents);
System.out.println(“ 插入数据实现，共耗时：”+(System.currentTimeMillis() – startInsert)+” 毫秒 ”);
后果：12068 毫秒，差距十分大。由此可见，MongoDB 批量插入比逐条数据插入效率进步了十分多。

补充：

MongoCollection 的 insertMany()办法和 bulkWrite()办法是等价的，测试工夫差不多，不再贴图。

public void insertMany(List<Document> documents) throws ParseException{
// 和 bulkWrite()办法等价
collection.insertMany(documents);
}
2、删除操作
(1)、批量删除

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

collection.createIndex(new Document(“productId”, 1));
因为随着 collection 数据量的增大，查找将越耗时，增加索引是为了进步查找效率，进而放慢删除效率。另外，值得一提的是 DeleteOneModel 示意至少删除一条匹配条件的记录，DeleteManyModel 示意删除匹配条件的所有记录。为了避免一次删除多条记录，这里应用 DeleteOneModel，保障一个操作只删除一条记录。当然这里不可能匹配多条记录，因为_id 是惟一的。

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”));
// 结构删除单个文档的操作模型，
DeleteOneModel<Document> dom = new DeleteOneModel<Document>(queryDocument);
requests.add(dom);
}
BulkWriteResult bulkWriteResult = collection.bulkWrite(requests);
System.out.println(bulkWriteResult.toString());
}
测试：10 万条数据

System.out.println(“ 开始删除数据。。。”);
long startDelete = System.currentTimeMillis();
instance.bulkWriteDelete(documents);
System.out.println(“ 删除数据实现，共耗时：”+(System.currentTimeMillis() – startDelete)+” 毫秒 ”);
后果：2251 毫秒

(2)、逐条删除

来看看在非批量下的删除

public void deleteOneByOne(List<Document> documents){
for (Document document : documents) {
Document queryDocument = new Document(“_id”,document.get(“_id”));
DeleteResult deleteResult = collection.deleteOne(queryDocument);
}
}
测试：10 万条数据

System.out.println(“ 开始删除数据。。。”);
long startDelete = System.currentTimeMillis();
instance.deleteOneByOne(documents);
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。

Java 技术栈
专一分享 Java 技术干货，包含多线程、JVM、Spring Boot、Spring Cloud、Intellij IDEA、Dubbo、Zookeeper、Redis、架构设计、微服务、音讯队列、Git、面试题、程序员攻略、最新动静等。
489 篇原创内容
公众号
这里会有个纳闷：这和匹配到查问条件后执行替换操作后果不一样吗？区别在于_id 字段，未匹配查问条件时插入的新的 Document 的_id 是新的，而胜利执行替换操作，_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”));
// 更新内容，改下书的价格
Document updateDocument = new Document(“$set”,new Document(“price”,”30.6″));
// 结构更新单个文档的操作模型
UpdateOneModel<Document> uom = new UpdateOneModel<Document>(queryDocument,updateDocument,new UpdateOptions().upsert(false));
//UpdateOptions 代表批量更新操作未匹配到查问条件时的动作，默认 false，什么都不干，true 时示意将一个新的 Document 插入数据库，他是查问局部和更新局部的联合
requests.add(uom);
}
BulkWriteResult bulkWriteResult = collection.bulkWrite(requests);
System.out.println(bulkWriteResult.toString());
}
测试：10 万条数据

System.out.println(“ 开始更新数据。。。”);
long startUpdate = System.currentTimeMillis();
instance.bulkWriteUpdate(documents);
System.out.println(“ 更新数据实现，共耗时：”+(System.currentTimeMillis() – startUpdate)+” 毫秒 ”);
后果：3198 毫秒

(2)、逐条更新

比照非批量下的更新

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);
}
}
测试：10 万条数据

System.out.println(“ 开始更新数据。。。”);
long startUpdate = System.currentTimeMillis();
instance.updateOneByOne(documents);
System.out.println(“ 更新数据实现，共耗时：”+(System.currentTimeMillis() – startUpdate)+” 毫秒 ”);
后果：13979 毫秒，比批量更新效率低很多

4、混合批量操作
bulkWrite() 办法能够对不同类型的写操作进行批量解决，代码如下：

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()两个办法和 insertMany()不同，它俩不是批量操作，而是代表更新（删除）匹配条件的所有数据。

二、与 MySQL 性能比照
1、插入操作
(1)、批处理插入

与 MongoDB 一样，也是插入 Product 实体对象，代码如下

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 中的参数，这样也能提高效率，避免参数积攒过多事务超时，但理论测试成果不显著}
count++;

}
conn.commit();
} catch (SQLException e) {
e.printStackTrace();
}
DBUtil.closeConnection(conn);
}
JDBC 默认主动提交事务，切记在获取连贯后增加上面一行代码，敞开事务主动提交。

connection.setAutoCommit(false);
测试：10 万条数据

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, "书籍", "追风筝的人", 20.5);
            list.add(product);
        }

        System.out.println("MYSQL 开始插入数据。。。");
        long insertStart = System.currentTimeMillis();
        test.insertBatch(list);
        System.out.println("MYSQL 插入数据实现，共耗时："+(System.currentTimeMillis() - insertStart)+"毫秒");

}
后果：7389 毫秒，屡次测试根本 7 秒左右

(2)、逐条插入

再来看看 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();// 加上这句每次插入都提交事务，后果将是十分耗时

}
conn.commit();
} catch (SQLException e) {
e.printStackTrace();
}
DBUtil.closeConnection(conn);
}
测试：10 万条记录

System.out.println(“MYSQL 开始插入数据。。。”);
long insertStart = System.currentTimeMillis();
test.insertOneByOne(list);
System.out.println(“MYSQL 插入数据实现，共耗时：”+(System.currentTimeMillis() – insertStart)+” 毫秒 ”);
后果：8921 毫秒，根本比批量慢 1 秒多。

2、删除操作
(1)、批处理删除

删除的 where 条件是 productId，这里在建表的时候没有增加主键，删除异常的慢，查了半天不晓得什么起因。切记增加主键，主键默认有索引，所有能更快匹配到记录。

Java 技术栈
专一分享 Java 技术干货，包含多线程、JVM、Spring Boot、Spring Cloud、Intellij IDEA、Dubbo、Zookeeper、Redis、架构设计、微服务、音讯队列、Git、面试题、程序员攻略、最新动静等。
489 篇原创内容
公众号
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);
}
测试：10 万条数据。另外，MySQL 系列面试题和答案全副整顿好了，微信搜寻 Java 技术栈，在后盾发送：面试，能够在线浏览。

System.out.println(“MYSQL 开始删除数据。。。”);
long deleteStart = System.currentTimeMillis();
test.deleteBatch(list);
System.out.println(“MYSQL 删除数据实现，共耗时：”+(System.currentTimeMillis() – deleteStart)+” 毫秒 ”);
后果：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();// 加上这句每次插入都提交事务，后果将是十分耗时

}

conn.commit();
} catch (SQLException e) {
e.printStackTrace();
}
DBUtil.closeConnection(conn);
}
测试：10 万条数据

System.out.println(“MYSQL 开始删除数据。。。”);
long deleteStart = System.currentTimeMillis();
test.deleteOneByOne(list);
System.out.println(“MYSQL 删除数据实现，共耗时：”+(System.currentTimeMillis() – deleteStart)+” 毫秒 ”);
后果：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 中的参数，这样也能提高效率，避免参数积攒过多事务超时，但理论测试成果不显著}
count++;

}
conn.commit();
} catch (SQLException e) {
e.printStackTrace();
}
DBUtil.closeConnection(conn);
}
测试：10 万条数据

System.out.println(“MYSQL 开始更新数据。。。”);
long updateStart = System.currentTimeMillis();
test.updateBatch(list);
System.out.println(“MYSQL 更新数据实现，共耗时：”+(System.currentTimeMillis() – updateStart)+” 毫秒 ”);
后果：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();// 加上这句每次插入都提交事务，后果将是十分耗时

}
conn.commit();
} catch (SQLException e) {
e.printStackTrace();
}
DBUtil.closeConnection(conn);
}
测试：10 万条数据

System.out.println(“MYSQL 开始更新数据。。。”);
long updateStart = System.currentTimeMillis();
test.updateOneByOne(list);
System.out.println(“MYSQL 更新数据实现，共耗时：”+(System.currentTimeMillis() – updateStart)+” 毫秒 ”);
后果：9430 毫秒，比批处理更新慢了 1 秒左右。

关键词：前端培训

关于mongodb:MongoDB-vs-MySQL哪个效率更高

Just My Socks（注册教程 内含优惠码）

Just My Socks（注册教程内含优惠码）