You need to enable JavaScript to run this app. Gin框架基于SSE实现向指定UID客户端定向推送事件的方法
优惠活动
大模型
产品
解决方案
定价
更多

Gin框架基于SSE实现向指定UID客户端定向推送事件的方法

定向SSE推送实现方案

当前代码的核心问题

你现在的实现跑起来其实有两个很隐蔽的问题:

  1. Broker里存的客户端只是个没有身份的裸通道,完全没绑定从路径参数取到的UID,根本没法区分哪个连接属于哪个用户,自然做不了过滤
  2. 所有客户端的流处理函数都在读同一个全局eventsStream.Message通道,实际效果是一条消息发出去只会被某一个抢到通道的客户端收到,连最基础的全量广播都实现不了

要实现按UID、按用户组的定向推送,核心是把客户端的身份信息和连接绑定,在Broker层做分维度的索引,投递的时候按目标匹配对应列表就行,不需要遍历全量客户端做过滤。


具体改造代码

1. 重构事件Broker

放弃原来的裸通道存储逻辑,给客户端加上身份标签,按UID、用户组两个维度建索引,消息结构增加目标字段:

package broker

import "log"

// 客户端结构:把身份信息和专属消息通道绑在一起
type Client struct {
    UID    string   // 来自路径参数的用户唯一标识
    Groups []string // 用户所属的组列表
    Ch     chan string // 客户端专属的消息接收通道
}

// 带目标标识的消息结构
type ClientMessage struct {
    Content     string // 要推送的消息内容
    TargetUID   string // 定向推送的目标UID,为空则不按UID匹配
    TargetGroup string // 定向推送的目标组,为空则不按组匹配
}

type EventBroker struct {
    Message       chan *ClientMessage
    NewClients    chan *Client
    ClosedClients chan *Client
    // 按UID存客户端列表,快速定位单个用户的所有连接
    ClientsByUID map[string][]*Client
    // 按用户组存客户端列表,快速定位组内所有用户的连接
    ClientsByGroup map[string][]*Client
}

func NewBroker() *EventBroker {
    b := &EventBroker{
        Message:        make(chan *ClientMessage),
        NewClients:      make(chan *Client),
        ClosedClients:   make(chan *Client),
        ClientsByUID:   make(map[string][]*Client),
        ClientsByGroup: make(map[string][]*Client),
    }
    go b.run()
    return b
}

func (b *EventBroker) run() {
    for {
        select {
        // 处理新客户端连接
        case client := <-b.NewClients:
            // 按UID登记
            b.ClientsByUID[client.UID] = append(b.ClientsByUID[client.UID], client)
            // 按所属组登记
            for _, group := range client.Groups {
                b.ClientsByGroup[group] = append(b.ClientsByGroup[group], client)
            }
            log.Printf("客户端连接,当前总连接数:%d", len(b.ClientsByUID[client.UID]))

        // 处理客户端断开
        case client := <-b.ClosedClients:
            // 从UID索引中移除
            uidList := b.ClientsByUID[client.UID]
            for idx, c := range uidList {
                if c.Ch == client.Ch {
                    b.ClientsByUID[client.UID] = append(uidList[:idx], uidList[idx+1:]...)
                    break
                }
            }
            if len(b.ClientsByUID[client.UID]) == 0 {
                delete(b.ClientsByUID, client.UID)
            }
            // 从组索引中移除
            for _, group := range client.Groups {
                groupList := b.ClientsByGroup[group]
                for idx, c := range groupList {
                    if c.Ch == client.Ch {
                        b.ClientsByGroup[group] = append(groupList[:idx], groupList[idx+1:]...)
                        break
                    }
                }
                if len(b.ClientsByGroup[group]) == 0 {
                    delete(b.ClientsByGroup, group)
                }
            }
            close(client.Ch)
            log.Printf("客户端断开")

        // 处理待发送的消息
        case msg := <-b.Message:
            // 按消息里的目标字段,匹配对应的客户端列表
            var targetList []*Client
            switch {
            case msg.TargetUID != "":
                // 定向给单个用户发,直接取UID索引下的所有连接
                targetList = b.ClientsByUID[msg.TargetUID]
            case msg.TargetGroup != "":
                // 定向给组内所有用户发,直接取组索引下的所有连接
                targetList = b.ClientsByGroup[msg.TargetGroup]
            default:
                // 全量广播,收集所有用户的连接
                for _, clients := range b.ClientsByUID {
                    targetList = append(targetList, clients...)
                }
            }
            // 非阻塞投递消息,避免单个慢客户端拖垮整个Broker
            for _, c := range targetList {
                select {
                case c.Ch <- msg.Content:
                default:
                    log.Printf("客户端通道已满,跳过投递")
                }
            }
        }
    }
}

2. 改造SSE GET端点

从路径参数提取UID,绑定到客户端对象上,注册到Broker;流处理时从当前客户端的专属通道读消息:

var eventsBroker = broker.NewBroker()

func GetRelevantMarkers(c *gin.Context) {
    c.Writer.Header().Set("Content-Type", "text/event-stream")
    c.Writer.Header().Set("Cache-Control", "no-cache")
    c.Writer.Header().Set("Connection", "keep-alive")
    c.Writer.Header().Set("Transfer-Encoding", "chunked")

    // 从路径参数取当前连接的UID
    currentUID := c.Param("uid")
    // 这里可以根据业务逻辑查当前用户所属的组,比如从数据库、权限服务拉
    currentGroups := []string{}

    // 新建带缓冲的专属通道,避免投递阻塞
    client := &broker.Client{
        UID:    currentUID,
        Groups: currentGroups,
        Ch:     make(chan string, 10),
    }

    // 注册到Broker
    eventsBroker.NewClients <- client

    defer func() {
        eventsBroker.ClosedClients <- client
    }()

    go func() {
        <-c.Done()
        eventsBroker.ClosedClients <- client
    }()

    // 从当前客户端自己的通道读消息推送
    c.Stream(func(w io.Writer) bool {
        if msg, ok := <-client.Ch; ok {
            c.SSEvent("message", msg)
            return true
        }
        return false
    })
}

3. 改造POST推送触发逻辑

根据业务需要构造带目标标识的消息:

// 原来的全量广播:通知所有连接的用户
func DeleteEvent(c *gin.Context) {
    eventsBroker.Message <- &broker.ClientMessage{
        Content: "event-deleted",
    }
}

// 定向推送给单个用户的示例
func SendNotificationToUser(c *gin.Context) {
    targetUID := c.Param("uid") // 从请求参数里拿要推送的目标用户UID
    eventsBroker.Message <- &broker.ClientMessage{
        Content:   "您有一条新的通知",
        TargetUID: targetUID,
    }
}

// 定向推送给整个用户组的示例
func SendNotificationToGroup(c *gin.Context) {
    targetGroup := c.Param("group") // 从请求参数里拿要推送的目标组ID
    eventsBroker.Message <- &broker.ClientMessage{
        Content:     "组内公告:xxx",
        TargetGroup: targetGroup,
    }
}

注意事项

  • 给每个客户端的消息通道加10左右的缓冲区,减少投递时的阻塞概率
  • 投递用非阻塞判断,遇到通道满的客户端直接跳过,不要等,否则会拖垮整个推送服务
  • 同一个UID下的多个连接(比如用户开了多个浏览器标签)会自动被归到同一列表,发消息时会同时推给所有活跃连接,符合常规使用习惯
  • 客户端断开时一定要同步从两个索引里清理连接,不然会有内存泄漏

内容的提问来源于stack exchange,提问作者Sree Grandhe

相关产品推荐
方舟 Agent Plan

超全模态模型 × Harness 升级,最新支持 Deepseek-V4.1-Flash、GLM-5.3 系列、Doubao-Seedream-5.0-pro、Kimi-K3 (部分), 限时 9.9 元起

最近更新时间:2026.11.02 02:24:06