Bancos de dados e coleções

Pré-requisitos

Você deve incluir as seguintes declarações de importação em seu programa para executar os exemplos de código neste guia:

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;

Conecte-se a um MongoDB deployment

Primeiro, conecte-se a uma implementação do MongoDB em execução.

O código a seguir se conecta a uma MongoDB deployment standalone em execução em localhost na porta 27017:

MongoClient mongoClient = MongoClients.create();

Para saber mais sobre como se conectar a sistemas do MongoDB, consulte o tutorial Conectar ao MongoDB .

Acessar um banco de dados

Após conectar uma instância do MongoClient a um MongoDB deployment, utilize o método `getDatabase() para acessar um banco de dados.

Passe o nome do banco de dados como um parâmetro para o método getDatabase() . Se um banco de dados não existir, o MongoDB o criará quando você inserir quaisquer dados no banco de dados.

O exemplo a seguir acessa o banco de dados do test :

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

Acessar uma coleção

Após criar uma instância do MongoDatabase , utilize o método getCollection() para acessar uma coleção de dentro deste banco de dados.

Passe o nome da coleção como um parâmetro para o método getCollection() .

Utilizando a instância database criada na seção anterior, o seguinte código acessa a coleção denominada myTestCollection:

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

Se uma coleção com esse nome não existir, o MongoDB a criará quando você inserir os dados pela primeira vez nessa coleção.

Você também pode criar diretamente uma coleção com várias opções, como definir o tamanho máximo ou criar regras de validação de documentação.

Criar uma coleção

O driver fornece o método createCollection() para criar uma coleção diretamente. Ao criar uma collection, você pode especificar várias opções de collection, como um tamanho máximo ou regras de validação de documentação, com a classe CreateCollectionOptions .

Se você não estiver especificando nenhuma opção, não precisará criar a coleção diretamente, pois o MongoDB cria automaticamente novas coleções quando você insere os dados pela primeira 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>());

Obter uma lista de coleções

Você pode obter uma lista das coleções em um banco de dados utilizando o método MongoDatabase.listCollectionNames() :

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

Solte uma coleção

Você pode descartar uma coleção e excluir todos os dados na coleção usando o método MongoCollection.drop() :

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

Soltar um banco de dados

Você pode descartar um banco de dados e excluir todas as suas coleções usando o método MongoDatabase.drop(), como mostrado no exemplo a seguir:

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

Imutabilidade

MongoDatabase e MongoCollection instâncias são imutáveis. Para criar novas instâncias a partir de instâncias existentes que tenham propriedades diferentes, como diferentes read concerns, read preferences e write concerns, as classes MongoDatabase e MongoCollection fornecem os seguintes métodos:

• MongoDatabase.withReadConcern()

• MongoDatabase.withReadPreference()

• MongoDatabase.withWriteConcern()

• MongoCollection.withReadConcern()

• MongoCollection.withReadPreference()

• MongoCollection.withWriteConcern()

Para saber mais, consulte os tutoriais Ler dados e Gravar dados no MongoDB.

CodecRegistry

Uma sobrecarga do método getCollection() permite especificar uma classe diferente para representar documentos BSON. Por exemplo, talvez você queira usar a classe BsonDocument rigorosa e com segurança de tipo para modelar seus documentos ao executar operações 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());

Há dois requisitos que qualquer classe deve atender para ser usada dessa forma:

• Codec a instância da classe deve ser registrada em CodecRegistry para MongoCollection.

• Codec A instância deve ser aquela que codifica e decodifica um documento BSON completo, e não apenas, por exemplo, um único valor BSON como um Int32.

Por padrão, um MongoCollection é configurado com instâncias do Codec para três classes:

• Document

• BsonDocument

• BasicDBObject

Os aplicativos são gratuitos para registrar implementações Codec para outras classes personalizando o CodecRegistry. Novas instâncias CodecRegistry são configuráveis nos seguintes níveis:

• Em um MongoClient dentro MongoClientSettings

• Em um MongoDatabase dentro de seu método withCodecRegistry

• Em um MongoCollection dentro de seu método withCodecRegistry

Considere o caso de instâncias de codificação e decodificação da classe UUID . O driver por padrão codifica instâncias de UUID usando uma ordenação de bytes que não é compatível com outros drivers do MongoDB, e alterar o padrão seria perigoso.

É possível que novos aplicativos que exigem interoperabilidade entre vários drivers possam alterar esse padrão, e eles podem fazer isso especificando um 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);