WebSocket sur Kotlin : créer des applications en temps réel

Introduction à WebSocket en Kotlin : de la théorie à la pratique en temps réel

Les applications web modernes nécessitent de plus en plus un échange instantané de données entre le client et le serveur. Le protocole HTTP traditionnel, fonctionnant selon le principe « requête-réponse », ne convient pas aux tâches où les informations doivent arriver en temps réel : chats en ligne, cotations boursières, jeux multijoueurs ou notifications push. C'est là que WebSocket vient à la rescousse — un protocole assurant une connexion bidirectionnelle permanente.

Kotlin, en tant que langage moderne pour JVM, JavaScript et Native, offre d'excellents outils pour travailler avec WebSocket. Dans cet article, nous allons voir comment créer des applications temps réel en Kotlin en utilisant la bibliothèque Ktor — un framework populaire pour construire des serveurs et clients asynchrones. Vous apprendrez à configurer une connexion WebSocket, envoyer et recevoir des messages, gérer les erreurs et construire des solutions évolutives.

1. Bases de WebSocket : pourquoi Kotlin et Ktor ?

WebSocket est un protocole qui, après avoir établi une connexion via une poignée de main HTTP, fait passer le canal en mode bidirectionnel permanent. Contrairement à HTTP, le serveur peut initier l'envoi de données sans requête du client. C'est idéal pour les scénarios temps réel.

Kotlin associé à Ktor offre :

• Asynchronisme — les coroutines Kotlin permettent de traiter des milliers de connexions simultanées sans bloquer les threads.
• Multiplateforme — le même code peut fonctionner sur JVM, JavaScript et Native.
• Concision — un minimum de code passe-partout, un maximum d'expressivité.
• Sécurité — prise en charge intégrée de SSL/TLS, de l'authentification et de CORS.

Passons à la pratique et créons un serveur et un client WebSocket simples en Kotlin.

2. Création d'un serveur WebSocket en Kotlin avec Ktor

2.1. Configuration du projet

Pour commencer, créez un nouveau projet Gradle ou Maven. Ajoutez les dépendances Ktor dans build.gradle.kts :

dependencies {    implementation("io.ktor:ktor-server-core:2.3.0")    implementation("io.ktor:ktor-server-netty:2.3.0")    implementation("io.ktor:ktor-server-websockets:2.3.0")    implementation("ch.qos.logback:logback-classic:1.4.11")}

2.2. Implémentation du serveur

Créons un serveur WebSocket qui accepte les connexions, lit les messages et y répond. L'exemple ci-dessous utilise la bibliothèque Ktor avec des coroutines :

import io.ktor.server.engine.*import io.ktor.server.netty.*import io.ktor.server.websocket.*import io.ktor.websocket.*import kotlinx.coroutines.delay

fun main() {    embeddedServer(Netty, port = 8080) {        install(WebSockets)        webSocket("/chat") {            send(Frame.Text("Bienvenue dans le chat !"))            for (frame in incoming) {                if (frame is Frame.Text) {                    val text = frame.readText()                    println("Reçu : $text")                    send(Frame.Text("Écho : $text"))                }            }        }    }.start(wait = true)}

Ici nous :

• Installons le plugin WebSockets.
• Définissons le point d'accès /chat.
• Dans la coroutine, traitons les trames entrantes et envoyons une réponse en écho.

2.3. Gestion des erreurs et fermeture de la connexion

Dans les applications réelles, il est important de gérer correctement les interruptions de connexion. Ajoutons la gestion des exceptions et la fermeture de session :

webSocket("/chat") {    try {        send(Frame.Text("Connexion établie"))        for (frame in incoming) {            when (frame) {                is Frame.Text -> {                    val text = frame.readText()                    if (text.equals("exit", ignoreCase = true)) {