gin实现jwt注册登录

首先，确保安装了所需的依赖库：

go get github.com/gin-gonic/gin
go get -u github.com/golang-jwt/jwt/v5
go get -u gorm.io/gorm
go get -u gorm.io/driver/mysql

然后实现JWT Token认证

package models

import (
    "gorm.io/gorm"
    "github.com/golang-jwt/jwt/v5"
)

type Claim struct {
    gorm.Model
    jwt.RegisteredClaims
}

var Msk []byte = []byte("nbyyyds666") // 加密串

编译获取Token的函数

func GetToken(b []byte, c uint) (string, error) {
    a := Claim{
        gorm.Model{
            ID: c,
        },
        jwt.RegisteredClaims{
            ExpiresAt: jwt.NewNumericDate(time.Now().Add(30 * 24 * time.Hour)), // 过期时间
            Issuer:    "nb", // 签发人
        },
    }
    token := jwt.NewWithClaims(jwt.SigningMethodHS256, a)
    return token.SignedString(b)
}

编译解析Token的函数

func ParseToken(a string) (*jwt.Token, *Claim, error) {
    claim := &Claim{}
    t, err := jwt.ParseWithClaims(a, claim, func(t *jwt.Token) (interface{}, error) {
        return Msk, nil
    })
    return t, claim, err
}

 定义用户表结构

type User struct {
    gorm.Model
    Openid string
    Role   int
}

func GetDB() *gorm.DB {
    dsn := "root:1234@tcp(127.0.0.1:3306)/database?charset=utf8&parseTime=True&loc=Local"
    db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
    if err != nil {
        fmt.Println(err)
        return nil
    }
    return db
}

实现JWT中间件

func Mid() gin.HandlerFunc {
    return func(ctx *gin.Context) {
        t := ctx.GetHeader("Authorization")
        if t == "" || !strings.HasPrefix(t, "Bearer ") {
            ctx.JSON(401, gin.H{"message": "解析失败"})
            ctx.Abort()
            return
        }
        t = t[7:] // 去掉头部
        tk, c, e := ParseToken(t)
        if e != nil || !tk.Valid {
            ctx.JSON(401, gin.H{"message": "解析失败1"})
            ctx.Abort()
            return
        }
        Uid := c.Model.ID
        db := GetDB()
        var user4 User
        db.Where("ID=?", Uid).First(&user4)
        if user4.ID == 0 {
            ctx.JSON(401, gin.H{"message": "没有该用户"})
            ctx.Abort()
            return
        }
        ctx.Set("user", user4)
        ctx.Next()
    }
}

注册函数

func Register(c *gin.Context) {
    var user User
    if err := c.ShouldBindJSON(&user); err != nil {
        c.JSON(400, gin.H{"message": "无效的请求"})
        return
    }
    db := GetDB()
    if err := db.Create(&user).Error; err != nil {
        c.JSON(500, gin.H{"message": "注册失败"})
        return
    }
    c.JSON(200, gin.H{"message": "注册成功"})
}

登录函数

func Login(c *gin.Context) {
    var user User
    if err := c.ShouldBindJSON(&user); err != nil {
        c.JSON(400, gin.H{"message": "无效的请求"})
        return
    }
    db := GetDB()
    var existingUser User
    if err := db.Where("openid = ?", user.Openid).First(&existingUser).Error; err != nil {
        c.JSON(400, gin.H{"message": "用户不存在"})
        return
    }
    str, err := GetToken(Msk, existingUser.ID)
    if err != nil {
        c.JSON(500, gin.H{"message": "加密失败"})
        return
    }
    c.JSON(200, gin.H{
        "token":   str,
        "message": "登录成功",
    })
}

主函数

func main() {
    r := gin.Default()

    r.POST("/register", Register)
    r.POST("/login", Login)

    r.GET("/protected", Mid(), func(c *gin.Context) {
        user := c.MustGet("user").(User)
        c.JSON(200, gin.H{
            "message": "受保护的资源",
            "user":    user,
        })
    })

    r.Run(":8080")
}