devbox
知新_RL
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

百万级并发 - IM项目实战_im实战

作者：知新_RL | 2024-07-20 23:11:18

赞

踩

im实战

百万级并发 - IM项目实战

需求分析：

项目目的：

项目背景：IM对性能和体验敏感度非常高 。 大厂必备

你将获得什么：

熟悉开发流程 ，熟练相关技术栈 gin+GORM+swagger + logrus auth 等中间件，三高性能

核心功能：

​ 发送和接受消息，文字 表情 图片 音频 ，访客，点对点，群聊 ，广播，快捷回复，撤回，心跳检测…

技术栈：

​ 前端 后端 （webSocket ,channel/goroutine ,gin ,temlate,gorm ,sql,nosql,mq…）

系统架构：

​ 四层：前端，接入层，逻辑层，持久层

消息发送流程：

​ A > 登录> 鉴权>(游客) > 消息类型 >(群/广播) > B

环境搭建：

​ go version go1.17.8 windows/amd64

​ set GO111MODULE=on

​ go mod init go_exam

​ go mod tidy

系统架构

image-1666343867758

核心流程：

image-1666343894583

image-1666343928806

image-1666343946893

效果展示：

image-1666344179175

image-1666344192229

image-1666344202937

image-1666344215099

image-1666344227541

image-1666344237243

image-1666344247334

image-1666344268342

image-1666344280635

image-1666344295006

部分项目代码展示

image-1666344380115

image-1666344404391

image-1666344418358

image-1666344432655

功能实现

完成用户模块基本的

加入修改电话号码和邮箱 并校验

先引入

  1.  get github.com/asaskevich/govalidator
  2.  结构体字段后面 加检验规则  
  3.  最后service govalidator.ValidatorStrut(user)
  4.

1.router包 app.go

  1. 	r.GET("/user/getUserList", service.GetUserList)
  2. 	r.GET("/user/createUser", service.CreateUser)
  3. 	r.GET("/user/deleteUser", service.DeleteUser)
  4. 	r.POST("/user/updateUser", service.UpdateUser)

2.service 包 userservice.go

  1. // GetUserList
  2. // @Summary 所有用户
  3. // @Tags 用户模块
  4. // @Success 200 {string} json{"code","message"}
  5. // @Router /user/getUserList [get]
  6. func GetUserList(c *gin.Context) {
  7. 	data := make([]*models.UserBasic, 10)
  8. 	data = models.GetUserList()
  9.  
  10. 	c.JSON(200, gin.H{
  11. 		"message": data,
  12. 	})
  13. }
  14.  
  15. // CreateUser
  16. // @Summary 新增用户
  17. // @Tags 用户模块
  18. // @param name query string false "用户名"
  19. // @param password query string false "密码"
  20. // @param repassword query string false "确认密码"
  21. // @Success 200 {string} json{"code","message"}
  22. // @Router /user/createUser [get]
  23. func CreateUser(c *gin.Context) {
  24. 	user := models.UserBasic{}
  25. 	user.Name = c.Query("name")
  26. 	password := c.Query("password")
  27. 	repassword := c.Query("repassword")
  28. 	if password != repassword {
  29. 		c.JSON(-1, gin.H{
  30. 			"message": "两次密码不一致！",
  31. 		})
  32. 		return
  33. 	}
  34. 	user.PassWord = password
  35. 	models.CreateUser(user)
  36. 	c.JSON(200, gin.H{
  37. 		"message": "新增用户成功！",
  38. 	})
  39. }
  40.  
  41. // DeleteUser
  42. // @Summary 删除用户
  43. // @Tags 用户模块
  44. // @param id query string false "id"
  45. // @Success 200 {string} json{"code","message"}
  46. // @Router /user/deleteUser [get]
  47. func DeleteUser(c *gin.Context) {
  48. 	user := models.UserBasic{}
  49. 	id, _ := strconv.Atoi(c.Query("id"))
  50. 	user.ID = uint(id)
  51. 	models.DeleteUser(user)
  52. 	c.JSON(200, gin.H{
  53. 		"message": "删除用户成功！",
  54. 	})
  55. }
  56.  
  57. // UpdateUser
  58. // @Summary 修改用户
  59. // @Tags 用户模块
  60. // @param id formData string false "id"
  61. // @param name formData string false "name"
  62. // @param password formData string false "password"
  63. // @param phone formData string false "phone"
  64. // @param email formData string false "email"
  65. // @Success 200 {string} json{"code","message"}
  66. // @Router /user/updateUser [post]
  67. func UpdateUser(c *gin.Context) {
  68. 	user := models.UserBasic{}
  69. 	id, _ := strconv.Atoi(c.PostForm("id"))
  70. 	user.ID = uint(id)
  71. 	user.Name = c.PostForm("name")
  72. 	user.PassWord = c.PostForm("password")
  73. 	user.Phone = c.PostForm("phone")
  74. 	user.Email = c.PostForm("email")
  75. 	fmt.Println("update :", user)
  76.  
  77. 	_, err := govalidator.ValidateStruct(user)
  78. 	if err != nil {
  79. 		fmt.Println(err)
  80. 		c.JSON(200, gin.H{
  81. 			"message": "修改参数不匹配！",
  82. 		})
  83. 	} else {
  84. 		models.UpdateUser(user)
  85. 		c.JSON(200, gin.H{
  86. 			"message": "修改用户成功！",
  87. 		})
  88. 	}
  89.  
  90. }

3.modesl包 user_basic.go

  1. 	Phone         string `valid:"matches(^1[3-9]{1}\\d{9}$)"`
  2. 	Email         string `valid:"email"`

4，然后测试 

重复注册校验：

  1. func FindUserByName(name string) UserBasic {
  2. 	user := UserBasic{}
  3. 	utils.DB.Where("name = ?", name).First(&user)
  4. 	return user
  5. }
  6. func FindUserByPhone(phone string) *gorm.DB {
  7. 	user := UserBasic{}
  8. 	return utils.DB.Where("Phone = ?", phone).First(&user)
  9. }
  10. func FindUserByEmail(email string) *gorm.DB {
  11. 	user := UserBasic{}
  12. 	return utils.DB.Where("email = ?", email).First(&user)
  13. }
  14.  
  15.  
  16. 再到service层 加入判断
  17. 	data := models.FindUserByName(user.Name)
  18. 	if data.Name != "" {
  19. 		c.JSON(-1, gin.H{
  20. 			"message": "用户名已注册！",
  21. 		})
  22. 		return
  23. 	}
  24.  
  25.  
  26.  
  27.

注册 加密操作

  1. package utils
  2.  
  3. import (
  4. 	"crypto/md5"
  5. 	"encoding/hex"
  6. 	"fmt"
  7. 	"strings"
  8. )
  9.  
  10. //小写
  11. func Md5Encode(data string) string {
  12. 	h := md5.New()
  13. 	h.Write([]byte(data))
  14. 	tempStr := h.Sum(nil)
  15. 	return hex.EncodeToString(tempStr)
  16. }
  17.  
  18. //大写
  19. func MD5Encode(data string) string {
  20. 	return strings.ToUpper(Md5Encode(data))
  21. }
  22.  
  23. //加密
  24. func MakePassword(plainpwd, salt string) string {
  25. 	return Md5Encode(plainpwd + salt)
  26. }
  27.  
  28. //解密
  29. func ValidPassword(plainpwd, salt string, password string) bool {
  30. 	md := Md5Encode(plainpwd + salt)
  31. 	fmt.Println(md + "				" + password)
  32. 	return md == password
  33. }
  34.  
  35.  
  36.  
  37. service层 判断之后加入
  38. 	//user.PassWord = password
  39. 	user.PassWord = utils.MakePassword(password, salt)
  40. 	user.Salt = salt  //表更新了字段  db.AutoMigrate(&models.UserBasic{})
  41. 	fmt.Println(user.PassWord)
  42. 	models.CreateUser(user)
  43.  
  44.  
  45.

登录解密 ：

  1. //dao层 
  2. func FindUserByNameAndPwd(name string, password string) UserBasic {
  3. 	user := UserBasic{}
  4. 	utils.DB.Where("name = ? and pass_word=?", name, password).First(&user)
  5. 	return user
  6. }
  7.  
  8.  
  9.  
  10. // GetUserList
  11. // @Summary 所有用户
  12. // @Tags 用户模块
  13. // @param name query string false "用户名"
  14. // @param password query string false "密码"
  15. // @Success 200 {string} json{"code","message"}
  16. // @Router /user/findUserByNameAndPwd [get]
  17. func FindUserByNameAndPwd(c *gin.Context) {
  18. 	data := models.UserBasic{}
  19.  
  20. 	name := c.Query("name")
  21. 	password := c.Query("password")
  22. 	user := models.FindUserByName(name)
  23. 	if user.Name == "" {
  24. 		c.JSON(200, gin.H{
  25. 			"message": "该用户不存在",
  26. 		})
  27. 		return
  28. 	}
  29.  
  30. 	flag := utils.ValidPassword(password, user.Salt, user.PassWord)
  31. 	if !flag {
  32. 		c.JSON(200, gin.H{
  33. 			"message": "密码不正确",
  34. 		})
  35. 		return
  36. 	}
  37. 	pwd := utils.MakePassword(password, user.Salt)
  38. 	data = models.FindUserByNameAndPwd(name, pwd)
  39.  
  40. 	c.JSON(200, gin.H{
  41. 		"message": data,
  42. 	})
  43. }
  44.  
  45.  
  46.  
  47. router层  ：
  48.  
  49. r.POST("/user/findUserByNameAndPwd", service.FindUserByNameAndPwd)
  50.

token的加入对返回的结构调整 。

修改登录的方法：

  1. func FindUserByNameAndPwd(name string, password string) UserBasic {
  2. 	user := UserBasic{}
  3. 	utils.DB.Where("name = ? and pass_word=?", name, password).First(&user)
  4.  
  5. 	//token加密
  6. 	str := fmt.Sprintf("%d", time.Now().Unix())
  7. 	temp := utils.MD5Encode(str)
  8. 	utils.DB.Model(&user).Where("id = ?", user.ID).Update("identity", temp)
  9. 	return user
  10. }
  11.  
  12.  
  13. // 返回的结果：
  14. 	c.JSON(200, gin.H{
  15. 			"code":    0, //  0成功   -1失败
  16. 			"message": "修改用户成功！",
  17. 			"data":    user,
  18. 		})
  19.

加入Redis

go get github.com/go-redis/redis

配置redis

  1. redis:
  2.   addr: "192.168.137.131:6379"
  3.   password: ""
  4.   DB: 0
  5.   poolSize: 30
  6.   minIdleConn: 30

然后main方法中

utils.InitRedis()

最后再 utils

  1. func InitRedis() {
  2. 	Red = redis.NewClient(&redis.Options{
  3. 		Addr:         viper.GetString("redis.addr"),
  4. 		Password:     viper.GetString("redis.password"),
  5. 		DB:           viper.GetInt("redis.DB"),
  6. 		PoolSize:     viper.GetInt("redis.poolSize"),
  7. 		MinIdleConns: viper.GetInt("redis.minIdleConn"),
  8. 	})
  9. 	pong, err := Red.Ping().Result()
  10. 	if err != nil {
  11. 		fmt.Println("init redis  。。。。", err)
  12. 	} else {
  13. 		fmt.Println(" Redis inited 。。。。", pong)
  14. 	}
  15. }

测试看是否正常

通过WebSocket通信

  1. go get github.com/gorilla/websocket
  2. go get github.com/go-redis/redis/v8
  3.  
  4.  
  5.  
  6. package utils
  7.  
  8. import (
  9. 	"context"
  10. 	"fmt"
  11. 	"log"
  12. 	"os"
  13. 	"time"
  14.  
  15. 	"github.com/go-redis/redis/v8"
  16. 	"github.com/spf13/viper"
  17. 	"gorm.io/driver/mysql"
  18. 	"gorm.io/gorm"
  19. 	"gorm.io/gorm/logger"
  20. )
  21.  
  22. var (
  23. 	DB  *gorm.DB
  24. 	Red *redis.Client
  25. )
  26.  
  27. func InitConfig() {
  28. 	viper.SetConfigName("app")
  29. 	viper.AddConfigPath("config")
  30. 	err := viper.ReadInConfig()
  31. 	if err != nil {
  32. 		fmt.Println(err)
  33. 	}
  34. 	fmt.Println("config  app inited 。。。。")
  35. }
  36.  
  37. func InitMySQL() {
  38. 	//自定义日志模板 打印SQL语句
  39. 	newLogger := logger.New(
  40. 		log.New(os.Stdout, "\r\n", log.LstdFlags),
  41. 		logger.Config{
  42. 			SlowThreshold: time.Second, //慢SQL阈值
  43. 			LogLevel:      logger.Info, //级别
  44. 			Colorful:      true,        //彩色
  45. 		},
  46. 	)
  47.  
  48. 	DB, _ = gorm.Open(mysql.Open(viper.GetString("mysql.dns")),
  49. 		&gorm.Config{Logger: newLogger})
  50. 	fmt.Println(" MySQL inited 。。。。")
  51. 	//user := models.UserBasic{}
  52. 	//DB.Find(&user)
  53. 	//fmt.Println(user)
  54. }
  55.  
  56. func InitRedis() {
  57. 	Red = redis.NewClient(&redis.Options{
  58. 		Addr:         viper.GetString("redis.addr"),
  59. 		Password:     viper.GetString("redis.password"),
  60. 		DB:           viper.GetInt("redis.DB"),
  61. 		PoolSize:     viper.GetInt("redis.poolSize"),
  62. 		MinIdleConns: viper.GetInt("redis.minIdleConn"),
  63. 	})
  64. }
  65.  
  66. const (
  67. 	PublishKey = "websocket"
  68. )
  69.  
  70. //Publish 发布消息到Redis
  71. func Publish(ctx context.Context, channel string, msg string) error {
  72. 	var err error
  73. 	fmt.Println("Publish 。。。。", msg)
  74. 	err = Red.Publish(ctx, channel, msg).Err()
  75. 	if err != nil {
  76. 		fmt.Println(err)
  77. 	}
  78. 	return err
  79. }
  80.  
  81. //Subscribe 订阅Redis消息
  82. func Subscribe(ctx context.Context, channel string) (string, error) {
  83. 	sub := Red.Subscribe(ctx, channel)
  84. 	fmt.Println("Subscribe 。。。。", ctx)
  85. 	msg, err := sub.ReceiveMessage(ctx)
  86. 	if err != nil {
  87. 		fmt.Println(err)
  88. 		return "", err
  89. 	}
  90. 	fmt.Println("Subscribe 。。。。", msg.Payload)
  91. 	return msg.Payload, err
  92. }
  93.  
  94.  
  95.  
  96.  
  97.  
  98. userservice.go中加入
  99.  
  100. //防止跨域站点伪造请求
  101. var upGrader = websocket.Upgrader{
  102. 	CheckOrigin: func(r *http.Request) bool {
  103. 		return true
  104. 	},
  105. }
  106.  
  107. func SendMsg(c *gin.Context) {
  108. 	ws, err := upGrader.Upgrade(c.Writer, c.Request, nil)
  109. 	if err != nil {
  110. 		fmt.Println(err)
  111. 		return
  112. 	}
  113. 	defer func(ws *websocket.Conn) {
  114. 		err = ws.Close()
  115. 		if err != nil {
  116. 			fmt.Println(err)
  117. 		}
  118. 	}(ws)
  119. 	MsgHandler(c, ws)
  120. }
  121. func MsgHandler(c *gin.Context, ws *websocket.Conn) {
  122. 	for {
  123. 		msg, err := utils.Subscribe(c, utils.PublishKey)
  124. 		if err != nil {
  125. 			fmt.Println(" MsgHandler 发送失败", err)
  126. 		}
  127.  
  128. 		tm := time.Now().Format("2006-01-02 15:04:05")
  129. 		m := fmt.Sprintf("[ws][%s]:%s", tm, msg)
  130. 		err = ws.WriteMessage(1, []byte(m))
  131. 		if err != nil {
  132. 			log.Fatalln(err)
  133. 		}
  134. 	}
  135. }
  136.  
  137.  
  138.  
  139. router层 app.go
  140. 	//发送消息
  141. 	r.GET("/user/sendMsg", service.SendMsg)
  142.  
  143.

测试： http://www.jsons.cn/websocket/

ws://localhost:8081/user/sendMsg

设计 关系表 ，群信息表 ，消息表

  1. package models
  2.  
  3. import "gorm.io/gorm"
  4.  
  5. //消息
  6. type Message struct {
  7. 	gorm.Model
  8. 	FormId   uint   //发送者
  9. 	TargetId uint   //接受者
  10. 	Type     string //消息类型  群聊 私聊 广播
  11. 	Media    int    //消息类型  文字 图片 音频
  12. 	Content  string //消息内容
  13. 	Pic      string
  14. 	Url      string
  15. 	Desc     string
  16. 	Amount   int //其他数字统计
  17. }
  18.  
  19. func (table *Message) TableName() string {
  20. 	return "message"
  21. }
  22.  
  23.  
  24. package models
  25.  
  26. import "gorm.io/gorm"
  27.  
  28. //群信息
  29. type GroupBasic struct {
  30. 	gorm.Model
  31. 	Name    string
  32. 	OwnerId uint
  33. 	Icon    string
  34. 	Type    int
  35. 	Desc    string
  36. }
  37.  
  38. func (table *GroupBasic) TableName() string {
  39. 	return "group_basic"
  40. }
  41.  
  42. package models
  43.  
  44. import "gorm.io/gorm"
  45.  
  46. //人员关系
  47. type Contact struct {
  48. 	gorm.Model
  49. 	OwnerId  uint //谁的关系信息
  50. 	TargetId uint //对应的谁
  51. 	Type     int  //对应的类型  0  1  3
  52. 	Desc     string
  53. }
  54.  
  55. func (table *Contact) TableName() string {
  56. 	return "contact"
  57. }
  58.

发送消息 接受消息

​ 需要 ：发送者ID ，接受者ID ，消息类型，发送的内容，发送类型

​ 校验token ，关系 ，

  1. package models
  2.  
  3. import (
  4. 	"encoding/json"
  5. 	"fmt"
  6. 	"net"
  7. 	"net/http"
  8. 	"strconv"
  9. 	"sync"
  10.  
  11. 	"github.com/gorilla/websocket"
  12. 	"gopkg.in/fatih/set.v0"
  13. 	"gorm.io/gorm"
  14. )
  15.  
  16. //消息
  17. type Message struct {
  18. 	gorm.Model
  19. 	FormId   int64  //发送者
  20. 	TargetId int64  //接受者
  21. 	Type     int    //发送类型  群聊 私聊 广播
  22. 	Media    int    //消息类型  文字 图片 音频
  23. 	Content  string //消息内容
  24. 	Pic      string
  25. 	Url      string
  26. 	Desc     string
  27. 	Amount   int //其他数字统计
  28. }
  29.  
  30. func (table *Message) TableName() string {
  31. 	return "message"
  32. }
  33.  
  34. type Node struct {
  35. 	Conn      *websocket.Conn
  36. 	DataQueue chan []byte
  37. 	GroupSets set.Interface
  38. }
  39.  
  40. //映射关系
  41. var clientMap map[int64]*Node = make(map[int64]*Node, 0)
  42.  
  43. //读写锁
  44. var rwLocker sync.RWMutex
  45.  
  46. //	需要 ：发送者ID ，接受者ID ，消息类型，发送的内容，发送类型
  47. func Chat(writer http.ResponseWriter, request *http.Request) {
  48. 	//1.  获取参数 并 检验 token 等合法性
  49. 	//token := query.Get("token")
  50. 	query := request.URL.Query()
  51. 	Id := query.Get("userId")
  52. 	userId, _ := strconv.ParseInt(Id, 10, 64)
  53. 	//msgType := query.Get("type")
  54. 	//targetId := query.Get("targetId")
  55. 	//	context := query.Get("context")
  56. 	isvalida := true //checkToke()  待.........
  57. 	conn, err := (&websocket.Upgrader{
  58. 		//token 校验
  59. 		CheckOrigin: func(r *http.Request) bool {
  60. 			return isvalida
  61. 		},
  62. 	}).Upgrade(writer, request, nil)
  63. 	if err != nil {
  64. 		fmt.Println(err)
  65. 		return
  66. 	}
  67. 	//2.获取conn
  68. 	node := &Node{
  69. 		Conn:      conn,
  70. 		DataQueue: make(chan []byte, 50),
  71. 		GroupSets: set.New(set.ThreadSafe),
  72. 	}
  73. 	//3. 用户关系
  74. 	//4. userid 跟 node绑定 并加锁
  75. 	rwLocker.Lock()
  76. 	clientMap[userId] = node
  77. 	rwLocker.Unlock()
  78. 	//5.完成发送逻辑
  79. 	go sendProc(node)
  80. 	//6.完成接受逻辑
  81. 	go recvProc(node)
  82. 	sendMsg(userId, []byte("欢迎进入聊天系统"))
  83.  
  84. }
  85.  
  86. func sendProc(node *Node) {
  87. 	for {
  88. 		select {
  89. 		case data := <-node.DataQueue:
  90. 			err := node.Conn.WriteMessage(websocket.TextMessage, data)
  91. 			if err != nil {
  92. 				fmt.Println(err)
  93. 				return
  94. 			}
  95. 		}
  96. 	}
  97. }
  98.  
  99. func recvProc(node *Node) {
  100. 	for {
  101. 		_, data, err := node.Conn.ReadMessage()
  102. 		if err != nil {
  103. 			fmt.Println(err)
  104. 			return
  105. 		}
  106. 		broadMsg(data)
  107. 		fmt.Println("[ws] <<<<< ", data)
  108. 	}
  109. }
  110.  
  111. var udpsendChan chan []byte = make(chan []byte, 1024)
  112.  
  113. func broadMsg(data []byte) {
  114. 	udpsendChan <- data
  115. }
  116.  
  117. func init() {
  118. 	go udpSendProc()
  119. 	go udpRecvProc()
  120. }
  121.  
  122. //完成udp数据发送协程
  123. func udpSendProc() {
  124. 	con, err := net.DialUDP("udp", nil, &net.UDPAddr{
  125. 		IP:   net.IPv4(192, 168, 0, 255),
  126. 		Port: 3000,
  127. 	})
  128. 	defer con.Close()
  129. 	if err != nil {
  130. 		fmt.Println(err)
  131. 	}
  132. 	for {
  133. 		select {
  134. 		case data := <-udpsendChan:
  135. 			_, err := con.Write(data)
  136. 			if err != nil {
  137. 				fmt.Println(err)
  138. 				return
  139. 			}
  140. 		}
  141. 	}
  142.  
  143. }
  144.  
  145. //完成udp数据接收协程
  146. func udpRecvProc() {
  147. 	con, err := net.ListenUDP("udp", &net.UDPAddr{
  148. 		IP:   net.IPv4zero,
  149. 		Port: 3000,
  150. 	})
  151. 	if err != nil {
  152. 		fmt.Println(err)
  153. 	}
  154. 	defer con.Close()
  155. 	for {
  156. 		var buf [512]byte
  157. 		n, err := con.Read(buf[0:])
  158. 		if err != nil {
  159. 			fmt.Println(err)
  160. 			return
  161. 		}
  162. 		dispatch(buf[0:n])
  163. 	}
  164. }
  165.  
  166. //后端调度逻辑处理
  167. func dispatch(data []byte) {
  168. 	msg := Message{}
  169. 	err := json.Unmarshal(data, &msg)
  170. 	if err != nil {
  171. 		fmt.Println(err)
  172. 		return
  173. 	}
  174. 	switch msg.Type {
  175. 	case 1: //私信
  176. 		sendMsg(msg.TargetId, data)
  177. 		// case 2:  //群发
  178. 		// 	sendGroupMsg()
  179. 		// case 3://广播
  180. 		// 	sendAllMsg()
  181. 		//case 4:
  182. 		//
  183. 	}
  184. }
  185.  
  186. func sendMsg(userId int64, msg []byte) {
  187. 	rwLocker.RLock()
  188. 	node, ok := clientMap[userId]
  189. 	rwLocker.RUnlock()
  190. 	if ok {
  191. 		node.DataQueue <- msg
  192. 	}
  193. }
  194.

集成html 登录和注册

  1. //app.go  加入 
  2. 	//首页
  3. 	r.GET("/", service.GetIndex)
  4. 	r.GET("/index", service.GetIndex)
  5. 	r.GET("/toRegister", service.ToRegister)
  6.  
  7.  
  8. // index.go
  9. package service
  10.  
  11. import (
  12. 	"text/template"
  13.  
  14. 	"github.com/gin-gonic/gin"
  15. )
  16.  
  17. // GetIndex
  18. // @Tags 首页
  19. // @Success 200 {string} welcome
  20. // @Router /index [get]
  21. func GetIndex(c *gin.Context) {
  22. 	ind, err := template.ParseFiles("index.html", "views/chat/head.html")
  23. 	if err != nil {
  24. 		panic(err)
  25. 	}
  26. 	ind.Execute(c.Writer, "index")
  27. 	// c.JSON(200, gin.H{
  28. 	// 	"message": "welcome !!  ",
  29. 	// })
  30. }
  31.  
  32. func ToRegister(c *gin.Context) {
  33. 	ind, err := template.ParseFiles("views/user/register.html")
  34. 	if err != nil {
  35. 		panic(err)
  36. 	}
  37. 	ind.Execute(c.Writer, "register")
  38. 	// c.JSON(200, gin.H{
  39. 	// 	"message": "welcome !!  ",
  40. 	// })
  41. }
  42.

然后页面 ：

  1. <!DOCTYPE html>
  2. <html>
  3.  
  4. <head>
  5.     <!--js include-->
  6.     {
  7.   {template "/chat/head.shtml"}}
  8. </head>
  9. <body>
  10.  
  11. <header class="mui-bar mui-bar-nav">
  12.     <h1 class="mui-title">登录</h1>
  13. </header>
  14. {
  15.   {.}}
  16. <div class
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/知新_RL/article/detail/858773
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号