进一步升级，做分布式支持 + Redis Pub/Sub 跨实例广播 + 限流，这样就可以支撑高并发和集群环境

最后发布时间:2026-02-04 14:43:01 浏览量:

好，那我们直接 上生产级 2.0 版本 👍
我给你一个真实可落地的 Go WebSocket 架构，支持：

✅ 单机 WebSocket（你刚才那个）
✅ Redis Pub/Sub 跨实例广播
✅ 逻辑清晰、可扩展
✅ 和你现在写的 Hub / Session 思路完全兼容

我会先讲 整体架构，再给你 关键代码（可运行）。

一、生产级 WebSocket 架构（集群版）

┌───────────┐
│  Browser  │
└─────┬─────┘
      │ WebSocket
┌─────▼─────┐
│  WS Node  │  ← gorilla/websocket
│  (Go)     │
│            │
│  Hub       │
│   ├─ local broadcast
│   └─ Redis publish
└─────┬─────┘
      │ Pub/Sub
┌─────▼─────┐
│   Redis   │
└─────┬─────┘
      │
┌─────▼─────┐
│  WS Node  │
│  (Go)     │
│  Hub       │
└───────────┘

关键点

每个 WS 实例只维护本机连接
跨实例通信完全交给 Redis
负载均衡只要保证 WebSocket 连接不断即可（不用 sticky）

二、核心设计拆分

1️⃣ 本地 Hub（你已经熟悉）

职责：

管理本机 client
向 Redis 发布消息
接收 Redis 消息 → 本机广播

2️⃣ Redis 广播模型

WebSocket 收到消息：
- 👉 本地广播
- 👉 PUBLISH ws:broadcast <msg>
Redis 订阅者：
- 👉 收到消息
- 👉 推给本机 Hub

三、代码实现（可直接跑）

1️⃣ Redis 客户端

import (
"context"
"github.com/redis/go-redis/v9"
)

var ctx = context.Background()

func newRedis() *redis.Client {
return redis.NewClient(&redis.Options{
Addr: "localhost:6379",
})
}

2️⃣ Hub（升级版）

type Hub struct {
clients    map[*Client]bool
register   chan *Client
unregister chan *Client
broadcast  chan []byte

redis *redis.Client
}

func newHub(rdb *redis.Client) *Hub {
return &Hub{
clients:    make(map[*Client]bool),
register:   make(chan *Client),
unregister: make(chan *Client),
broadcast:  make(chan []byte),
redis:      rdb,
}
}

3️⃣ Hub 主循环

func (h *Hub) run() {
for {
select {
case c := <-h.register:
h.clients[c] = true

case c := <-h.unregister:
if _, ok := h.clients[c]; ok {
delete(h.clients, c)
close(c.send)
}

case msg := <-h.broadcast:
// 1. 本地广播
for c := range h.clients {
select {
case c.send <- msg:
default:
delete(h.clients, c)
close(c.send)
}
}

// 2. 广播到 Redis
h.redis.Publish(ctx, "ws:broadcast", msg)
}
}
}

4️⃣ Redis 订阅 → 推给本机 Hub

func (h *Hub) subscribeRedis() {
sub := h.redis.Subscribe(ctx, "ws:broadcast")
ch := sub.Channel()

for msg := range ch {
data := []byte(msg.Payload)

// 防止死循环：只做本地广播，不再 publish
for c := range h.clients {
select {
case c.send <- data:
default:
delete(h.clients, c)
close(c.send)
}
}
}
}

📌 重点：
Redis 消息 不要再 publish 回 Redis，否则会形成风暴。

5️⃣ Client（和你刚才的版本几乎一致）

type Client struct {
hub  *Hub
conn *websocket.Conn
send chan []byte
}

readPump / writePump 不需要改逻辑，只需：

// readPump 中
c.hub.broadcast <- message

6️⃣ main 启动

func main() {
rdb := newRedis()
hub := newHub(rdb)

go hub.run()
go hub.subscribeRedis()

http.HandleFunc("/ws", func(w http.ResponseWriter, r *http.Request) {
serveWs(hub, w, r)
})

log.Println("WS server on :8080")
log.Fatal(http.ListenAndServe(":8080", nil))
}