GolangWebSocket多客户端连接管理教程

各位小伙伴们，大家好呀！看看今天我又给各位带来了什么文章？本文标题是《Golang WebSocket多客户端管理教程》，很明显是关于Golang的文章哈哈哈，其中内容主要会涉及到等等，如果能帮到你，觉得很不错的话，欢迎各位多多点评和分享！

答案：使用Golang和gorilla/websocket实现WebSocket多客户端管理，通过Client结构体封装连接，ClientManager进行注册、注销和广播。1. 客户端连接由Client结构体表示，包含Conn和Send通道；2. ClientManager维护客户端集合，处理注册、注销及消息广播；3. ServeHTTP升级HTTP连接并启动读写协程；4. readPump从客户端读取消息，writePump发送消息；5. Run方法监听事件并更新客户端状态。

在使用 Golang 构建 WebSocket 服务时，管理多个客户端连接是一个常见需求。下面是一个简洁、实用的多客户端管理示例，使用标准库 net/http 和 gorilla/websocket 实现。

依赖安装

go get github.com/gorilla/websocket

这是目前最常用的 WebSocket 第三方库。

WebSocket 客户端结构体设计

每个客户端连接封装为一个结构体，便于统一管理。

package main

import (
    "net/http"
    "sync"

    "github.com/gorilla/websocket"
)

var upgrader = websocket.Upgrader{
    CheckOrigin: func(r *http.Request) bool {
        return true // 允许跨域，生产环境建议严格校验
    },
}

type Client struct {
    Conn *websocket.Conn
    Send chan []byte
}

type ClientManager struct {
    clients    map[*Client]bool
    register   chan *Client
    unregister chan *Client
    broadcast  chan []byte
    mutex      sync.RWMutex
}

Client 表示一个 WebSocket 连接，包含连接实例和发送消息的通道。
ClientManager 是核心管理器，用于注册、注销和广播消息。

启动管理器并处理连接

实现管理器的运行逻辑和 HTTP 处理函数。

func NewClientManager() *ClientManager {
    return &ClientManager{
        clients:    make(map[*Client]bool),
        register:   make(chan *Client),
        unregister: make(chan *Client),
        broadcast:  make(chan []byte),
    }
}

func (manager *ClientManager) Run() {
    for {
        select {
        case client := <-manager.register:
            manager.mutex.Lock()
            manager.clients[client] = true
            manager.mutex.Unlock()
            println("客户端加入，当前总数:", len(manager.clients))

        case client := <-manager.unregister:
            manager.mutex.Lock()
            if _, ok := manager.clients[client]; ok {
                delete(manager.clients, client)
                close(client.Send)
            }
            manager.mutex.Unlock()
            println("客户端退出，剩余:", len(manager.clients))

        case message := <-manager.broadcast:
            manager.mutex.RLock()
            for client := range manager.clients {
                select {
                case client.Send <- message:
                default:
                    // 发送失败，关闭该连接
                    manager.unregister <- client
                }
            }
            manager.mutex.RUnlock()
        }
    }
}

func (manager *ClientManager) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    conn, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        http.Error(w, "WebSocket 升级失败", http.StatusBadRequest)
        return
    }

    client := &Client{Conn: conn, Send: make(chan []byte, 10)}
    manager.register <- client

    go manager.readPump(client)
    go manager.writePump(client)
}

readPump 负责从客户端读取消息：

```go func (manager *ClientManager) readPump(client *Client) { defer func() { manager.unregister for { _, message, err := client.Conn.ReadMessage() if err != nil { break } manager.broadcast <- message }

}

<p><strong>writePump</strong> 负责向客户端发送消息：</p>
```go
func (manager *ClientManager) writePump(client *Client) {
    defer func() {
        manager.unregister <- client
        client.Conn.Close()
    }()

    for message := range client.Send {
        err := client.Conn.WriteMessage(websocket.TextMessage, message)
        if err != nil {
            break
        }
    }
}

主函数启动服务

完整启动一个 WebSocket 服务，监听 8080 端口。

func main() {
    manager := NewClientManager()
    go manager.Run()

    http.Handle("/ws", manager)
    println("WebSocket 服务启动在 :8080/ws")
    http.ListenAndServe(":8080", nil)
}

访问 ws://localhost:8080/ws 的客户端将被纳入管理，任意客户端发送消息，其他所有客户端都能收到。

基本上就这些。这个示例结构清晰，易于扩展，比如加入用户ID、分组广播、心跳检测等。不复杂但容易忽略的是并发安全和连接异常处理，这里通过互斥锁和 defer 已做基础保障。

今天关于《GolangWebSocket多客户端连接管理教程》的内容介绍就到此结束，如果有什么疑问或者建议，可以在golang学习网公众号下多多回复交流；文中若有不正之处，也希望回复留言以告知！