《从0到1搭建一个IM项目》消息模块开发之消息体的设计

HiChat   
    ├── common    //放置公共文件
    |      |——md5.go
    |      |——resp.go
    │  
    ├── config    //做配置文件
    │  
    ├── dao//数据库crud
    │     |——user.go
    |     |——relation.go
    |     |——community.go
    |
    ├── global    //放置各种连接池，配置等
    │           |——global.go
    |
    ├── initialize  //项目初始化文件
    │              |——db.go
    |              |——logger.go
    |
    ├── middlewear  //放置web中间件
    |              |——jwt.go
    ├── models      //数据库表设计
    │           |——user_basic.go
    |           |——relation.go
    |           |——community.go
    |
    ├── router           //路由
    |       |——router.go
    │   
    ├── service     //对外api
    |       |——user.go
    |       |——relation.go
    |       |——attach_upload.go
    │   
    ├── test        //测试文件
    │  
    ├── main.go     //项目入口
    ├── go.mod            //项目依赖管理
    ├── go.sum            //项目依赖管理
Copy

type Model struct {
    ID        uint `gorm:"primaryKey"`
    CreatedAt time.Time
    UpdatedAt time.Time
    DeletedAt gorm.DeletedAt `gorm:"index"`
}Copy

type Message struct {
    Model
    FormId   int64  `json:"userId"`   //信息发送者
    TargetId int64  `json:"targetId"` //信息接收者
    Type     int    //聊天类型：群聊 私聊 广播
    Media    int    //信息类型：文字 图片 音频
    Content  string //消息内容
    Pic      string `json:"url"` //图片相关
    Url      string //文件相关
    Desc     string //文件描述
    Amount   int    //其他数据大小
}

//MsgTableName 生成指定数据表名
func (m *Message) MsgTableName() string {
    return "message"
}
Copy

//Node 构造连接
type Node struct {
    Conn      *websocket.Conn //socket连接
    Addr      string          //客户端地址
    DataQueue chan []byte     //消息内容
    GroupSets set.Interface   //好友 / 群
}Copy

package models

import (
    "context"
    "encoding/json"
    "fmt"
    "net"
    "net/http"
    "strconv"
    "sync"

  "HiChat/global"

    "github.com/go-redis/redis/v8"
    "github.com/gorilla/websocket"
    "go.uber.org/zap"
    "gopkg.in/fatih/set.v0"
)

type Message struct {
    Model
    FormId   int64  `json:"userId"`   //信息发送者
    TargetId int64  `json:"targetId"` //信息接收者
    Type     int    //聊天类型：群聊 私聊 广播
    Media    int    //信息类型：文字 图片 音频
    Content  string //消息内容
    Pic      string `json:"url"` //图片相关
    Url      string //文件相关
    Desc     string //文件描述
    Amount   int    //其他数据大小
}

func (m *Message) MsgTableName() string {
    return "message"
}

//Node 构造连接
type Node struct {
    Conn      *websocket.Conn //连接
    Addr      string          //客户端地址
    DataQueue chan []byte     //消息
    GroupSets set.Interface   //好友 / 群
}

//映射关系
var clientMap map[int64]*Node = make(map[int64]*Node, 0)

//读写锁，绑定node时需要线程安全
var rwLocker sync.RWMutex
Copy

//Chat    需要 ：发送者ID ，接受者ID ，消息类型，发送的内容，发送类型
func Chat(w http.ResponseWriter, r *http.Request) {
    //1.  获取参数信息发送者userId
    query := r.URL.Query()
    Id := query.Get("userId")
    userId, err := strconv.ParseInt(Id, 10, 64)
    if err != nil {
        zap.S().Info("类型转换失败", err)
        return
    }

    //升级为socket
    var isvalida = true
    conn, err := (&websocket.Upgrader{
        CheckOrigin: func(r *http.Request) bool {
            return isvalida
        },
    }).Upgrade(w, r, nil)
    if err != nil {
        fmt.Println(err)
        return
    }

    //获取socket连接,构造消息节点
    node := &Node{
        Conn:      conn,
        DataQueue: make(chan []byte, 50),
        GroupSets: set.New(set.ThreadSafe),
    }

    //将userId和Node绑定
    rwLocker.Lock()
    clientMap[userId] = node
    rwLocker.Unlock()

    //服务发送消息
    go sendProc(node)

    //服务接收消息
    go recProc(node)

    //sendMsg(userId, []byte("欢迎进入聊天系统"))
}Copy

//sendProc 从node中获取信息并写入websocket中
func sendProc(node *Node) {
    for {
        select {
        case data := <-node.DataQueue:
            err := node.Conn.WriteMessage(websocket.TextMessage, data)
            if err != nil {
                zap.S().Info("写入消息失败", err)
                return
            }
            fmt.Println("数据发送socket成功")
        }

    }
}Copy

//recProc 从websocket中将消息体拿出，然后进行解析，再进行信息类型判断， 最后将消息发送至目的用户的node中
func recProc(node *Node) {
    for {
        //获取信息
        _, data, err := node.Conn.ReadMessage()
        if err != nil {
            zap.S().Info("读取消息失败", err)
            return
        }

        //这里是简单实现的一种方法
        msg := Message{}
        err = json.Unmarshal(data, &msg)
        if err != nil {
            zap.S().Info("json解析失败", err)
            return
        }

        if msg.Type == 1 {
            zap.S().Info("这是一条私信:", msg.Content)
            tarNode, ok := clientMap[msg.TargetId]
            if !ok {
                zap.S().Info("不存在对应的node", msg.TargetId)
                return
            }

            tarNode.DataQueue <- data
            fmt.Println("发送成功：", string(data))
        }

    }
}
Copy

//SendUserMsg 发送消息
func SendUserMsg(ctx *gin.Context) {
    models.Chat(ctx.Writer, ctx.Request)
}Copy

//用户模块
    user := v1.Group("user")
    {
        ……
    ……
    ……
        user.GET("/SendUserMsg", middlewear.JWY(), service.SendUserMsg)
    }Copy

        //token := c.PostForm("token")
        token := c.Query("token")
        user := c.Query("userId")Copy

user.GET("/SendUserMsg", middlewear.JWY(), service.SendUserMsg)Copy

{"TargetId":13,"Type":1,"CreateTime":1672996855236,"userId":14,"Media":1,"Content":"在干嘛"}Copy