Bases de datos y colecciones

Requisitos previos

Debe incluir las siguientes declaraciones de importación en su 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, conéctese 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 obtener más información sobre cómo conectarse a implementaciones de MongoDB, consulte el tutorial Conectarse a MongoDB.

Acceder a una base de datos

Una vez que tenga una instancia MongoClient conectada a una implementación de MongoDB, use 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 MongoDatabase, utilice el método getCollection() para acceder a una colección desde dentro de esa base de datos.

Pase el nombre de la colección como 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 denominada myTestCollection:

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

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

También puede 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 controlador proporciona el método createCollection() para crear directamente una colección. Al crear una colección, se pueden especificar varias opciones, como el tamaño máximo o las reglas de validación de la documentación, con la clase CreateCollectionOptions.

Si no especifica ninguna opción, no necesita crear directamente la colección ya que MongoDB crea automáticamente nuevas colecciones cuando inserta datos 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

Puede eliminar una colección y eliminar todos los datos de la colección utilizando el método MongoCollection.drop():

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

Descartar una base de datos

Puede eliminar una base de datos y eliminar todas sus colecciones utilizando 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 Las MongoCollection instancias y son inmutables. Para crear nuevas instancias a partir de instancias existentes con propiedades diferentes, como interesesde lectura, preferencias de lectura y intereses de escritura, las MongoDatabase MongoCollection clases y proporcionan 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.

Registro de códecs

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 de la clase debe estar registrada en el CodecRegistry para el MongoCollection.

• Codec La instancia debe ser una que codifique y decodifique un documento BSON completo, y no solo, por ejemplo, un único valor BSON como Int32.

De forma predeterminada, un MongoCollection se configura con Codec instancias para tres clases:

• Document

• BsonDocument

• BasicDBObject

Las aplicaciones pueden registrar libremente implementaciones Codec para otras clases personalizando CodecRegistry. Las nuevas instancias CodecRegistry se pueden configurar 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 la codificación y decodificación de instancias de la clase UUID. El controlador codifica, por defecto, las instancias de UUID mediante un orden de bytes incompatible con otros controladores de MongoDB, y modificar este valor predeterminado sería peligroso.

Es posible que las nuevas aplicaciones que requieren interoperabilidad entre múltiples controladores puedan cambiar ese valor predeterminado, 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);