Conecte-se ao MongoDB

Visão geral

Esta página contém exemplos de código que mostram como conectar seu aplicativo Kotlin ao MongoDB com várias configurações.

Para usar um exemplo de conexão desta página, copie o exemplo de código em seu aplicativo. Certifique-se de substituir todos os espaços reservados nos exemplos de código, como <hostname>, pelos valores relevantes para sua implantação do MongoDB .

import com.mongodb.kotlin.client.coroutine.MongoClient
import com.mongodb.kotlin.client.coroutine.MongoDatabase
import kotlinx.coroutines.runBlocking
import org.bson.Document
import org.bson.BsonInt32
import com.mongodb.MongoException
fun main() = runBlocking {
    // Replace the placeholder with your connection string
    val uri = "<connection string>"
    // Create a new client and connect to the server
    val mongoClient = MongoClient.create(uri)
    val database: MongoDatabase = mongoClient.getDatabase("test")
    try {
        // Send a ping to confirm a successful connection
        val command = Document("ping", BsonInt32(1))
        val commandResult = database.runCommand(command)
        println("Ping response: $commandResult")
        println("Pinged your deployment. You successfully connected to MongoDB!")
    } catch (me: MongoException) {
        System.err.println(me)
    }
}

Conexão

As seções a seguir descrevem como se conectar a diferentes destinos, como uma instância local do MongoDB ou uma instância hospedada na nuvem no Atlas.

val uri = "mongodb://localhost:27017/"
val client = MongoClient.create(uri)

import com.mongodb.kotlin.client.coroutine.MongoClient
import com.mongodb.MongoClientSettings
import com.mongodb.ConnectionString
import com.mongodb.ServerApi
import com.mongodb.ServerApiVersion
val uri = "<Atlas connection string>"
val serverApi = ServerApi.builder()
    .version(ServerApiVersion.V1)
    .strict(true)
    .deprecationErrors(true)
    .build()
val settings = MongoClientSettings.builder()
    .applyConnectionString(ConnectionString(uri))
    .serverApi(serverApi)
    .build()
val client = MongoClient.create(settings)

val uri = "mongodb://<replica set member>:<port>/?replicaSet=<replica set name>"
val client = MongoClient.create(uri)

Seleção do Servidor

O seguinte código mostra como especificar uma função de seleção de servidor :

import com.mongodb.kotlin.client.coroutine.MongoClient
import com.mongodb.MongoClientSettings
import com.mongodb.ConnectionString
val uri = "mongodb://<db_username>:<db_password>@<hostname>:<port>"
val settings = MongoClientSettings.builder()
    .applyConnectionString(ConnectionString(uri))
    .serverSelector(<selector function>)
    .build()
val client = MongoClient.create(settings)

Para saber mais sobre como personalizar a seleção do servidor, consulte Personalizar seleção do servidor.

Stable API

O código a seguir mostra como especificar as configurações da Stable API para uma conexão:

import com.mongodb.kotlin.client.coroutine.MongoClient
import com.mongodb.MongoClientSettings
import com.mongodb.ConnectionString
import com.mongodb.ServerApi
import com.mongodb.ServerApiVersion
val uri = "mongodb://<db_username>:<db_password>@<hostname>:<port>"
val serverApi = ServerApi.builder()
    .version(ServerApiVersion.V1)
    .build()
val settings = MongoClientSettings.builder()
    .applyConnectionString(ConnectionString(uri))
    .serverApi(serverApi)
    .build()
val client = MongoClient.create(settings)

Para saber mais sobre a stable API, consulte stable API.

Limitar o tempo de execução do servidor MongoDB

import com.mongodb.kotlin.client.coroutine.MongoClient
import com.mongodb.MongoClientSettings
import com.mongodb.ConnectionString
import java.util.concurrent.TimeUnit
val uri = "mongodb://<db_username>:<db_password>@<hostname>:<port>"
val settings = MongoClientSettings.builder()
    .applyConnectionString(ConnectionString(uri))
    .timeout(200L, TimeUnit.MILLISECONDS)
    .build()
val client = MongoClient.create(settings)

import com.mongodb.kotlin.client.coroutine.MongoClient
val uri = "mongodb://<db_username>:<db_password>@<hostname>:<port>/?timeoutMS=<timeout length>"
val client = MongoClient.create(uri)

Pool de Conexões

Cada instância MongoClient tem um pool de conexões integrado para cada servidor em sua topologia do MongoDB. Os pools de conexões abrem soquetes sob demanda para oferecer suporte às operações simultâneas do MongoDB em seu aplicativo de threads múltiplas.

O tamanho máximo de cada conjunto de conexões é definido pela opção maxPoolSize, que padroniza para 100. Se o número de conexões em uso com um servidor atingir o valor de maxPoolSize, a próxima solicitação para esse servidor aguardará até que uma conexão fique disponível.

Cada instância MongoClient abre dois soquetes adicionais por servidor em sua topologia MongoDB para monitorar o estado do servidor.

Por exemplo, um cliente conectado a um conjunto de réplicas de 3 nós abre 6 soquetes de monitoramento. Ele também abre quantos soquetes forem necessários para oferecer suporte aos threads de um aplicativo em cada servidor, até o valor de maxPoolSize. Se maxPoolSize for 100 e o aplicativo usar apenas o primário (o padrão), somente o pool de conexões primárias crescerá e poderá haver no máximo 106 conexões totais. Se a aplicação usar uma preferência de leitura para consultar os nós secundários, seus pools também crescerão e poderá haver um total 306 conexões.

Além disso, os pools de conexões têm taxa limitada de modo que cada pool de conexões só pode criar, no máximo, o valor de maxConnecting conexões em paralelo a qualquer momento. Qualquer thread adicional para de esperar nos seguintes casos:

• Um dos threads existentes termina de criar uma conexão, ou uma conexão existente é verificada novamente no pool.

• A capacidade do driver de reutilizar conexões existentes melhora devido aos limites de taxa na criação de conexões.

Você pode configurar o número mínimo de conexões simultâneas para cada servidor com a opção minPoolSize , que padroniza para 0. O pool de conexões será inicializado com este número de tomadas. Se os soquetes forem fechados devido a qualquer erro de rede, fazendo com que o número total de soquetes (em uso e ociosos) caia abaixo do mínimo, mais soquetes serão abertos até que o mínimo seja atingido.

Você pode definir o número máximo de milésimos de segundo que uma conexão pode permanecer ociosa no grupo antes de ser removida e substituída pela opção maxIdleTimeMS , que padroniza para 0 (sem limite).

A seguinte configuração padrão para um MongoClient funciona para a maioria dos aplicativos:

val client = MongoClient("<connection string>")

Crie um cliente uma vez para cada processo e reutilize-o para todas as operações. É um erro comum criar um novo cliente para cada solicitação, o que é muito ineficiente.

Para oferecer suporte a um grande número de operações simultâneas do MongoDB em um processo, você pode aumentar o maxPoolSize. Quando o pool atinge seu tamanho máximo, threads adicionais aguardam a disponibilidade de soquetes.

O driver não limita o número de threads que podem aguardar a disponibilidade de soquetes, e é responsabilidade do aplicativo limitar o tamanho de seu pool para limitar o enfileiramento durante um pico de carga. Os threads aguardam a quantidade de tempo especificada na opção waitQueueTimeoutMS , que padroniza para 120000 (120 segundos).

Um thread que aguarda mais do que o período de tempo definido por waitQueueTimeoutMS para um soquete gera um erro de conexão. Use essa opção se for mais importante limitar a duração das operações durante um pico de carga do que concluir cada operação.

Quando MongoClient.close() é chamado por qualquer thread, o driver fecha todos os soquetes ociosos e fecha todos os soquetes que estão em uso à medida que são retornados ao pool.