Guide de développement de Golang Websocket : implémentation de la fonction de collaboration en ligne multi-personnes

Guide de développement de Golang Websocket : Implémentation d'une fonction de collaboration en ligne multi-personnes

Introduction :
Websocket est un protocole de communication qui établit une connexion persistante entre le client et le serveur. Il peut permettre au serveur de transmettre activement des messages au client. Fonction. Dans les applications pratiques, Websocket est largement utilisé dans les notifications en temps réel, les salons de discussion, la collaboration en ligne entre plusieurs personnes et d'autres scénarios. Cet article présentera comment utiliser Golang pour développer des applications Websocket et le combinera avec des exemples de code pour démontrer comment mettre en œuvre une collaboration en ligne entre plusieurs personnes.

1. Introduction à Golang Websocket
Golang est livré avec une bibliothèque Websocket intégrée pour permettre aux développeurs de créer rapidement des applications Websocket. À l'aide de la bibliothèque Websocket de Golang, vous pouvez facilement implémenter des fonctions Websocket telles que la connexion, l'envoi et la réception de messages et la gestion du pool de connexions.

2. Configuration de l'environnement de développement Golang Websocket

1. Installez l'environnement de développement Golang

2. Installez la bibliothèque Golang Websocket

   • Ouvrez un terminal ou une fenêtre de ligne de commande
   • Exécutez la commande : allez chercher github.com/gorilla/websocket

3. Processus de développement de Golang Websocket

1. Importez les bibliothèques requises
   Importez les bibliothèques "golang.org/x/net/websocket" et "github.com/gorilla/websocket" au début du code.

2. Définir un pool de connexions
   L'exemple de code suivant utilisera un pool de connexions global pour gérer les connexions Websocket de tous les clients afin d'atteindre la fonction de collaboration en ligne entre plusieurs personnes. Définissez un pool de connexions de type structure. Les champs de la structure incluent un mutex et une tranche pour stocker la connexion.

   type ConnPool struct {
       connLock sync.Mutex
       conns    []*websocket.Conn
   }

3. Gestion des requêtes WebSocket
   Dans Golang, les requêtes HTTP peuvent être surveillées et traitées via le package Http. Nous devons écrire une fonction qui gère les requêtes Websocket et enregistrer la fonction sur le serveur HTTP.

   func wsHandler(w http.ResponseWriter, r *http.Request) {
       conn, err := websocket.Upgrade(w, r, nil, 1024, 1024)
       if err != nil {
           log.Println("websocket upgrade failed:", err)
           return
       }
   
       // 将连接添加到连接池中
       pool.add(conn)
       
       // 具体的消息处理逻辑
       go handleMessages(conn)
   }

4. Logique de traitement des messages
   Dans l'exemple de code, nous utilisons une goroutine pour gérer l'envoi et la réception de messages pour chaque connexion. En lisant les messages sur la connexion, la fonction de collaboration en ligne multi-personnes est réalisée. Lorsqu'un nouveau message est envoyé, toutes les connexions transitent par le pool de connexions et le message est envoyé.

   func handleMessages(conn *websocket.Conn) {
       for {
           message := ""
           err := conn.ReadJSON(&message)
           if err != nil {
               log.Println("read message failed:", err)
               // 从连接池中删除连接
               pool.remove(conn)
               break
           }
           
           // 遍历连接池，广播消息
           pool.broadcast(message)
       }
   }

5. Démarrer le serveur Websocket
   Écrivez une fonction pour démarrer le serveur Websocket. Dans cette fonction, nous devons créer une instance de serveur HTTP et lier la fonction qui gère les requêtes Websocket.

   func startServer() {
       http.HandleFunc("/ws", wsHandler)
       http.ListenAndServe(":8000", nil)
   }

6. Exemple de code complet
   Ce qui suit est l'exemple de code complet de l'application Websocket :

   package main
   
   import (
       "log"
       "net/http"
       "sync"
   
       "github.com/gorilla/websocket"
   )
   
   type ConnPool struct {
       connLock sync.Mutex
       conns    []*websocket.Conn
   }
   
   var pool ConnPool
   
   func (p *ConnPool) add(conn *websocket.Conn) {
       p.connLock.Lock()
       defer p.connLock.Unlock()
   
       p.conns = append(p.conns, conn)
   }
   
   func (p *ConnPool) remove(conn *websocket.Conn) {
       p.connLock.Lock()
       defer p.connLock.Unlock()
   
       newConns := make([]*websocket.Conn, 0, len(p.conns)-1)
       for _, c := range p.conns {
           if c != conn {
               newConns = append(newConns, c)
           }
       }
   
       p.conns = newConns
   }
   
   func (p *ConnPool) broadcast(message string) {
       p.connLock.Lock()
       defer p.connLock.Unlock()
   
       for _, conn := range p.conns {
           err := conn.WriteJSON(message)
           if err != nil {
               log.Println("write message failed:", err)
           }
       }
   }
   
   func wsHandler(w http.ResponseWriter, r *http.Request) {
       conn, err := websocket.Upgrade(w, r, nil, 1024, 1024)
       if err != nil {
           log.Println("websocket upgrade failed:", err)
           return
       }
   
       pool.add(conn)
       go handleMessages(conn)
   }
   
   func handleMessages(conn *websocket.Conn) {
       for {
           message := ""
           err := conn.ReadJSON(&message)
           if err != nil {
               log.Println("read message failed:", err)
               pool.remove(conn)
               break
           }
   
           pool.broadcast(message)
       }
   }
   
   func startServer() {
       http.HandleFunc("/ws", wsHandler)
       http.ListenAndServe(":8000", nil)
   }
   
   func main() {
       startServer()
   }

Quatre Exécutez l'exemple

1. Compilez et exécutez l'exemple de code :

   go build main.go
   ./main

2. Ouvrez le navigateur et visitez localhost. :8000, Vous pouvez accéder à la page de l'application Websocket.
3. Ouvrez cette page dans plusieurs fenêtres de navigateur pour démontrer la fonction de collaboration en ligne entre plusieurs personnes. Après avoir saisi un message dans n'importe quelle fenêtre, les autres fenêtres reçoivent le message.

Conclusion :
Cet article présente comment utiliser Golang pour développer des applications Websocket et, à travers des exemples de code spécifiques, montre comment réaliser la fonction de collaboration en ligne multi-personnes. J'espère que cet article vous aidera à comprendre et à utiliser Golang Websocket !

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!