Menu Docs
Página inicial do Docs
/
Idiomas
/
Java
/
Driver de fluxos reativos do Java

Gravar dados no MongoDB

Nesta página

  • Visão geral
  • insertOne
  • Inserir vários
  • UpdateOne
  • Atualizar vários
  • replaceOne
  • Excluir um
  • Excluir vários
  • Gravação em massa

Visão geral

Esta página contém exemplos de código copiáveis de métodos de driver do Java Reactive Streams que você pode usar para escrever dados no MongoDB.

Dica

Para saber mais sobre qualquer um dos métodos mostrados nesta página, consulte o link fornecido em cada seção.

Para usar um exemplo desta página, copie o exemplo de código para oaplicativo de amostra ou para seu próprio aplicativo. Certifique-se de substituir todos os espaços reservados nos exemplos de código, como <connection string>, pelos valores relevantes para sua implantação do MongoDB.

Este guia usa a biblioteca Project Reactor para consumir Publisher instâncias do retornadas pelos métodos de driver Java Reactive Streams. Para saber mais sobre a biblioteca do Projeto Reactor e como usá-la, consulte Introdução na documentação do Reactor.

Há também outras maneiras de consumir instâncias do Publisher . Você pode usar uma das muitas bibliotecas alternativas, como RxJava ou chame Publisher.subscribe() diretamente e passe sua própria implementação de um Subscriber.

Este guia usa o método Mono.block() do Reactor para assinar um Publisher e bloquear o thread atual até que o Publisher atinja seu estado de terminal. Para saber mais sobre a Iniciativa Reactive Streams, consulte Reactive Streams.

Importante

Os editores devolvidos estão frios

Todas as instâncias Publisher retornadas pelos métodos do driver Java Reactive Streams estão frios, o que significa que a operação correspondente não ocorrerá a menos que você assine o Publisher retornado. Recomendamos assinar apenas os Publisher retornados uma vez, porque assinar mais de uma vez pode levar a erros.

Você pode usar o seguinte aplicativo de exemplo para testar os exemplos de código nesta página. Para usar o aplicativo de amostra, execute as seguintes etapas:

  1. Crie um novo projeto Java no seu IDE.

  2. Instale o driver Java Reactive Streams em seu projeto Java .

  3. Instale a biblioteca do Project Reactor em seu projeto Java .

  4. Copie o código a seguir e cole-o em um novo arquivo Java chamado WriteOperations.java.

  5. Copie um exemplo de código desta página e cole-o nas linhas especificadas no arquivo.

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

Para saber mais sobre o método insertOne() , consulte o guia Inserir documentos .

Inserir vários

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

Para saber mais sobre o método insertMany() , consulte o guia Inserir documentos .

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

Para saber mais sobre o método updateOne() , consulte o guia Atualizar documentos .

Atualizar vários

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

Para saber mais sobre o método updateMany() , consulte o guia Atualizar documentos .

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

Para saber mais sobre o método replaceOne() , consulte o guia Substituir documentos .

Excluir um

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

Para saber mais sobre o método deleteOne() , consulte o guia Excluir documentos .

Excluir vários

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

Para saber mais sobre o método deleteMany() , consulte o guia Excluir documentos .

Gravação em massa

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

Voltar

reconhecimento de data center e collection

Próximo

Insert