Conéctese a MongoDB

Overview

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

Para usar un ejemplo de conexión de esta página, copie el código de ejemplo en su aplicación. Asegúrese 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 cómo personalizar la selección del servidor, consulte Personalizar la selección del servidor.

Stable API

El siguiente código muestra cómo especificar la configuración de API estable 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 MongoClient abre dos sockets adicionales por servidor en su topología MongoDB para monitorear el estado del servidor.

Por ejemplo, un cliente conectado a un conjunto 3 6 de réplicas de nodos abre sockets de monitorización. También abre tantos sockets como sean necesarios para soportar los subprocesos de una aplicación en cada servidor, hasta un valor maxPoolSize de. Si maxPoolSize es 100 y la aplicación solo usa el servidor principal (predeterminado), solo el grupo de conexiones principal crece y puede haber 106 un máximo de conexiones. Si la aplicación usa una preferencia de lectura para consultar los nodos secundarios, sus grupos también crecen y puede haber un 306 total de conexiones.

Además, los grupos de conexiones tienen una velocidad limitada, de modo que cada uno solo puede crear, como máximo, maxConnecting conexiones en paralelo en cualquier momento. Cualquier subproceso 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.

Puede establecer el número mínimo de conexiones simultáneas a cada servidor con la opción minPoolSize, cuyo valor predeterminado es 0. El grupo de conexiones se inicializará con este número de sockets. Si los sockets se cierran debido a errores de red, lo que provoca que el número total de sockets (tanto en uso como inactivos) caiga por debajo del mínimo, se abrirán más sockets hasta alcanzarlo.

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 predeterminada 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 subproceso que espera más tiempo del definido por waitQueueTimeoutMS para un socket genera un error de conexión. Use 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.