与 golang 套接字一对一聊天

2024-02-08 20:02:01 400人浏览八月长安

摘要

问题内容我有一个购物应用程序，用户可以在其中发布可用性，其他用户可以找到他们并加入他们的可用性。我现在有一个聊天服务，本质上是为了聊天。即顾客可以与购物者聊天以确认细节或其他事情。

问题内容

我有一个购物应用程序，用户可以在其中发布可用性，其他用户可以找到他们并加入他们的可用性。

我现在有一个聊天服务，本质上是为了聊天。即顾客可以与购物者聊天以确认细节或其他事情。这次聊天应该是一对一的。因此，可能有 5 个客户询问购物帖子，我希望聊天是唯一的，因为客户 a 关于购物的聊天应该与客户 b 关于同一购物的聊天分开。购物者应该能够看到聊天并做出回应。

这是我目前所拥有的，但这似乎是向参考中的每个人广播消息。我只想让购物者收到特定发件人发送的消息，而其他人无法访问聊天。

“client.Go”

type client struct {
    conn           *websocket.conn
    chatrepository chat.chatrepository
    message        chan *message
    id             string `JSON:"id"`
    reference      string `json:"reference"`
    username       string `json:"username"`
    sender         string `json:"sender"`
    recipient      string `json:"recipient"`
}

type message struct {
    content   string `json:"content"`
    reference string `json:"reference"`
    // username  string `json:"username"`
    sender string `json:"sender"`
}

func (c *client) writemessage() {
    defer func() {
        c.conn.close()
    }()

    for {
        message, ok := <-c.message
        if !ok {
            return
        }
        uuid, err := uuid.newv4()
        if err != nil {
            log.fatalf("failed to generate uuid: %v", err)
        }
        chatmessage := chat.chatmessage{
            id:     uuid.string(),
            sender: message.sender,
            // recipient: recipient,
            timestamp: time.now(),
            content:   message.content,
        }
        if c.sender == message.sender {
            _, errx := c.chatrepository.addmessage(message.reference, chatmessage)
            if err != nil {
                log.fatalf("failed to generate uuid: %v", errx)
            }
        }
        c.conn.writejson(chatmessage)
    }
}

func (c *client) readmessage(hub *hub) {
    defer func() {
        hub.unreGISter <- c
        c.conn.close()
    }()

    for {
        _, m, err := c.conn.readmessage()
        if err != nil {
            if WEBSocket.isunexpectedcloseerror(err, websocket.closegoingaway, websocket.closeabnORMalclosure) {
                log.printf("error: %v", err)
            }
            break
        }

        msg := &message{
            content:   string(m),
            reference: c.reference,
            sender:    c.sender,
            // username:  c.username,
        }

        hub.broadcast <- msg
    }
}

“hub.go”

type room struct {
    id      string             `json:"id"`
    name    string             `json:"name"`
    clients map[string]*client `json:"clients"`
}

type hub struct {
    rooms      map[string]*room
    register   chan *client
    unregister chan *client
    broadcast  chan *message
    emmiter    events.emitter
}

func newhub(emmiter events.emitter) *hub {
    return &hub{
        rooms:      make(map[string]*room),
        register:   make(chan *client),
        unregister: make(chan *client),
        broadcast:  make(chan *message, 5),
        emmiter:    emmiter,
    }
}

func (h *hub) run() {
    for {
        select {
        case cl := <-h.register:
            if _, ok := h.rooms[cl.reference]; ok {
                r := h.rooms[cl.reference]

                if _, ok := r.clients[cl.id]; !ok {
                    r.clients[cl.id] = cl
                }

            }
        case cl := <-h.unregister:
            if _, ok := h.rooms[cl.reference]; ok {
                if _, ok := h.rooms[cl.reference].clients[cl.id]; ok {
                    // if len(h.rooms[cl.reference].clients) != 0 {
                    //  h.broadcast <- &message{
                    //      content:   "user left the chat",
                    //      reference: cl.reference,
                    //      username:  cl.username,
                    //  }
                    // }

                    delete(h.rooms[cl.reference].clients, cl.id)
                    close(cl.message)
                }
            }

        case m := <-h.broadcast:
            if _, ok := h.rooms[m.reference]; ok {
                for _, cl := range h.rooms[m.reference].clients {
                    cl.message <- m
                    if m.sender != cl.recipient {
                        notifications.sendpush(h.emmiter, cl.recipient, fmt.sprintf("new message from %v", cl.username), m.content)
                    }
                }
            }
        }
    }
}

“处理程序.go”

type handler struct {
    hub            *hub
    chatrepository chat.chatrepository
}

func newhandler(h *hub, chatrepository chat.chatrepository) *handler {
    return &handler{
        hub:            h,
        chatrepository: chatrepository,
    }
}

var upgrader = websocket.upgrader{
    readbuffersize:  1024,
    writebuffersize: 1024,
    checkorigin: func(r *Http.request) bool {
        return true
    },
}

func (h *handler) joinroom(c *gin.context) {
    conn, err := upgrader.upgrade(c.writer, c.request, nil)
    if err != nil {
        utils.handleerror(c, nil, "error creating chat connection", http.statusbadgateway)
        return
    }

    reference := c.param("reference")
    sender := c.query("sender")
    username := c.query("username")
    recipient := c.query("recipient")

    if reference == "" || sender == "" || username == "" || recipient == "" {
        utils.handleerror(c, nil, "required parameters missing", http.statusbadgateway)
        return
    }
    if _, ok := h.hub.rooms[reference]; !ok {
        // room doesn't exist, handle accordingly
        _, err1 := h.chatrepository.getchathistory(reference)
        if err1 != nil {
            log.printf("failed to retrieve chat history: %s", err1)
            errx := h.chatrepository.createchat(reference)
            if errx != nil {
                utils.handleerror(c, nil, "error storing connection", http.statusbadgateway)
                return
            }
        }
        h.hub.rooms[reference] = &room{
            id:      reference,
            name:    sender,
            clients: make(map[string]*client),
        }
    }

    cl := &client{
        conn:           conn,
        chatrepository: h.chatrepository,
        message:        make(chan *message, 10),
        id:             sender,
        reference:      reference,
        sender:         sender,
        username:       username,
        recipient:      recipient,
    }

    h.hub.register <- cl
    go cl.writemessage()
    cl.readmessage(h.hub)
}

“路线.go”

hub := ws.newhub(events.neweventemitter(conn))
    wshandler := ws.newhandler(hub, pr.newchatrepository(db, client))
    go hub.run()
v1.get("/chat/ws/:reference", g.guard([]string{"user", "admin", "dispatcher"}, nil), wshandler.joinroom)

"chat.model.go"

    type Chat struct {
        ID        string        `json:"id,omitempty" bson:"_id,omitempty"`
        Reference string        `json:"reference" bson:"reference"`
        Messages  []ChatMessage `json:"messages" bson:"messages"`
    }
    type ChatMessage struct {
        ID        string    `json:"id,omitempty" bson:"_id,omitempty"`
        Sender    string    `json:"sender" bson:"sender,omitempty"`
        Timestamp time.Time `json:"timestamp" bson:"timestamp,omitempty"`
        Content   string    `json:"content" bson:"content,omitempty"`
    }

正确答案

您的代码向房间中具有相同引用的每个人广播消息的主要原因是您在 hub 的 broadcast 频道中处理消息的方式。在当前的实现中，当发送消息时，它会被转发到同一房间中的每个客户端（即具有相同的引用）。这是在 hub 的 run 方法中完成的：

case m := <-h.broadcast:
    if _, ok := h.rooms[m.reference]; ok {
        for _, cl := range h.rooms[m.reference].clients {
            cl.message <- m
            ...

我希望比分是1-1。引用是postid

如果 reference 是 postid ，并且您希望购物者（发布可用性帖子的人）和每个客户之间进行一对一的通信，那么您需要确保每个聊天都是唯一可识别的。

每个聊天会话的唯一密钥应该是 postid (reference) 和客户 id (sender) 的组合。这可确保每个客户在每个帖子中都与购物者进行独特的聊天会话。

然后，您可以更新 client 结构，使其具有 chatid ，它是 reference 和 sender 的组合。

type client struct {
    ...
    chatid string `json:"chat_id"`
}

您可以更新 hub 来管理聊天会话地图（由 chatid 标识）而不是房间。

type hub struct {
    chats      map[string]*chat
    ...
}

每个 chat 的结构如下：

type chat struct {
    shopper *client
    customer *client
}

为了处理消息，当客户发送消息时，消息会发送给购物者，当购物者回复时，消息会发送给客户。可以使用 chatid 来完成路由。

例如，在您的 broadcast 逻辑中：

case m := <-h.broadcast:
    chat, ok := h.chats[m.chatid]
    if ok {
        if m.sender == chat.customer.id {
            // message is from customer to shopper
            chat.shopper.message <- m
        } else if m.sender == chat.shopper.id {
            // message is from shopper to customer
            chat.customer.message <- m
        }
    }

m 变量的类型为 *message，它没有 chatid 字段。
要解决此问题，您应该考虑将 chatid 字段添加到 message 结构中。

首先，我们修改 message 结构体：

type message struct {
    content string `json:"content"`
    chatid  string `json:"chat_id"`
    sender  string `json:"sender"`
}

然后，当您在 client 的 readmessage 方法中构造一个新的 message 时：

msg := &message{
    content:   string(m),
    chatid:    c.chatid,
    sender:    c.sender,
}

初始化聊天时：

chatID := reference + "_" + sender

cl := &Client{
    ...
    ChatID: chatID,
}

// If the chat session does not exist, create it.
if _, ok := h.hub.Chats[chatID]; !ok {
    h.hub.Chats[chatID] = &Chat{
        Customer: cl,
        Shopper: nil, // That will be set when the shopper joins.
    }
} else {
    // That assumes only the customer or the shopper can join, not both at the same time.
    if h.hub.Chats[chatID].Shopper == nil {
        h.hub.Chats[chatID].Shopper = cl
    } else {
        h.hub.Chats[chatID].Customer = cl
    }
}

警告：这只是该功能的基本框架，但它并未考虑额外的复杂性，例如处理客户或购物者可能拥有多个设备的情况、确保强大的错误处理等等。

以上就是与 golang 套接字一对一聊天的详细内容，更多请关注编程网其它相关文章！

您可能感兴趣的文档: