Go language Websocket development practice: how to handle exceptions and close connections

Go Language Websocket Development Practice: How to Handle Abnormal Closure of Connections

Introduction:
In Web development, two-way communication can be achieved using the Websocket protocol, which is usually used Real-time data transmission, chat applications and other scenarios. However, when using Websocket, it is easy to encounter unexpected connection interruptions, such as network fluctuations, abnormal client shutdown, etc. How to correctly handle abnormal connection closing in this case and ensure the stability and reliability of the application have become issues that need to be focused on during development. This article will combine sample code and take the Go language as an example to introduce how to handle exceptions and close connections.

1. Create a Websocket server:
First, we need to create a simple Websocket server. The following is a basic sample code:

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. Handle abnormal closing of the connection:
When the client closes abnormally, the server needs to be able to correctly detect that the connection has been closed and handle it accordingly. The following is a sample code on how to handle abnormally closed connections:

// 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")
}

In the above sample code, we determine whether the connection is abnormally closed by calling the IsUnexpectedCloseError function. If the connection is abnormally closed, the corresponding error message will be recorded, the loop will be jumped out, and the connection will be closed. In addition, we also added a coroutine function named handleCloseConnection to handle the logic after the connection is closed.

Conclusion:
When developing Websocket applications, handling exceptions and closing connections is a very important step. By using the IsUnexpectedCloseError function and coroutine processing, we can detect and handle abnormal connection closures, avoiding application crashes due to connection exceptions. In actual applications, corresponding expansion can be carried out according to specific needs, such as recording logs, sending notifications, etc., to improve the reliability and maintainability of the application.

References:

• [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)

The above is the detailed content of Go language Websocket development practice: how to handle exceptions and close connections. For more information, please follow other related articles on the PHP Chinese website!