WebSocket in Go: Die Bibliothek gorilla/websocket und die Standardimplementierung

WebSocket-Bibliothek Go (Golang): gorilla/websocket und das standardmäßige net/http

WebSocket ist ein Protokoll, das eine Vollduplex-Kommunikation zwischen Client und Server über eine einzige langlebige TCP-Verbindung ermöglicht. Im Gegensatz zum klassischen HTTP können Daten nach dem Verbindungsaufbau jederzeit in beide Richtungen übertragen werden, ohne dass ständige Anfragen vom Client erforderlich sind. Dies ist die ideale Lösung für Chats, Echtzeit-Benachrichtigungen, Online-Spiele und Handelsplattformen.

Im Go-Ökosystem (Golang) gibt es mehrere Möglichkeiten, mit WebSocket zu arbeiten. Die beliebteste und bewährteste ist die Bibliothek gorilla/websocket. Seit Go 1.22 ist es jedoch auch möglich, einen grundlegenden WebSocket-Server ohne externe Abhängigkeiten zu implementieren, indem das Standardpaket net/http verwendet wird. In diesem Artikel werden wir beide Ansätze im Detail besprechen.

Installation der Bibliothek gorilla/websocket

Um mit gorilla/websocket zu beginnen, installieren Sie es über go get:

go get github.com/gorilla/websocket

Die Bibliothek bietet eine benutzerfreundliche API zum Erstellen sowohl von Server- als auch von Client-Komponenten. Sie verarbeitet den Handshake, das Nachrichten-Framing, unterstützt Komprimierung und automatisches Ping/Pong.

WebSocket-Server mit gorilla/websocket

Betrachten wir ein Beispiel eines einfachen Echo-Servers. Der Client sendet eine Nachricht, der Server sendet sie zurück:

package main

import (    "log"    "net/http"    "github.com/gorilla/websocket")

var upgrader = websocket.Upgrader{    CheckOrigin: func(r *http.Request) bool {        return true // erlaubt alle Ursprünge (für die Entwicklung)    },}

func echoHandler(w http.ResponseWriter, r *http.Request) {    conn, err := upgrader.Upgrade(w, r, nil)    if err != nil {        log.Print("Upgrade fehlgeschlagen:", err)        return    }    defer conn.Close()

    for {        messageType, message, err := conn.ReadMessage()        if err != nil {            log.Println("Lesefehler:", err)            break        }        log.Printf("Empfangen: %s", message)

        if err := conn.WriteMessage(messageType, message); err != nil {            log.Println("Schreibfehler:", err)            break        }    }}

func main() {    http.HandleFunc("/echo", echoHandler)    log.Fatal(http.ListenAndServe(":8080", nil))}

Hier wandelt Upgrader eine normale HTTP-Anfrage in eine WebSocket-Verbindung um. Die Funktion CheckOrigin steuert, von welchen Domains Verbindungen erlaubt sind. In der Produktion wird empfohlen, bestimmte Quellen zu überprüfen.

WebSocket-Client mit gorilla/websocket

Ein Beispiel eines Clients, der eine Verbindung zu unserem Server herstellt und eine Nachricht sendet:

package main

import (    "log"    "os"    "os/signal"    "time"    "github.com/gorilla/websocket")

func main() {    interrupt := make(chan os.Signal, 1)    signal.Notify(interrupt, os.Interrupt)

    url := "ws://localhost:8080/echo"    c, _, err := websocket.DefaultDialer.Dial(url, nil)    if err != nil {        log.Fatal("dial:", err)    }    defer c.Close()

    done := make(chan struct{})

    // Goroutine zum Lesen der Antworten    go func() {        defer close(done)        for {            _, message, err := c.ReadMessage()            if err != nil {                log.Println("read:", err)                return            }            log.Printf("recv: %s", message)        }    }()

    // Senden einer Nachricht    ticker := time.NewTicker(time.Second)    defer ticker.Stop()

    for {        select {        case <-done:            return        case t := <-ticker.C:            err := c.WriteMessage(websocket.TextMessage, []byte(t.String()))            if err != nil {                log.Println("write:", err)                return            }        case <-interrupt:            log