WebSocket sur Kotlin : création d'applications en temps réel de zéro

Introduction : pourquoi WebSocket et Kotlin sont le duo idéal pour le temps réel

Les applications web modernes exigent de plus en plus souvent une transmission instantanée des données : des chats et jeux en ligne aux cotations boursières et systèmes de monitoring. Le HTTP traditionnel avec son modèle requête-réponse est inefficace pour de telles tâches — il génère des latences et un trafic superflu. C'est là que WebSocket vient à la rescousse — un protocole assurant une connexion bidirectionnelle permanente entre le client et le serveur.

Kotlin, avec sa syntaxe concise, sa compatibilité totale avec Java et son puissant support des coroutines, est idéal pour créer des applications temps réel. Le framework Ktor de JetBrains offre un support intégré de WebSocket, permettant d'écrire du code performant et sécurisé en quelques lignes seulement.

Dans cet article, nous allons voir comment créer une application temps réel complète en Kotlin avec WebSocket. Vous apprendrez :

• Comment configurer un serveur WebSocket avec Ktor
• Comment s'y connecter depuis un navigateur ou une application mobile
• Comment organiser l'échange de messages en temps réel
• Quels patterns et approches utiliser pour la montée en charge

1. Les bases de WebSocket et ses avantages en Kotlin

Qu'est-ce que WebSocket ?

WebSocket est un protocole fonctionnant au-dessus de TCP. Après l'établissement de la connexion via une poignée de main HTTP (upgrade), le client et le serveur peuvent échanger des données dans les deux sens sans requêtes répétées. Cela réduit considérablement la latence et diminue la charge réseau.

Pourquoi Kotlin ?

• Les coroutines — permettent de gérer des milliers de connexions WebSocket simultanées sans bloquer les threads.
• Ktor — un framework asynchrone léger avec un support natif de WebSocket.
• Sécurité de typage — les erreurs sont détectées à la compilation, pas à l'exécution.
• Multiplateforme — le même code peut fonctionner sur JVM, JS et Native.

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

Étape 1 : Configuration du projet

Ajoutez les dépendances 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")}

Étape 2 : Serveur de base avec WebSocket

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)}

Ce code crée un simple serveur d'écho. Lors de la connexion, le client reçoit un message de bienvenue, et chaque message qu'il envoie lui est renvoyé avec le préfixe "Écho :".

Étape 3 : Gestion de plusieurs clients et diffusion

Pour un chat en temps réel, il faut stocker la liste des sessions actives :

import io.ktor.server.engine.*import io.ktor.server.netty.*import io.ktor.server.websocket.*import io.ktor.websocket.*import kotlinx.coroutines.channels.ConcurrentHashMap

val clients = ConcurrentHashMap<String, WebSocketSession>()

fun main() {    embeddedServer(Netty, port = 8080) {        install(WebSockets)        webSocket("/chat") {            val userName = "User_${System.currentTimeMillis()}"            clients[userName] = this            try {