golang Websocket Development Guide: Implementing multi-person online collaboration function

Golang Websocket Development Guide: Implementing multi-person online collaboration function

Introduction:
Websocket is a method that establishes a persistent connection between the client and the server Communication protocol, which can realize the function of the server actively pushing messages to the client. In practical applications, Websocket is widely used in real-time notifications, chat rooms, multi-person online collaboration and other scenarios. This article will introduce how to use Golang to develop Websocket applications, and combine it with code examples to demonstrate how to implement multi-person online collaboration.

1. Introduction to Golang Websocket
Golang comes with a built-in Websocket library to facilitate developers to quickly build Websocket applications. Using Golang's Websocket library, you can easily implement Websocket functions such as connection, message sending and receiving, and connection pool management.

2. Golang Websocket development environment configuration

1. Install Golang development environment

2. Install Golang Websocket library

   • Open the terminal Or command line window
   • Execute the command: go get github.com/gorilla/websocket

3. Golang Websocket development process

1. Import the required libraries
   Import the "golang.org/x/net/websocket" and "github.com/gorilla/websocket" libraries at the beginning of the code.

2. Define connection pool
   The subsequent sample code will use a global connection pool to manage the Websocket connections of all clients to achieve the function of multi-person online collaboration. Define a connection pool of structure type. The fields in the structure include a mutex and a slice to store the connection.

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

   Copy after login

3. Handling WebSocket requests
   In Golang, HTTP requests can be monitored and processed through the Http package. We need to write a function that handles Websocket requests and register the function in the HTTP server.

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

   Copy after login

4. Message processing logic
   In the sample code, we use a goroutine to handle the sending and receiving of messages for each connection. By reading messages on the connection, multiple people can collaborate online. When a new message is sent, all connections are traversed through the connection pool and the message is sent.

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

   Copy after login

5. Start the Websocket server
   Write a function to start the Websocket server. In this function, we need to create an Http server instance and bind the function that handles Websocket requests.

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

   Copy after login

6. Complete sample code
   The following is the complete Websocket application sample code:

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

   Copy after login

4. Run the example

1. Compile and run the sample code:

   go build main.go
   ./main

   Copy after login
2. Open the browser and visit localhost:8000 to enter the Websocket application page.
3. Open this page in multiple browser windows to demonstrate the function of multi-person online collaboration. After you enter a message in any window, the other windows receive the message.

Conclusion:
This article introduces how to use Golang to develop Websocket applications, and through specific code examples, shows how to realize the function of multi-person online collaboration. I hope this article will help you understand and use Golang Websocket!

The above is the detailed content of golang Websocket Development Guide: Implementing multi-person online collaboration function. For more information, please follow other related articles on the PHP Chinese website!