So registrieren Sie eine neue WebSocket-Verbindung bei gooptic

php-Editor Yuzai zeigt Ihnen, wie Sie eine neue WebSocket-Verbindung bei gooptic registrieren. GoOptic ist eine Open-Source-Websocket-Bibliothek der Go-Sprache zum Erstellen leistungsstarker Echtzeit-Kommunikationsanwendungen. Um eine neue WebSocket-Verbindung zu registrieren, müssen Sie zunächst die GoOptic-Bibliothek in Ihr Go-Programm importieren. Anschließend können Sie die von GoOptic bereitgestellten Funktionen verwenden, um einen Websocket-Server zu erstellen und die Adresse und den Port anzugeben, auf dem lauscht werden soll. Als Nächstes können Sie die von GoOptic bereitgestellte HandleFunc-Funktion verwenden, um verschiedene Ereignisse der Websocket-Verbindung zu verarbeiten, z. B. das Empfangen von Nachrichten, das Senden von Nachrichten usw. Rufen Sie abschließend die von GoOptic bereitgestellte Serve-Funktion auf, um den Websocket-Server zu starten, damit er neue Verbindungen akzeptieren kann. Mit diesen Schritten können Sie erfolgreich eine neue WebSocket-Verbindung bei gooptic registrieren.

Frageninhalte

Ich versuche, einen einfachen Websocket-Server einzurichten, der dem Client in unbekannten Abständen einige Inhalte bereitstellen soll.

Mein Code sieht derzeit so aus:

router.go

func setuproutes(app *fiber.app) error {

    app.get("/whop/validate", handler.handlewhopvalidate)
    /*other non-websocket routes*/

    /*...*/

    app.get("/ws/monitor", websocket.new(wshandler.handlewsmonitor))

    app.use(func(c *fiber.ctx) error {
        c.sendstatus(404)
        return c.next()
    })

    return nil
}

handler.go

package handlers

import (
    "fmt"
    "log"

    "github.com/gofiber/websocket/v2"
)

var register = make(chan *websocket.conn)
var unregister = make(chan *websocket.conn)

func handlewsmonitor(c *websocket.conn) {
    go socketlistener()
    defer func() {
        unregister <- c
        //may need to check whether connection is already closed before re-closing?
        c.close()
    }()
    //sends conn into channel
    register <- c
    for {
        messagetype, message, err := c.readmessage()
        if err != nil {
            if websocket.isunexpectedcloseerror(err, websocket.closegoingaway, websocket.closeabnormalclosure) {
                log.println("read error:", err)
            }
            return
        }
        if messagetype == websocket.textmessage {
            log.println("got textmessage:", string(message))
        } else {
            log.println("received message of type:", messagetype)
        }
    }
}

func socketlistener() {
    for {
        select {
        case c := <-register:
            messagetype, message, err := c.readmessage()
            if err != nil {
                log.println(err)
                unregister <- c
                return
            }

            fmt.printf("got message of type: %d\nmessage:%s\n", messagetype, string(message))
            fmt.printf("connection params: %s\n", c.params("id"))
            //append to list of co
        case c := <-unregister:
            //remove conection from list of clients
            c.close()
            fmt.printf("closed connection\n")

        }

    }
}

Das Problem, das ich habe, ist, dass beim Herstellen einer Verbindung zum Websocket mein Registrierungsauswahlfall fehlt (ich möchte die Client-Verbindung zur Karte mit der UUID registrieren, die ich dem Client zuvor bereitgestellt habe).

client.go

package main

import (
    "flag"
    "log"
    "net/url"

    "github.com/fasthttp/websocket"
)

type Client struct {
    C *websocket.Conn
}

func main() {
    addr := flag.String("addr", "localhost:8080", "http service address")
    u := url.URL{
        Scheme:   "ws",
        Host:     *addr,
        Path:     "/ws/monitor",
        RawQuery: "id=12",
    }
    wsClient := &Client{}

    log.Printf("connecting to %s\n", u.String())
    // Connect to the WebSocket server
    conn, resp, err := websocket.DefaultDialer.Dial(u.String(), nil)
    if err != nil {
        log.Fatal("Dial:", err)
    }
    wsClient.C = conn
    if resp != nil {
        log.Println("Got response:", resp)
    }
    defer wsClient.closeConn()
}

func (client *Client) closeConn() {
    err := client.C.WriteMessage(
        websocket.CloseMessage,
        websocket.FormatCloseMessage(websocket.CloseNormalClosure, ""),
    )
    if err != nil {
        log.Println("Write close:", err)
        return
    }
    client.C.Close()
    log.Println("Connection closed")
}

Fehlt etwas in

handler.go oder sollte ich einen anderen Ansatz wählen, wenn ich den Client zum Herstellen einer Verbindung zum Server verwende?

Problemumgehung

Meinen Tests zufolge trifft der ausgewählte Fall des Registers zu (der von mir verwendete Code ist unten an dieser Antwort angehängt).

Aber ich habe andere Probleme im Code gefunden:

Zwischen
1. unregister chan 是无缓冲的，socketlistener 中的 unregister <- c​​ 将被阻塞。当代码到达 unregister <- c​​ 时，它和 case c := <-unregister kommt es zu einem Deadlock.
2. Sieht so aus, als bräuchten wir nur einen socketlistener goroutine。如果是这种情况，应将其移至 handlewsmonitor für den gesamten Server.
3. handlewsmonitor 和 socketlistener 都从连接中读取。 socketlistenerWas sind deine Aufgaben? Es scheint, dass es nicht aus der Verbindung gelesen werden sollte.

Wenn ich noch einmal darüber nachdenke, scheint es, dass es direkt in handlewsmonitor中的地图上添加连接和删除连接。 socketlistener vollständig gelöscht werden kann. Einfachheit sollte ein zentrales Ziel des Designs sein. Siehe das Kussprinzip.

package main

import (
    "log"

    "github.com/gofiber/fiber/v2"
    "github.com/gofiber/websocket/v2"
)

var (
    register   = make(chan *websocket.Conn)
    unregister = make(chan *websocket.Conn)
)

func main() {
    // Make it easy to find out which line prints the log.
    log.SetFlags(log.Lshortfile)
    app := fiber.New()

    app.Get("/ws/monitor", websocket.New(HandleWsMonitor))

    log.Fatal(app.Listen(":8080"))
}

func HandleWsMonitor(c *websocket.Conn) {
    // It seems the we only need one SocketListener goroutine for the whole server.
    // If this is the case, the next line should be moved outside of this func.
    go SocketListener()
    defer func() {
        unregister <- c
        c.Close()
    }()

    register <- c
    for {
        messageType, message, err := c.ReadMessage()
        if err != nil {
            if websocket.IsUnexpectedCloseError(err, websocket.CloseGoingAway, websocket.CloseAbnormalClosure) {
                log.Println("read error:", err)
            }
            return
        }
        if messageType == websocket.TextMessage {
            log.Println("got textmessage:", string(message))
        } else {
            log.Println("received message of type:", messageType)
        }
    }
}

func SocketListener() {
    for {
        select {
        case c := <-register:
            // This did appear in the log.
            log.Println("case c := <-register")
            messageType, message, err := c.ReadMessage()
            if err != nil {
                log.Println(err)
                // unregister is unbuffered, the sending will be blocked.
                unregister <- c
                // If we use only one SocketListener goroutine then it should
                // not return here.
                return
            }

            log.Printf("Got message of type: %d\nMessage:%s\n", messageType, string(message))
            log.Printf("Connection Params: %s\n", c.Params("id"))
        case c := <-unregister:
            c.Close()
            log.Println("Closed connection")

        }
    }
}

Das obige ist der detaillierte Inhalt vonSo registrieren Sie eine neue WebSocket-Verbindung bei gooptic. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!