golang Websocket-Entwicklungshandbuch: Implementierung der Online-Zusammenarbeitsfunktion für mehrere Personen

Golang Websocket-Entwicklungshandbuch: Implementierung der Online-Zusammenarbeitsfunktion für mehrere Personen

Einführung:
Websocket ist ein Kommunikationsprotokoll, das eine dauerhafte Verbindung zwischen dem Client und dem Server herstellt. Es kann dem Server ermöglichen, Nachrichten aktiv an den Client zu senden Funktion. In praktischen Anwendungen wird Websocket häufig in Echtzeitbenachrichtigungen, Chatrooms, Online-Zusammenarbeit mit mehreren Personen und anderen Szenarien eingesetzt. In diesem Artikel wird die Verwendung von Golang zum Entwickeln von Websocket-Anwendungen vorgestellt und mit Codebeispielen kombiniert, um zu demonstrieren, wie die Online-Zusammenarbeit mehrerer Personen implementiert wird.

1. Einführung in Golang Websocket
Golang verfügt über eine integrierte Websocket-Bibliothek, um Entwicklern die schnelle Erstellung von Websocket-Anwendungen zu erleichtern. Mit der Websocket-Bibliothek von Golang können Sie Websocket-Funktionen wie Verbindung, Senden und Empfangen von Nachrichten sowie Verbindungspoolverwaltung problemlos implementieren.

2. Konfiguration der Golang Websocket-Entwicklungsumgebung

1. Installieren Sie die Golang-Entwicklungsumgebung

2. Installieren Sie die Golang Websocket-Bibliothek

   • Öffnen Sie ein Terminal- oder Befehlszeilenfenster
   • Führen Sie den Befehl aus: go get github.com/gorilla/websocket

3. Golang Websocket-Entwicklungsprozess

1. Importieren Sie die erforderlichen Bibliotheken
   Importieren Sie die Bibliotheken „golang.org/x/net/websocket“ und „github.com/gorilla/websocket“ am Anfang des Codes.

2. Verbindungspool definieren
   Der folgende Beispielcode verwendet einen globalen Verbindungspool, um die Websocket-Verbindungen aller Clients zu verwalten und die Funktion der Online-Zusammenarbeit mehrerer Personen zu erreichen. Definieren Sie einen Verbindungspool vom Strukturtyp. Die Felder in der Struktur umfassen einen Mutex und einen Slice zum Speichern der Verbindung.

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

3. Umgang mit WebSocket-Anfragen
   In Golang können HTTP-Anfragen über das Http-Paket überwacht und verarbeitet werden. Wir müssen eine Funktion schreiben, die Websocket-Anfragen verarbeitet, und die Funktion im HTTP-Server registrieren.

   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. Logik zur Nachrichtenverarbeitung
   Im Beispielcode verwenden wir eine Goroutine, um das Senden und Empfangen von Nachrichten für jede Verbindung zu verwalten. Durch das Lesen von Nachrichten über die Verbindung können mehrere Personen online zusammenarbeiten. Wenn eine neue Nachricht gesendet wird, durchlaufen alle Verbindungen den Verbindungspool und die Nachricht wird gesendet.

   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. Websocket-Server starten
   Schreiben Sie eine Funktion zum Starten des Websocket-Servers. In dieser Funktion müssen wir eine HTTP-Serverinstanz erstellen und die Funktion binden, die Websocket-Anfragen verarbeitet.

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

6. Vollständiger Beispielcode
   Das Folgende ist der vollständige Beispielcode für die Websocket-Anwendung:

   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()
   }

Vier. Führen Sie das Beispiel aus

1. Kompilieren Sie den Beispielcode und führen Sie ihn aus:

   go build main.go
   ./main

2. Öffnen Sie den Browser und besuchen Sie localhost :8000, Sie können die Websocket-Anwendungsseite aufrufen.
3. Öffnen Sie diese Seite in mehreren Browserfenstern, um die Funktion der Online-Zusammenarbeit mit mehreren Personen zu demonstrieren. Nachdem Sie in einem beliebigen Fenster eine Nachricht eingegeben haben, erhalten die anderen Fenster die Nachricht.

Fazit:
Dieser Artikel stellt vor, wie man Golang zum Entwickeln von Websocket-Anwendungen verwendet, und zeigt anhand spezifischer Codebeispiele, wie die Funktion der Online-Zusammenarbeit mehrerer Personen realisiert werden kann. Ich hoffe, dieser Artikel hilft Ihnen, Golang Websocket zu verstehen und zu verwenden!

Das obige ist der detaillierte Inhalt vongolang Websocket-Entwicklungshandbuch: Implementierung der Online-Zusammenarbeitsfunktion für mehrere Personen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!