Conéctese a MongoDB

Overview

Esta página contiene ejemplos de código que muestran cómo conectar tu aplicación Kotlin a MongoDB con varias configuraciones.

Para usar un ejemplo de conexión de esta página, copie el ejemplo de código en su aplicación. Asegúrate de reemplazar todos los marcadores de posición en los ejemplos de código, como <hostname>, con los valores relevantes para su implementación de 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)
    }
}

Conexión

Las siguientes secciones describen cómo conectarse a diferentes destinos, como una instancia local de MongoDB o una instancia alojada en la nube en 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)

Selección de servidores

El siguiente código muestra cómo especificar una función de selección 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 obtener más información sobre la personalización de la selección de servidores, consulte Personaliza la selección de servidores.

Stable API

El siguiente código muestra cómo especificar la configuración de Stable API para una conexión:

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 obtener más información sobre la Stable API, consulta Stable API.

Limite el tiempo de ejecución del servidor

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)

Pools de conexiones

Cada instancia de MongoClient tiene un grupo de conexiones integrado para cada servidor en la topología de MongoDB. Los pools de conexiones abren sockets on-demand para soportar operaciones concurrentes de MongoDB en su aplicación de subprocesos múltiples.

El tamaño máximo de cada grupo de conexiones se establece mediante la opción maxPoolSize, cuyo valor predeterminado es 100. Si el número de conexiones en uso a un servidor alcanza maxPoolSize, la siguiente solicitud a ese servidor esperará hasta que haya una conexión disponible.

Cada instancia de MongoClient abre dos sockets adicionales por servidor en tu topología de MongoDB para la supervisión del estado del servidor.

Por ejemplo, un cliente conectado a un set de réplicas de 3 nodos abre 6 sockets de supervisión. También abre tantos sockets como sea necesario para admitir los hilos de una aplicación en cada servidor, hasta el valor de maxPoolSize. Si maxPoolSize es 100 y la aplicación utiliza únicamente la opción primario (por defecto), solo el pool de conexiones primario crecerá y puede haber, como máximo, 106 conexiones en total. Si la aplicación utiliza una preferencia de lectura para consultar los nodos secundarios, sus pools también crecen y puede haber un total de 306 conexiones.

Además, los pools de conexiones tienen un límite de tasa, de modo que cada pool de conexiones solo puede crear, como máximo, el valor de maxConnecting conexiones en paralelo en cualquier momento. Cualquier hilo adicional deja de esperar en los siguientes casos:

• Uno de los subprocesos existentes termina de crear una conexión, o una conexión existente se devuelve al grupo.

• La capacidad del controlador para reutilizar conexiones existentes mejora debido a los límites de velocidad en la creación de conexiones.

Puedes establecer el número mínimo de conexiones concurrentes a cada servidor con la opción minPoolSize, que por defecto es 0. El pool de conexiones se inicializará con este número de sockets. Si se cierran sockets debido a errores de red y el número total de sockets (tanto en uso como inactivos) cae por debajo del mínimo, se abrirán más sockets hasta alcanzar el mínimo.

Puede establecer la cantidad máxima de milisegundos que una conexión puede permanecer inactiva en el grupo antes de ser eliminada y reemplazada con la opción maxIdleTimeMS, cuyo valor predeterminado es 0 (sin límite).

La siguiente configuración por defecto para un MongoClient funciona para la mayoría de las aplicaciones:

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

Cree un cliente para cada proceso y reutilícelo para todas las operaciones. Es un error común crear un cliente para cada solicitud, lo cual resulta muy ineficiente.

Para soportar un alto número de operaciones MongoDB concurrentes dentro de un proceso, puede aumentar maxPoolSize. Una vez que el pool alcanza su tamaño máximo, los hilos adicionales esperan a que los sockets estén disponibles.

El controlador no limita la cantidad de hilos que pueden esperar a que estén disponibles los sockets, y es responsabilidad de la aplicación limitar el tamaño de su grupo para limitar la cola durante un pico de carga. Los hilos esperan durante el tiempo especificado en la opción waitQueueTimeoutMS, que por defecto es 120000 (120 segundos).

Un hilo que espera más tiempo del definido por waitQueueTimeoutMS para un socket genera un error de conexión. Utiliza esta opción si es más importante limitar la duración de las operaciones durante un pico de carga que completar cada operación.

Cuando cualquier hilo llama a MongoClient.close(), el controlador cierra todos los sockets inactivos y cierra todos los sockets que están en uso a medida que se devuelven al grupo.