基于go+vue的多人在线聊天的im系统

席万里2024-04-22 20:34

基于go+vue的多人在线聊天的im系统

文章目录

一、前端部分

打算优化一下界面，正在开发中。。。

二、后端部分

1、中间件middleware设计jwt和cors

jwt.go

go 复制代码 
package middlewares

import (
	"crypto/rsa"
	"fmt"
	"github.com/dgrijalva/jwt-go"
	"github.com/gin-gonic/gin"
	"im/global"
	"io/ioutil"
	"net/http"
	"os"
	"time"
)

func JWT() gin.HandlerFunc {
	return func(ctx *gin.Context) {
		// 从请求头获取token
		token := ctx.Request.Header.Get("w-token")
		if token == "" {
			ctx.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{
				"msg": "请登录",
			})
			return
		}
		// 打开存储公钥文件
		file, _ := os.Open(global.SrvConfig.JWTInfo.PublicKeyPath)
		// 读取公钥文件
		bytes, _ := ioutil.ReadAll(file)
		// 解析公钥
		publickey, _ := jwt.ParseRSAPublicKeyFromPEM(bytes)

		jwtVerier := &JWTTokenVerifier{PublicKey: publickey}

		claim, err := jwtVerier.Verify(token)
		if err != nil {
			fmt.Println(err)
			ctx.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{
				"msg": "请登录",
			})
			return
		}
		ctx.Set("claim", claim)        //获取全部信息
		ctx.Set("name", claim.Subject) // 获取用户名
		ctx.Next()
	}
}

func Auth(token string) (*MyClaim, error) {
	if token == "" {
		return nil, fmt.Errorf("ws认证失败，token为空")
	}
	file, _ := os.Open(global.SrvConfig.JWTInfo.PublicKeyPath)
	bytes, _ := ioutil.ReadAll(file)
	publickey, _ := jwt.ParseRSAPublicKeyFromPEM(bytes)
	jwtVerier := &JWTTokenVerifier{PublicKey: publickey}
	return jwtVerier.Verify(token)
}

type JWTTokenVerifier struct {
	// 存储用于验证签名的公钥
	PublicKey *rsa.PublicKey
}

type MyClaim struct {
	Role int
	jwt.StandardClaims
}

func (v *JWTTokenVerifier) Verify(token string) (*MyClaim, error) {
	t, err := jwt.ParseWithClaims(token, &MyClaim{},
		func(*jwt.Token) (interface{}, error) {
			return v.PublicKey, nil
		})

	if err != nil {
		return nil, fmt.Errorf("cannot parse token: %v", err)
	}

	if !t.Valid {
		return nil, fmt.Errorf("token not valid")
	}

	clm, ok := t.Claims.(*MyClaim)
	if !ok {
		return nil, fmt.Errorf("token claim is not MyClaim")
	}

	if err := clm.Valid(); err != nil {
		return nil, fmt.Errorf("claim not valid: %v", err)
	}
	return clm, nil

}

type JWTTokenGen struct {
	privateKey *rsa.PrivateKey
	issuer     string
	nowFunc    func() time.Time
}

func NewJWTTokenGen(issuer string, privateKey *rsa.PrivateKey) *JWTTokenGen {
	return &JWTTokenGen{
		issuer:     issuer,
		nowFunc:    time.Now,
		privateKey: privateKey,
	}
}

func (t *JWTTokenGen) GenerateToken(userName string, expire time.Duration) (string, error) {
	nowSec := t.nowFunc().Unix()
	tkn := jwt.NewWithClaims(jwt.SigningMethodRS512, &MyClaim{
		StandardClaims: jwt.StandardClaims{
			Issuer:    t.issuer,
			IssuedAt:  nowSec,
			ExpiresAt: nowSec + int64(expire.Seconds()),
			Subject:   userName,
		},
	})
	return tkn.SignedString(t.privateKey)
}

cors.go

go 复制代码 
package middlewares

import (
	"github.com/gin-gonic/gin"
	"net/http"
)

func Cors() gin.HandlerFnc {
	return func(c *gin.Context) {
		method := c.Request.Method

		c.Header("Access-Control-Allow-Origin", "*")
		c.Header("Access-Control-Allow-Headers", "Content-Type,AccessToken,X-CSRF-Token, Authorization, Token, w-token")
		c.Header("Access-Control-Allow-Methods", "POST, GET, OPTIONS, DELETE, PATCH, PUT")
		c.Header("Access-Control-Expose-Headers", "Content-Length, Access-Control-Allow-Origin, Access-Control-Allow-Headers, Content-Type")
		c.Header("Access-Control-Allow-Credentials", "true")

		if method == "OPTIONS" {
			c.AbortWithStatus(http.StatusNoContent)
		}
	}
}

2、配置文件设计

config.yaml

yaml 复制代码 
jwt:
  privateKeyPath: ./config/private.key
  publicKeyPath: ./config/public.key
port: 9288
name: user-web
redis:
  ip: 
  port: 6379
mysql:
  ip: 
  username: 
  password: 
  db_name: im

config/config.go

go 复制代码 
package config

// 读取yaml配置文件,形成映射的相关类
type JWTconfig struct {
	PrivateKeyPath string `mapstructure:"privateKeyPath" json:"privateKeyPath"`
	PublicKeyPath  string `mapstructure:"publicKeyPath" json:"publicKeyPath"`
}

type RedisConfig struct {
	IP   string `mapstructure:"ip"`
	Port string `mapstructure:"port"`
}

type MysqlConfig struct {
	IP       string `mapstructure:"ip"`
	Username string `mapstructure:"username"`
	Password string `mapstructure:"password"`
	DbName   string `mapstructure:"db_name"`
}

type SrvConfig struct {
	Name      string      `mapstructure:"name" json:"name"`
	Port      int         `mapstructure:"port" json:"port"`
	JWTInfo   JWTconfig   `mapstructure:"jwt" json:"jwt"`
	RedisInfo RedisConfig `mapstructure:"redis" json:"redis"`
	MysqlInfo MysqlConfig `mapstructure:"mysql" json:"mysql"`
}

initalize/config.go

go 复制代码 
package Initialize

import (
	"fmt"
	"github.com/fsnotify/fsnotify"
	"github.com/spf13/viper"
	"im/global"
)

func InitConfig() {
	//从配置文件中读取出对应的配置
	var configFileName = fmt.Sprintf("./config.yaml" )
	v := viper.New()
	//文件的路径
	v.SetConfigFile(configFileName)
	if err := v.ReadInConfig(); err != nil {
		panic(err)
	}
	// 开启实时监控
	v.WatchConfig()
	//这个对象如何在其他文件中使用 - 全局变量
	if err := v.Unmarshal(&global.SrvConfig); err != nil {
		panic(err)
	}

	// 文件更新的回调函数
	v.OnConfigChange(func(in fsnotify.Event) {
		fmt.Println("配置改变")
		if err := v.Unmarshal(&global.SrvConfig); err != nil {
			panic(err)
		}
	})
}

func GetEnvInfo(env string) bool {
	viper.AutomaticEnv()
	return viper.IsSet(env)
}

global.go 声明全局变量

go 复制代码 
package global

import (
	"github.com/go-redis/redis/v8"
	"github.com/jinzhu/gorm"
	"im/config"
	"sync"
)

var (
	// 配置信息
	SrvConfig = config.SrvConfig{}
	// 分别管理存储已注册用户和在线用户
	// 已注册用户map，key为name value为password
	UserMap = sync.Map{}

	// 在线用户map，key为name value为连接句柄list
	LoginMap = sync.Map{}

	// redis客户端
	Redis *redis.Client

	// db服务
	DB *gorm.DB
)

3、Mysql和Redis连接

db.go

go 复制代码 
package Initialize

import (
	"fmt"
	"github.com/jinzhu/gorm"
	_ "github.com/jinzhu/gorm/dialects/mysql"
	"im/global"
	"os"
)

var err error

func InitDB() {
	// 构建数据库连接字符串
	dbConfig := fmt.Sprintf("%s:%s@tcp(%s)/%s?charset=utf8&parseTime=True&loc=Local",
		global.SrvConfig.MysqlInfo.Username,
		global.SrvConfig.MysqlInfo.Password,
		global.SrvConfig.MysqlInfo.IP,
		global.SrvConfig.MysqlInfo.DbName)
	// 连接数据库
	global.DB, err = gorm.Open("mysql", dbConfig)
	if err != nil {
		fmt.Println("[Initialize] 数据库连接失败:%v", err)
		return
	}
	// 设置连接池参数
	global.DB.DB().SetMaxIdleConns(10)     //设置数据库连接池最大空闲连接数
	global.DB.DB().SetMaxOpenConns(100)    //设置数据库最大连接数
	global.DB.DB().SetConnMaxLifetime(100) //设置数据库连接超时时间

	// 测试数据库连接
	if err = global.DB.DB().Ping(); err != nil {
		fmt.Printf("[Initialize] 数据库连接测试失败:%v\n", err)
		os.Exit(0)
	}
	fmt.Println("[Initialize] 数据库连接测试成功")
}

redis.og

go 复制代码 
package Initialize

import (
	"context"
	"fmt"
	"github.com/go-redis/redis/v8"
	"im/global"
	"log"
	"sync"
	"time"
)

var once sync.Once

func InitRedis() {
	addr := fmt.Sprintf("%v:%v", global.SrvConfig.RedisInfo.IP, global.SrvConfig.RedisInfo.Port)
	// once.Do() 在一个应用程序生命周期内只会执行一次
	once.Do(func() {
		global.Redis = redis.NewClient(&redis.Options{
			Network:      "tcp",
			Addr:         addr,
			Password:     "",
			DB:           0,               // 指定Redis服务器的数据库索引，0为默认
			PoolSize:     15,              // 连接池最大连接数
			MinIdleConns: 10,              // 连接池最小连接数
			DialTimeout:  5 * time.Second, // 连接超时时间
			ReadTimeout:  3 * time.Second, // 读超时时间
			WriteTimeout: 3 * time.Second, // 写超时时间
			PoolTimeout:  4 * time.Second, // 连接池获取连接的超时时间

			IdleCheckFrequency: 60 * time.Second,
			IdleTimeout:        5 * time.Minute,
			MaxConnAge:         0 * time.Second,

			MaxRetries:      0,
			MinRetryBackoff: 8 * time.Millisecond,
			MaxRetryBackoff: 512 * time.Millisecond,
		})
		pong, err := global.Redis.Ping(context.Background()).Result()
		if err != nil {
			log.Fatal(err)
		}
		log.Println(pong)
	})
}

4、路由设计

go 复制代码 
	// 注册
	r.POST("/api/register", handle.Register)
	// 已注册用户列表
	r.GET("/api/list", handle.UserList)
	// 登录
	r.POST("/api/login", handle.Login)
	// ws连接
	r.GET("/api/ws", handle.WS)
	// 获取登录列表(目前没用到)
	r.GET("/api/loginlist", handle.LoginList)
	// JWT
	r.Use(middlewares.JWT())
	// 获取用户名
	r.GET("/api/user", handle.UserInfo)

5、核心功能设计

handle/handle.go

go 复制代码 
package handle

import (
	"fmt"
	"github.com/dgrijalva/jwt-go"
	"github.com/gin-gonic/gin"
	"im/global"
	"im/middlewares"
	"im/mysql"
	"io/ioutil"
	"net/http"
	"os"
	"time"
)

type Reg struct {
	Name     string `json:"name"`
	Password string `json:"password"`
}
type UList struct {
	Names []string `json:"names"`
}
type LoginStruct struct {
	Name     string `json:"name" `
	Password string `json:"password" `
}

func Register(c *gin.Context) {
	var reg Reg
	err := c.Bind(&reg)
	if err != nil {
		fmt.Println(err)
		c.JSON(http.StatusOK, gin.H{
			"msg":  "用户名或密码格式错误，请重试",
			"code": "4001",
		})
		return
	}
	mysql.StorageUserToMap()
	_, ok := global.UserMap.Load(reg.Name)
	if ok {
		fmt.Println("用户已存在")
		c.JSON(http.StatusOK, gin.H{
			"msg":  "用户已存在，请登录或更换用户名注册",
			"code": "4000",
		})
		return
	}
	if err := mysql.AddUserToMysql(reg.Name, reg.Password); err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{
			"msg":  "内部错误",
			"code": "5000",
		})
		return
	}
	mysql.StorageUserToMap()
	c.JSON(http.StatusOK, gin.H{
		"msg":  "创建用户成功，请登录",
		"code": "2000",
	})
}

func Login(c *gin.Context) {
	var loginData LoginStruct
	err := c.Bind(&loginData)
	if err != nil {
		fmt.Println(err)
		c.JSON(http.StatusOK, gin.H{
			"msg":  "用户名或密码格式错误，请重试",
			"code": "4001",
		})
		return
	}
	psw, ok := global.UserMap.Load(loginData.Name)
	if !ok {
		fmt.Println("用户不存在")
		c.JSON(http.StatusOK, gin.H{
			"msg":  "用户不存在，请注册",
			"code": "4003",
		})
		return
	}
	if loginData.Password != psw.(string) {
		c.JSON(http.StatusOK, gin.H{
			"msg":  "密码错误，请重新输入",
			"code": "4005",
		})
		return
	}

	file, err := os.Open(global.SrvConfig.JWTInfo.PrivateKeyPath)
	if err != nil {
		fmt.Println(err)
		return
	}
	pkBytes, err := ioutil.ReadAll(file)
	privateKey, err := jwt.ParseRSAPrivateKeyFromPEM([]byte(pkBytes))
	tokenGen := middlewares.NewJWTTokenGen("user", privateKey)
	token, err := tokenGen.GenerateToken(loginData.Name, time.Hour*24*20)
	if err != nil {
		fmt.Println(err)
		return
	}

	c.JSON(http.StatusOK, &gin.H{
		"msg":   "登录成功",
		"code":  "2000",
		"name":  loginData.Name,
		"token": token,
	})
}

func LoginList(c *gin.Context) {
	var users UList
	global.LoginMap.Range(func(key, value interface{}) bool {
		users.Names = append(users.Names, key.(string))
		return true
	})
	c.JSON(http.StatusOK, &users)
}

func getLoginList() *UList {
	var users UList
	global.LoginMap.Range(func(key, value interface{}) bool {
		users.Names = append(users.Names, key.(string))
		return true
	})
	return &users
}

func UserInfo(c *gin.Context) {
	name, _ := c.Get("name")
	userName := name.(string)
	c.JSON(http.StatusOK, gin.H{
		"msg":  "成功",
		"code": "2000",
		"name": userName,
	})
}

func UserList(c *gin.Context) {
	var users UList
	global.UserMap.Range(func(key, value interface{}) bool {
		users.Names = append(users.Names, key.(string))
		return true
	})
	c.JSON(http.StatusOK, &users)
}

ws.go

go 复制代码 
// websocket 通信


package handle

import (
	"container/list"
	"context"
	"encoding/json"
	"fmt"
	"github.com/gin-gonic/gin"
	"github.com/gorilla/websocket"
	"im/global"
	"im/middlewares"
	"log"
	"net/http"
)

type WsInfo struct {
	Type    string   `json:"type"`
	Content string   `json:"content"`
	To      []string `json:"to"`
	From    string   `json:"from"`
}

func WS(ctx *gin.Context) {
	var claim *middlewares.MyClaim
	wsConn, _ := Upgrader.Upgrade(ctx.Writer, ctx.Request, nil)
	for {
		_, data, err := wsConn.ReadMessage()
		if err != nil {
			wsConn.Close()
			if claim != nil {
				RemoveWSConnFromMap(claim.Subject, wsConn)
				r, _ := json.Marshal(gin.H{
					"type":    "loginlist",
					"content": getLoginList(),
					"to":      []string{},
				})
				SendMsgToAllLoginUser(r)
			}
			fmt.Println(claim.Subject, "出错，断开连接：", err)
			fmt.Println("当前在线用户列表：", getLoginList().Names)
			return
		}

		var wsInfo WsInfo
		json.Unmarshal(data, &wsInfo)
		if wsInfo.Type == "auth" {
			claim, err = middlewares.Auth(wsInfo.Content)
			if err != nil {
				// 认证失败
				fmt.Println(err)
				rsp := WsInfo{
					Type:    "no",
					Content: "认证失败，请重新登录",
					To:      []string{},
				}
				r, _ := json.Marshal(rsp)
				wsConn.WriteMessage(websocket.TextMessage, r)
				wsConn.Close()

				continue
			}
			// 认证成功
			// 将连接加入map记录
			AddWSConnToMap(claim.Subject, wsConn)

			fmt.Println(claim.Subject, " 加入连接")
			fmt.Println("当前在线用户列表：", getLoginList().Names)

			rsp := WsInfo{
				Type:    "ok",
				Content: "连接成功，请发送消息",
				To:      []string{},
			}
			r, _ := json.Marshal(rsp)
			// 更新登录列表
			wsConn.WriteMessage(websocket.TextMessage, r)
			r, _ = json.Marshal(gin.H{
				"type":    "loginlist",
				"content": getLoginList(),
				"to":      []string{},
			})
			SendMsgToAllLoginUser(r)
			// 发送离线消息
			cmd := global.Redis.LRange(context.Background(), claim.Subject, 0, -1)
			msgs, err := cmd.Result()
			if err != nil {
				log.Println(err)
				continue
			}
			for _, msg := range msgs {
				wsConn.WriteMessage(websocket.TextMessage, []byte(msg))
			}
			global.Redis.Del(context.Background(), claim.Subject)

		} else {
			rsp, _ := json.Marshal(gin.H{
				"type":    "normal",
				"content": wsInfo.Content,
				"to":      []string{},
				"from":    claim.Subject,
			})
			SendMsgToOtherUser(rsp, claim.Subject, wsInfo.To...)
		}
	}
	wsConn.Close()
}

var (
	Upgrader = websocket.Upgrader{
		//允许跨域
		CheckOrigin: func(r *http.Request) bool {
			return true
		},
	}
)

func AddWSConnToMap(userName string, wsConn *websocket.Conn) {
	// 同一用户可以有多个ws连接（登录多次）
	loginListInter, ok := global.LoginMap.Load(userName)
	if !ok {
		// 之前没登录
		loginList := list.New()
		loginList.PushBack(wsConn)
		global.LoginMap.Store(userName, loginList)
	} else {
		// 多次登录
		loginList := loginListInter.(*list.List)
		loginList.PushBack(wsConn)
		global.LoginMap.Store(userName, loginList)
	}
}

func RemoveWSConnFromMap(userName string, wsConn *websocket.Conn) {
	loginListInter, ok := global.LoginMap.Load(userName)
	if !ok {
		fmt.Println("没有连接可以关闭")
	} else {
		// 有连接
		loginList := loginListInter.(*list.List)
		if loginList.Len() <= 1 {
			global.LoginMap.Delete(userName)
		} else {
			for e := loginList.Front(); e != nil; e = e.Next() {
				if e.Value.(*websocket.Conn) == wsConn {
					loginList.Remove(e)
					break
				}
			}
			global.LoginMap.Store(userName, loginList)
		}
	}
}

func SendMsgToOtherUser(data []byte, myName string, otherUserName ...string) {
	for _, otherName := range otherUserName {
		if otherName != myName {
			v, ok := global.LoginMap.Load(otherName)
			if ok {
				// 在线，发送给目标用户的所有客户端
				l := v.(*list.List)
				for e := l.Front(); e != nil; e = e.Next() {
					conn := e.Value.(*websocket.Conn)
					conn.WriteMessage(websocket.TextMessage, data)
				}
			} else {
				_, ok := global.UserMap.Load(otherName)
				if ok {
					//离线消息缓存到redis
					global.Redis.LPush(context.Background(), otherName, data)
				}
			}
		}
	}
}

func SendMsgToAllLoginUser(data []byte) {
	global.LoginMap.Range(func(key, value interface{}) bool {
		l := value.(*list.List)
		for e := l.Front(); e != nil; e = e.Next() {
			conn := e.Value.(*websocket.Conn)
			conn.WriteMessage(websocket.TextMessage, data)
		}
		return true
	})
}

mysql数据读取 mysql.go

go 复制代码 
package mysql

import (
	"fmt"
	"im/global"
)

type User struct {
	UserName string `gorm:"column:username"`
	Password string `gorm:"column:password"`
}

func StorageUserToMap() {
	var users []User
	err := global.DB.Find(&users).Error
	if err != nil {
		fmt.Printf("[mysql] 查询用户失败：%v\n", err)
		return
	}
	// 将查询到的用户名和密码存储到 UserMap 中
	for _, user := range users {
		global.UserMap.Store(user.UserName, user.Password)
	}
}

func AddUserToMysql(userName, psw string) error {
	// 创建用户模型
	user := User{
		UserName: userName,
		Password: psw,
	}
	// 插入用户记录
	err := global.DB.Create(&user).Error
	if err != nil {
		fmt.Printf("[mysql] 注册失败：%v\n", err)
		return err
	}
	fmt.Printf("[mysql] 注册成功\n")
	return nil
}

项目地址：https://github.com/jiangxyb/goim-websocket

相关推荐
Devil枫1 小时前
Vue 3 单元测试与E2E测试
前端·vue.js·单元测试
GIS程序媛—椰子2 小时前
【Vue 全家桶】6、vue-router 路由（更新中）
前端·vue.js
毕业设计制作和分享3 小时前
ssm《数据库系统原理》课程平台的设计与实现+vue
前端·数据库·vue.js·oracle·mybatis
程序媛小果3 小时前
基于java+SpringBoot+Vue的旅游管理系统设计与实现
java·vue.js·spring boot
从兄4 小时前
vue 使用docx-preview 预览替换文档内的特定变量
javascript·vue.js·ecmascript
凉辰5 小时前
设计模式 策略模式 场景Vue （技术提升）
vue.js·设计模式·策略模式
薛一半6 小时前
PC端查看历史消息，鼠标向上滚动加载数据时页面停留在上次查看的位置
前端·javascript·vue.js
MarcoPage6 小时前
第十九课 Vue组件中的方法
前端·javascript·vue.js
工业互联网专业7 小时前
Python毕业设计选题：基于Hadoop的租房数据分析系统的设计与实现
vue.js·hadoop·python·flask·毕业设计·源码·课程设计
你好龙卷风！！！7 小时前
vue3 怎么判断数据列是否包某一列名
前端·javascript·vue.js
热门推荐
01【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总02(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明03组基轨迹建模 GBTM的介绍与实现（Stata 或 R）04【AIGC】重塑未来的科技巨轮05全面解析：构建基于深度学习的安全帽检测系统（UI界面+YOLO代码+数据集）06【经验分享】Ubuntu22.04安装微信(linux官方版)07基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测08Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO09RAG 实践- Ollama+RagFlow 部署本地知识库10红米手机使用google play