WebSockets en Kotlin : Créer des applications en temps réel de zéro

WebSockets en Kotlin : de la théorie à la magie du temps réel

Imaginez que vous ouvrez un messager, envoyez un message — et il apparaît instantanément chez votre interlocuteur. Sans rechargement de page, sans requêtes constantes au serveur. Ce n'est pas de la magie, ce sont les WebSockets en Kotlin. Si vous avez déjà voulu créer votre propre chat, un système de notifications en temps réel ou un jeu multijoueur, vous êtes au bon endroit.

Dans cet article, nous allons voir comment fonctionnent les WebSockets, écrire une application temps réel complète en Kotlin en utilisant Ktor, et je vous montrerai du code que vous pouvez exécuter immédiatement. C'est parti !

Que sont les WebSockets et pourquoi en avez-vous besoin en Kotlin ?

WebSocket est un protocole de communication bidirectionnelle entre un client et un serveur sur une seule connexion TCP. Contrairement au HTTP classique où le client initie toujours la requête, WebSocket permet au serveur d'envoyer lui-même des données au client à tout moment.

En quoi WebSocket est-il meilleur que HTTP ?

• Instantaneité : les données sont livrées en millisecondes
• Économie de trafic : pas d'en-têtes superflus comme en HTTP
• Bidirectionnalité : le serveur peut initier l'envoi
• Connexion permanente : pas besoin de rétablir à chaque fois

Kotlin, avec ses coroutines et le framework Ktor, est idéal pour travailler avec les WebSockets. Asynchronisme, légèreté et syntaxe expressive — voilà ce qui rend le développement Kotlin WebSocket si agréable.

Quand utiliser les WebSockets ?

Voici quelques scénarios où les applications temps réel en Kotlin avec WebSockets seront indispensables :

• Chats et messageries — transmission de messages en temps réel
• Systèmes de notifications — alertes, fenêtres contextuelles, mises à jour de statut
• Jeux en ligne — synchronisation des joueurs
• Cotations boursières — mise à jour des prix sans rechargement
• Édition collaborative — fonctionnalité de type Google Docs

Configuration du projet : Ktor + WebSockets

Pour créer un serveur WebSocket en Kotlin, nous allons utiliser Ktor — un framework asynchrone moderne de JetBrains. Configurons le projet.

Étape 1 : Ajouter les dépendances

Si vous utilisez Gradle (et je suis sûr que c'est le cas), ajoutez dans build.gradle.kts :

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

Étape 2 : Créer le serveur WebSocket

Écrivons maintenant le serveur lui-même. Il acceptera les connexions et diffusera les messages à tous les clients connectés — la logique de base d'un chat.

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

fun main() {    val clients = mutableSetOf<WebSocketSession>()

    embeddedServer(Netty, port = 8080) {        install(WebSockets) {            pingPeriod = 15_000 // 15 secondes            timeout = 15_000            maxFrameSize = Long.MAX_VALUE        }

        routing {            webSocket("/chat") {                // Ajouter le client                clients.add(this)                println("Nouvelle connexion : $this")

                try {                    for (frame in incoming) {                        if (frame is Frame.Text) {                            val message = frame.readText()                            println("Reçu : $message")

                            // Envoyer à tous les clients