Guide de programmation Golang WebSocket : création d'applications en temps réel hautes performances

Guide de programmation Golang WebSocket : Création d'applications en temps réel hautes performances

Introduction :
Avec le développement rapide d'Internet, le besoin de communication en temps réel devient de plus en plus urgent. En tant que protocole de communication bidirectionnel, WebSocket peut établir une connexion persistante entre le navigateur et le serveur, offrant ainsi une solution efficace et fiable pour les applications en temps réel. Cet article expliquera comment utiliser Golang pour créer des applications en temps réel hautes performances et donnera des exemples de code spécifiques.

1. Qu'est-ce que le protocole WebSocket ? Le protocole WebSocket est un protocole basé sur TCP qui permet au serveur de transmettre activement des données au navigateur en établissant une connexion full-duplex persistante entre le navigateur et le serveur pour établir une communication en temps réel. . Par rapport au protocole HTTP traditionnel, le protocole WebSocket présente les avantages suivants :

Par rapport au protocole HTTP, le processus de prise de contact du protocole WebSocket est plus simple, réduisant ainsi le délai d'établissement de la connexion.
1. Le protocole WebSocket peut transmettre des données dans les deux sens en une seule connexion, réduisant ainsi la surcharge de transmission des données.
2. Le protocole WebSocket prend en charge la communication entre domaines et peut établir des connexions sous différents noms de domaine pour réaliser le partage et l'échange de données.

2. Programmation WebSocket dans Golang

Golang, en tant que langage de programmation hautes performances, fournit une bibliothèque standard pratique et facile à utiliser pour gérer la communication WebSocket. Voici un exemple de code pour un simple serveur WebSocket :

package main

import (
    "log"
    "net/http"

    "github.com/gorilla/websocket"
)

var upgrader = websocket.Upgrader{
    CheckOrigin: func(r *http.Request) bool {
        return true
    },
}

func main() {
    http.HandleFunc("/echo", echoHandler)
    log.Fatal(http.ListenAndServe(":8080", nil))
}

func echoHandler(w http.ResponseWriter, r *http.Request) {
    conn, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        log.Fatal("upgrade error:", err)
    }
    defer conn.Close()

    for {
        messageType, message, err := conn.ReadMessage()
        if err != nil {
            log.Println("read error:", err)
            break
        }
        log.Println("receive:", string(message))

        err = conn.WriteMessage(messageType, message)
        if err != nil {
            log.Println("write error:", err)
            break
        }
    }
}

Dans le code ci-dessus, la requête WebSocket est mappée à via la fonction <code>http.HandleFunc et la route /echo Fonction echoHandler. Dans la fonction echoHandler, nous utilisons websocket.Upgrader pour mettre à niveau la connexion HTTP vers une connexion WebSocket et obtenir une instance websocket.Conn. Un simple serveur WebSocket Echo est implémenté en lisant les messages dans conn et en écrivant les mêmes messages.

http.HandleFunc函数和路由/echo将WebSocket请求映射到echoHandler函数。在echoHandler函数中，我们使用websocket.Upgrader来升级HTTP连接为WebSocket连接，并得到一个websocket.Conn实例。通过读取conn中的消息并写入相同的消息，实现了一个简单的WebSocket Echo服务器。

三、实时聊天室示例
以上示例只实现了简单的消息回显功能。下面，我们将展示如何使用Golang构建一个实时聊天室，其中多个用户可以同时进行实时通信。

package main

import (
    "log"
    "net/http"

    "github.com/gorilla/websocket"
)

var upgrader = websocket.Upgrader{
    CheckOrigin: func(r *http.Request) bool {
        return true
    },
}

type Message struct {
    Username string `json:"username"`
    Content  string `json:"content"`
}

type Room struct {
    clients  map[*websocket.Conn]bool
    broadcast chan Message
    join     chan *websocket.Conn
    leave    chan *websocket.Conn
}

func (r *Room) start() {
    for {
        select {
        case conn := <-r.join:
            r.clients[conn] = true
        case conn := <-r.leave:
            delete(r.clients, conn)
            close(conn)
        case message := <-r.broadcast:
            for conn := range r.clients {
                err := conn.WriteJSON(message)
                if err != nil {
                    log.Println("write error:", err)
                    delete(r.clients, conn)
                    close(conn)
                }
            }
        }
    }
}

func main() {
    r := Room{
        clients:  make(map[*websocket.Conn]bool),
        broadcast: make(chan Message),
        join:     make(chan *websocket.Conn),
        leave:    make(chan *websocket.Conn),
    }

    go r.start()

    http.HandleFunc("/ws", func(w http.ResponseWriter, r *http.Request) {
        conn, err := upgrader.Upgrade(w, r, nil)
        if err != nil {
            log.Fatal("upgrade error:", err)
        }

        r.join <- conn

        defer func() {
            r.leave <- conn
        }()

        for {
            var message Message
            err = conn.ReadJSON(&message)
            if err != nil {
                log.Println("read error:", err)
                break
            }

            r.broadcast <- message
        }
    })

    log.Fatal(http.ListenAndServe(":8080", nil))
}

在上述代码中，我们定义了一个Room类型来管理连接的客户端。Room类型内部包含了clients用来保存所有已连接的客户端，broadcast用来广播消息，join和leave用来处理客户端的连接和断开。

在main函数中，我们创建了一个Room实例，并通过go r.start()启动Room实例的消息处理协程。通过http.HandleFunc函数和路由/ws将WebSocket请求映射到匿名函数。在匿名函数中，我们将连接加入到Room的join通道中，并在函数末尾将连接从Room的leave通道中移除。同时，我们使用conn.ReadJSON和conn.WriteJSON3. Exemple de salle de discussion en temps réel

L'exemple ci-dessus implémente uniquement une simple fonction d'écho de message. Ci-dessous, nous montrerons comment utiliser Golang pour créer une salle de discussion en temps réel où plusieurs utilisateurs peuvent communiquer en temps réel en même temps.

rrreee
Dans le code ci-dessus, nous définissons un type Room pour gérer les clients connectés. Le type Room contient en interne des clients pour enregistrer tous les clients connectés, broadcast pour diffuser des messages, et rejoindre et leave sont utilisés pour gérer les connexions et déconnexions des clients.

🎜Dans la fonction main, nous créons une instance Room et démarrons Room via go r.start() code>La coroutine de traitement des messages de l’instance. Mappez les requêtes WebSocket vers des fonctions anonymes via la fonction <code>http.HandleFunc et routez /ws. Dans la fonction anonyme, nous rejoignons la connexion au canal join de Room, et à la fin de la fonction nous quittons la connexion de Room quitter Supprimé de la chaîne. En même temps, nous utilisons conn.ReadJSON et conn.WriteJSON pour lire et écrire des messages au format JSON respectivement. 🎜🎜Conclusion :🎜Cet article donne un guide pour créer des applications temps réel hautes performances en présentant les caractéristiques du protocole WebSocket et comment l'utiliser dans Golang. En fournissant des exemples de code spécifiques, les lecteurs peuvent rapidement démarrer avec la programmation Golang WebSocket et appliquer des fonctions de communication en temps réel dans les projets. J'espère que cet article vous aidera ! 🎜

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!