Biblioteca WebSocket de Kotlin: ktor-client-websockets para tiempo real

Biblioteca WebSocket para Kotlin: ktor-client-websockets

En el desarrollo web moderno, cada vez se requiere más el intercambio de datos en tiempo real: chats en línea, notificaciones, cotizaciones bursátiles, juegos multijugador. Para Kotlin, una de las bibliotecas más potentes y nativas para trabajar con el protocolo WebSocket es ktor-client-websockets, parte del ecosistema Ktor (cliente HTTP de Kotlin).

En este artículo, analizaremos en detalle cómo conectar y usar WebSocket en Kotlin con Ktor. Aprenderá cómo instalar la biblioteca, establecer una conexión, enviar y recibir mensajes, así como manejar errores y el cierre de la conexión.

¿Qué es WebSocket y para qué sirve?

WebSocket es un protocolo que proporciona una conexión bidireccional persistente entre un cliente (por ejemplo, una aplicación Android o un servidor) y un servidor. A diferencia de HTTP, donde el cliente inicia una solicitud cada vez, WebSocket permite que el servidor envíe datos al cliente instantáneamente, tan pronto como aparecen. Es ideal para:

• chats y mensajería instantánea;
• notificaciones y feeds de eventos;
• juegos y editores colaborativos;
• tickers financieros y trading.

Instalación de la biblioteca ktor-client-websockets

Para empezar, agregue la dependencia en su archivo build.gradle.kts (proyecto en Kotlin/JVM o Kotlin Multiplatform).

// build.gradle.ktsdependencies {    implementation("io.ktor:ktor-client-core:2.3.7")    implementation("io.ktor:ktor-client-cio:2.3.7") // u otro motor    implementation("io.ktor:ktor-client-websockets:2.3.7")}

Si usa Kotlin Multiplatform, asegúrese de agregar el módulo para cada plataforma (por ejemplo, ktor-client-okhttp para Android).

Creación de un cliente WebSocket

La clase principal para trabajar con WebSocket es HttpClient con el plugin WebSockets. Veamos un ejemplo simple de conexión a un servidor WebSocket.

import io.ktor.client.*import io.ktor.client.plugins.websocket.*import io.ktor.websocket.*

suspend fun main() {    val client = HttpClient {        install(WebSockets)    }

    client.webSocket("ws://echo.websocket.org") {        // Enviamos un mensaje        send(Frame.Text("¡Hola, WebSocket!"))

        // Recibimos la respuesta        for (frame in incoming) {            when (frame) {                is Frame.Text -> {                    println("Recibido: ${frame.readText()}")                }                else -> println("Otro tipo de frame: $frame")            }        }    }

    client.close()}

En este código:

1. Creamos un cliente HTTP con soporte WebSocket.
2. Establecemos una conexión con el servidor de prueba ws://echo.websocket.org.
3. Enviamos un mensaje de texto.
4. Leemos los frames entrantes y los mostramos en la consola.

Manejo de errores y cierre de conexión

En aplicaciones reales, es importante manejar correctamente las excepciones y cerrar la conexión. Use try-catch y finally.

import io.ktor.client.*import io.ktor.client.plugins.websocket.*import io.ktor.websocket.*import kotlinx.coroutines.*

suspend fun main() = coroutineScope {    val client = HttpClient {        install(WebSockets)    }

    try {        client.webSocket("ws://your-server.com/ws") {            // Envío            send(Frame.Text("Ping"))

            // Recepción con timeout            withTimeout(5000) {                for (frame in incoming) {                    if (frame is Frame.Text) {                        println("Respuesta: ${frame.readText()}")                    }                }            }        }    } catch (e: Exception) {        println("Error de WebSocket: ${e.message}")    } finally {        cli