以循环方式向客户端提供消息的 WebSocket 服务器

目前golang学习网上已经有很多关于Golang的文章了，自己在初次阅读这些文章中，也见识到了很多学习思路；那么本文《以循环方式向客户端提供消息的 WebSocket 服务器》，也希望能帮助到大家，如果阅读完后真的对你学习Golang有帮助，欢迎动动手指，评论留言并分享~

我在 go 中有一个使用 gorilla websocket 包的 websocket 服务器。在此阶段，我将只有一台服务器为 5 个客户端提供服务。我从上游收到一些消息到 websocket 服务器。我的目的是不将所有消息广播到连接的客户端。我只想以循环方式将消息的一份副本发送给连接的客户端。哪个客户端获取它并不重要，只要只有一个客户端获取它即可。

我尝试的解决方案 我有一个简单的 go 服务器，创建了一个我正在接收的客户端池（websocket 连接）。但是，我没有看到任何如上所述的循环消息的选项。我所有的客户都收到了这个消息。如何只向连接的客户端发送一份消息副本，而不是向所有客户端广播。

抑制器 我的代码取自在线资源并根据我的要求进行了修改。我对 go 和 websockets 还比较陌生。 使用 websockets 是否可以做到这一点？

main.go

package main

import (
    "fmt"
    "net/http"

    "github.com/realtime-chat-go-react/backend/pkg/websocket"
)

func servews(pool *websocket.pool, w http.responsewriter, r *http.request) {
    fmt.println("websocket endpoint hit")
    conn, err := websocket.upgrade(w, r)
    if err != nil {
        fmt.fprintf(w, "%+v\n", err)
    }

    client := &websocket.client{
        conn: conn,
        pool: pool,
    }

    pool.register <- client
    client.read()
}

func setuproutes() {
    pool := websocket.newpool()
    go pool.start()

    http.handlefunc("/ws", func(w http.responsewriter, r *http.request) {
        servews(pool, w, r)
    })
}

func main() {
    setuproutes()
    err := http.listenandserve(":8080",nil)

    if err != nil {
        fmt.println(err)
    }
}

websocket.go

package websocket

import (
    "log"
    "net/http"

    "github.com/gorilla/websocket"
)

var upgrader = websocket.upgrader{
    readbuffersize:  1024,
    writebuffersize: 1024,
}

var wslist []*websocket.conn

func upgrade(w http.responsewriter, r *http.request) (*websocket.conn, error) {
    upgrader.checkorigin = func(r *http.request) bool { return true }
    conn, err := upgrader.upgrade(w, r, nil)
    wslist = append(wslist, conn) //creating a list here to store all websocket clients.

    if err != nil {
        log.println(err)
        return nil, err
    }

    return conn, nil
}

pool.go

package websocket

import "fmt"

type pool struct {
    register   chan *client
    unregister chan *client
    clients    map[*client]bool
    broadcast  chan message
}

func newpool() *pool {
    return &pool{
        register:   make(chan *client),
        unregister: make(chan *client),
        clients:    make(map[*client]bool),
        broadcast:  make(chan message),
    }
}

func (pool *pool) start() {
    for {
        select {
        case client := <-pool.register:
            pool.clients[client] = true
            fmt.println("size of connection pool: ", len(pool.clients))
            for client, _ := range pool.clients {
                fmt.println(client)
                client.conn.writejson(message{type: 1, body: "new user joined..."})
            }
            break
        case client := <-pool.unregister:
            delete(pool.clients, client)
            fmt.println("size of connection pool: ", len(pool.clients))
            for client, _ := range pool.clients {
                client.conn.writejson(message{type: 1, body: "user disconnected..."})
            }
            break
        case message := <-pool.broadcast:     //this is where i need to modify the code but not sure how
            fmt.println("sending message to all clients in pool")
            for client, _ := range pool.clients {
                if err := client.conn.writejson(message); err != nil {
                    fmt.println(err)
                    return
                }
            }
        }
    }
}

client.go

package websocket

import (
    "fmt"
    "log"
    "sync"

    "github.com/gorilla/websocket"
)

type Client struct {
    ID   string
    Conn *websocket.Conn
    Pool *Pool
    mu   sync.Mutex
}

type Message struct {
    Type int    `json:"type"`
    Body string `json:"body"`
}

func (c *Client) Read() {
    defer func() {
        c.Pool.Unregister <- c
        c.Conn.Close()
    }()

    for {
        messageType, p, err := c.Conn.ReadMessage()
        if err != nil {
            log.Println(err)
            return
        }

        message := Message{Type: messageType, Body: string(p)}
        c.Pool.Broadcast <- message
        fmt.Printf("Message Received: %+v\n", message)

    }
}

解决方案

修改池以将客户端存储在切片而不是映射中。添加字段来记录以前使用过的客户端的索引。

type pool struct {
    register   chan *client
    unregister chan *client
    clients    []*client
    broadcast  chan message
    prevclientindex int
}

循环而不是广播：

case message := <-pool.broadcast: 
    if len(pool.clients) == 0 {
        continue
    }
    pool.prevclientindex++
    if pool.prevclientindex >= len(pool.clients) {
       pool.prevclientindex = 0
    }
    client := pool.clients[pool.prevclientindex]
    if err := client.conn.writejson(message); err != nil {
        // handle error
        ...

注册附加到切片：

case client := <-pool.register:
    pool.clients = append(pool.clients, client)
    ...

取消注册将从切片中删除客户端：

case client := <-pool.Unregister:
    j := 0
    for _, c := range pool.Clients {
       if c != client {
          c.Clients[j] = c
          j++
       }
    }
    pool.Clients = pool.Clients[:j]
    ...

理论要掌握，实操不能落！以上关于《以循环方式向客户端提供消息的 WebSocket 服务器》的详细介绍，大家都掌握了吧！如果想要继续提升自己的能力，那么就来关注golang学习网公众号吧！