WebSockets in Go: Eine Echtzeit-Anwendung von Grund auf neu schreiben

Warum Go und WebSockets das ideale Gespann für Echtzeit sind?

Stellen Sie sich folgende Situation vor: Sie starten einen Online-Chat, einen Börsenterminal oder ein Multiplayer-Spiel. Die Benutzer erwarten eine sofortige Reaktion. Niemand möchte die Seite manuell aktualisieren oder 5 Sekunden warten, bis eine Antwort vom Server kommt. Hier kommen WebSockets ins Spiel.

Go (Golang) eignet sich hervorragend für diese Aufgabe. Seine leichtgewichtigen Goroutinen ermöglichen es, zehntausende gleichzeitige Verbindungen ohne Leistungseinbußen zu halten. Und die Standardbibliothek net/http in Kombination mit dem Paket gorilla/websocket macht das Schreiben von Echtzeit-Anwendungen zu einem reinen Vergnügen.

In diesem Artikel werden wir uns ansehen, wie WebSocket in Go funktioniert, einen einfachen Chat schreiben und Best Practices besprechen. Los geht's!

Was ist WebSocket und worin ist es besser als HTTP?

Kurz gesagt – WebSocket ist ein Protokoll, das eine dauerhafte bidirektionale Verbindung zwischen Client (Browser) und Server herstellt. Im Gegensatz zum klassischen HTTP, bei dem der Client immer die Anfrage initiiert, erlaubt WebSocket dem Server, jederzeit selbst Daten an den Client zu senden.

Die Vorteile liegen auf der Hand:

• Sofortige Zustellung – keine Verzögerungen durch den Aufbau einer neuen Verbindung.
• Weniger Traffic – Header werden nur einmal beim Handshake gesendet.
• Effizienz – eine Verbindung statt tausend HTTP-Anfragen.

Go kommt hervorragend mit der Verwaltung dieser Verbindungen zurecht. Anstatt Betriebssystem-Threads zu erzeugen (was teuer ist), verwendet Go Goroutinen. Eine Goroutine – eine Verbindung. Tausende Goroutinen arbeiten auf wenigen Betriebssystem-Threads und verbrauchen dabei ein Minimum an Speicher.

Installation und Vorbereitung des Go-Projekts

Angenommen, Go ist bereits installiert. Falls nicht – brew install go oder von golang.org herunterladen.

Erstellen wir ein neues Modul:

mkdir go-websocket-chatcd go-websocket-chatgo mod init go-websocket-chat

Jetzt installieren wir die beliebteste Bibliothek gorilla/websocket:

go get github.com/gorilla/websocket

Fertig. Jetzt haben wir alles, um eine Echtzeit-Anwendung in Go zu erstellen.

Einen WebSocket-Server in Go schreiben

Beginnen wir mit dem Einfachsten – einem Echo-Server. Der Client sendet eine Nachricht, der Server gibt sie zurück. Das hilft, die grundlegende Mechanik zu verstehen.

Schritt 1: Struktur und Upgrade der Verbindung

Eine WebSocket-Verbindung beginnt mit einer HTTP-Anfrage (Handshake). Der Server muss diese auf WebSocket „upgraden". In Go geschieht dies über http.Hijacker oder über die praktische Methode Upgrader aus dem Paket gorilla/websocket.

Erstellen Sie die Datei main.go:

package main

import (    "fmt"    "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 handleWebSocket(w http.ResponseWriter, r *http.Request) {    conn, err := upgrader.Upgrade(w, r, nil)    if err != nil {        log.Print("Upgrade-Fehler:", err)        return    }    defer conn.Close()

    // Endlose Schleife zum Lesen und Schreiben    for {        messageType, message, err := conn.ReadMessage()        if err != nil {            log.Println("Lesefehler:", err)            break        }        log.Printf("Empfangen: %s", message)

        // Das Gleiche zurücksenden        err = conn.WriteMessage(messageType, message)        if err != nil {            log.Println("Schreibfehler:", err)            break        }    }}

func main() {    http.HandleFunc("/ws", handleWebSocket)    fmt.Println("Server gestartet auf :8080")    log.Fatal(http.ListenAndServe(":8080", nil))}

Starten Sie: go run main.go