WebSocket in Go: Erstellung von Echtzeit-Anwendungen in Golang

WebSocket auf Go: Erstellung von Echtzeit-Anwendungen mit Golang

Moderne Webanwendungen erfordern zunehmend eine sofortige Datenübertragung zwischen Client und Server. Das traditionelle HTTP-Anfrage-Antwort-Modell eignet sich nicht für Chats, Online-Spiele, Handelsplattformen und Echtzeit-Überwachung. Hier kommt das Protokoll WebSocket zum Einsatz, das eine permanente bidirektionale Verbindung herstellt. In diesem Artikel auf pythonlib.ru werden wir uns ansehen, wie man eine Echtzeit-Anwendung mit Go (Golang) unter Verwendung von WebSocket erstellt.

Go ist aufgrund seiner integrierten Unterstützung für Nebenläufigkeit (Goroutinen und Channels) und seiner hohen Leistung ideal für diese Aufgabe geeignet. Gemeinsam werden wir einen einfachen WebSocket-Server schreiben, einen Chat implementieren und typische Probleme betrachten.

Was ist WebSocket und warum wird es in Go benötigt?

WebSocket ist ein Protokoll, das über TCP arbeitet. Es wird als HTTP-Anfrage (Handshake) initiiert, woraufhin die Verbindung zu einem permanenten bidirektionalen Kanal "upgegradet" wird. Im Gegensatz zu Long Polling oder Server-Sent Events ermöglicht WebSocket es Server und Client, jederzeit Daten zu senden, ohne die Verbindung neu aufbauen zu müssen.

Vorteile der Verwendung von WebSocket in Go:

• Nebenläufigkeit: Goroutinen verarbeiten problemlos tausende gleichzeitige Verbindungen.
• Leistung: Minimaler Speicherverbrauch pro Verbindung.
• Einfachheit: Die Standardbibliothek net/http und das Paket gorilla/websocket machen den Code prägnant.

WebSocket wird häufig eingesetzt in:

• Chat-Systemen und Messengern
• Online-Editoren (Google Docs)
• Handelsterminals (Börsenkurse)
• Spielen und Simulationen

Installation und Konfiguration von WebSocket in Go

Go hat keine integrierte WebSocket-Unterstützung in der Standardbibliothek, aber es gibt das hervorragende Paket gorilla/websocket. Installieren wir es:

go get github.com/gorilla/websocket

Erstellen wir einen minimalen HTTP-Server, der WebSocket-Verbindungen bedient. Zunächst schreiben wir eine Handler-Funktion, die die HTTP-Anfrage zu WebSocket "upgradet".

package main

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

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

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

    // Endlose Schleife zum Lesen von Nachrichten    for {        messageType, message, err := conn.ReadMessage()        if err != nil {            log.Println("Read error:", err)            break        }        log.Printf("Received: %s", message)

        // Echo-Antwort: sende dieselbe Nachricht zurück        if err := conn.WriteMessage(messageType, message); err != nil {            log.Println("Write error:", err)            break        }    }}

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

Dieser Code erstellt einen einfachen Echo-Server. Der Client verbindet sich mit ws://localhost:8080/ws und erhält alle gesendeten Nachrichten zurück.

Erstellung eines Echtzeit-Chats auf Go mit WebSocket

Jetzt verkomplizieren wir die Aufgabe: Wir erstellen einen Chat, in dem alle verbundenen Clients die Nachrichten der anderen sehen. Dazu müssen wir die Liste der Verbindungen verwalten und Nachrichten verteilen.

Hauptkomponenten:

• Hub — der zentrale Manager, der Clients registriert/entfernt und Nachrichten verteilt.
• Clien