答案：使用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 是核心管理器，用于注册、注销和广播消息。
立即学习“go语言免费学习笔记（深入）”；
启动管理器并处理连接
实现管理器的运行逻辑和 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 }
<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 已做基础保障。
