Fiber WebSocket Beispiel

Basierend auf dem Fiber Fasthttp WebSocket-Komponente wird die Methode *fiber.Ctx verwendet, wie z.B. Locals, Params, Query und Cookies. Hier ist ein Beispiel zur Verwendung von WebSocket in Fiber.

Hinweis: Go Version 1.18 und höher ist erforderlich.

Installation

go get -u github.com/gofiber/fiber/v2
go get -u github.com/gofiber/contrib/websocket

Funktionssignatur

func New(handler func(*websocket.Conn), config ...websocket.Config) fiber.Handler {

Konfiguration

Eigenschaft Typ Beschreibung Standardwert
Filter func(*fiber.Ctx) bool Definiert eine Funktion zum Überspringen des Middleware. nil
HandshakeTimeout time.Duration HandshakeTimeout gibt die Dauer für den Abschluss des Handshakes an. 0 (kein Timeout)
Subprotocols []string Subprotocols geben die vom Client angeforderten Subprotokolle an. nil
Ursprünge []string Basierend auf dem Origin-Header zugelassene Ursprünge. Wenn leer, werden alle Ursprünge zugelassen. nil
ReadBufferSize int ReadBufferSize gibt die E/A-Puffergröße für den Empfang von Nachrichten (in Bytes) an. 0 (Standardgröße)
WriteBufferSize int WriteBufferSize gibt die E/A-Puffergröße für das Senden von Nachrichten (in Bytes) an. 0 (Standardgröße)
WriteBufferPool websocket.BufferPool WriteBufferPool ist der für Schreibvorgänge verwendete Pufferpool. nil
EnableCompression bool EnableCompression gibt an, ob der Client für jede Nachricht eine Komprimierung verhandeln soll (RFC 7692). false
RecoverHandler func(*websocket.Conn) void RecoverHandler ist eine Behandlungsfunktion zur Wiederherstellung von Panik. defaultRecover

Beispiel

package main

import (
	"log"
	"github.com/gofiber/fiber/v2"
	"github.com/gofiber/contrib/websocket"
)

func main() {
	app := fiber.New()

	app.Use("/ws", func(c *fiber.Ctx) error {
		// Gibt true zurück, wenn der Client eine Aktualisierung auf das WebSocket-Protokoll anfordert
		if websocket.IsWebSocketUpgrade(c) {
			c.Locals("allowed", true)
			return c.Next()
		}
		return fiber.ErrUpgradeRequired
	})

	app.Get("/ws/:id", websocket.New(func(c *websocket.Conn) {
		// c.Locals wird zu *websocket.Conn hinzugefügt
		log.Println(c.Locals("allowed"))  // true
		log.Println(c.Params("id"))       // 123
		log.Println(c.Query("v"))         // 1.0
		log.Println(c.Cookies("session")) // ""

		var (
			mt  int
			msg []byte
			err error
		)
		for {
			if mt, msg, err = c.ReadMessage(); err != nil {
				log.Println("read:", err)
				break
			}
			log.Printf("recv: %s", msg)

			if err = c.WriteMessage(mt, msg); err != nil {
				log.Println("write:", err)
				break
			}
		}
	}))

	log.Fatal(app.Listen(":3000"))
	// Zugriff auf WebSocket-Server: ws://localhost:3000/ws/123?v=1.0
	// https://www.websocket.org/echo.html
}

Hinweise zur Verwendung des Cache-Middleware

Wenn beim Verwenden des Cache-Middleware ein websocket: bad handshake Fehler auftritt, verwenden Sie config.Next, um den WebSocket-Pfad zu überspringen.

app := fiber.New()
app.Use(cache.New(cache.Config{
	Next: func(c *fiber.Ctx) bool {
		return strings.Contains(c.Route().Path, "/ws")
	},
}))

app.Get("/ws/:id", websocket.New(func(c *websocket.Conn) {}))

Überlegungen zur Verwendung des Wiederherstellungs-Middleware

Aufgrund interner Implementierungsgründe ist das Wiederherstellungs-Middleware derzeit nicht mit dem WebSocket-Middleware kompatibel. Bitte verwenden Sie config.RecoverHandler, um einen Wiederherstellungs-Handler für die WebSocket-Endpunkte hinzuzufügen. Standardmäßig stellt die RecoverHandler-Konfiguration nach einem Panikfall den Stack-Trace in stderr dar und gibt auch eine Antwort zurück, die die Panikmeldung im error-Feld enthält.

app := fiber.New()

app.Use(cache.New(cache.Config{
    Next: func(c *fiber.Ctx) bool {
        return strings.Contains(c.Route().Path, "/ws")
    },
}))

cfg := Config{
    RecoverHandler: func(conn *Conn) {
        if err := recover(); err != nil {
            conn.WriteJSON(fiber.Map{"customError": "Fehler aufgetreten"})
        }
    },
}

app.Get("/ws/:id", websocket.New(func(c *websocket.Conn) {}, cfg))