Docs Menu
Docs Home
/ /
Driver de Java Reactive Streams
Docs Home
/
Librerías de clientes
/
Java
/
Driver de Java Reactive Streams
Docs Home
/
Librerías de clientes
/
Java
/
Driver de Java Reactive Streams

Escribe datos en MongoDB

Overview

Esta página contiene ejemplos de código copiables de métodos de controlador Java Reactive Streams que puede utilizar para escribir datos en MongoDB.

Tip

Para obtener más información sobre cualquiera de los métodos que se muestran en esta página, consulte el enlace proporcionado en cada sección.

Para utilizar un ejemplo de esta página, copie el ejemplo de código en el Aplicación de ejemplo o su propia aplicación. Asegúrese de reemplazar todos los marcadores de posición en los ejemplos de código, como <connection string>, con los valores relevantes para su implementación de MongoDB.

Esta guía utiliza la biblioteca Project Reactor para consumir Publisher las instancias devueltas por los métodos del controlador Java Reactive Streams. Para obtener más información sobre la biblioteca Project Reactor y cómo usarla, consulte la sección "Introducción" en la documentación de Reactor.

También hay otras formas de consumir Publisher instancias. Puedes usar una de las muchas bibliotecas alternativas, como RxJava, o llamar Publisher.subscribe() directamente a y pasar tu propia implementación de Subscriber un.

Esta guía utiliza el Mono.block() método de Reactor para suscribirse a un Publisher y bloquear el hilo actual hasta que el Publisher alcance su estado terminal. Para obtener más información sobre la iniciativa Reactive Streams, consulte Reactive Streams.

Importante

Los editores que regresaron son fríos

Todas las instancias de Publisher devueltas por los métodos del controlador de Java Reactive Streams son frías, lo que significa que la operación correspondiente no ocurre a menos que se suscriba al Publisher devuelto. Recomendamos suscribirse solo una vez al Publisher devuelto, porque suscribirse más de una vez puede provocar errores.

Puede utilizar la siguiente aplicación de muestra para probar los ejemplos de código en esta página. Para usar la aplicación de muestra, siga los siguientes pasos:

  1. Crea un nuevo proyecto Java en tu IDE.

  2. Instale el controlador Java Reactive Streams en su proyecto Java.

  3. Instale la biblioteca Project Reactor en su proyecto Java.

  4. Copie el siguiente código y péguelo en un nuevo archivo Java llamado WriteOperations.java.

  5. Copia un ejemplo de código de esta página y pégalo en las líneas especificadas del archivo.

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}

Inserte uno

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 obtener más información sobre el método insertOne(), consulte la Guía deinserción de documentos.

Insertar múltiples

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 obtener más información sobre el método insertMany(), consultar la guía Insertar Documentos.

Actualiza uno

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 obtener más información sobre el método updateOne(), consulte la Guía para actualizar documentos.

Actualiza múltiples

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 obtener más información sobre el método updateMany(), consulte la Guía para actualizar documentos.

Reemplace uno

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 aprender más sobre el método replaceOne(), consulta la guía Reemplazar Documentos.

deleteOne

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

Para obtener más información sobre el método deleteOne(), consulta la guía Borrar Documentos.

Borrar múltiples

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

Para obtener más información sobre el método deleteMany(), consulta la guía Borrar Documentos.

Guardado masivo

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

Volver

Bases de datos y colecciones

Next

Insert

En esta página