Petua untuk menyelesaikan sambungan sambungan Websocket yang kerap terputus dalam bahasa Go

Dengan populariti aplikasi Web, WebSocket, sebagai salah satu protokol komunikasi yang paling biasa digunakan, sering digunakan untuk komunikasi masa nyata antara pelanggan dan pelayan. Dalam bahasa Go, gorilla/websocket ialah salah satu perpustakaan pihak ketiga yang paling popular untuk menggunakan WebSocket. Walau bagaimanapun, apabila menggunakan WebSocket, anda sering menghadapi masalah pemotongan sambungan yang kerap. Beberapa petua untuk menyelesaikan masalah ini dan contoh kod Go yang berkaitan ada di bawah. 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. Degupan jantung sambungan

Dalam penggunaan WebSocket, beberapa faktor boleh menyebabkan sambungan terputus, seperti kehilangan sambungan rangkaian pelayar/klien atau animasi digantung bahagian pelayan. Untuk menyelesaikan masalah ini, operasi degupan jantung boleh digunakan untuk mengekalkan sambungan. Operasi degupan jantung secara khusus menghantar mesej ping untuk memastikan sambungan WebSocket hidup dan melancarkan goroutine untuk mengesan respons.

Berikut ialah contoh kod: 🎜rrreee🎜Dalam kod di atas, fungsi degupan jantung memulakan goroutine setiap 10 saat Hantar mesej ping. Apabila mesej ping dihantar, pernyataan select menunggu 500 milisaat untuk menerima mesej pong. Jika tiada mesej pong diterima, sambungan diputuskan atau ralat dikembalikan. Contoh ini menunjukkan cara menggunakan degupan jantung untuk mengekalkan sambungan WebSocket. 🎜🎜2. Kurangkan kekerapan permintaan ping pelanggan🎜🎜Dalam sesetengah kes, menghantar permintaan ping yang kerap juga boleh mengganggu sambungan WebSocket. Contohnya, apabila WebSocket digunakan dengan proksi rangkaian korporat, proksi mungkin menyekat permintaan ping berterusan. 🎜🎜Untuk mengelakkan situasi ini, anda boleh mengurangkan kekerapan mesej ping. Sebagai contoh, dalam coretan di bawah, Denyutan Jantung menghantar permintaan ping pada selang 10 saat. Mengawal kekerapan ping dan melaraskannya dengan sewajarnya boleh meningkatkan kestabilan sambungan WebSocket. 🎜rrreee🎜3. Kendalikan penutupan WebSocket🎜🎜Periksa dengan kerap sama ada sambungan WebSocket ditutup untuk mengelakkan sambungan terputus. Anda boleh menambah fungsi defer untuk menutup sambungan WebSocket bagi memastikan sambungan WebSocket telah ditutup sepenuhnya sebelum fungsi keluar. 🎜rrreee🎜Dalam kod di atas, semakan ralat digabungkan dengan panggilan ke conn.ReadMessage(). Dalam sambungan WebSocket, ReadMessage() akan menyekat menunggu mesej yang diterima, jadi kami boleh menggunakan gelung tak terhingga untuk menyemak dengan kerap sama ada WebSocket telah ditutup untuk mengelakkan kemasukan ralat semakan panggilan- ralat Semak-panggilangelung tak terhingga. 🎜🎜Kesimpulan🎜🎜Petua di atas boleh membantu anda menyelesaikan masalah sambungan WebSocket yang kerap terputus. Dengan menggunakan mekanisme degupan jantung, mengurangkan kekerapan ping dan mengendalikan penutupan WebSocket, kestabilan sambungan WebSocket boleh dipertingkatkan dengan baik, memastikan komunikasi masa nyata yang lebih lancar dengan pelanggan. 🎜

Atas ialah kandungan terperinci Petua untuk menyelesaikan sambungan sambungan Websocket yang kerap terputus dalam bahasa Go. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!