将数据写入 MongoDB

1
import com.mongodb.MongoException;
2
import com.mongodb.ConnectionString;
3
import com.mongodb.MongoClientSettings;
4
import com.mongodb.ServerApi;
5
import com.mongodb.ServerApiVersion;
6
import com.mongodb.bulk.BulkWriteResult;
7
8
import com.mongodb.client.model.DeleteOneModel;
9
import com.mongodb.client.model.InsertOneModel;
10
import com.mongodb.client.model.ReplaceOneModel;
11
import com.mongodb.client.model.UpdateOneModel;
12
import com.mongodb.client.model.DeleteOptions;
13
import com.mongodb.client.model.InsertManyOptions;
14
import com.mongodb.client.model.InsertOneOptions;
15
import com.mongodb.client.model.UpdateOptions;
16
import com.mongodb.client.model.Updates;
17
import com.mongodb.client.result.UpdateResult;
18
import com.mongodb.client.result.DeleteResult;
19
import com.mongodb.client.result.InsertManyResult;
20
import com.mongodb.client.result.InsertOneResult;
21
import com.mongodb.reactivestreams.client.MongoCollection;
22
23
import org.bson.Document;
24
25
import com.mongodb.reactivestreams.client.MongoClient;
26
import com.mongodb.reactivestreams.client.MongoClients;
27
import com.mongodb.reactivestreams.client.MongoDatabase;
28
import reactor.core.publisher.Mono;
29
30
import java.util.ArrayList;
31
import java.util.Arrays;
32
import java.util.List;
33
34
import static com.mongodb.client.model.Filters.eq;
35
import static com.mongodb.client.model.Updates.set;
36
37
class 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
}

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());

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());

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());

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());

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());

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

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

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());