Bibliothèque WebSocket Gorilla pour Go | Guide

Bibliothèque Gorilla WebSocket pour Go (Golang)

Gorilla WebSocket est l'une des bibliothèques les plus populaires et les plus stables pour travailler avec le protocole WebSocket en langage Go (Golang). Elle fait partie de l'écosystème Gorilla Toolkit et offre aux développeurs un outil puissant, flexible et performant pour créer des applications en temps réel : chats, notifications en temps réel, jeux en ligne, tableaux de bord et bien plus encore.

La bibliothèque implémente entièrement la spécification RFC 6455, prend en charge à la fois les côtés serveur et client, et gère automatiquement la fragmentation des messages, les mécanismes ping/pong et le contrôle de la connexion. Gorilla WebSocket est écrite en Go pur sans dépendances externes, ce qui la rend légère et rapide.

Fonctionnalités principales

Prise en charge complète du protocole WebSocket (RFC 6455).
API simple et intuitive.
Prise en charge des messages textuels et binaires.
Gestion automatique du ping/pong pour maintenir la connexion.
Possibilité de vérifier l'origine de la requête (Origin).
Prise en charge de la compression des messages (permessage-deflate).
Fonctionne avec TLS/HTTPS.
Haute performance et faible consommation de mémoire.

Installation

Pour installer la bibliothèque, exécutez la commande :

go get github.com/gorilla/websocket

Ensuite, importez le package dans votre code :

import "github.com/gorilla/websocket"

Exemple de serveur WebSocket en Go

Voici un serveur simple qui accepte les connexions WebSocket et renvoie les messages reçus (serveur écho) :

package main

import (    "fmt"    "log"    "net/http"

    "github.com/gorilla/websocket")

var upgrader = websocket.Upgrader{    CheckOrigin: func(r *http.Request) bool {        return true // Autoriser toutes les origines (pour le développement)    },}

func echoHandler(w http.ResponseWriter, r *http.Request) {    // Établir la connexion WebSocket    conn, err := upgrader.Upgrade(w, r, nil)    if err != nil {        log.Print("Erreur de mise à niveau :", err)        return    }    defer conn.Close()

    // Boucle infinie de lecture des messages    for {        messageType, message, err := conn.ReadMessage()        if err != nil {            log.Println("Erreur de lecture :", err)            break        }        log.Printf("Message reçu : %s", message)

        // Renvoyer le message        err = conn.WriteMessage(messageType, message)        if err != nil {            log.Println("Erreur d'écriture :", err)            break        }    }}

func main() {    http.HandleFunc("/echo", echoHandler)    fmt.Println("Serveur démarré sur :8080")    log.Fatal(http.ListenAndServe(":8080", nil))}

Client WebSocket en Go

Exemple d'un client simple qui se connecte au serveur et envoie un message :

package main

import (    "fmt"    "log"    "net/url"

    "github.com/gorilla/websocket")

func main() {    u := url.URL{Scheme: "ws", Host: "localhost:8080", Path: "/echo"}    fmt.Printf("Connexion à %s", u.String())

    conn, _, err := websocket.DefaultDialer.Dial(u.String(), nil)    if err != nil {        log.Fatal("Erreur de connexion :", err)    }    defer conn.Close()

    // Envoyer un message textuel    err = conn.WriteMessage(websocket.TextMessage, []byte("Bonjour, WebSocket!"))    if err != nil {        log.Fatal("Erreur d'envoi :", err)    }

    // Lire la réponse    _, message, err := conn.ReadMessage()    if err != nil {        log.Fatal("Erreur de lecture :", err)    }    fmt.Printf("Réponse reçue : %s", message)}