Menu Docs
Página inicial do Docs
/
Idiomas
/
Java
/
Driver de fluxos reativos do Java
/
Conecte-se ao MongoDB

Escolha um destino de conexão

Nesta página

  • Visão geral
  • Atlas
  • Implantações locais
  • Conjuntos de réplicas
  • Inicialização
  • Documentação da API

Visão geral

Neste guia, você pode aprender como utilizar uma string de conexão e um objeto do MongoClient para conectar a diferentes tipos de sistemas MongoDB .

Atlas

Para se conectar a uma MongoDB deployment no Atlas, inclua os seguintes elementos em sua connection string:

  • URL do seu cluster Atlas

  • Nome de usuário do MongoDB

  • Senha do MongoDB

Em seguida, passe sua string de conexão para o método create() construindo um objeto MongoClient .

Dica

Siga oguia de conexão do driver do Atlas para recuperar sua connection string.

Ao se conectar ao Atlas, recomendamos usar a opção de cliente Stable API para evitar alterações significativas quando o Atlas atualizar para uma nova versão do MongoDB Server. Para saber mais sobre o recurso Stable API , consulte Stable API no manual do MongoDB Server .

O seguinte código mostra como utilizar o driver Java Reactive Streams para conectar a um cluster do Atlas . O código usa a opção serverApi para especificar uma versão da Stable API .

Importante

Métodos da Biblioteca do Reactor

Este guia usa métodos da Biblioteca Reactor, uma biblioteca baseada na especificação Reactive Streams. Para instalar o Reactor, consulte Obtendo o Reactor na documentação do Projeto Reactor.

import com.mongodb.ConnectionString;
import com.mongodb.MongoClientSettings;
import com.mongodb.ServerApi;
import com.mongodb.ServerApiVersion;
import org.bson.BsonDocument;
import org.bson.BsonInt64;
import com.mongodb.reactivestreams.client.MongoClient;
import com.mongodb.reactivestreams.client.MongoClients;
import com.mongodb.reactivestreams.client.MongoDatabase;
import org.bson.conversions.Bson;
import reactor.core.publisher.Mono;
public class testing {
    public static void main(String[] args) {
        // Replace the placeholder with your Atlas connection string
        String uri = "<connection string>";
        // Construct a ServerApi instance using the ServerApi.builder() method
        ServerApi serverApi = ServerApi.builder()
                .version(ServerApiVersion.V1)
                .build();
        MongoClientSettings settings = MongoClientSettings.builder()
                .applyConnectionString(new ConnectionString(uri))
                .serverApi(serverApi)
                .build();
        // Create a new client and connect to the server
        try (MongoClient mongoClient = MongoClients.create(settings))
        {
            MongoDatabase database = mongoClient.getDatabase("<database name>");
            Bson command = new BsonDocument("ping", new BsonInt64(1));
            Mono.from(database.runCommand(command))
                    .doOnSuccess(x -> System.out.println("Pinged your deployment. You successfully connected to MongoDB!"))
                    .doOnError(err -> System.out.println("Error: " + err.getMessage()))
                    .block();
        }
    }
}

Implantações locais

Para se conectar a uma implantação local do MongoDB, use localhost como nome do host. Por padrão, o processo mongod é executado na porta 27017, embora você possa personalizar isso para seu sistema.

O código a seguir mostra como usar o driver Java Reactive Streams para se conectar a um sistema local do MongoDB :

import com.mongodb.reactivestreams.client.MongoClients;
import com.mongodb.reactivestreams.client.MongoClient;
public class MongoConnection {
    public static void main(String[] args) {
        String uri = "mongodb://localhost:27017/";
        try (MongoClient client = MongoClients.create(uri)) {
            // use `client` here
        }
    }
}

Conjuntos de réplicas

Para se conectar a um conjunto de réplicas, especifique o nome de host (ou endereço IP) e o número de porta dos membros do conjunto de réplicas em sua connection string.

Se você não conseguir fornecer uma lista completa de hosts no conjunto de réplicas, poderá especificar um ou mais hosts no conjunto de réplicas e instruir o driver Java Reactive Streams a executar a descoberta automática para encontrar os outros. Para instruir o driver a realizar a descoberta automática, execute uma das seguintes ações:

  • Especifique o nome do conjunto de réplica como o valor do parâmetro replicaSet.

  • Especifique false como o valor do parâmetro directConnection.

  • Especifique mais de um host no conjunto de réplica.

No exemplo a seguir, o driver usa um URI de conexão de exemplo para se conectar ao conjunto de réplicas do MongoDB sampleRS, que está sendo executado na porta 27017 de três hosts diferentes, incluindo host1:

import com.mongodb.reactivestreams.client.MongoClients;
import com.mongodb.reactivestreams.client.MongoClient;
public class MongoConnection {
    public static void main(String[] args) {
        String uri = "mongodb://localhost:27017/?replicaSet=sampleRS";
        try (MongoClient client = MongoClients.create(uri)) {
            // use `client` here
        }
    }
}

Observação

create() não está bloqueando

O método create() que constrói um MongoClient não está bloqueando. Quando você se conecta a um conjunto de réplicas, o método retorna imediatamente enquanto o cliente usa threads de background para se conectar ao conjunto de réplicas.

Se você criar um MongoClient e imprimir imediatamente a representação de string de seu atributo nodes , a lista poderá estar vazia enquanto o cliente se conecta aos membros do conjunto de réplicas.

Inicialização

Para inicializar um conjunto de réplicas, você deve se conectar diretamente a um único membro. Para fazer isso, defina a opção de conexão directConnection como True. Você pode fazer isso das seguintes maneiras:

  • Passando um argumento para o método create() construindo um MongoClient

  • Definindo o parâmetro em sua string de conexão.

import com.mongodb.reactivestreams.client.MongoClients;
import com.mongodb.reactivestreams.client.MongoClient;
public class MongoConnection {
public static void main(String[] args) {
    try (MongoClient client = 
    MongoClients.create("mongodb://<hostname>:<port>", directConnection=True)){
            // use `client` here
        }
    }
}
import com.mongodb.reactivestreams.client.MongoClients;
import com.mongodb.reactivestreams.client.MongoClient;
public class MongoConnection {
public static void main(String[] args) {
    String uri = "mongodb://<hostname>:<port>/?directConnection=true";
    try (MongoClient client = MongoClients.create(uri)){
            // use `client` here
        }
    }
}

Documentação da API

Para saber mais sobre como criar uma instância do MongoClient no driver Java Reactive Streams, consulte a seguinte documentação da API:

Voltar

Criar um MongoClient

Próximo

Especificar opções de URI de conexão