WebSocket em Kotlin: criação de aplicações real-time de nível avançado

Introdução: Por que WebSocket em Kotlin é a escolha dos profissionais para sistemas em tempo real

Aplicações web modernas exigem reação instantânea às ações dos usuários: chats, jogos online, cotações de bolsa, sistemas de monitoramento. O protocolo HTTP, baseado em requisição-resposta, é ineficiente para essas tarefas. É aqui que entra o WebSocket — um protocolo que fornece uma conexão bidirecional persistente entre cliente e servidor.

A linguagem Kotlin com seu poderoso sistema de coroutines e o framework Ktor fornece um ambiente ideal para criar aplicações em tempo real escaláveis e tolerantes a falhas. Neste artigo, abordaremos técnicas avançadas de trabalho com WebSocket em Kotlin: desde a arquitetura da aplicação até o ajuste fino de desempenho. Você aprenderá como ir além de um simples servidor echo e construir uma solução de nível industrial.

Arquitetura de aplicação WebSocket em Kotlin: do simples ao complexo

Fundação: Ktor Server e WebSockets Plugin

Vamos começar com a configuração básica. O framework Ktor é o padrão de facto para criar servidores assíncronos em Kotlin. Para trabalhar com WebSocket, é necessário adicionar o plugin:

// build.gradle.ktsimplementation("io.ktor:ktor-server-websockets:$ktor_version")implementation("io.ktor:ktor-server-netty:$ktor_version")

A inicialização básica do servidor com suporte a WebSocket é assim:

import io.ktor.server.engine.*import io.ktor.server.netty.*import io.ktor.server.websocket.*import io.ktor.websocket.*import io.ktor.server.routing.*

fun main() {    embeddedServer(Netty, port = 8080) {        install(WebSockets) {            pingPeriod = 15.seconds // Keep-alive ping            timeout = 15.seconds    // Timeout para resposta            maxFrameSize = Long.MAX_VALUE // Tamanho máximo do frame        }

        routing {            webSocket("/chat") {                // Lógica de trabalho com a conexão                send("Bem-vindo ao chat!")                for (frame in incoming) {                    if (frame is Frame.Text) {                        val text = frame.readText()                        // Processamento da mensagem                    }                }            }        }    }.start(wait = true)}

Observe os parâmetros pingPeriod e timeout. Em produção, eles devem ser configurados com base nas condições de rede para evitar o rompimento da conexão durante atrasos temporários.

Gerenciamento de sessões: não apenas uma lista de sockets

Em um nível avançado, simplesmente armazenar uma lista de DefaultWebSocketServerSession não é suficiente. É necessário gerenciar sessões, agrupá-las por salas/canais e tratar corretamente as desconexões.

class ChatRoom(private val name: String) {    private val sessions = mutableSetOf<WebSocketSession>()

    @Synchronized    fun add(session: WebSocketSession) {        sessions.add(session)        broadcast("${session.call.request.local.remoteHost} entrou em $name")    }

    @Synchronized    fun remove(session: WebSocketSession) {        sessions.remove(session)        broadcast("${session.call.request.local.remoteHost} saiu de $name")    }

    @Synchronized    fun broadcast(message: String) {        sessions.forEach { session ->            GlobalScope.launch {                try {                    session.send(Frame.Text(message))                } catch (e: Exception) {                    // Registramos e removemos a conexão problemática                    remove(session)                }            }        }    }}

Ponto importante: O uso de @Synchronized protege contra condições de corrida no acesso concorrente a mutableSetOf. Em sistemas de alta carga, vale a pena