Go-Sprache Websocket-Entwicklungspraxis: Umgang mit Ausnahmen und Schließen von Verbindungen

? Chat-Anwendungen und andere Szenarien. Bei der Verwendung von Websocket kann es jedoch leicht zu unerwarteten Verbindungsunterbrechungen wie Netzwerkschwankungen, abnormalem Herunterfahren des Clients usw. kommen. Wie man in diesem Fall mit abnormalen Verbindungsabbrüchen richtig umgeht und die Stabilität und Zuverlässigkeit der Anwendung gewährleistet, ist zu einem Problem geworden, auf das man sich bei der Entwicklung konzentrieren muss. In diesem Artikel wird Beispielcode kombiniert und die Go-Sprache als Beispiel verwendet, um den Umgang mit Ausnahmen und das Schließen von Verbindungen vorzustellen.

1. Erstellen Sie einen Websocket-Server:

Zuerst müssen wir einen einfachen Websocket-Server erstellen. Das Folgende ist ein grundlegender Beispielcode:

package main

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

// 定义Websocket读写的缓冲区大小
const bufferSize = 1024

// Websocket处理函数
func wsHandler(w http.ResponseWriter, r *http.Request) {
    // 升级HTTP连接为Websocket连接
    conn, err := websocket.Upgrade(w, r, nil, bufferSize, bufferSize)
    if err != nil {
        fmt.Println("Failed to upgrade the connection to websocket: ", err)
        return
    }

    for {
        // 读取客户端发送的消息
        messageType, message, err := conn.ReadMessage()
        if err != nil {
            fmt.Println("Failed to read message from client: ", err)
            break
        }

        // 处理接收到的消息
        handleMessage(conn, messageType, message)
    }

    // 关闭连接
    defer conn.Close()
}

// 处理接收到的消息
func handleMessage(conn *websocket.Conn, messageType int, message []byte) {
    // 处理消息的逻辑
    fmt.Println("Received message: ", string(message))
}

2. Behandeln Sie das abnormale Schließen der Verbindung:
Wenn der Client abnormal schließt, muss der Server in der Lage sein, korrekt zu erkennen, dass die Verbindung geschlossen wurde, und entsprechend damit umzugehen. Im Folgenden finden Sie einen Beispielcode zum Umgang mit abnormal geschlossenen Verbindungen:

// Websocket处理函数
func wsHandler(w http.ResponseWriter, r *http.Request) {
    // 升级HTTP连接为Websocket连接
    conn, err := websocket.Upgrade(w, r, nil, bufferSize, bufferSize)
    if err != nil {
        fmt.Println("Failed to upgrade the connection to websocket: ", err)
        return
    }

    // 异常关闭连接处理协程
    go handleCloseConnection(conn)

    for {
        // 读取客户端发送的消息
        messageType, message, err := conn.ReadMessage()
        if err != nil {
            // 检测到连接异常关闭的错误
            if websocket.IsUnexpectedCloseError(err, websocket.CloseGoingAway, websocket.CloseAbnormalClosure) {
                fmt.Println("Connection closed unexpectedly: ", err)
                break
            }
            // 其他错误处理
            fmt.Println("Failed to read message from client: ", err)
            break
        }

        // 处理接收到的消息
        handleMessage(conn, messageType, message)
    }

    // 关闭连接
    conn.Close()
}

// 异常关闭连接处理协程
func handleCloseConnection(conn *websocket.Conn) {
    // 读取关闭消息，表示客户端主动关闭连接
    _, _, err := conn.ReadMessage()
    if err != nil {
        fmt.Println("Failed to read close message from client: ", err)
    }

    // 处理连接关闭后的逻辑
    fmt.Println("Connection closed by client")
}

Im obigen Beispielcode ermitteln wir, ob die Verbindung abnormal geschlossen ist, indem wir die Funktion IsUnexpectedCloseError aufrufen. Wenn die Verbindung abnormal geschlossen wird, wird die entsprechende Fehlermeldung aufgezeichnet, die Schleife wird übersprungen und die Verbindung wird geschlossen. Darüber hinaus haben wir eine Coroutine-Funktion namens handleCloseConnection hinzugefügt, um die Logik nach dem Schließen der Verbindung zu verarbeiten.

Fazit:

Bei der Entwicklung von Websocket-Anwendungen ist die Behandlung von Ausnahmen und das Schließen von Verbindungen ein sehr wichtiger Schritt. Mithilfe der Funktion IsUnexpectedCloseError und der Coroutine-Verarbeitung können wir abnormale Verbindungsabschlüsse erkennen und behandeln und so Anwendungsabstürze aufgrund von Verbindungsausnahmen vermeiden. In tatsächlichen Anwendungen kann eine entsprechende Erweiterung entsprechend den spezifischen Anforderungen durchgeführt werden, z. B. das Aufzeichnen von Protokollen, das Senden von Benachrichtigungen usw., um die Zuverlässigkeit und Wartbarkeit der Anwendung zu verbessern.

Referenzen:

IsUnexpectedCloseError函数来判断连接是否异常关闭。如果是异常关闭的情况，则记录相应的错误信息，并跳出循环，关闭连接。另外，我们还添加了一个名为handleCloseConnection的协程函数，用于处理连接关闭后的逻辑。

结论：
在开发Websocket应用时，处理异常关闭连接是非常重要的一环。通过使用IsUnexpectedCloseError

[Gorilla WebSocket](https://github.com/gorilla/websocket)

[Go Standard Library Documentation](https://golang.org/pkg/net/http/)

• [WebSocket Protocol Development Guide](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket_API/Writing_WebSocket_servers)

Das obige ist der detaillierte Inhalt vonGo-Sprache Websocket-Entwicklungspraxis: Umgang mit Ausnahmen und Schließen von Verbindungen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!