douwei2713 2019-01-21 12:35
浏览 646


I am very new to Go and have found myself working with sockets as my first project. This is a redundant question, but I have failed to understand how to send a websocket update to a specific client in Go (using Gorilla).

The broad problem that I am trying to solve is - Building a typeahead using websockets and a search engine like ES/Lucene. I have maintained a bunch of indexes on my search engine and have a Go wrapper around it. When I started working on using websockets in Go, I have been finding almost all the examples showing broadcasting mechanism. When I tried to dig into this and tried to modify the example given in Gorilla's github repo based on the examples given in this thread and in this answer, I don't seem to understand connections and how does that fit in client.go

Ideally, the way I would like to see this working is -

  • A socket connection between the client and server is established
  • Upon the client sending inputs via the socket, the server fetches it and throws into into a channel (Go channel)
  • The indexing wrapper checks for this channel, and once there is something to fetch, the index is retrieved and written back to the socket

How can the server uniquely identify the Client?

I have used the examples given on Gorilla's Github repo

From my codebase hub.go has the following

type Hub struct {
    // Registered clients.
    clients map[*Client]bool

    // Inbound messages from the clients.
    broadcast chan []byte

    // Register requests from the clients.
    register chan *Client

    // Unregister requests from clients.
    unregister chan *Client

    connections map[string]*connection

func newHub() *Hub {
    return &Hub{
        broadcast:  make(chan []byte),
        register:   make(chan *Client),
        unregister: make(chan *Client),
        clients:    make(map[*Client]bool),
        connection: make(map[*Client]bool), // is this alright?

func (h *Hub) run() {
    for {
        select {
        case client := <-h.register:
            h.clients[client] = true
        case client := <-h.unregister:
            if _, ok := h.clients[client]; ok {
                delete(h.clients, client)
        case message := <-h.broadcast:
            for client := range h.connections {
                select {
                case client.send <- message:
                    delete(h.connections, client)

and I am unsure with what I should be adding to client.go

type Client struct {
    // unique ID for each client
    // id string

    // Hub object
    hub *Hub

    // The websocket connection.
    conn *websocket.Conn

    // Buffered channel of outbound messages.
    send chan []byte

    // connection --> (what should the connection property be?)
    connection string

Please note - I will be adding an Id field within the Client struct. How can I proceed from here?

  • 写回答

1条回答 默认 最新

  • doutan1671 2019-01-21 16:49

    The chat example shows how to implement broadcast. The chat example is not a good starting point for an application if broadcast is not required.

    To send a message to a specific websocket connection, simply write to the connection using NextWriter or WriteMessage. These methods do not support concurrent writers, so you may need to use a mutex or goroutine to ensure a single writer.

    The simple approach for finding a specific *websocket.Connection is to pass *websocket.Connection to the code that needs it. If the application needs to associate other state with a connection, then define a type to hold that state and pass a pointer to that around:

    type Client struct {
        conn *websocket.Conn
        mu sync.Mutex

    The Hub can be modified to send messages to specific connection, but it's a roundabout path if broadcast is not needed. Here's how to do it:

    Add ID field to client:

     ID idType // replace idType with int, string, or whatever you want to use

    Change the Gorilla hub field from connections map[*connection]bool to connections map[idType]*connection.

    Define a message type containing the message data and the ID of the target client:

    type message struct {
       ID idtype
       data []byte

    Replace the hub broadcast field with:

       send chan message

    Change the hub for loop to:

    for {
        select {
        case client := <-h.register:
            h.clients[client.ID] = client
        case client := <-h.unregister:
            if _, ok := h.clients[client.ID]; ok {
                delete(h.clients, client.ID)
        case message := <-h.send:
            if client, ok := h.clients[message.ID]; ok {
                select {
                case client.send <-
                    delete(h.connections, client)

    Send messages to a specific client by creating a message with the appropriate ID:

       hub.send <- message{ID: targetID, data: data}
    本回答被题主选为最佳回答 , 对您是否有帮助呢?



  • ¥15 vb6.0+webbrowser无法加载某个网页求解
  • ¥15 RPA财务机器人采购付款流程
  • ¥15 计算机图形多边形及三次样条曲线绘制
  • ¥15 根据protues画的图用keil写程序
  • ¥200 如何使用postGis实现最短领规划?
  • ¥15 pyinstaller打包错误
  • ¥20 cesm的气溶胶排放文件
  • ¥15 逐月累计,月份不连续,补齐月份
  • ¥15 应用简单的Python代码完成一个学生成绩管理系统
  • ¥15 用matlab求微分方程初值问题