Pratique de développement Go Language Websocket : comment gérer les exceptions et fermer les connexions

Pratique de développement de Websocket Go Language : Comment gérer la fermeture anormale des connexions

Introduction :
Dans le développement Web, le protocole Websocket peut être utilisé pour réaliser une communication bidirectionnelle, qui est généralement utilisée dans la transmission de données en temps réel, applications de chat et autres scénarios. Cependant, lors de l'utilisation de Websocket, il est facile de rencontrer des interruptions de connexion inattendues, telles que des fluctuations du réseau, un arrêt anormal du client, etc. Comment gérer correctement la fermeture anormale d’une connexion dans ce cas et garantir la stabilité et la fiabilité de l’application sont devenus des problèmes sur lesquels il faut se concentrer lors du développement. Cet article combinera des exemples de code et prendra le langage Go comme exemple pour présenter comment gérer les exceptions et fermer les connexions.

1. Créer un serveur Websocket :
Tout d'abord, nous devons créer un serveur Websocket simple. Voici un exemple de code de base :

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. Gérer la fermeture anormale de la connexion :
Lorsque le client se ferme anormalement, le serveur doit être capable de détecter correctement que la connexion a été fermée et de la gérer en conséquence. Voici un exemple de code sur la façon de gérer les connexions anormalement fermées :

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

Dans l'exemple de code ci-dessus, nous déterminons si la connexion est anormalement fermée en appelant la fonction IsUnexpectedCloseError. Si la connexion est anormalement fermée, le message d'erreur correspondant sera enregistré, la boucle sera sautée et la connexion sera fermée. De plus, nous avons également ajouté une fonction coroutine nommée handleCloseConnection pour gérer la logique après la fermeture de la connexion. IsUnexpectedCloseError函数来判断连接是否异常关闭。如果是异常关闭的情况，则记录相应的错误信息，并跳出循环，关闭连接。另外，我们还添加了一个名为handleCloseConnection的协程函数，用于处理连接关闭后的逻辑。

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

Conclusion :

Lors du développement d'applications Websocket, la gestion des exceptions et la fermeture des connexions sont une étape très importante. En utilisant la fonction IsUnexpectedCloseError et le traitement de la coroutine, nous pouvons détecter et gérer les fermetures de connexion anormales, évitant ainsi les plantages d'application dus à des exceptions de connexion. Dans les applications réelles, l'extension correspondante peut être effectuée en fonction de besoins spécifiques, tels que l'enregistrement de journaux, l'envoi de notifications, etc., pour améliorer la fiabilité et la maintenabilité de l'application.

Références :
• [Gorilla WebSocket](https://github.com/gorilla/websocket)
• [Documentation de la bibliothèque standard Go](https://golang.org/pkg/net/http/)

[Guide de développement du protocole WebSocket](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket_API/Writing_WebSocket_servers)🎜🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!