How to implement Websocket heartbeat detection using Go language

How to use Go language to implement Websocket heartbeat detection

Websocket is a protocol that implements two-way communication in Web applications. It allows the server to actively push data to the client. . In some applications with high real-time requirements, we may need to monitor the status of the client in real time to ensure the stability of the connection. To achieve this goal, we can use a heartbeat detection mechanism.

This article will introduce how to use Go language to implement Websocket heartbeat detection and provide specific code examples.

First, we need to use the websocket package of Go language to create a WebSocket server. On the server side, we can use the github.com/gorilla/websocket package to implement WebSocket communication. You can use the following command to install this package:

go get github.com/gorilla/websocket

In the Go language, we can use the http.ListenAndServe function to create a simple WebSocket server. The following is an example:

package main

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

    "github.com/gorilla/websocket"
)

var upgrader = websocket.Upgrader{
    ReadBufferSize:  1024,
    WriteBufferSize: 1024,
}

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

    for {
        // 读取客户端发送的消息
        _, msg, err := conn.ReadMessage()
        if err != nil {
            log.Println(err)
            break
        }

        // 打印接收到的消息
        fmt.Println("Received:", string(msg))

        // 回复客户端消息
        err = conn.WriteMessage(websocket.TextMessage, []byte("Received: "+string(msg)))
        if err != nil {
            log.Println(err)
            break
        }
    }
}

func main() {
    http.HandleFunc("/ws", echo)
    log.Println("WebSocket server started on localhost:8080")
    log.Fatal(http.ListenAndServe(":8080", nil))
}

The echo function in this example is used to handle WebSocket connections and implement the reception and reply of messages. We can use the http.HandleFunc function to associate this function with the path /ws.

Next, we need to implement the heartbeat detection function on the client. We can use JavaScript's setInterval function to periodically send heartbeat messages to the server, and reconnect when no reply is received from the server for a period of time. The following is a simple JavaScript code example:

var socket = new WebSocket("ws://localhost:8080/ws");
var pingInterval = null;

socket.onopen = function() {
    console.log("Websocket connected");

    // 每隔5秒发送心跳消息
    pingInterval = setInterval(function() {
        socket.send("ping");
    }, 5000);
}

socket.onmessage = function(event) {
    console.log("Received:", event.data);

    // 收到服务器回复后重置心跳计时器
    clearInterval(pingInterval);
    pingInterval = setInterval(function() {
        socket.send("ping");
    }, 5000);
}

socket.onclose = function(event) {
    console.log("Websocket closed");

    // 连接关闭后清除心跳计时器
    clearInterval(pingInterval);
}

In this example, we first create a WebSocket connection and then use the onopen function to set the heartbeat timer. Send a ping message to the server every 5 seconds. When we receive a reply from the server, we reset the heartbeat timer. If the connection is closed we clear the timer.

The above are the basic steps and code examples for implementing WebSocket heartbeat detection using Go language. In this way, we can monitor the status of the client in real time and ensure the stability of the connection. Hope this article can be helpful to you!

The above is the detailed content of How to implement Websocket heartbeat detection using Go language. For more information, please follow other related articles on the PHP Chinese website!