/ /

Empezar

Docs Home

/ /

Driver de Java Reactive Streams

Driver de Java Reactive Streams

Empezar

Inicio rápido

Esta versión de la documentación está archivada y ya no se admite. Ver la Documentación actual para aprender cómo actualizar su versión del controlador Java Reactive Streams.

Los ejemplos de código de esta guía provienen de QuickTour.java archivo en el repositorio de código fuente del controlador de GitHub.

Nota

Para obtener instrucciones sobre cómo instalar el controlador Java Reactive Streams, consulte la Guía de instalación.

Importante

Esta guía utiliza el Subscriber implementaciones, que se describen en la Guía de inicio rápido.

Requisitos previos

Debe configurar los siguientes componentes para ejecutar los ejemplos de código de esta guía:

Servidor MongoDB ejecutándose en el puerto predeterminado para MongoDB (27017)
Dependencia del controlador instalada en su proyecto

Las siguientes declaraciones de importación:

import com.mongodb.bulk.BulkWriteResult;
import com.mongodb.client.model.BulkWriteOptions;
import com.mongodb.client.model.DeleteOneModel;
import com.mongodb.client.model.InsertOneModel;
import com.mongodb.client.model.ReplaceOneModel;
import com.mongodb.client.model.UpdateOneModel;
import com.mongodb.client.model.WriteModel;
import com.mongodb.client.result.InsertOneResult;
import com.mongodb.client.result.InsertManyResult;
import com.mongodb.client.result.DeleteResult;
import com.mongodb.client.result.UpdateResult;
import com.mongodb.reactivestreams.client.MongoClient;
import com.mongodb.reactivestreams.client.MongoClients;
import com.mongodb.reactivestreams.client.MongoCollection;
import com.mongodb.reactivestreams.client.MongoDatabase;
import org.bson.Document;
import java.util.ArrayList;
import java.util.List;
import static com.mongodb.client.model.Accumulators.*;
import static com.mongodb.client.model.Aggregates.*;
import static com.mongodb.client.model.Filters.*;
import static com.mongodb.client.model.Projections.*;
import static com.mongodb.client.model.Sorts.*;
import static com.mongodb.client.model.Updates.*;
import static java.util.Arrays.asList;
import static java.util.Collections.singletonList;

Establezca una conexión

Utilice el método MongoClients.create() para establecer una conexión a una implementación de MongoDB en ejecución.

La instancia MongoClient representa un conjunto de conexiones a la base de datos. Solo se necesita una instancia de MongoClient, incluso al usar subprocesos de operaciones concurrentes.

Importante

Normalmente, se crea solo una instancia MongoClient para una implementación de MongoDB, como una implementación independiente, un conjunto de réplicas o un clúster fragmentado, y se usa el cliente en toda la aplicación. Sin embargo, si crea varias instancias, tenga en cuenta lo siguiente:

Todos los límites de uso de recursos (por ejemplo, conexiones máximas) se aplican a cada instancia MongoClient.
Para eliminar una instancia, llame al método MongoClient.close() para limpiar recursos.

Conectarse a una única implementación de MongoDB

El siguiente ejemplo muestra varias formas de conectarse a una única implementación de MongoDB.

Puede conectarse a una única implementación de MongoDB de las siguientes maneras:

Cree una instancia de un objeto MongoClient sin ningún parámetro para conectarse a un servidor MongoDB que se ejecuta en el host local en el puerto 27017:
```
MongoClient mongoClient = MongoClients.create();
```

Especifique explícitamente hostname para conectarse a una instancia de MongoDB que se ejecuta en el host especificado en el puerto 27017:

MongoClient mongoClient = MongoClients.create(
   MongoClientSettings.builder()
       .applyToClusterSettings(builder ->
           builder.hosts(Arrays.asList(new ServerAddress("hostOne"))))
       .build());

Especifique explícitamente el hostname y el port:

MongoClient mongoClient = MongoClients.create(
   MongoClientSettings.builder()
       .applyToClusterSettings(builder ->
           builder.hosts(Arrays.asList(new ServerAddress("hostOne", 27018))))
       .build());

Especifique ConnectionString:
```
MongoClient mongoClient = MongoClients.create("mongodb://hostOne:27017");
```

Acceder a una base de datos

Una vez que tenga una instancia MongoClient conectada a una implementación de MongoDB, use el método MongoClient.getDatabase() para acceder a una base de datos.

Especifique el nombre de la base de datos en el método getDatabase(). Si no existe una base de datos, MongoDB la crea al almacenar datos de ella por primera vez.

El siguiente ejemplo accede a la base de datos mydb:

MongoDatabase database = mongoClient.getDatabase("mydb");

MongoDatabase Las instancias son inmutables.

Acceder a una colección

Una vez que tengas una instancia MongoDatabase, utiliza el método getCollection()` para acceder a una colección.

Especifique el nombre de la colección en el método getCollection(). Si no existe una colección, MongoDB la crea al almacenar los datos de esa colección por primera vez.

Por ejemplo, utilizando la instancia de base de datos, la siguiente declaración accede a la colección denominada test en la base de datos mydb:

MongoCollection<Document> collection = database.getCollection("test");

MongoCollection Las instancias son inmutables.

Crear un documento

Para crear el documento utilizando el controlador, utilice la clase Document.

Por ejemplo, considere el siguiente documento JSON:

{
   "name" : "MongoDB",
   "type" : "database",
   "count" : 1,
   "versions": [ "v3.2", "v3.0", "v2.6" ],
   "info" : { x : 203, y : 102 }
}

Para crear el documento con el controlador, cree una instancia de un objeto Document con un campo y un valor, y utilice su método append() para añadir campos y valores adicionales al objeto de documento. El valor puede ser otro objeto Document para especificar un documento incrustado:

Document doc = new Document("name", "MongoDB")
    .append("type", "database")
    .append("count", 1)
    .append("versions", Arrays.asList("v3.2", "v3.0", "v2.6"))
    .append("info", new Document("x", 203).append("y", 102));

Nota

El tipo BSON de una matriz corresponde al tipo java.util.List de Java. Para obtener una lista de los tipos BSON y sus correspondientes tipos en Java, consulte la asignación Document.

Insertar un documento

Una vez que tengas el objeto MongoCollection, puedes insertar documentos en la colección.

Inserta un documento

Para insertar un solo documento en una colección, puede utilizar el método insertOne().

var subscriber = new OperationSubscriber<InsertOneResult>();
collection.insertOne(doc).subscribe(subscriber);
// Wait for the insertOne operation to complete
subscriber.await();

Nota

Si no se especifica ningún campo _id de nivel superior en el documento, MongoDB genera automáticamente un valor y añade este campo al documento insertado.

Importante

En la API, todos los métodos que devuelven una instancia Publisher son flujos fríos, lo que significa que no sucede nada hasta que se suscriben a ellos.

Por ejemplo, el siguiente ejemplo no hace nada:

Publisher<InsertOneResult> publisher = collection.insertOne(doc);

La operación solo ocurre cuando se suscribe a un Publisher y se solicitan datos.

publisher.subscribe(new Subscriber<InsertOneResult>() {
    @Override
    public void onSubscribe(final Subscription s) {
        s.request(1);  // <--- Data requested and the insertion will now occur
    }
    @Override
    public void onNext(final InsertOneResult result) {
        System.out.println("Inserted: " + result);
    }
    @Override
    public void onError(final Throwable t) {
        System.out.println("Failed");
    }
    @Override
    public void onComplete() {
        System.out.println("Completed");
    }
});

Una vez que se haya insertado el documento, se llama al método onNext() e imprime Inserted: seguido del resultado. Por último, el método onComplete() imprime Completed. Si se produjera un error por cualquier motivo, el método onError() imprimiría Failed.

Inserta varios documentos

Para insertar varios documentos, puede utilizar el método insertMany() de la colección, que toma una lista de documentos para insertar.

El siguiente ejemplo agrega varios documentos en el siguiente formato:

{ "i" : value }

Crea los documentos en un bucle y agrégalos a la lista documents:

List<Document> documents = new ArrayList<Document>();
for (int i = 0; i < 100; i++) {
    documents.add(new Document("i", i));
}

Para insertar estos documentos en la colección, pase la lista de documentos al método insertMany():

var subscriber = new OperationSubscriber<InsertManyResult>();
collection.insertMany(documents).subscribe(subscriber);
// Wait for the insertMany operation to complete
subscriber.await();

El ejemplo anterior bloquea en el Publisher hasta que termine. Esto garantiza que los datos estén en la base de datos antes de que se ejecute la siguiente operación.

Contar documentos en una colección

Para contar el número de documentos en una colección, puede usar el método countDocuments() de la colección. El siguiente código debe mostrar 101, describiendo los 100 documentos insertados con insertMany() y los 1 insertados con insertOne().

collection.count()
    .subscribe(new PrintSubscriber<Long>("total # of documents: %s"));

Consulta de la colección

Para consultar la colección, puede usar el método find(). Puede llamarlo sin argumentos para consultar todos los documentos de una colección o aplicar un filtro para buscar documentos que cumplan los criterios de filtrado.

Encuentra el primer documento de una colección

Para devolver el primer documento de la colección, utilice el método find() sin ningún parámetro y encadene el método first().

Tip

La construcción find().first() es útil para consultas que solo deben coincidir con un único documento o si solo está interesado en el primer documento coincidente.

El siguiente ejemplo imprime el primer documento encontrado en la colección:

collection.find().first().subscribe(new PrintDocumentSubscriber());

El ejemplo debería imprimir el siguiente documento:

{
  "_id" : { "$oid" : "551582c558c7b4fbacf16735" },
  "name" : "MongoDB",
  "type" : "database",
  "count" : 1,
  "info" : { "x" : 203, "y" : 102 }
}

Nota

MongoDB agregó automáticamente el elemento _id a su documento y su valor será diferente al mostrado. MongoDB reserva los nombres de campo que empiezan por _ y $ para uso interno.

Encuentre todos los documentos en una colección

Para recuperar todos los documentos de la colección, utilice el método find(). El método find() devuelve una instancia FindPublisher que proporciona una interfaz fluida para encadenar o controlar operaciones de búsqueda. El siguiente código recupera e imprime todos los documentos de la colección:

collection.find().subscribe(new PrintDocumentSubscriber());

Especificar un filtro de consulta

Para consultar documentos que cumplan ciertas condiciones, pase un objeto de filtro al método find(). Para facilitar la creación de objetos de filtro, el controlador proporciona métodos auxiliares Filters.

Obtener un solo documento que coincida con un filtro

Para encontrar el primer documento en el que el campo i tiene el valor 71, pase una definición de filtro eq() para especificar la condición de igualdad:

collection.find(eq("i", 71)).first().subscribe(new PrintDocumentSubscriber());

El ejemplo imprime un documento:

{ "_id" : { "$oid" : "5515836e58c7b4fbc756320b" }, "i" : 71 }

Obtener todos los documentos que coinciden con un filtro

El siguiente ejemplo devuelve e imprime todos los documentos en los que el valor de i es mayor que 50:

collection.find(gt("i", 50)).subscribe(new PrintDocumentSubscriber());

Para especificar un filtro para un rango, como 50 < i <= 100, puede utilizar el ayudante and():

collection.find(and(gt("i", 50), lte("i", 100)))
    .subscribe(new PrintDocumentSubscriber());

Update Documents

Para actualizar documentos en una colección, puede utilizar los métodos updateOne() y updateMany() de la colección.

Pase los siguientes parámetros a los métodos:

Objeto de filtro para determinar el documento o los documentos que se actualizarán. Para facilitar la creación de objetos de filtro, el controlador proporciona métodos auxiliares Filters. Para especificar un filtro vacío y buscar coincidencias con todos los documentos de la colección, utilice un objeto Document vacío.
Documento de actualización que especifica las modificaciones. Para ver una lista de los operadores disponibles, consulte "Operadores de actualización" en el manual del servidor.

Los métodos de actualización devuelven un tipo UpdateResult que proporciona información sobre la operación, incluido el número de documentos modificados por la actualización.

Actualiza un solo documento

Para actualizar un solo documento, utilice el método updateOne().

El siguiente ejemplo actualiza el primer documento en el que i es 10 y establece el valor de i en 110:

collection.updateOne(eq("i", 10), set("i", 110))
    .subscribe(new PrintSubscriber<UpdateResult>("Update Result: %s"));

Actualiza varios documentos

Para actualizar todos los documentos que coincidan con un filtro de query, utiliza el método updateMany().

El siguiente ejemplo incrementa el valor de i en 100 en todos los documentos en los que el valor de i sea menor que 100:

UpdateResult updateResult = collection.updateMany(lt("i", 100), inc("i", 100))
    .subscribe(new PrintSubscriber<UpdateResult>("Update Result: %s"));

Delete Documents

Para eliminar documentos de una colección, puede utilizar los métodos deleteOne() y deleteMany() de la colección.

Pase un objeto de filtro para determinar el documento o los documentos que se eliminarán. Para facilitar la creación de objetos de filtro, el controlador proporciona métodos auxiliares Filters. Para especificar un filtro vacío y buscar todos los documentos de la colección, utilice un objeto Document vacío.

Los métodos de eliminación devuelven un DeleteResult que proporciona información sobre la operación, incluido el número de documentos eliminados.

Eliminar un solo documento que coincida con un filtro

Para eliminar un solo documento que coincida con el filtro, utilice el método deleteOne().

El siguiente ejemplo elimina el primer documento en el que el valor de i es igual a 110:

collection.deleteOne(eq("i", 110))
    .subscribe(new PrintSubscriber<DeleteResult>("Delete Result: %s"));

Eliminar todos los documentos que coinciden con un filtro

Para eliminar todos los documentos que coincidan con el filtro, utilice el método deleteMany().

El siguiente ejemplo elimina todos los documentos en los que el valor de i sea mayor o igual a 100:

DeleteResult deleteResult = collection.deleteMany(gte("i", 100))
    .subscribe(new PrintSubscriber<DeleteResult>("Delete Result: %s"));

Cree índices

Para crear un índice en uno o más campos, pase un documento de especificación de índice al método createIndex(). Un documento de especificación de clave de índice contiene los campos a indexar y el tipo de índice de cada campo, según el siguiente documento:

new Document(<field1>, <type1>).append(<field2>, <type2>) ...

Para crear un tipo de índice ascendente, especifique 1 para <type>. Para crear un tipo de índice descendente, especifique -1 para <type>.

El siguiente ejemplo crea un índice ascendente en el campo i:

collection.createIndex(new Document("i", 1))
    .subscribe(new PrintSubscriber<String>("Create Index Result: %s"));

Para ver una lista de otros tipos de índices, consulte la guía Crear índices.

Información Adicional

Para obtener tutoriales adicionales que demuestran cómo usar MongoDB con POJO, consulte la guía de Inicio rápido (ejemplos de POJO).

Para encontrar tutoriales adicionales, consulte la sección Tutoriales.

Volver

Primer

Inicio rápido (ejemplos de POJO)