Go Academy · Lektion

gorilla/websocket verwenden

Verbindungen upgraden und verwalten

gorilla/websocket verwenden ist eine kostenlose Go Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Go Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Go Academy-Kurs umfasst insgesamt 4 Lektionen.

Die gorilla/websocket-Bibliothek

gorilla/websocket ist die am weitesten verbreitete Go-Bibliothek für WebSockets. Sie übernimmt den Upgrade-Handshake und stellt Ihnen ein Verbindungsobjekt zum Lesen und Schreiben von Frames bereit. Installieren Sie sie mit go get github.com/gorilla/websocket.

import "github.com/gorilla/websocket"

Der Upgrader

Ein Upgrader wandelt eine HTTP-Anfrage in eine WebSocket-Verbindung um. Sie konfigurieren Puffergrößen und eine Origin-Prüfung.

var upgrader = websocket.Upgrader{
    ReadBufferSize:  1024,
    WriteBufferSize: 1024,
}

CheckOrigin und Sicherheit

Standardmäßig weist der Upgrader Anfragen aus anderen Origins zurück. Während der Entwicklung können Sie diese Prüfung lockern. In der Produktion sollten Sie jedoch den Origin-Header validieren, um Cross-Site-WebSocket-Hijacking zu verhindern.

upgrader.CheckOrigin = func(r *http.Request) bool {
    return r.Header.Get("Origin") == "https://myapp.com"
}

Upgrade in einem Handler

Rufen Sie innerhalb einer http.HandlerFunc Upgrade auf. Bei Erfolg erhalten Sie eine *websocket.Conn.

func wsHandler(w http.ResponseWriter, r *http.Request) {
    conn, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        return
    }
    defer conn.Close()
    // read/write loop here
}

Nachrichten lesen

ReadMessage blockiert, bis ein Frame eintrifft, und gibt den Nachrichtentyp sowie die Payload-Bytes zurück.

mt, data, err := conn.ReadMessage()
if err != nil {
    return // client closed or error
}
fmt.Printf("got %d bytes\n", len(data))
_ = mt

Nachrichten schreiben

WriteMessage sendet einen Frame des angegebenen Typs:

err := conn.WriteMessage(websocket.TextMessage, []byte("hello"))
if err != nil {
    return
}

Die Echo-Schleife

Ein klassisches Beispiel liest eine Nachricht und schreibt sie zurück. Die Schleife endet, sobald Read einen Fehler zurückgibt (der Client hat die Verbindung getrennt).

for {
    mt, msg, err := conn.ReadMessage()
    if err != nil {
        break
    }
    conn.WriteMessage(mt, msg)
}

JSON-Hilfsfunktionen

gorilla stellt ReadJSON und WriteJSON bereit, um Go-Werte direkt über den Socket zu marshalen. Das ist praktisch für strukturierte Nachrichten. Das Feld Msg trägt im echten Quelltext das Tag json:"text".

type Msg struct {
    Text string // tag: json text
}
var m Msg
conn.ReadJSON(&m)
conn.WriteJSON(Msg{Text: "ack"})

Regel: ein Reader, ein Writer

Wichtig: Eine einzelne Verbindung erlaubt nur jeweils einen nebenläufigen Reader und Writer. Wenn mehrere Goroutinen schreiben, schützen Sie die Schreibvorgänge mit einem Mutex oder bündeln Sie sie in einer einzigen Goroutine (das wird beim Broadcasting behandelt).

Route registrieren

Binden Sie den Handler wie jede andere HTTP-Route ein. Clients verbinden sich mit ws://host/ws.

http.HandleFunc("/ws", wsHandler)
http.ListenAndServe(":8080", nil)

Ausführbar: Analogie zum JSON-Roundtrip

WebSocket-Code benötigt die externe Bibliothek. Dieses Beispiel aus der Standardbibliothek bildet ReadJSON/WriteJSON nach, indem es eine eingehende Nachricht in eine Map unmarshalt und eine Antwort marshalt.

package main

import (
    "encoding/json"
    "fmt"
)

func main() {
    in := []byte("{\"text\":\"ping\"}")
    var m map[string]string
    json.Unmarshal(in, &m)
    reply, _ := json.Marshal(map[string]string{"text": m["text"] + "-ack"})
    fmt.Println(string(reply))
}

Kurztest

Testen Sie Ihr Verständnis der Verwendung von gorilla/websocket.

Zusammenfassung

Sie haben gelernt, gorilla/websocket zu verwenden:

Ein Upgrader führt den Handshake durch; validieren Sie CheckOrigin
Upgrade liefert eine *websocket.Conn
Verwenden Sie ReadMessage/WriteMessage oder die JSON-Hilfsfunktionen
Pro Verbindung darf es jeweils nur einen Reader und einen Writer geben

Häufig gestellte Fragen

Ist die Lektion „gorilla/websocket verwenden“ kostenlos?

Ja — der vollständige Text von „gorilla/websocket verwenden“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Go Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Go Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „gorilla/websocket verwenden“?

Verbindungen upgraden und verwalten Du übst Go Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Go Academy zu starten?

Keine Vorkenntnisse erforderlich. Go Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.

Wie lange dauert die Lektion „gorilla/websocket verwenden“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Go Academy-Lektion Code schreiben und ausführen?

Ja. Jede Go Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Go Academy