Guide de développement de Websocket en langage Go : Comment gérer le problème de perte de messages
Tout d'abord, vous devez importer les packages net/http et github.com/gorilla/websocket. net/http和github.com/gorilla/websocket包。
import (
"net/http"
"github.com/gorilla/websocket"
)接下来，创建一个websocket处理器：
func handleWebsocket(w http.ResponseWriter, r *http.Request) {
// 允许跨域连接
upgrader := websocket.Upgrader{
CheckOrigin: func(r *http.Request) bool { return true },
}
// 升级HTTP连接为Websocket连接
conn, err := upgrader.Upgrade(w, r, nil)
if err != nil {
log.Println("Websocket upgrade failed: ", err)
return
}
// 处理消息
for {
messageType, message, err := conn.ReadMessage()
if err != nil {
log.Println("Read error: ", err)
break
}
// 处理消息逻辑
handleMessage(message)
// 回复消息
err = conn.WriteMessage(messageType, message)
if err != nil {
log.Println("Write error: ", err)
break
}
}
// 关闭连接
conn.Close()
}以上代码中，我们首先通过Upgrader结构体将HTTP连接升级为Websocket连接。然后循环读取、处理、回复消息，直到出现异常或连接关闭。
最后，创建一个HTTP服务器，并将Websocket处理器注册到指定的路径上：
http.HandleFunc("/websocket", handleWebsocket)
http.ListenAndServe(":8000", nil)3.1 消息确认机制
可以在消息中添加一个唯一标识符（例如递增的序列号），当接收方收到消息后，发送一个确认消息给发送方。发送方在一定时间内没有收到确认消息时，需要重新发送该消息。
我们可以定义一个结构体来处理消息确认机制：
type Message struct {
ID int
Content string
AckChan chan int
}
type MessageHandler struct {
messages map[int]Message
}
func (handler *MessageHandler) handleMessage(message Message) {
// 处理消息逻辑
// ...
// 发送确认消息
message.AckChan <- message.ID
}在handleWebsocket函数中，我们可以按照以下方式进行消息处理：
messageHandler := MessageHandler{
messages: make(map[int]Message),
}
for {
messageType, message, err := conn.ReadMessage()
if err != nil {
log.Println("Read error: ", err)
break
}
// 创建消息对象
ackChan := make(chan int)
msg := Message{
ID: len(messageHandler.messages) + 1,
Content: string(message),
AckChan: ackChan,
}
// 处理消息
messageHandler.handleMessage(msg)
// 等待确认消息
select {
case <-ackChan:
// 收到确认消息
case <-time.After(time.Second):
// 消息发送超时，重新发送消息
conn.WriteMessage(messageType, message)
}
// 回复消息
err = conn.WriteMessage(messageType, message)
if err != nil {
log.Println("Write error: ", err)
break
}
}在MessageHandler中，我们使用一个map来保存已发送但还未收到确认的消息。当收到确认消息时，我们从map中移除该消息。
在消息处理逻辑完成后，发送一个确认消息给发送方，发送方通过传递的AckChan通道接收该确认消息。如果一定时间内没有收到确认消息，则重新发送该消息。
3.2 心跳机制
除了使用消息确认机制外，我们还可以使用心跳机制来检测连接是否正常。
可以定时向客户端发送一个心跳消息，如果一段时间内还未收到回复，则认为连接已经断开。
可以定义一个心跳结构体：
type Heartbeat struct {
PingMsg []byte
PongMsg []byte
Interval time.Duration
}
func (h *Heartbeat) Start(conn *websocket.Conn) {
ticker := time.NewTicker(h.Interval)
defer ticker.Stop()
for range ticker.C {
// 发送心跳消息
err := conn.WriteMessage(websocket.PingMessage, h.PingMsg)
if err != nil {
log.Println("Heartbeat error: ", err)
break
}
// 设置心跳超时时间
conn.SetReadDeadline(time.Now().Add(h.Interval))
// 等待心跳回复
_, _, err = conn.ReadMessage()
if err != nil {
log.Println("Heartbeat error: ", err)
break
}
}
}在handleWebsocket
heartbeat := Heartbeat{
PingMsg: []byte("ping"),
PongMsg: []byte("pong"),
Interval: time.Second * 10,
}
go heartbeat.Start(conn)rrreee
Dans le code ci-dessus, nous mettons d'abord à niveau la connexion HTTP vers une connexion Websocket via la structureUpgrader. Ensuite, il boucle pour lire, traiter et répondre aux messages jusqu'à ce qu'une exception se produise ou que la connexion soit fermée. handleWebsocket, nous pouvons traiter les messages de la manière suivante : 🎜rrreee🎜Dans MessageHandler , nous utilisons une carte pour enregistrer les messages qui ont été envoyés mais qui n'ont pas encore reçu de confirmation. Lorsqu'un message de confirmation est reçu, nous supprimons le message de la carte. 🎜🎜Une fois la logique de traitement du message terminée, un message de confirmation est envoyé à l'expéditeur, et l'expéditeur reçoit le message de confirmation via le canal AckChan transmis. Si aucun message de confirmation n'est reçu dans un certain délai, le message sera renvoyé. 🎜🎜3.2 Mécanisme de battement de coeur🎜En plus d'utiliser le mécanisme de confirmation de message, nous pouvons également utiliser le mécanisme de battement de coeur pour détecter si la connexion est normale. 🎜🎜Vous pouvez envoyer régulièrement un message de battement de cœur au client. Si aucune réponse n'est reçue dans un délai donné, la connexion est considérée comme ayant été déconnectée. 🎜🎜Vous pouvez définir une structure de battement de coeur : 🎜rrreee🎜Dans la fonction handleWebsocket, nous pouvons activer le battement de coeur de la manière suivante : 🎜rrreee🎜Dans le code ci-dessus, nous utilisons un minuteur pour envoyer un battement de coeur messages à intervalles, puis définissez le délai d'expiration du battement de cœur et attendez la réponse du battement de cœur. Si aucune réponse de battement de cœur n'est reçue dans un délai donné, la connexion est considérée comme déconnectée. 🎜🎜🎜Résumé🎜Cet article présente comment utiliser le langage Go pour développer des applications Websocket et gérer les problèmes de perte de messages. En utilisant le mécanisme de confirmation de message et le mécanisme de battement de cœur, nous pouvons résoudre efficacement le problème de la perte de message. Bien entendu, en fonction du scénario commercial spécifique, nous pouvons également effectuer un traitement plus détaillé si nécessaire. 🎜🎜🎜En étudiant cet article, vous pouvez rapidement comprendre le développement de Websocket en langage Go et appliquer ces technologies dans des projets réels. J'espère que cet article vous sera utile ! 🎜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!
Utilisation du mot-clé Type dans Go
Comment implémenter une liste chaînée en go
Que sont les logiciels de programmation en langage Go ?
Comment apprendre le langage go à partir de 0 bases
Quelles sont les méthodes pour implémenter la surcharge d'opérateurs en langage Go ?
Quels sont les opérateurs en langage Go ?
Top 10 des bureaux de change
Comment éliminer le code HTML
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
