1、服务端代码
package main
import (
"fmt"
"net"
)
func handleClient(conn net.Conn) {
defer conn.Close()
fmt.Println("Client connected:", conn.RemoteAddr())
// 读取客户端的数据
buffer := make([]byte, 1024)
for {
n, err := conn.Read(buffer)
if err != nil {
fmt.Println("Error reading:", err)
return
}
// 处理接收到的数据
data := string(buffer[:n])
fmt.Printf("Received from %s: %s\n", conn.RemoteAddr(), data)
// 回复心跳响应
response := "Heartbeat response"
conn.Write([]byte(response))
}
}
func main() {
listener, err := net.Listen("tcp", ":8080")
if err != nil {
fmt.Println("Error:", err)
return
}
defer listener.Close()
fmt.Println("Heartbeat server listening on :8080")
for {
conn, err := listener.Accept()
if err != nil {
fmt.Println("Error accepting connection:", err)
continue
}
// 启动一个goroutine处理客户端连接
go handleClient(conn)
}
}
2、客户端代码
package main
import (
"fmt"
"net"
"time"
)
func sendHeartbeat(conn net.Conn) {
for {
// 发送心跳数据
heartbeat := "Heartbeat message"
conn.Write([]byte(heartbeat))
// 等待一段时间再发送下一次心跳
time.Sleep(time.Second * 5)
}
}
func main() {
conn, err := net.Dial("tcp", "localhost:8080")
if err != nil {
fmt.Println("Error connecting to server:", err)
return
}
defer conn.Close()
fmt.Println("Connected to server:", conn.RemoteAddr())
// 启动goroutine发送心跳
go sendHeartbeat(conn)
// 主goroutine保持运行，等待心跳
select {}
}
3、最终实现效果
4、方法补充
除了上文的方法，小编还为大家整理了其他golang实现心跳机制的方法，希望对大家有所帮助
第一步：创建WebSocket连接
首先，我们需要创建一个WebSocket连接。Golang提供了一个内置的websocket包，可以方便地创建和管理WebSocket连接。以下是一个简单的示例代码，用于创建一个WebSocket连接：
package main
import (
“log”
“net/http”
“github.com/gorilla/websocket”
)
var upgrader = websocket.Upgrader{
ReadBufferSize: 1024,
WriteBufferSize: 1024,
}
func main() {
http.HandleFunc(“/ws”, func(w http.ResponseWriter, r *http.Request) {
conn, err := upgrader.Upgrade(w, r, nil)
if err != nil {
log.Println(err)
return
}
})
log.Fatal(http.ListenAndServe(“:8080”, nil))
}
第二步：添加心跳处理程序
接下来，我们需要添加一个心跳处理程序，用于定期发送心跳包。我们可以使用goroutine和定时器来实现这个功能。以下是一个示例代码，用于添加心跳处理程序：
package main
import (
“log”
“net/http”
“time”
“github.com/gorilla/websocket”
)
var upgrader = websocket.Upgrader{
ReadBufferSize: 1024,
WriteBufferSize: 1024,
}
func main() {
http.HandleFunc(“/ws”, func(w http.ResponseWriter, r *http.Request) {
conn, err := upgrader.Upgrade(w, r, nil)
if err != nil {
log.Println(err)
return
}
go heartbeat(conn)
// 处理其他操作
})
log.Fatal(http.ListenAndServe(“:8080”, nil))
}
func heartbeat(conn *websocket.Conn) {
ticker := time.NewTicker(5 * time.Second)
defer ticker.Stop()
for {
select {
case <-ticker.C:
err := conn.WriteMessage(websocket.PingMessage, []byte(“heartbeat”))
if err != nil {
log.Println(err)
return
}
}
}
}
在上面的代码中，我们使用time.NewTicker函数创建了一个定时器，每隔5秒触发一次。然后，我们使用conn.WriteMessage函数发送一个WebSocket ping消息作为心跳包。
第三步：处理心跳响应
最后，我们需要处理来自客户端的心跳响应。如果客户端未在规定的时间内响应心跳包，我们可以将其标记为离线状态。以下是一个示例代码，用于处理心跳响应：
package main
import (
“log”
“net/http”
“time”
“github.com/gorilla/websocket”
)
var upgrader = websocket.Upgrader{
ReadBufferSize: 1024,
WriteBufferSize: 1024,
}
func main() {
http.HandleFunc(“/ws”, func(w http.ResponseWriter, r *http.Request) {
conn, err := upgrader.Upgrade(w, r, nil)
if err != nil {
log.Println(err)
return
}
go heartbeat(conn)
// 处理其他操作
})
log.Fatal(http.ListenAndServe(“:8080”, nil))
}
func heartbeat(conn *websocket.Conn) {
ticker := time.NewTicker(5 * time.Second)
defer ticker.Stop()
for {
select {
case <-ticker.C:
err := conn.WriteMessage(websocket.PingMessage, []byte(“heartbeat”))
if err != nil {
log.Println(err)
return
}
conn.SetReadDeadline(time.Now().Add(10 * time.Second))
_, _, err = conn.ReadMessage()
if err != nil {
log.Println(“heartbeat response error:”, err)
return
}
}
}
}
在上述代码中，我们使用conn.SetReadDeadline函数设置一个10秒的读取超时时间。如果在超时时间内未收到心跳响应，将会触发ReadMessage函数返回错误。我们可以在错误处理程序中添加适当的操作，如重新连接或关闭连接。
