第一篇：【Go】基于GoFiber从零开始搭建一个GoWeb后台管理系统（一）搭建项目
第二篇：【Go】基于GoFiber从零开始搭建一个GoWeb后台管理系统（二）日志输出中间件、校验token中间件、配置路由、基础工具函数。
前两篇我们搭好了项目，并且配置好了中间件和路由，这篇开始我们可以正式写业务代码了。
日志管理
首先我们先来实现日志管理这个模块，像登录、退出、操作数据库（增、删、改）都会记录日志保存到sys_log表中。
数据库表我在第一篇已经全部写出来了，这里就不再重复了。
先看看记录的数据：
日志管理这个模块，其实接口的话就一个接口：列表查询。
router.go
// 日志管理路由
func logRouter(app *fiber.App) {
log := app.Group("/sys/log")
{
log.Get("/list", api.LogController{
}.GetPage) // 日志列表
}
}
congroller层：sys_log.go
package sys
import (
"github.com/gofiber/fiber/v2"
"go-web2/app/common/config"
"go-web2/app/model/sys"
"time"
)
type LogController struct{
}
// 日志列表分页
func (LogController) GetPage(c *fiber.Ctx) error {
syslog := sys.SysLog{
}
syslog.IP = c.Query("code")
name := c.Query("name")
createTime, _ := time.Parse("2006-01-02", c.Query("startDate"))
syslog.CreatorId = &name
syslog.CreateTime = createTime
pageSize := c.QueryInt("pageSize", 10)
pageNum := c.QueryInt("pageNum", 1)
return c.Status(200).JSON(config.Success(syslog.GetPage(pageSize, pageNum)))
}
model层：sys_log.go
package sys
import (
"fmt"
"github.com/google/uuid"
"go-web2/app/common/config"
"strings"
"time"
)
// 操作日志管理
type SysLog struct {
config.BaseModel
IP string `gorm:"ip" json:"ip"` // 用户请求IP
Title string `gorm:"title" json:"title"` // 用户请求的标题
Type string `gorm:"type" json:"title"` // 操作类型（其他 登录 退出 新增 修改 删除 上传 导入 设置状态 设置密码）
Method string `gorm:"method" json:"method"` // 用户请求的方法
Url string `gorm:"url" json:"url"` // 请求url
Info string `gorm:"info" json:"info"` // 详细信息
State string `gorm:"state" json:"state"` // 状态（操作成功 操作失败）
}
// 获取表名
func (SysLog) TableName() string {
return "sys_log"
}
// 列表
func (e *SysLog) GetPage(pageSize int, pageNum int) config.PageInfo {
var list []SysLog // 查询结果
var total int64 // 总数
query := config.DB.Table(e.TableName())
var creatorId string
if e.CreatorId != nil {
creatorId = *e.CreatorId
}
if creatorId != "" {
query.Where("creator_id like ?", fmt.Sprintf("%%%s%%", creatorId))
}
if e.IP != "" {
query.Where("ip like ?", fmt.Sprintf("%%%s%%", e.IP))
}
if !e.CreateTime.IsZero() {
query.Where("DATE_FORMAT(create_time,'%Y-%m-%d') = ?", e.CreateTime.Format("2006-01-02"))
}
offset := (pageNum - 1) * pageSize // 计算跳过的记录数
query.Debug().Order("create_time desc").Offset(offset).Limit(pageSize).Find(&list) // 分页查询，根据offset和limit来查询
query.Count(&total)
return config.PageInfo{
list, total}
}
// 新增
func (e *SysLog) Insert() (err error) {
e.Id = strings.ReplaceAll(uuid.NewString(), "-", "")
e.CreateTime = time.Now()
config.DB.Create(e)
return
}
记录操作日志中间件
列表查询这个没什么，这个模块主要难在怎么获取到需要的数据，然后处理好添加到数据库中。
在Java中，我们可以用注解+aop的方式，设置和获取对应的信息，比如通过注解设置 title、type，通过aop切面获取 请求的接口、前端传给后端的参数、后端返回给前端的数据等等。
在go中，我们想实现类似的功能，需要用中间件，不过中间件只能实现类似Java中aop的功能，也就是说中间件只能获取请求到的信息和返回的信息。像设置 title、type 就只能自己定义标准，然后根据请求的接口来判断、设置 title、type。
title：就是接口名称，type：就是操作类型。
思路
我的思路就是：每个接口按模块来划分，像注册路由的时候，我们也都是一个模块的接口全部放到一个路由组中。然后接口命名也保持统一风格。这样我们一个模块的所有接口都有一个共同的前缀。
比如用户管理模块，它的路由是这样的：
// 用户管理路由
func userRouter(app *fiber.App) {
controller := api.UserController{
}
user := app.Group("/sys/user")
{
user.Get("/getLoginUser", controller.GetLoginUser) // 获取当前登录的用户
user.Get("/list", controller.GetPage) // 用户列表
user.Get("/getById/:id", controller.GetById) // 根据id获取用户
user.Post("/insert", controller.Insert) // 新增用户
user.Post("/update", controller.Update) // 修改用户
user.Delete("/delete", controller.Delete) // 删除用户
user.Post("/updatePassword", controller.UpdatePassword) // 修改密码
user.Post("/resetPassword", controller.ResetPassword) // 重置密码
user.Post("/upload", controller.Upload) // 上传头像
}
}
这里面的接口，都是 /sys/user 开头的；其他模块也是同理，所以我们定义一个标准就是接口以什么开头就属于哪个模块。以 /sys/user 开头的接口都是用户管理模块的，以 /sys/dept 开头的都是部门管理模块。
然后接口命名保持统一风格，增、删、改、查这些接口命名风格统一（主要是增、删、改）
- 新增接口统一用 insert 命名或开头
- 修改接口统一用 update 命名或开头
- 删除接口统一用 delete 命名或开头
- 上传接口统一用 upload 命名或开头
- 导入接口统一用 imports 命名或开头
这样我们判断 操作类型 时就好判断了。比如 /sys/user/insert 接口我们就可以判断 type = 新增，title = 用户新增 。
代码
middleware.go
// 路由接口前缀（名称），用于在日志中间件中，获取请求接口的title
var RouteNames = map[string]string{
"/sys/logout": "用户退出",
"/sys/safe": "安全设置",
"/sys/user": "用户",
"/sys/dept": "部门",
"/sys/role": "角色",
"/sys/menu": "菜单",
"/sys/dict": "字典",
"/sys/dict/deleteType": "字典类型",
}
// 保存日志到数据库：操作日志
func SysLogInit(c *fiber.Ctx) error {
path := c.Path() // 获取当前请求的路径
// 跳过get请求
if c.Method() == fiber.MethodGet || strings.Contains(path, "/sys/login") {
return c.Next()
}
var entity model.SysLog
re := regexp.MustCompile(`^/(.*?)(?:\?.*)?$`) // 根据正则解析接口
match := re.FindStringSubmatch(path)
if len(match) > 1 {
api := match[1]
if !strings.HasPrefix(api, "/") {
api = "/" + api
}
method := ""
title := RouteNames[api] // 直接根据接口名获取接口名称
if title == "" {
// 如果获取不到则只获取接口前缀，根据前缀拿到当前接口是属于哪个模块的
split := strings.Split(api, "/") // api根据 / 分割
str := ""
for i, s := range split {
if s == "" {
continue
}
if i > 0 {
str += "/"
}
str += s
title = RouteNames[str] // 获取到接口前缀
if title != "" {
method = split[i+1] // 如果拿到了接口前缀，那么当前索引+1就是具体的接口名
break
}
}
}
entity.State = "操作成功"
if strings.Contains(api, "/sys/logout") {
entity.Type = "退出"
entity.Info = "退出成功"
entity.Title = "用户退出"
} else if strings.Contains(path, "insert") {
entity.Type = "新增"
} else if strings.Contains(path, "update") && !strings.Contains(path, "updateState") && !strings.Contains(path, "updatePassword") {
entity.Type = "修改"
} else if strings.Contains(path, "delete") {
entity.Type = "删除"
} else if strings.Contains(path, "updateState") {
entity.Type = "设置状态"
entity.Title = "设置" + title + "状态"
} else if strings.Contains(path, "updatePassword") {
entity.Type = "修改密码"
entity.Title = "修改密码"
} else if strings.Contains(path, "resetPassword") {
entity.Type = "重置密码"
entity.Title = "重置密码"
} else if strings.Contains(path, "upload") {
entity.Type = "上传"
} else if strings.Contains(path, "imports") {
entity.Type = "导入"
} else {
entity.Type = "其他"
}
if entity.Title == "" {
// 新增用户、修改用户、删除用户、设置用户状态、上传用户、导入用户、字典类型删除......
entity.Title = entity.Type + title
}
entity.Info = entity.Title + "成功"
// 调用下一个中间件或路由处理程序，用来获取响应给前端的数据
c.Next()
code := c.Response().StatusCode()
if code != 200 {
entity.State = "操作失败"
entity.Info = "未知异常"
} else {
var result config.Result
json.Unmarshal(c.Response().Body(), &result)
if result.Code != 0 {
entity.State = "操作失败"
entity.Info = entity.Title + "失败：" + result.Message
}
}
if method == "" {
methods := strings.Split(api, "/") // 当前接口根据 / 分割
entity.Method = methods[len(methods)-1] // 获取当前请求的方法
} else {
entity.Method = method
}
entity.IP = c.IP() // 获取用户IP
entity.Url = api // 获取当前请求的路径
token := c.Get(config.TokenHeader)
if token != "" {
user := model.GetLoginUser(token)
entity.CreatorId = &user.UserName
entity.Info = user.UserName + " " + entity.Info
}
entity.Insert()
}
return c.Next()
}
// 省略其他代码.....
这样我们就可以获取到操作日志了。然后登录日志的话，我们在登录接口设置更好一点。
用户登录、退出
接下来我们来实现登录模块。
// 登录路由
func loginRouter(app *fiber.App) {
controller := api.LoginController{
}
login := app.Group("/sys")
{
login.Get("/getKey", controller.GetKey) // 获取RSA公钥
login.Get("/getCode", controller.GetCode) // 获取验证码
login.Post("/login", controller.Login) // 用户登录
login.Delete("/logout", controller.Logout) // 用户退出
}
}
登录模块有上面这几个接口，除了登录退出，还有获取登录的验证码，还有登录的时候用户输入用户名、密码调用登录接口时，前端需要将用户名、密码根据RSA公钥进行加密传输，后端接收到参数时也需要根据RSA私钥进行解密，获取到真正的用户名和密码。
登录时校验密码，有错误次数限定超过了这个账号就会锁定15或30分钟，在这期间不允许再次登录。
controller层：sys_login.go
这里因为我没有前端用的是apipost测试的，所以RSA加解密那块我注释掉了。
package sys
import (
"fmt"
"github.com/gofiber/fiber/v2"
"github.com/pkg/errors"
"go-web2/app/common/config"
"go-web2/app/common/util"
"go-web2/app/model/sys"
"time"
)
type LoginController struct{
}
// 获取公钥
func (LoginController) GetKey(c *fiber.Ctx) error {
return c.Status(200).JSON(config.Success(util.GetPublicKey()))
}
// 获取验证码
func (LoginController) GetCode(c *fiber.Ctx) error {
id, base64 := util.GenerateCaptcha(4, 100, 42)
code := make(map[string]string)
code["codeId"] = id
code["code"] = base64
return c.Status(200).JSON(config.Success(code))
}
// 登录
func (LoginController) Login(c *fiber.Ctx) error {
//code := c.FormValue("code")
//codeId := c.FormValue("codeId")
userName := c.FormValue("userName")
password := c.FormValue("password")
// 解密
//userName = util.RSADecrypt(userName)
//password = util.RSADecrypt(password)
// 校验验证码是否正确
//b := util.CaptVerify(codeId, code)
//if !b {
// return c.Status(200).JSON(config.Error("验证码错误或已过期"))
//}
var syslog = sys.SysLog{
IP: c.IP(), Title: "用户登录", Type: "登录", Method: "login", Url: "/sys/login", State: "登录成功"}
syslog.CreatorId = &userName
// 校验用户名和密码
safe := sys.SysSafe{
}
safe.GetById()
user, result := passwordErrorNum(userName, password, safe)
if result.Code != 0 {
syslog.State = "登录失败"
syslog.Info = result.Message
syslog.Insert()
return c.Status(200).JSON(result)
}
i := safe.IdleTimeSetting //如果系统闲置时间为0，设置token和session永不过期
// 登录
token := ""
if i == 0 {
token = user.Login("", -1) // 永不过期
} else {
token = user.Login("", config.TokenExpire) // 默认保持登录为30分钟
}
syslog.Info = userName + "登录成功"
syslog.Insert()
return c.Status(200).JSON(config.Success(token))
}
// 退出
func (LoginController) Logout(c *fiber.Ctx) error {
token := c.Get(config.TokenHeader) // 获取请求头中的 Token
sys.Logout(token) // 退出登录
return c.Status(200).JSON(config.Success(nil))
}
/**
* 判断账号是否锁定
*/
func lockedUser(currentTime, errorCount int64, userName string) (error, bool) {
flag := false
exists, _ := config.RedisConn.Exists(config.ERROR_COUNT + userName).Result()
// 如果没有错误次数，直接返回
if exists == 0 {
return nil, flag
}
loginTime, _ := config.RedisConn.HGet(config.ERROR_COUNT+userName, "loginTime").Int64()
i, _ := config.RedisConn.HGet(config.ERROR_COUNT+userName, "errorNum").Int64()
if i >= errorCount && currentTime < loginTime {
diff := loginTime - currentTime // 计算时间差
minutes := int(diff / 60) // 将差值转换为分钟
msg := fmt.Sprintf("账号锁定中，还没到允许登录的时间，请%d分钟后再尝试", minutes)
return errors.New(msg), flag
} else {
flag = true
}
return nil, flag
}
// 校验用户名和密码
func passwordErrorNum(userName, password string, safe sys.SysSafe) (*sys.SysUser, config.Result) {
user := sys.SysUser{
}
user.UserName = userName
//查询用户
err := user.GetUser()
if err != nil || user.Id == "" {
return nil, config.ErrorCode(1001, "用户不存在或密码错误")
}
//根据前端输入的密码（明文），和加密的密码、盐值进行比较，判断输入的密码是否正确
authenticate := util.AuthenticatePassword(password, user.Password)
if authenticate {
//密码正确错误次数清零
config.RedisConn.Del(config.ERROR_COUNT + userName)
} else {
// 获取当前时间的时间戳（单位：秒）
currentTime := time.Now().Unix()
flag := false
//错误3次，锁定15分钟后才可登陆 允许时间加上定义的登陆时间（毫秒）
str := "15"
var errorCount int64 = 3
timeStamp := currentTime + 900
//密码登录限制（0：连续错3次，锁定账号15分钟。1：连续错5次，锁定账号30分钟）
if safe.PwdLoginLimit == 1 {
errorCount = 5
str = "30"
timeStamp = currentTime + 1800
}
//判断账号是否锁定
err, flag = lockedUser(currentTime, errorCount, userName)
if err != nil {
return nil, config.ErrorCode(1004, err.Error())
}
exists, _ := config.RedisConn.Exists(config.ERROR_COUNT + userName).Result()
if exists == 0 {
// 键不存在，第一次登录
loginMap := map[string]any{
"errorNum": 1,
"loginTime": timeStamp,
}
config.RedisConn.HMSet(config.ERROR_COUNT+userName, loginMap)
} else {
i, _ := config.RedisConn.HGet(config.ERROR_COUNT+userName, "errorNum").Int64()
if flag && i == errorCount {
config.RedisConn.HSet(config.ERROR_COUNT+userName, "errorNum", 1)
} else {
config.RedisConn.HIncrBy(config.ERROR_COUNT+userName, "errorNum", 1)
}
config.RedisConn.HSet(config.ERROR_COUNT+userName, "loginTime", timeStamp)
}
i, _ := config.RedisConn.HGet(config.ERROR_COUNT+userName, "errorNum").Int64()
if i == errorCount {
return nil, config.ErrorCode(1004, fmt.Sprintf("您的密码已错误%d次，现已被锁定，请%s分钟后再尝试", errorCount, str))
}
return nil, config.ErrorCode(1000, fmt.Sprintf("密码错误，总登录次数%d次，剩余次数: %d", errorCount, (errorCount-i)))
}
return &user, config.Success(nil)
}
model层：sys_login.go
其实这个文件的这几个登录、token相关的方法，本来是应该放在 sys_user.go 文件里的，然后因为 sys_user.go 代码有点多，我想了下最后还是决定单独建个 sys_login.go 文件分开来。
package sys
import (
"encoding/json"
"fmt"
"go-web2/app/common/config"
"go-web2/app/common/util"
"strconv"
"strings"
"time"
)
// ======================================= 登录相关 =======================================
// 用户登录：user 用户信息 loginType 登录类型 expire 有效期
func (user *SysUser) Login(loginType string, expire time.Duration) string {
str := util.MD5(user.UserName) // 用户名md5加密
// 删除所有以当前用户名开头的key
keys, _, _ := config.RedisConn.Scan(uint64(0), config.CachePrefix+str+"*", 1000).Result()
for i := range keys {
config.RedisConn.Del(keys[i])
}
// 设置登录类型前缀
if len(loginType) > 0 {
str = loginType + "_" + str
}
token := str + util.GenerateRandomToken(32) // 生成token
user.Token = token
userJson, _ := json.Marshal(user)
loginMap := map[string]any{
"token": token,
"createTime": time.Now().Unix(),
"user": string(userJson),
}
// 将用户信息map设置到redis中
config.RedisConn.HMSet(config.CachePrefix+token, loginMap)
// 设置有效期
if expire > 0 {
config.RedisConn.Expire(config.CachePrefix+token, expire)
}
// 判断当前用户部门是否存在数据权限设置
exists, _ := config.RedisConn.Exists(config.DATA_SCOPE + user.DeptId).Result()
if exists == 0 {
SetDataScope(user.DeptId) // 如果没有，则需要设置
}
return token
}
// 用户退出
func Logout(token string) {
config.RedisConn.Del(config.CachePrefix + token)
}
// 获取当前用户的剩余有效时长，返回秒数，返回 -2 时，key已过期
func GetTimeOut(token string) int {
// 使用 TTL 命令获取 key 的剩余有效时长，如果 key 不存在或已过期，TTL 将返回 -2
ttl, err := config.RedisConn.TTL(config.CachePrefix + token).Result()
if err != nil {
return -2
}
return int(ttl.Seconds())
}
// 获取当前用户
func GetLoginUser(token string) *SysUser {
val, _ := config.RedisConn.HGet(config.CachePrefix+token, "user").Result()
user := SysUser{
}
json.Unmarshal([]byte(val), &user)
// 判断当前用户部门是否存在数据权限设置
exists, _ := config.RedisConn.Exists(config.DATA_SCOPE + user.DeptId).Result()
if exists == 0 {
SetDataScope(user.DeptId) // 如果没有，则需要设置
}
dataScope := config.RedisConn.HGetAll(config.DATA_SCOPE + user.DeptId).Val()
user.AncestorId = dataScope["ancestorId"]
user.AncestorName = dataScope["ancestorName"]
user.ChildId = dataScope["childId"]
user.ChildName = dataScope["childName"]
return &user
}
// 获取当前用户id
func GetLoginId(token string) *string {
user := GetLoginUser(token)
return &user.Id
}
// 获取当前用户token的创建时间
func GetCreateTime(token string) int64 {
val, _ := config.RedisConn.HGet(config.CachePrefix+token, "createTime").Result()
r, _ := strconv.ParseInt(val, 10, 64)
return r
}
// 刷新过期时间
func UpdateTimeOut(token string, expire time.Duration) {
if expire.Seconds() < 0 {
// -1 永不过期，Persist 将删除key的过期时间，使其永不过期
config.RedisConn.Persist(config.CachePrefix + token)
} else {
config.RedisConn.Expire(config.CachePrefix+token, expire)
}
}
// 更新用户信息
func (user *SysUserView) UpdateUser(token string) {
config.RedisConn.HSet(config.CachePrefix+token, "user", user)
}
// ======================================= 数据权限相关 =======================================
// 设置当前部门的数据范围
func SetDataScope(deptId string) {
if deptId != "" {
dept := SysDept{
}
dept.Id = deptId
// 这里的数据权限条件存了部门id和名称，如果没有特殊要求的话，只用部门id也可以的。
// 但是因为我的项目的业务原因，需要用到部门名称来过滤数据（因为有的表的数据判断是哪个部门的数据，用的不是部门id而是部门名称）
childId, childName := GetDeptChild(deptId) // 当前部门及子部门id和名称
ancestorId, ancestorName := dept.GetAncestor() // 当前部门祖级id和名称
dataScope := map[string]any{
"ancestorId": ancestorId,
"ancestorName": ancestorName,
"childId": childId,
"childName": childName,
}
// 将数据范围信息map设置到redis中，并设置有效期为2小时
config.RedisConn.HMSet(config.DATA_SCOPE+dept.Id, dataScope)
config.RedisConn.Expire(config.DATA_SCOPE+dept.Id, time.Second*7200)
}
}
// 获取数据范围条件
func GetDataScope(token string, ignoreAdmin, isId bool) string {
if token == "" {
return ""
}
loginUser := GetLoginUser(token)
// ignoreAdmin=true 表示不管是不是管理员，都要过滤数据; ignoreAdmin=false 表示只有非管理员角色才需要过滤数据
if ignoreAdmin || (!ignoreAdmin && loginUser.RoleKey != "CJGLY") {
if isId {
return loginUser.ChildId
} else {
return loginUser.ChildName
}
}
return ""
}
// 统一的数据过滤 fieldName 要查询的字段，ignoreAdmin 是否忽略超级管理员（true 忽略 false 不忽略），isId 表示是用id还是用name查询
// dataScope 数据范围（1 所有数据 2 所在部门及子部门数据 3 所在部门数据 4 仅本人数据 5 自定义数据）
func AppendQueryDataScope(token, fieldName, dataScope string, ignoreAdmin, isId bool) string {
str := GetDataScope(token, ignoreAdmin, isId)
sql := ""
if str != "" {
// 根据 当前用户的数据范围 拼接查询条件语句 scope 数据范围、过滤条件、fieldName 查询的字段名
if dataScope == "5" {
// 自定义数据范围（暂不需要）
// 5 和其他数字的范围取并集，用 or 连接，并且它们的外层不要忘了用括号括起来
} else if dataScope == "2" {
// 所在部门及子部门数据（用FIND_IN_SET查询）
sql = fmt.Sprintf("FIND_IN_SET(%s,'%s')", fieldName, str)
} else if dataScope == "3" {
// 所在部门数据（用等于查询）
sql = fmt.Sprintf("%s = '%s'", fieldName, str)
} else if dataScope == "4" {
// 仅本人数据直接用等于查询
sql = fmt.Sprintf("%s = '%s'", fieldName, str)
}
}
return sql
}
// 校验是否有数据权限（新增、修改、删除数据时）：verified 需要校验的值
func CheckDataScope(token, verified string, ignoreAdmin, isId bool) bool {
scope := GetDataScope(token, ignoreAdmin, isId)
// 当scope不是空值时，判断需要校验的值是否包含在scope中，不包含说明没有权限
if scope != "" && !util.IsContain(strings.Split(scope, ","), verified) {
return false
}
return true
}
关于数据权限
数据权限这一块，仅作一个参考，我感觉我现在这个实现方式，也还是有点点问题，但是又想不到其他特别好的解决办法，就暂时先用这种方式吧。。。
我现在的实现方式：
- 用户登录，获取用户的部门id，根据这个部门id获取它下面的子部门数据；
- 获取到子部门数据后，以用户部门id为key，部门数据、子部门数据为value，缓存到redis中；
- 过滤数据或判断数据权限时，就是按当前用户的部门id，去redis中找有没有对应的key，有就直接获取，没有就添加到redis中；
- 以用户部门id为key，这样只要是这个部门的用户登录，都是共用一个数据权限信息；
- 新增部门时，判断它的 parentId 有没有存在于redis，存在则需要更新 parentId 的数据权限（把这个新增的部门加到这个 parentId 的子级部门数据中）
上面的实现方式还存在一个问题：新增部门时要更新 parentId 的数据权限，但是修改部门要不要更新呢？修改的时候是只更新当前 id 的缓存，还是 parentId 的缓存也要一起更新？（暂时不知道要怎么做，就先这样吧）
最后
ok，以上就是本篇文章的全部内容了，等我更完这个项目的全部文章，我会放出完整代码的地址，欢迎大家多多点赞支持下，最后可以关注我不迷路~