Panduan Pembangunan Soket Web golang: Melaksanakan fungsi kerjasama dalam talian berbilang orang

Panduan Pembangunan Golang Websocket: Melaksanakan fungsi kerjasama dalam talian berbilang orang

Pengenalan:
Websocket ialah protokol komunikasi yang mewujudkan sambungan berterusan antara pelanggan dan pelayan Ia boleh membolehkan pelayan menghantar mesej secara aktif kepada pelanggan Fungsi. Dalam aplikasi praktikal, Websocket digunakan secara meluas dalam pemberitahuan masa nyata, bilik sembang, kerjasama dalam talian berbilang orang dan senario lain. Artikel ini akan memperkenalkan cara menggunakan Golang untuk membangunkan aplikasi Websocket dan menggabungkannya dengan contoh kod untuk menunjukkan cara melaksanakan kerjasama dalam talian berbilang orang.

1. Pengenalan kepada Golang Websocket
Golang dilengkapi dengan perpustakaan Websocket terbina dalam untuk memudahkan pembangun membina aplikasi Websocket dengan cepat. Menggunakan pustaka Websocket Golang, anda boleh melaksanakan fungsi Websocket dengan mudah seperti sambungan, penghantaran dan penerimaan mesej serta pengurusan kumpulan sambungan. Konfigurasi persekitaran pembangunan Golang Websocket

1. 3. Proses pembangunan Golang Websocket

2. Import perpustakaan yang diperlukan

   Import pustaka "golang.org/x/net/websocket" dan "github.com/gorilla/websocket".
   • Tentukan kumpulan sambungan
   • Kod sampel seterusnya akan menggunakan kumpulan sambungan global untuk mengurus sambungan Websocket semua pelanggan untuk mencapai fungsi kerjasama dalam talian berbilang orang. Tentukan kumpulan sambungan jenis struktur Medan dalam struktur termasuk mutex dan kepingan untuk menyimpan sambungan.

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

Mengendalikan permintaan WebSocket

Di Golang, permintaan HTTP boleh dipantau dan diproses melalui pakej Http. Kita perlu menulis fungsi yang mengendalikan permintaan Websocket dan mendaftarkan fungsi dalam pelayan 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)
}

1. 
   Logik pemprosesan mesej
Dalam kod sampel, kami menggunakan goroutine untuk mengendalikan penghantaran dan penerimaan mesej untuk setiap sambungan. Dengan membaca mesej pada sambungan, fungsi kerjasama dalam talian berbilang orang direalisasikan. Apabila mesej baharu dihantar, semua sambungan dilalui melalui kolam sambungan dan mesej dihantar.

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

   
   

   Mulakan Pelayan Websocket
Tulis fungsi untuk memulakan Pelayan Websocket. Dalam fungsi ini, kita perlu mencipta contoh pelayan Http dan mengikat fungsi yang mengendalikan permintaan Websocket.

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

   
   

   Kod contoh lengkap
Berikut ialah kod contoh aplikasi Websocket yang lengkap:

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

   
   

   Four. :8000, Anda boleh memasuki halaman aplikasi Websocket.
5. Buka halaman ini dalam berbilang tetingkap penyemak imbas untuk menunjukkan fungsi kerjasama dalam talian berbilang orang. Selepas anda memasukkan mesej dalam mana-mana tetingkap, tetingkap lain menerima mesej itu.

   
   

   Kesimpulan:
Artikel ini memperkenalkan cara menggunakan Golang untuk membangunkan aplikasi Websocket, dan melalui contoh kod khusus, menunjukkan cara merealisasikan fungsi kerjasama dalam talian berbilang orang. Saya harap artikel ini akan membantu anda memahami dan menggunakan Golang Websocket!

Atas ialah kandungan terperinci Panduan Pembangunan Soket Web golang: Melaksanakan fungsi kerjasama dalam talian berbilang orang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!