Comment Go WebSocket implémente-t-il la file d'attente des messages ?

Go WebSocket implémente les files d'attente de messages en utilisant des canaux. Les étapes d'implémentation sont les suivantes : 1. Créez un canal de file d'attente de messages. 2. Démarrez une goroutine pour écouter les messages entrants. 3. Dans le gestionnaire, écrivez le message dans la file d'attente des messages. 4. Lorsqu'un message doit être envoyé, écrivez-le dans la file d'attente. Cette approche peut être utilisée pour créer des applications en temps réel telles que le chat, les éditeurs collaboratifs et les mises à jour des stocks en temps réel.

Comment Go WebSocket implémente la file d'attente des messages

WebSocket est un protocole de communication full-duplex qui peut établir une connexion continue entre le client et le serveur. Il est basé sur TCP et peut être utilisé pour créer des applications en temps réel telles que le chat, des éditeurs collaboratifs et des mises à jour de stocks en temps réel.

Go fournit une prise en charge native de WebSocket, permettant aux développeurs d'établir et de gérer facilement les connexions WebSocket. Cependant, dans des applications réelles, il peut être nécessaire d'implémenter une file d'attente de messages pour gérer un grand nombre de messages entrants et sortants.

Implémentation de files d'attente de messages

Un moyen simple d'implémenter des files d'attente de messages dans Go consiste à utiliser des canaux. Les canaux sont un mécanisme de communication synchrone qui permet d'échanger des valeurs en toute sécurité entre coroutines concurrentes.

Créez un canal de file d'attente de messages :

var messageQueue chan []byte

Démarrez une goroutine pour écouter les messages entrants :

go func() {
    for message := range messageQueue {
        // 处理传入消息
    }
}()

Dans le gestionnaire, écrivez le message dans la file d'attente des messages :

func handleConnection(conn *websocket.Conn) {
    for {
        message, err := conn.ReadMessage()
        if err != nil {
            // 处理错误
        }

        messageQueue <- message.Payload
    }
}

Lorsqu'un message doit être envoyé, écrivez-le dans la file d'attente :

func sendMessage(message []byte) {
    messageQueue <- message
}

Cas pratique

Considérons une application de chat simple où le client et le serveur communiquent à l'aide de WebSocket.

Code client :

package main

import (
    "context"
    "flag"
    "fmt"
    "log"

    "github.com/gorilla/websocket"
)

var addr = flag.String("addr", "localhost:8080", "http service address")

func main() {
    flag.Parse()

    // 连接到服务器
    conn, _, err := websocket.DefaultDialer.DialContext(context.Background(), "ws://"+*addr, nil)
    if err != nil {
        log.Fatal("Could not connect to server", err)
    }

    // 读取来自服务器的消息
    go func() {
        for {
            _, message, err := conn.ReadMessage()
            if err != nil {
                log.Println("Could not read message:", err)
                return
            }

            fmt.Println(string(message))
        }
    }()

    // 发送消息到服务器
    scanner := bufio.NewScanner(os.Stdin)
    for scanner.Scan() {
        conn.WriteMessage(websocket.TextMessage, []byte(scanner.Text()))
    }
}

Code serveur :

package main

import (
    "context"
    "flag"
    "log"
    "net/http"

    "github.com/gorilla/websocket"
)

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

var addr = flag.String("addr", ":8080", "http service address")
var messageQueue chan []byte

func main() {
    flag.Parse()

    messageQueue = make(chan []byte)

    // 启动消息队列监听器
    go func() {
        for message := range messageQueue {
            // 处理消息
        }
    }()

    // 处理 WebSocket 连接
    http.HandleFunc("/ws", wsHandler)
    log.Fatal(http.ListenAndServe(*addr, nil))
}

func wsHandler(w http.ResponseWriter, r *http.Request) {
    // 升级到 WebSocket 连接
    conn, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        log.Println("Could not upgrade", err)
        http.Error(w, "Could not upgrade", http.StatusInternalServerError)
        return
    }

    // 处理连接
    go handleConnection(conn)
}

func handleConnection(conn *websocket.Conn) {
    for {
        // 读取消息
        _, message, err := conn.ReadMessage()
        if err != nil {
            log.Println("Could not read message:", err)
            return
        }

        // 存储消息到队列
        messageQueue <- message
    }
}

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!