Bases de datos y colecciones

Requisitos previos

Debes incluir las siguientes instrucciones de importación en tu programa para ejecutar los ejemplos de código de esta guía:

import com.mongodb.reactivestreams.client.MongoClients;
import com.mongodb.reactivestreams.client.MongoClient;
import com.mongodb.reactivestreams.client.MongoCollection;
import com.mongodb.reactivestreams.client.MongoDatabase;
import static com.mongodb.client.model.Filters.*;
import com.mongodb.client.model.CreateCollectionOptions;
import com.mongodb.client.model.ValidationOptions;

Conectarse a una implementación de MongoDB

Primero, conectate a una implementación de MongoDB en ejecución.

El siguiente código se conecta a una implementación independiente de MongoDB que se ejecuta en localhost en el puerto 27017:

MongoClient mongoClient = MongoClients.create();

Para aprender más sobre cómo conectar implementaciones de MongoDB, consulta el tutorial Conectar a MongoDB.

Acceder a una base de datos

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

Pase el nombre de la base de datos como parámetro al método getDatabase(). Si una base de datos no existe, MongoDB la crea cuando se inserta cualquier dato en la base de datos.

El siguiente ejemplo accede a la base de datos test:

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

Acceder a una colección

Después de crear una instancia de MongoDatabase, utiliza el método getCollection() para acceder a una colección dentro de esa base de datos.

Pasa el nombre de la colección como un parámetro al método getCollection().

Utilizando la instancia database creada en la sección anterior, el siguiente código accede a la colección llamada myTestCollection:

MongoCollection<Document> coll = database.getCollection("myTestCollection");

Si no existe una colección con ese nombre, MongoDB la crea cuando se insertan datos por primera vez en esa colección.

También puedes crear directamente una colección con varias opciones, como establecer el tamaño máximo o crear reglas de validación de documentación.

Crear una colección

El driver proporciona el método createCollection() para crear una colección directamente. Cuando se crea una colección, es posible especificar diversas opciones para la colección, como tamaño máximo o reglas de validación de documentación, con la clase CreateCollectionOptions.

Si no está especificando ninguna opción, no necesita crear directamente la colección, ya que MongoDB crea automáticamente nuevas colecciones cuando se inserta por primera vez.

database.createCollection(
    "cappedCollection",
    new CreateCollectionOptions().capped(true).sizeInBytes(0x100000)
).subscribe(new OperationSubscriber<Void>());

ValidationOptions collOptions = new ValidationOptions().validator(
         Filters.or(Filters.exists("email"), Filters.exists("phone")));
database.createCollection(
    "contacts",
    new CreateCollectionOptions().validationOptions(collOptions)
).subscribe(new OperationSubscriber<Void>());

Obtén una lista de colecciones

Puede obtener una lista de las colecciones en una base de datos utilizando el método MongoDatabase.listCollectionNames():

database.listCollectionNames().subscribe(new PrintToStringSubscriber<String>());

Descarta una colección

Puedes descartar una colección y borrar todos los datos de la colección usando el método MongoCollection.drop():

MongoCollection<Document> collection = database.getCollection("contacts");
collection.drop().subscribe(new OperationSubscriber<Void>());

Descartar una base de datos

Puedes descartar una base de datos y borrar todas sus colecciones usando el método MongoDatabase.drop(), como se muestra en el siguiente ejemplo:

MongoDatabase database = mongoClient.getDatabase("test");
database.drop().subscribe(new OperationSubscriber<Void>());

Inmutabilidad

MongoDatabase y MongoCollection instancias son inmutables. Para crear nuevas instancias a partir de instancias existentes que tengan diferentes propiedades, como diferentes niveles de consistencia de lectura, preferencias de lectura y niveles de confirmación de escritura (write concern), la clase MongoDatabase y MongoCollection proporciona los siguientes métodos:

• MongoDatabase.withReadConcern()

• MongoDatabase.withReadPreference()

• MongoDatabase.withWriteConcern()

• MongoCollection.withReadConcern()

• MongoCollection.withReadPreference()

• MongoCollection.withWriteConcern()

Para obtener más información, consulte los tutoriales Leer datos y Escribir datos en MongoDB.

CodecRegistry

Una sobrecarga del método getCollection() permite especificar una clase diferente para representar documentos BSON. Por ejemplo, podría usar la clase BsonDocument, estricta y con seguridad de tipos, para modelar sus documentos al realizar operaciones CRUD:

// pass BsonDocument.class as the second argument
MongoCollection<BsonDocument> collection = database
    .getCollection("mycoll", BsonDocument.class);
// insert a document
BsonDocument document = BsonDocument.parse("{x: 1}");
collection.insertOne(document).subscribe(new OperationSubscriber<Void>());
document.append("x", new BsonInt32(2)).append("y", new BsonInt32(3));
// replace a document
collection.replaceOne(Filters.eq("_id", document.get("_id")), document)
    .subscribe(new PrintSubscriber<UpdateResult>("Update Result: %s"));
// find documents
collection.find().subscribe(new PrintDocumentSubscriber());

Hay dos requisitos que cualquier clase debe cumplir para ser utilizada de esta manera:

• Codec La instancia para la clase debe estar registrada en el CodecRegistry para el MongoCollection.

• Codec la instancia debe ser capaz de codificar y decodificar un documento BSON completo, y no solo, por ejemplo, un solo valor BSON como un Int32.

Por defecto, un MongoCollection está configurado con Codec instancias para tres clases:

• Document

• BsonDocument

• BasicDBObject

Las aplicaciones pueden registrar implementaciones de Codec para otras clases personalizando el CodecRegistry. Las nuevas instancias de CodecRegistry son configurables en los siguientes niveles:

• En un MongoClient dentro de MongoClientSettings

• En un MongoDatabase dentro de su método withCodecRegistry

• En un MongoCollection dentro de su método withCodecRegistry

Considere el caso de codificar y decodificar instancias de la clase UUID. El controlador por defecto codifica las instancias de UUID utilizando un orden de bytes que no es compatible con otros controladores de MongoDB, y cambiar la configuración por defecto sería peligroso.

Es posible que las nuevas aplicaciones que requieran interoperabilidad entre múltiples drivers puedan cambiar ese por defecto, y pueden hacerlo especificando un CodecRegistry

// replaces the default UuidCodec to use the standard UUID representation
CodecRegistry codecRegistry = CodecRegistries.fromRegistries(
    CodecRegistries.fromCodecs(new UuidCodec(UuidRepresentation.STANDARD)
), MongoClientSettings.getDefaultCodecRegistry());
// globally
MongoClientSettings settings = MongoClientSettings.builder()
    .codecRegistry(codecRegistry).build();
MongoClient client = MongoClients.create(settings);
// or per database
MongoDatabase database = client.getDatabase("mydb")
    .withCodecRegistry(codecRegistry);
// or per collection
MongoCollection<Document> collection = database.getCollection("mycoll")
    .withCodecRegistry(codecRegistry);