GolangWebSocket多客户端连接管理详解

本文深入浅出地讲解了如何使用 Golang 结合 gorilla/websocket 库高效管理多个 WebSocket 客户端连接，通过精心设计的 Client 结构体封装单个连接与消息通道、ClientManager 实现线程安全的注册/注销/广播机制，并配合 readPump 与 writePump 协程分离读写逻辑，构建出高并发、易维护的实时通信服务骨架——无论你是初探 WebSocket 的开发者，还是正在为聊天系统、实时通知或协同应用寻找稳定后端方案，这套简洁实用的模式都能为你提供清晰可复用的核心架构思路。

在使用 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学习网公众号！