导读
mongodb-java-driver是mongodb的Java驱动项目。
本文是对MongoDB-java-driver官方文档 MongoDB Async Driver Quick Tour 的翻译(原创翻译)。
mongodb-java-driver 从3.0版本开始同时支持同步、异步方式(分别是不同的驱动应用)。异步的好处,众所周知,就是支持快速、非阻塞式的IO操作,可以提高处理速度。
请注意:本文仅介绍异步驱动的使用指南。同步驱动官方文档:mongo-java-driver ,需要了解的朋友,请移驾。
安装
简单提下安装说明。
注:MongoDB 异步驱动需要依赖Netty 或 Java 7。
如果你的项目是maven项目,只需在pom.xml中添加如下依赖:
<dependencies>
<dependency>
<groupId>org.mongodb</groupId>
<artifactId>mongodb-driver-async</artifactId>
<version>3.3.0</version>
</dependency>
</dependencies>
你也可以点击链接直接下载jar包: 下载点这里 。
分割线,下面是 MongoDB Async Driver Quick Tour 的译文。
MongoDB 异步驱动快速指南
以下的代码片段来自于 async driver source 的范例代码 QuickTour.java
。
注意
如何安装MongoDB异步驱动请参考 安装指导 。
执行异步回调
MongoDB异步驱动利用Netty或Java7的AsynchronousSocketChannel
来提供一个支持异步的API,以支持快速的、非阻塞式的IO操作。
该API形式和MongoDB同步驱动的新API保持一致,但是任何会导致网络IO的方法都会有一个SingleResponseCallback
并且会立即返回,其中T
是响应对于该文档的类型的任何方法。
SingleResponseCallback
回调接口需要实现一个简单方法onResult(T result, Throwable t)
,这个方法在操作完成时被调用。其中,如果操作成功, result
参数包含着操作结果;如果操作失败,t
中包含着抛出的异常信息。
重要
在SingleResponseCallback
的实现中检查错误并适当处理错误是十分重要的。下面的错误检查仅为简便起见而省略。
创建一个连接
下面的例子展示多种方法去链接本地机器上的mydb
数据库。详情参考 MongoClients.create
API手册。
// 直接连接默认服务host和端口,即 localhost:27017
MongoClient mongoClient = MongoClients.create();
// 使用一个字符串
MongoClient mongoClient = MongoClients.create("mongodb://localhost");
// 使用一个ConnectionString
MongoClient mongoClient = MongoClients.create(new ConnectionString("mongodb://localhost"));
// 使用MongoClientSettings
ClusterSettings clusterSettings = ClusterSettings.builder().hosts(asList(new ServerAddress("localhost"))).build();
MongoClientSettings settings = MongoClientSettings.builder().clusterSettings(clusterSettings).build();
MongoClient mongoClient = MongoClients.create(settings);
MongoDatabase database = mongoClient.getDatabase("mydb");
此时,database
对象是一个MongoDB 服务器中指定数据库的连接。
注意
getDatabase("mydb")
方法并没有回调,因为它没有涉及网络IO操作。一个 MongoDatabase
实例提供了与数据库进行交互的方法,若数据库不存在,它会在插入数据时创建一个新的数据库。例如,创建一个 collection 或插入 document(这些确实需要回调,因为需要涉及网络IO)。
MongoClient
MongoClient
实例实际上代表了一个数据库的连接池;即使要并发执行异步操作,你也仅仅需要一个 MongoClient
实例。
重要
一般情况下,在一个指定的数据库集群中仅需要创建一个MongoClient
实例,并通过你的应用使用它。
当创建多个实例时:
- 所有的资源使用限制(例如最大连接数)适用于每个
MongoClient
实例 - 销毁实例时,请确保调用
MongoClient.close()
清理资源。
获得一个 collection
要获得一个 collection ,你需要在 getCollection(String collectionName)
方法中指定 collection 的名字:
下面的例子获得名为 test
的collection :
MongoCollection<Document> collection = database.getCollection("test");
添加一个 document
一旦你有了collection对象,你就可以向collection中插入document。例如,考虑如下的json形式document;document中含包含了一个名为 info
的子document。
{
"name" : "MongoDB",
"type" : "database",
"count" : 1,
"info" : {
x : 203,
y : 102
}
}
要创建document,需要使用 Document 类。你可以使用这个类来创建嵌入式的document。
Document doc = new Document("name", "MongoDB")
.append("type", "database")
.append("count", 1)
.append("info", new Document("x", 203).append("y", 102));
要向 collection 中插入 document ,需要使用 insertOne()
方法。
collection.insertOne(doc, new SingleResultCallback<Void>() {
@Override
public void onResult(final Void result, final Throwable t) {
System.out.println("Inserted!");
}
});
SingleResponseCallback
是一个 函数式接口 并且它可以以lambda方式实现(前提是你的APP工作在JDK8):
collection.insertOne(doc, (Void result, final Throwable t) -> System.out.println("Inserted!"));
一旦document成功插入,onResult 回调方法会被调用并打印“Inserted!”。记住,在一个普通应用中,你应该总是检查 t
变量中是否有错误信息。
添加多个 document
要添加多个 documents,你可以使用 insertMany()
方法。
接下来的例子会添多个document,document形式如下:
{ "i" : value }
循环创建多个 documents 。
List<Document> documents = new ArrayList<Document>();
for (int i = 0; i < 100; i++) {
documents.add(new Document("i", i));
}
要插入多个 document 到 collection,传递 documents 列表到 insertMany()
方法.
collection.insertMany(documents, new SingleResultCallback<Void>() {
@Override
public void onResult(final Void result, final Throwable t) {
System.out.println("Documents inserted!");
}
});
统计一个 collection的document数量
既然前面的多个例子中我们已经插入了 101 个 document,我们可以检查一下插入数量,使用 count()
方法。下面的代码应该打印 101
。
collection.count(
new SingleResultCallback<Long>() {
@Override
public void onResult(final Long count, final Throwable t) {
System.out.println(count);
}
});
查询 collection
使用 find()
方法来查询 collection。
在一个 collection 中找到第一个 document
要获得 collection 中的第一个 document ,需要调用 first()
方法。collection.find().first()
返回第一个 document 或 null 值,而不是一个游标。这种查询适用于匹配一个单一的 document,,或你仅对第一个 document 有兴趣。
注意
有时你需要多次使用相同或相似的回调方法。在这种情况下,合理的做法是DRY(不要重复自己):把回调保存为一个具体的类或分配给一个变量。
SingleResultCallback<Document> printDocument = new SingleResultCallback<Document>() {
@Override
public void onResult(final Document document, final Throwable t) {
System.out.println(document.toJson());
}
};
下面的例子传递 printDocument
回调给 first
方法:
collection.find().first(printDocument);
范例会打印下面的 document:
{ "_id" : { "$oid" : "551582c558c7b4fbacf16735" },
"name" : "MongoDB", "type" : "database", "count" : 1,
"info" : { "x" : 203, "y" : 102 } }
注意
_id
元素会被MongoDB动态的添加到你的 document 上,并且值也会与展示的不同。“_” 和 “$”开头的域是MongoDB 预留给内部使用的。
遍历查找一个collection中所有的 document
要检索 collection 中所有的 document,需要使用 find()
方法。find() 方法返回一个 FindIterable
实例,它提供了一个接口来链接和控制查找操作。使用 forEach()
方法可以提供一个 Block
作用于每个 document 并且迭代结束时执行回调一次。下面的代码遍历 collection 中所有的 document 并逐一打印,最后打印 “Operation Finished!”。
Block<Document> printDocumentBlock = new Block<Document>() {
@Override
public void apply(final Document document) {
System.out.println(document.toJson());
}
};
SingleResultCallback<Void> callbackWhenFinished = new SingleResultCallback<Void>() {
@Override
public void onResult(final Void result, final Throwable t) {
System.out.println("Operation Finished!");
}
};
collection.find().forEach(printDocumentBlock, callbackWhenFinished);
通过查询条件获得一个 document
我们可以创建一个过滤器传递给 find() 方法,以获得我们 collection 中的一组子集。例如,如果我们想查找 key为“i” ,value为71 的 document,我们要按下面的方法做(重用 printDocument
回调)。
import static com.mongodb.client.model.Filters.*;
collection.find(eq("i", 71)).first(printDocument);
最终会只印一个 document:
{ "_id" : { "$oid" : "5515836e58c7b4fbc756320b" }, "i" : 71 }
重要
请使用 Filters
、Sorts
、Projections
和 Updates
API手册来找到简单、清晰的方法构建查询。
通过查询获得一组 documents
我们可以使用查询来从我们的 collection 中获得一组 document 集合。例如,如果我们想获得所有 key 为“i”,value 大于50 的 document ,我们应该按下面方式做(重用 printDocumentBlock
阻塞和 callbackWhenFinished
回调):
// 使用范围查询获取子集
collection.find(gt("i", 50)).forEach(printDocumentBlock, callbackWhenFinished);
范例应该会打印所有 i > 50
的document。
我们也可以增加上限范围,如 50 < i <= 100
:
collection.find(and(gt("i", 50), lte("i", 100))).forEach(printDocumentBlock, callbackWhenFinished);
document 排序
我们可以对 document 进行排序。通过在 FindIterable
上调用 sort()
方法,我们可以在一个查询上进行一次排序。
下面的例子中,我们使用 exists()
和 降序排序 descending("i")
来为我们的 document 排序。
collection.find(exists("i")).sort(descending("i")).first(printDocument);
投射域
有时我们不需要将所有的数据都存在一个 document 中。Projections 可以用来为查询操作构建投射参数并限制返回的字段。
下面的例子中,我们会对collection进行排序,排除 _id
字段,并输出第一个匹配的 document。
collection.find().projection(excludeId()).first(printDocument);
聚合
有时,我们需要将存储在 MongoDB 中的数据聚合。 Aggregates
支持对每种类型的聚合阶段进行构建。
下面的例子,我们执行一个两步骤的转换来计算 i * 10
的值。首先我们使用 Aggregates.match
查找所有 i > 0
的document 。接着,我们使用 Aggregates.project
结合 $multiply
操作来计算 “ITimes10
” 的值。
collection.aggregate(asList(
match(gt("i", 0)),
project(Document.parse("{ITimes10: {$multiply: ['$i', 10]}}")))
).forEach(printDocumentBlock, callbackWhenFinished);
For $group
operations use the Accumulators
helper for any accumulator operations.
对于 $group
操作使用 Accumulators
来处理任何 累加操作 。
下面的例子中,我们使用 Aggregates.group
结合 Accumulators.sum
来累加所有 i
的和。
collection.aggregate(singletonList(group(null, sum("total", "$i")))).first(printDocument);
注意
当前,还没有专门用于 聚合表达式 的工具类。可以使用 Document.parse()
来快速构建来自于JSON的聚合表达式。
更新 document
MongoDB 支持许多的 更新操作 。
要更新至多一个 document (可能没有匹配的document),使用 updateOne
方法指定过滤器并更新 document 。这里,我们使用 Updates.set
来更新匹配过滤器 i
等于 10 的第一个 document 并设置 i
的值为 110。
collection.updateOne(eq("i", 10), set("i", 110),
new SingleResultCallback<UpdateResult>() {
@Override
public void onResult(final UpdateResult result, final Throwable t) {
System.out.println(result.getModifiedCount());
}
});
使用 updateMany
方法可以更新所有匹配过滤器的 document 。这里我们使用 Updates.inc
来为所有 i
小于 100 的document 增加 100 。
collection.updateMany(lt("i", 100), inc("i", 100),
new SingleResultCallback<UpdateResult>() {
@Override
public void onResult(final UpdateResult result, final Throwable t) {
System.out.println(result.getModifiedCount());
}
});
更新方法返回一个 UpdateResult
,其中包含了操作的信息(被修改的 document 的数量)。
删除 document
要删除至多一个 document (可能没有匹配的document)可以使用 deleteOne
方法。
collection.deleteOne(eq("i", 110), new SingleResultCallback<DeleteResult>() {
@Override
public void onResult(final DeleteResult result, final Throwable t) {
System.out.println(result.getDeletedCount());
}
});
使用 deleteMany
方法可以删除所有匹配过滤器的 document 。这里我们删除所有 i
大于等于的 document。
collection.deleteMany(gte("i", 100), new SingleResultCallback<DeleteResult>() {
@Override
public void onResult(final DeleteResult result, final Throwable t) {
System.out.println(result.getDeletedCount());
}
});
删除方法返回一个 DeleteResult
,其中包含了操作的信息(被删除的 document 的数量)。
批量操作
批量操作允许批量的执行 插入、更新、删除操作。批量操作有两种类型:
有序的批量操作
有序的执行所有操作并在第一个写操作的错误处报告错误。
无序的批量操作
执行所有的操作并报告任何错误。
无序的批量操作不保证执行顺序。
我们来围观一下两个分别使用有序和无序操作的简单例子:
SingleResultCallback<BulkWriteResult> printBatchResult = new SingleResultCallback<BulkWriteResult>() {
@Override
public void onResult(final BulkWriteResult result, final Throwable t) {
System.out.println(result);
}
};
// 2. 有序批量操作
collection.bulkWrite(
Arrays.asList(new InsertOneModel<>(new Document("_id", 4)),
new InsertOneModel<>(new Document("_id", 5)),
new InsertOneModel<>(new Document("_id", 6)),
new UpdateOneModel<>(new Document("_id", 1),
new Document("$set", new Document("x", 2))),
new DeleteOneModel<>(new Document("_id", 2)),
new ReplaceOneModel<>(new Document("_id", 3),
new Document("_id", 3).append("x", 4))),
printBatchResult
);
// 2. 无序批量操作
collection.bulkWrite(
Arrays.asList(new InsertOneModel<>(new Document("_id", 4)),
new InsertOneModel<>(new Document("_id", 5)),
new InsertOneModel<>(new Document("_id", 6)),
new UpdateOneModel<>(new Document("_id", 1),
new Document("$set", new Document("x", 2))),
new DeleteOneModel<>(new Document("_id", 2)),
new ReplaceOneModel<>(new Document("_id", 3),
new Document("_id", 3).append("x", 4))),
new BulkWriteOptions().ordered(false),
printBatchResult
);
重要
不推荐在pre-2.6的MongoDB 服务器上使用 bulkWrite
方法。因为这是第一个支持批量写操作(插入、更新、删除)的服务器版本,它允许驱动去实现 BulkWriteResult
和 BulkWriteException
的语义。这个方法虽然仍然可以在pre-2.6服务器上工作,但是性能不好,一次只能执行一个写操作。