Docs 菜单
Docs 主页
/
语言
/
Java
/
Java Reactive Streams 驱动程序

将数据写入 MongoDB

在此页面上

  • Overview
  • insertOne
  • 插入多个
  • updateOne
  • 更新多个
  • replaceOne
  • deleteOne
  • 删除多个
  • 批量写入

Overview

本页包含Java Reactive Streams驾驶员方法的可复制代码示例，您可以使用这些方法将数据写入MongoDB。

提示

要了解有关此页面上显示的任何方法的更多信息，请参阅每个部分中提供的链接。

要使用本页中的示例，请将代码示例复制到示例应用程序或您自己的应用程序中。 请务必将代码示例中的所有占位符（例如 <connection string> ）替换为 MongoDB 部署的相关值。

本指南使用 Project ReactorPublisher 库来使用Java Reactive Streams驾驶员方法返回的 实例。要学习；了解有关 Project Reactor 库及其使用方法的更多信息，请参阅 Reactor 文档中的“入门” 。

还有其他方法可以使用Publisher实例。 您可以使用许多替代库之一，例如 RxJava 或直接调用Publisher.subscribe() 并传递您自己的Subscriber 实施。

本指南使用 Reactor 中的Mono.block()方法订阅Publisher并区块当前线程，直到Publisher达到其终止状态。 要学习；了解有关 Reactive Streams 计划的更多信息，请参阅 Reactive Streams。

重要

返回的发布者处于冷状态

Java Reactive Streams驾驶员方法返回的所有Publisher实例都是冷实例，这意味着除非您订阅返回的Publisher ，否则不会发生相应的操作。 我们建议仅订阅返回的Publisher一次，因为订阅多次可能会导致错误。

您可以使用以下示例应用程序来测试本页上的代码示例。 要使用示例应用程序，请执行以下步骤：

  1. 在 IDE 中创建一个新的Java项目。

  2. 在Java项目中安装Java Reactive Streams驾驶员。

  3. 安装 Project Reactor 库 在您的Java项目中。

  4. 复制以下代码并将其粘贴到名为WriteOperations.java的新Java文件中。

  5. 从此页面复制代码示例，并将其粘贴到文件中的指定行。

1import com.mongodb.MongoException;
2import com.mongodb.ConnectionString;
3import com.mongodb.MongoClientSettings;
4import com.mongodb.ServerApi;
5import com.mongodb.ServerApiVersion;
6import com.mongodb.bulk.BulkWriteResult;
7
8import com.mongodb.client.model.DeleteOneModel;
9import com.mongodb.client.model.InsertOneModel;
10import com.mongodb.client.model.ReplaceOneModel;
11import com.mongodb.client.model.UpdateOneModel;
12import com.mongodb.client.model.DeleteOptions;
13import com.mongodb.client.model.InsertManyOptions;
14import com.mongodb.client.model.InsertOneOptions;
15import com.mongodb.client.model.UpdateOptions;
16import com.mongodb.client.model.Updates;
17import com.mongodb.client.result.UpdateResult;
18import com.mongodb.client.result.DeleteResult;
19import com.mongodb.client.result.InsertManyResult;
20import com.mongodb.client.result.InsertOneResult;
21import com.mongodb.reactivestreams.client.MongoCollection;
22
23import org.bson.Document;
24
25import com.mongodb.reactivestreams.client.MongoClient;
26import com.mongodb.reactivestreams.client.MongoClients;
27import com.mongodb.reactivestreams.client.MongoDatabase;
28import reactor.core.publisher.Mono;
29
30import java.util.ArrayList;
31import java.util.Arrays;
32import java.util.List;
33
34import static com.mongodb.client.model.Filters.eq;
35import static com.mongodb.client.model.Updates.set;
36
37class WriteOperations {
38    public static void main(String[] args) throws InterruptedException {
39        // Replace the placeholder with your Atlas connection string
40        String uri = "<connection string>";
41
42        // Construct a ServerApi instance using the ServerApi.builder() method
43        ServerApi serverApi = ServerApi.builder()
44                .version(ServerApiVersion.V1)
45                .build();
46
47        MongoClientSettings settings = MongoClientSettings.builder()
48                .applyConnectionString(new ConnectionString(uri))
49                .serverApi(serverApi)
50                .build();
51        
52        // Create a new client and connect to the server
53        try (MongoClient mongoClient = MongoClients.create(settings)) {
54            MongoDatabase database = mongoClient.getDatabase("<database name>");
55            MongoCollection<Document> collection = database.getCollection("<collection name>");
56            // Start example code here
57
58            // End example code here
59        }
60    }
61}

insertOne

Document document = new Document("<field name>", "<value>");
Publisher<InsertOneResult> insertOnePublisher = collection.insertOne(document);
InsertOneResult result = Mono.from(insertOnePublisher).block();
System.out.printf("Inserted 1 document with ID %s.", 
      result.getInsertedId());

要学习；了解有关insertOne()方法的更多信息，请参阅插入文档指南。

插入多个

Document doc1 = new Document("<field name>", "<value>");
Document doc2 = new Document("<field name>", "<value>");
List<Document> documents = Arrays.asList(doc1, doc2);
Publisher<InsertManyResult> insertManyPublisher = collection.insertMany(documents);
InsertManyResult result = Mono.from(insertManyPublisher).block();
System.out.printf("Inserted documents with IDs %s.",
      result.getInsertedIds());

要了解有关insertMany()方法的更多信息，请参阅“插入文档”指南。

updateOne

Publisher<UpdateResult> updateOnePublisher = collection.updateOne(
      eq("<field name>", "<value>"),
      set("<field name>", "<new value>"));
UpdateResult result = Mono.from(updateOnePublisher).block();
System.out.printf("Updated %s document.",
      result.getModifiedCount());

要了解有关updateOne()方法的更多信息，请参阅更新文档指南。

更新多个

Publisher<UpdateResult> updateManyPublisher = collection.updateMany(
        eq("<field name>", "<value>"),
        set("<field name>", "<new value>"));
UpdateResult result = Mono.from(updateManyPublisher).block();
System.out.printf("Updated %s documents.",
      result.getModifiedCount());

要了解有关updateMany()方法的更多信息，请参阅更新文档指南。

replaceOne

Publisher<UpdateResult> replaceOnePublisher = collection.replaceOne(
        eq("<field name>", "<value>"),
        new Document().append("<field name>", "<new value>")
                .append("<new field name>", "<new value>"));
UpdateResult result = Mono.from(replaceOnePublisher).block();
System.out.printf("Replaced %s document.",
      result.getModifiedCount());

要了解有关replaceOne()方法的更多信息，请参阅替换文档指南。

deleteOne

Publisher<DeleteResult> deleteOnePublisher = collection.deleteOne(
        eq("<field name>", "<value>"));
DeleteResult result = Mono.from(deleteOnePublisher).block();
System.out.printf("Deleted %s document.", result.getDeletedCount());

要了解有关deleteOne()方法的更多信息，请参阅“删除文档”指南。

删除多个

Publisher<DeleteResult> deleteManyPublisher = collection.deleteMany(
        eq("<field name>", "<value>"));
DeleteResult result = Mono.from(deleteManyPublisher).block();
System.out.printf("Deleted %s documents.", result.getDeletedCount());

要了解有关deleteMany()方法的更多信息，请参阅“删除文档”指南。

批量写入

Publisher<BulkWriteResult> bulkWritePublisher = collection.bulkWrite(
        Arrays.asList(new InsertOneModel<>(
                        new Document("<field name>", "<value>")),
                new InsertOneModel<>(new Document("<field name>", "<value>")),
                new UpdateOneModel<>(eq("<field name>", "<value>"),
                        set("<field name>", "<new value>")),
                new DeleteOneModel<>(eq("<field name>", "<value>")),
                new ReplaceOneModel<>(eq("<field name>", "<value>"),
                        new Document("<field name>", "<new value>")
                                .append("<new field name>", "<new value>"))));
BulkWriteResult bulkResult = Mono.from(bulkWritePublisher).block();
System.out.printf("Modified %s documents and deleted %s documents.",
      bulkResult.getModifiedCount(), bulkResult.getDeletedCount());

后退

数据库和collection

来年

Insert