Utiliser WebSocket pour la communication en temps réel dans Beego

À l'ère d'Internet d'aujourd'hui, la communication en temps réel est devenue une fonction indispensable dans de nombreux scénarios d'application. Du chat en ligne aux jeux en temps réel en passant par les systèmes de surveillance, la communication en temps réel est de plus en plus demandée. Le moyen le plus courant d’établir une communication en temps réel consiste à utiliser le protocole WebSocket.

Le protocole WebSocket est un nouveau protocole de communication réseau dans la spécification HTML5. Il peut fournir un canal de communication full-duplex sur une connexion TCP. Les fonctions de communication en temps réel peuvent être facilement réalisées à l'aide du protocole WebSocket, et Beego, en tant que framework Web rapide et efficace, prend naturellement en charge le protocole WebSocket.

Cet article présentera le processus d'utilisation de WebSocket pour réaliser une communication en temps réel dans Beego. Tout d'abord, nous devons installer le framework Beego :

go get github.com/astaxie/beego

Une fois l'installation terminée, nous pouvons commencer à utiliser le framework Beego. Avant d'utiliser Beego pour implémenter WebSocket, nous devons d'abord comprendre le protocole WebSocket. Le protocole WebSocket comporte trois phases : prise de contact, transfert de données et fermeture.

Dans la phase de handshake, le client envoie une requête HTTP au serveur pour passer au protocole WebSocket. Après avoir reçu la requête, le serveur renvoie une réponse 101 Switching Protocols. À ce stade, la connexion WebSocket a été établie. Pendant la phase de transfert de données, le client et le serveur peuvent se transférer des données. Pendant la phase d'arrêt, le client ou le serveur peut envoyer une trame d'arrêt pour fermer la connexion WebSocket.

Dans Beego, nous pouvons implémenter les trois étapes de WebSocket en implémentant la fonction WebSocket de beego.Controller.

Tout d'abord, nous devons créer un contrôleur WebSocket :

package controllers

import (
    "github.com/astaxie/beego"
    "github.com/gorilla/websocket"
)

type WebSocketController struct {
    beego.Controller
}

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

func (this *WebSocketController) Get() {
    conn, err := upgrader.Upgrade(this.Ctx.ResponseWriter, this.Ctx.Request, nil)
    if err != nil {
        beego.Error("WebSocket协议升级失败：", err)
        return
    }
    // 处理连接
}

Dans le code ci-dessus, nous avons créé un Upgrader via le package gorilla/websocket et l'avons appelé dans la méthode Get. La méthode de mise à niveau de Upgrader est utilisée pour mettre à niveau le protocole. À ce stade, la connexion WebSocket a été établie avec succès. Ensuite, nous devons gérer la connexion WebSocket.

Pour le traitement des connexions WebSocket, nous pouvons utiliser goroutine. Chaque fois qu'il y a une nouvelle connexion, nous ouvrons une nouvelle goroutine pour traiter la connexion :

func (this *WebSocketController) Get() {
    conn, err := upgrader.Upgrade(this.Ctx.ResponseWriter, this.Ctx.Request, nil)
    if err != nil {
        beego.Error("WebSocket协议升级失败：", err)
        return
    }
    go this.handleConnection(conn)
}

func (this *WebSocketController) handleConnection(conn *websocket.Conn) {
    defer conn.Close()
    // 处理连接
}

Dans la méthode de traitement de la connexion, nous pouvons utiliser une boucle for pour lire en continu les données du client Data :

func (this *WebSocketController) handleConnection(conn *websocket.Conn) {
    defer conn.Close()
    for {
        _, msg, err := conn.ReadMessage()
        if err != nil {
            beego.Error("读取消息失败：", err)
            return
        }
        // 处理消息
    }
}

Dans la méthode de traitement des messages, nous pouvons effectuer le traitement correspondant en fonction des données envoyées par le client et renvoyer les résultats du traitement au client :

func (this *WebSocketController) handleConnection(conn *websocket.Conn) {
    defer conn.Close()
    for {
        _, msg, err := conn.ReadMessage()
        if err != nil {
            beego.Error("读取消息失败：", err)
            return
        }
        // 处理消息
        reply := "收到消息：" + string(msg)
        err = conn.WriteMessage(websocket.TextMessage, []byte(reply))
        if err != nil {
            beego.Error("发送消息失败：", err)
            return
        }
    }
}

Ce qui précède Le code implémente un simple serveur d'écho WebSocket, qui renvoie directement les données telles quelles après avoir reçu les données du client. Dans les applications pratiques, nous pouvons effectuer le traitement des données correspondant selon les besoins et transmettre les résultats du traitement au client en temps réel.

Enfin, nous devons enregistrer le contrôleur WebSocket dans le routage :

beego.Router("/websocket", &controllers.WebSocketController{})

À ce stade, nous avons terminé le processus d'utilisation de WebSocket pour obtenir une communication en temps réel dans le Cadre Beego. Il convient de noter que Beego utilise le package gorilla/websocket pour implémenter la fonction WebSocket, ce package doit donc être importé dans le projet.

En résumé, Beego est un framework Web puissant et simple à utiliser qui peut facilement mettre en œuvre des fonctions de communication en temps réel lorsqu'il est combiné avec le protocole WebSocket. Lorsque nous utilisons WebSocket pour implémenter une communication en temps réel, nous devons prêter attention aux trois phases du protocole et utiliser goroutine pour le traitement.

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!