Conseils pour résoudre les déconnexions fréquentes de la connexion Websocket en langage Go

Avec la popularité des applications Web, WebSocket, en tant que l'un des protocoles de communication les plus couramment utilisés, est souvent utilisé pour la communication en temps réel entre clients et serveurs. En langage Go, gorilla/websocket est l'une des bibliothèques tierces les plus populaires pour l'utilisation de WebSocket. Cependant, lorsque vous utilisez WebSocket, vous rencontrez souvent le problème des déconnexions fréquentes. Quelques conseils pour résoudre ce problème et des exemples de code Go associés sont ci-dessous. gorilla/websocket 是使用WebSocket的最受欢迎的第三方库之一。但是，通过使用WebSocket时经常会遇到连接频繁断开的问题。解决这个问题的一些技巧，与相关的Go代码示例如下。

1.连接心跳

在WebSocket的使用中，一些因素可能导致连接断开，例如浏览器/客户端网络连接的丢失或服务器端假死。为了解决这些问题，可以使用心跳操作来保持连接。心跳操作专门发送ping消息，以保持WebSocket连接活动状态，并启动goroutine以检测响应。

下面是一个示例代码：

package main

import (
    "log"
    "net/http"
    "time"

    "github.com/gorilla/websocket"
)

var (
    upgrader = websocket.Upgrader{
        ReadBufferSize:  1024,
        WriteBufferSize: 1024,
        CheckOrigin:     func(r *http.Request) bool { return true },
    }
)

func main() {
    http.HandleFunc("/ws", wsHandler)
    log.Fatal(http.ListenAndServe(":8080", nil))
}

func wsHandler(w http.ResponseWriter, r *http.Request) {
    conn, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        log.Println("upgrade error:", err)
        return
    }
    defer conn.Close()

    heartbeat(conn)
}

func heartbeat(conn *websocket.Conn) {
    ticker := time.NewTicker(10 * time.Second)

    defer ticker.Stop()

    for {
        select {
        case <-ticker.C:
            if err := conn.WriteMessage(websocket.PingMessage, []byte{}); err != nil {
                log.Println("write ping error:", err)
                return
            }
        }
    }
}

在上面的代码中，heartbeat函数启动了一个goroutine，该goroutine每10秒发送ping消息。当一个ping消息发送时，select语句等待500毫秒来接收pong消息。如果未收到pong消息，则断开连接或返回错误。这个例子展示了如何利用心跳来维持WebSocket连接。

2.降低客户端ping请求频率

在某些情况下，频繁发送ping请求也可能会中断WebSocket连接。例如，当WebSocket与公司网络代理一起使用时，代理可能会阻止连续的ping请求。

为了避免这种情况，可以降低ping消息的频率。例如，在下面的代码段中，心跳以10秒为间隔发送ping请求。控制ping频率并适当地调整它可以改善WebSocket连接的稳定性。

func heartbeat(conn *websocket.Conn) {
    ticker := time.NewTicker(10 * time.Second)

    defer ticker.Stop()

    for {
        select {
        case <-ticker.C:
            if err := conn.WriteMessage(websocket.PingMessage, []byte{}); err != nil {
                log.Println("write ping error:", err)
                return
            }
        }
    }
}

3.处理WebSocket关闭

定期检查WebSocket连接是否关闭，可以避免连接断开的情况。可以添加一个defer函数来关闭WebSocket连接，以确保在函数退出之前 WebSocket连接已经被完全关闭。

func wsHandler(w http.ResponseWriter, r *http.Request) {
    conn, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        log.Println("upgrade error:", err)
        return
    }
    defer conn.Close()

    ticker := time.NewTicker(10 * time.Second)
    defer ticker.Stop()

    for {
        _, _, err := conn.ReadMessage()
        if err != nil {
            log.Println("read error:", err)
            return
        }
    }
}

在上面的代码中，错误检查与conn.ReadMessage()的调用并置。在WebSocket连接中，ReadMessage()会阻塞等待收到的消息，所以我们可以利用无限循环来实现定期检查WebSocket是否已经关闭，以防止进入 错误检查-调用-错误检查-调用

1. Battement de connexion

Dans l'utilisation de WebSocket, certains facteurs peuvent entraîner la déconnexion de la connexion, comme la perte de la connexion réseau navigateur/client ou l'animation suspendue côté serveur. Pour résoudre ces problèmes, des opérations de pulsation peuvent être utilisées pour maintenir la connexion. L'opération de battement de cœur envoie spécifiquement un message ping pour maintenir la connexion WebSocket active et lance un goroutine pour détecter les réponses.

Voici un exemple de code : 🎜rrreee🎜Dans le code ci-dessus, la fonction heartbeat démarre une goroutine toutes les 10 secondes. Envoyez un message ping. Lorsqu'un message ping est envoyé, l'instruction select attend 500 millisecondes pour recevoir le message pong. Si aucun message pong n'est reçu, la connexion est déconnectée ou une erreur est renvoyée. Cet exemple montre comment utiliser les pulsations pour maintenir une connexion WebSocket. 🎜🎜2. Réduisez la fréquence des requêtes ping des clients🎜🎜Dans certains cas, l'envoi de requêtes ping fréquentes peut également interrompre la connexion WebSocket. Par exemple, lorsque WebSocket est utilisé avec un proxy de réseau d'entreprise, le proxy peut bloquer les demandes ping continues. 🎜🎜Pour éviter cette situation, vous pouvez réduire la fréquence des messages ping. Par exemple, dans l'extrait ci-dessous, Heartbeat envoie des requêtes ping à des intervalles de 10 secondes. Contrôler la fréquence de ping et l'ajuster de manière appropriée peut améliorer la stabilité des connexions WebSocket. 🎜rrreee🎜3. Gérer la fermeture du WebSocket🎜🎜 Vérifiez régulièrement si la connexion WebSocket est fermée pour éviter la déconnexion. Vous pouvez ajouter une fonction defer pour fermer la connexion WebSocket afin de garantir que la connexion WebSocket a été complètement fermée avant la fermeture de la fonction. 🎜rrreee🎜Dans le code ci-dessus, la vérification des erreurs est colocalisée avec l'appel à conn.ReadMessage(). Dans une connexion WebSocket, ReadMessage() bloquera l'attente des messages reçus, nous pouvons donc utiliser une boucle infinie pour vérifier régulièrement si le WebSocket a été fermé pour éviter de saisir error check-call-error La boucle infinie de Check-call. 🎜🎜Conclusion🎜🎜Les conseils ci-dessus peuvent vous aider à résoudre le problème des déconnexions fréquentes des connexions WebSocket. En utilisant le mécanisme de battement de cœur, en réduisant la fréquence de ping et en gérant l'arrêt de WebSocket, la stabilité de la connexion WebSocket peut être considérablement améliorée, garantissant une communication en temps réel plus fluide avec le client. 🎜

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!