原始碼地址
https://gitee.com/bin-0821/chat-room-demo-go-websocket
關于websocket,上一篇文章講述了如何通過websocket進行服務端與客戶端的通信，本篇將會帶領大家把各個websocket進行相互通信，在開始之前，請確保有理解
1 go的通道
2 go的執行緒
3 gin基礎
事實上，websocket與websocket之間是無法進行直接相互通信的，需要我們將資料接收后，發送給另一個websocket鏈接，可以理解為
conn1.ReadJson(&data)
conn2.WriteJson(data)
而建立一個類似微信聊天一樣的，能進行多群聊，一對多，一對一的聊天,需要對websocket進行管理，本篇文章的重點便是如何管理好所有用戶的websocket連接，主要有以下方面
1，一個根據業務進行設計的資料結構
2，用戶上下線后conn的處理
3，用戶發送資訊的群發或單發
首先，要搞清楚我們在做什么，聊天室要實作的功能類似微信
a,b,c三人，1,2,3 三個聊天室
人員 加入的聊天室
a 1,2,3
b 1,2
c 1
a在1發送資訊，全部人都能收到
a在2發送資訊，c收不到，以此類推
a可以與c單獨發送資訊，接收方不在線時，系統能正常運行
1. 目錄結構
相比上篇文章 多了manage_socket_conn，service兩個模塊，重點在于多了manage_socket_conn模塊中
D:.
│ go.mod
│ go.sum
│ main.go
│ msg.json
├─api
│ socket_conn.go
├─manage_socket_conn //用戶的websocket管理模塊
│ char_room_thread.go //執行緒 主要負責對資訊的群發
│ room_set.go //聊天室房間管理，房間的創建，銷毀 存盤房間內的用戶id
│ user_set.go //用戶websocket鏈接管理，資訊的發送，存盤所有在線的webscoket鏈接，用戶上下線
├─middleware
│ Cros.go
├─model
│ socket_msg_form_front.go
│ to_front.go
├─route
│ route.go
└─service
chat_room.go //資料層，模擬用戶加入了那些聊天室
2. 代碼內容
user_set.go
package manage_socket_conn
import (
"WebSocketDemo/model"
"errors"
"fmt"
"github.com/gorilla/websocket"
"sync"
)
func init() {
GetUserSet()
}
//用戶map 用來存盤每個在線的用戶id與對應的conn
type userSet struct {
// 用戶鏈接集 用戶id => 鏈接物件
users map[int]*websocket.Conn
lock sync.Mutex
once sync.Once
}
var us = new(userSet)
// 單例模式
func GetUserSet() *userSet {
us.once.Do(func() {
us.users = make(map[int]*websocket.Conn)
us.users[-1] = nil
us.lock = sync.Mutex{}
})
return us
}
// 用戶創建發起websocket連接
// join_type 加入模式
// 1 正常加入 占線無法加入
// 2 強制加入 即踢下線前者
func (u *userSet) ConnConnect(user_id, join_type int, conn *websocket.Conn) (int, error) {
u.lock.Lock()
defer u.lock.Unlock()
if join_type == 1 {
// 用戶id是否已經在線
if _, ok := u.users[user_id]; ok {
return 1, errors.New("該賬號已被登陸")
}
} else if join_type == 2 {
// 如果原用戶id 已經存在map內 進行銷毀擠出
if conn2, ok := u.users[user_id]; ok {
err := conn2.Close()
if err != nil {
fmt.Println(err)
}
delete(u.users, user_id)
}
// 重新加入
u.users[user_id] = conn
}
return -1, nil
}
// 鏈接斷開
func (u *userSet) ConnDisconnect(user_id int, conn *websocket.Conn) error {
u.lock.Lock()
defer u.lock.Unlock()
if conn2, ok := u.users[user_id]; ok {
if conn == conn2 {
delete(u.users, user_id)
}
} else {
// Log 不存在的鏈接申請斷開
}
return nil
}
// 對單個鏈接發送資訊
func (u *userSet) SendMsgByUid(user_id int, msg interface{}) error {
var err error
if conn, ok := u.users[user_id]; ok {
err = conn.WriteJSON(msg)
} else {
err = errors.New("不存在的鏈接")
}
return err
}
// 對多個連接發送資訊
func (u *userSet) SendMsgByUidList(user_id_list []int, msg interface{}) (id_list []int, err_list []error) {
for _, user_id := range user_id_list {
// 這里判斷用戶是否自己,是自己就跳過
c := msg.(model.ChatMsg)
if c.ChatMsgType == 1 {
if (c.Data["form_user_id"].(int)) == user_id {
continue
}
}
if conn, ok := u.users[user_id]; ok {
err := conn.WriteJSON(msg)
if err != nil {
id_list = append(id_list, user_id)
err_list = append(err_list, err)
}
} else {
id_list = append(id_list, user_id)
err_list = append(err_list, errors.New("不存在的鏈接"))
}
}
return
}
room_set.go
package manage_socket_conn
import (
"sync"
)
//群map 用來存盤每個群在線的用戶id
type roomSet struct {
// 群id 群內的用戶id
rooms map[int]map[int]struct{}
lock sync.Mutex
once sync.Once
}
var rs = new(roomSet)
// 單例
func GetRoomSet() *roomSet{
rs.once.Do(func() {
rs.rooms = make(map[int]map[int]struct{})
rs.lock = sync.Mutex{}
})
return rs
}
// 向用戶發送
func (r *roomSet)SendMsgToUserList (r_id int ,msg interface{}){
userS := GetUserSet()
r.lock.Lock()
defer r.lock.Unlock()
var user_id_list []int
for key, _ := range r.rooms[r_id] {
user_id_list = append(user_id_list, key)
}
userS.SendMsgByUidList(user_id_list,msg)
}
// 用戶下線/退群 退出聊天室鏈接集合
func (r *roomSet) UserQuitRooms(room_id_list []int ,user_id int) {
r.lock.Lock()
defer r.lock.Unlock()
for _, room_id := range room_id_list {
if v ,ok := r.rooms[room_id];ok {
delete(v,user_id)
// 房間沒人就銷毀
if len(r.rooms[room_id]) <= 0 {
delete(r.rooms, room_id)
}
}
}
return
}
// 用戶上線/入群 加入聊天室連接集合
func (r *roomSet)UserJoinRooms(room_id_list []int,user_id int) {
r.lock.Lock()
defer r.lock.Unlock()
for _, room_id := range room_id_list {
if v,ok := r.rooms[room_id];!ok {
// 房間不存在就創建
r.rooms[room_id] = make(map[int]struct{})
r.rooms[room_id][user_id] = struct{}{}
}else {
v[user_id] = struct{}{}
}
}
return
}
// 用戶下線/退群 退出聊天室鏈接集合
func (r *roomSet) UserQuitRoom(room_id ,user_id int) {
r.lock.Lock()
defer r.lock.Unlock()
if v ,ok := r.rooms[room_id];ok {
delete(v,user_id)
// 房間沒人就銷毀
if len(r.rooms[room_id]) <= 0 {
delete(r.rooms, room_id)
}
}
return
}
// 用戶上線/入群 加入聊天室連接集合
func (r *roomSet)UserJoinRoom(room_id,user_id int) {
r.lock.Lock()
defer r.lock.Unlock()
if v,ok := r.rooms[room_id];!ok {
// 房間不存在就創建
r.rooms[room_id] = make(map[int]struct{})
r.rooms[room_id][user_id] = struct{}{}
}else {
v[user_id] = struct{}{}
}
return
}
char_room_thread.go
package manage_socket_conn
import (
"WebSocketDemo/model"
"fmt"
"sync"
)
var cRoomThread = new(charRoomThread)
type charRoomThread struct {
msgChannel chan model.ConnMsg
lock sync.Mutex
once sync.Once
}
// 向通道發送資料
func (c *charRoomThread)SendMsg(msg model.ConnMsg){
fmt.Println(msg)
c.msgChannel <- msg
}
// 單例
func GetCharRoomThread() *charRoomThread {
cRoomThread.once.Do(func() {
cRoomThread.msgChannel = make(chan model.ConnMsg,30)
cRoomThread.lock = sync.Mutex{}
})
return cRoomThread
}
// 啟動通道監聽
// ChatMsgType 1 群聊資訊 2 一對一資訊
func (c *charRoomThread) Start() {
for {
select {
case msg := <-c.msgChannel:
if msg.Msg.ChatMsgType == 1 {
// 標明發送方用戶id
msg.Msg.Data["form_user_id"] = msg.FormUserID
// 在這里你可以將聊天資訊入庫等等操作
// do something
// 發送資訊
// 注意 msg.Msg.Data["room_id"].(int) 這種寫法在data為nil時 運行時會 panic 導致整個系統停掉
// 所以在上一層最好對資料內容進行判斷，再把值發送到通道內
GetRoomSet().SendMsgToUserList(int(msg.Msg.Data["room_id"].(float64)),msg.Msg)
}else if msg.Msg.ChatMsgType == 2 {
msg.Msg.Data["form_user_id"] = msg.FormUserID
// 如果發送不成功 說明接收方不在線
_ = GetUserSet().SendMsgByUid(int(msg.Msg.Data["to_user_id"].(float64)),msg.Msg)
}
}
}
}
main.go做以下修改
package main
import (
"WebSocketDemo/route"
Mg"WebSocketDemo/manage_socket_conn"
)
func main() {
ro := route.GetRoute()
go Mg.GetCharRoomThread().Start()
_ = ro.Run("0.0.0.0:8083")
}
api層 socket_conn.go 內容
package api
import (
Mg "WebSocketDemo/manage_socket_conn"
"WebSocketDemo/model"
Service "WebSocketDemo/service"
"fmt"
"github.com/gin-gonic/gin"
"github.com/gorilla/websocket"
"net/http"
"strconv"
)
// websocket配置
var upgrader = websocket.Upgrader{
ReadBufferSize: 1024,
WriteBufferSize: 1024,
CheckOrigin: checkOrigin,
}
func checkOrigin(r *http.Request) bool {
return true
}
var (
ServiceChatRoom Service.ChatRoom
)
// 用戶申請創建socket鏈接
func ConCreateConn(ctx *gin.Context) {
var (
conn *websocket.Conn
err error
user_id int
)
// 獲取user_id 這里可以是token,經過中間件決議后的存在 ctx 的user_id
// 為方便演示 這里直接請求頭帶user_id,正常開發不建議
user_id, err = strconv.Atoi(ctx.GetHeader("user_id"))
if err != nil && user_id <= 0 {
ctx.JSON(200, model.ResDatas(500, "請求必須帶user_id"+err.Error(), nil))
return
}
//fmt.Println("user_id", user_id)
// 判斷請求過來的鏈接是否要升級為websocket
if websocket.IsWebSocketUpgrade(ctx.Request) {
// 將請求升級為 websocket鏈接
conn, err = upgrader.Upgrade(ctx.Writer, ctx.Request, ctx.Writer.Header())
if err != nil {
ctx.JSON(200, model.ResDatas(500, "創建鏈接失敗"+err.Error(), nil))
return
}
}else {
return
}
// 獲取用戶加入的聊天室id陣列
room_ids, _ := ServiceChatRoom.GetUserRoomIds(user_id)
// 用戶加入房間集
Mg.GetRoomSet().UserJoinRooms(room_ids,user_id)
// 用戶加入鏈接集
_,_ = Mg.GetUserSet().ConnConnect(user_id,2,conn)
// 用戶斷開銷毀
defer func() {
_ = conn.Close()
// 用戶斷開時也要銷毀在聊天集內的物件
_ = Mg.GetUserSet().ConnDisconnect(user_id,conn)
}()
for {
var msg model.ConnMsg
// ReadJSON 獲取值的方式類似于gin的 ctx.ShouldBind() 通過結構體的json映射值
// 如果讀不到值 則堵塞在此處
err = conn.ReadJSON(&msg)
if err != nil {
// 寫回錯誤資訊
err = conn.WriteJSON(model.ResDatas(400, "獲取資料錯誤："+err.Error(), nil))
if err != nil {
fmt.Println("用戶斷開")
return
}
}
// do something.....
msg.FormUserID = user_id
// 發送回資訊
//err = conn.WriteJSON(msg)
if err != nil {
fmt.Println("用戶斷開")
return
}
if err = valMsg(msg);err != nil{
_ = conn.WriteJSON(model.ResDatas(400, "資料不合法："+err.Error(), nil))
continue
}
// 將資料發送進通道
Mg.GetCharRoomThread().SendMsg(msg)
}
}
// 驗證資料 例如用戶是否有加入聊天室
func valMsg(msg model.ConnMsg) error {
// do something...
return nil
}
關于代碼的解釋在注釋里已經寫的非常清楚了，
主要是兩個結構體
//群map 用來存盤每個群在線的用戶id
type roomSet struct {
// 群id 群內的用戶id
rooms map[int]map[int]struct{}
lock sync.Mutex
once sync.Once
}
//用戶map 用來存盤每個在線的用戶id與對應的conn
type userSet struct {
// 用戶鏈接集 用戶id => 鏈接物件
users map[int]*websocket.Conn
lock sync.Mutex
once sync.Once
}
可能有人會問，roomSet.rooms[房間id]map[用戶id]struct{}
這里的用戶集為什么是map型別，而不是[]int型別
答：
想一下，當用戶下線或退出群聊時，怎么在[]int內進行洗掉該用戶的id，注意：此時的[]int是無序的，而加入群時，又要防止id重復，所以實作起來過于麻煩，倒不如使用map，go底層為你封裝好的值判斷，使用起來會更方便，這里的struct{}是沒有意義的，僅作為占位，
當我要把資訊發送給群里的所有用戶時，先從roomSet根據房間id拿到用戶id map，將key轉化為[]int,呼叫userSet的 SendMsgByUidList()方法這樣就完成了資訊的群發
而一對一的單發就不再重復說了，跳過roomSet,直接發送
其他內容已經在代碼注釋里講得非常詳細了
3. 具體流程
// 1 main方法內 啟動一條執行緒 監聽從api層的socket_conn ConCreateConn()用戶寫入的發送的值
go Mg.GetCharRoomThread().Start()
// 2 ConCreateConn()方法內
// 獲取用戶加入的聊天室id陣列
room_ids, _ := ServiceChatRoom.GetUserRoomIds(user_id)
// 用戶加入房間集
Mg.GetRoomSet().UserJoinRooms(room_ids,user_id)
// 用戶加入鏈接集
_,_ = Mg.GetUserSet().ConnConnect(user_id,2,conn)
defer func() {
_ = conn.Close()
// 用戶斷開時也要銷毀在聊天集內的物件
_ = Mg.GetUserSet().ConnDisconnect(user_id,conn)
}()
//3 用戶發送資料
Mg.GetCharRoomThread().SendMsg(msg)
//啟動的執行緒將會接收到通道的資料 char_room_thread
Mg.GetCharRoomThread().Start()
// 判斷資料發送型別進行發送
// ChatMsgType 1 群聊資訊 2 一對一資訊
if msg.Msg.ChatMsgType == 1 {
// 標明發送方用戶id
msg.Msg.Data["form_user_id"] = msg.FormUserID
// 在這里你可以將聊天資訊入庫等等操作
// do something
// 發送資訊
// 注意 msg.Msg.Data["room_id"].(int) 這種寫法在data為nil時 運行時會 panic 導致整個系統停掉
// 所以在上一層最好對資料內容進行判斷，再把值發送到通道內
GetRoomSet().SendMsgToUserList(int(msg.Msg.Data["room_id"].(float64)),msg.Msg)
}else if msg.Msg.ChatMsgType == 2 {
msg.Msg.Data["form_user_id"] = msg.FormUserID
// 如果發送不成功 說明接收方不在線
_ = GetUserSet().SendMsgByUid(int(msg.Msg.Data["to_user_id"].(float64)),msg.Msg)
}
4. 啟動專案并測驗
使用apipost進行websocket測驗
用戶加入的群在servic層已經模擬了
func (ChatRoom) GetUserRoomIds(user_id int) (r_ids []int,err error) {
if user_id == 1 {
r_ids = []int{1,2,3}
}else if user_id == 2 {
r_ids = []int{1,2}
}else if user_id == 3 {
r_ids = []int{1}
}
return
}
user_id與介面名稱一樣,然后將所有websocket進行連接
發送json資料
{
"msg": {
"chat_msg_type": 1,
"data": {
"room_id": 2,
"content": "我是用戶1發送的資訊，房間2，只有用戶3，不在房間"
}
}
}
房間2 只有用戶3不存在房間里所以用戶3接收不到資訊
用戶2 發送資訊
{
"msg": {
"chat_msg_type": 1,
"data": {
"room_id": 1,
"content": "我是用戶2發送的資訊，房間1，所有人都可以接收"
}
}
}
可以看到所有人都可以接收資訊
一對一測驗
用戶1發送json給用戶3
{
"msg": {
"chat_msg_type": 2,
"data": {
"to_user_id": 3,
"content": "不要讓用戶2看到"
}
}
}
可以看到只有用戶2無法收到一對一的資訊
5. 總結
關于websocket系列教程就已經結束了
本章重點在于如何進行設計一個websocket管理模塊，對在線的用戶進行管理
不足點：
由于怕篇幅過長，沒有將聊天資料存盤起來，實作原理便是在發送資訊前把資料存入庫，搭配gorm的事務，當有錯誤時便回滾，
用戶上線時，前端獲取本地存盤的聊天資料id，拉取最后的資料串列，便可做到用戶上線讀取未接收的資料，這里可以在api層直接實作
程式的所有問題，大部分都可以通過創造性的思想進行解決，希望本篇內容能對你有所幫助
歡迎大家點贊轉發
本文來自博客園，作者：樹杉，轉載請注明原文鏈接：https://www.cnblogs.com/xushushan/p/16492439.html
選擇了程式員這條路，那就要學習一輩子
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/499602.html
標籤：Go
上一篇：C/C++宏定義講解