[golang]在Gin框架中使用JWT鉴权

什么是JWT

JWT，全称 JSON Web Token，是一种开放标准（RFC 7519），用于安全地在双方之间通报信息。尤其适用于身份验证和授权场景。JWT 的设计允许信息在各方之间安全地、 compactly（紧凑地）传输，因为其自身包含了所有需要的认证信息，从而淘汰了需要查询数据库或会话存储的需求。
JWT主要由三部门组成，通过.毗连：

• Header（头部）：描述JWT的元数据，通常包括类型（通常是JWT）和使用的签名算法（如HS256、RS256等）。
  
• Payload（载荷）：包含声明（claims），即用户的相关信息。这些信息可以是公开的，也可以是私有的，但应避免放入敏感信息，因为该部门可以被解码查看。载荷中的声明可以验证，但不加密。
  
• Signature（签名）：用于验证JWT的完整性和来源。它是通过将Header和Payload分别进行Base64编码后，再与一个秘钥（secret）一起通过指定的算法（如HMAC SHA256）盘算得出的。
  

JWT的工作流程大致如下：

• 认证阶段：用户向服务器提供凭据（如用户名和密码）。服务器验证凭据无误后，生成一个JWT，其中包含用户标识符和其他声明，并使用秘钥对其进行签名。
  
• 使用阶段：客户端收到JWT后，可以在后续的每个请求中将其放在HTTP请求头中发送给服务器，以此证实自己的身份。
  
• 验证阶段：服务器收到JWT后，会使用相同的秘钥验证JWT的签名，确保其未被窜改，并检查过期时间等其他声明，从而决定是否允许实行请求。
  

JWT的优势在于它的无状态性，服务器不需要存储会话信息，这减轻了服务器的压力，同时也方便了跨域认证。但需要留意的是，JWT的安全性依赖于秘钥的安全保管以及对JWT过期时间等的合理设置。
API设计

这里设计两个公共接口和一个受保护的接口。
API描述/api/login公开接口。用于用户登录/api/register公开接口。用于用户注册/api/admin/user保护接口，需要验证JWT开发预备

初始化项目目次并切换进入

1. mkdir gin-jwt
2. cd gin-jwt

复制代码

使用go mod初始化工程

1. go mod init gin-jwt

复制代码

安装依赖

1. go get -u github.com/gin-gonic/gin
2. go get -u gorm.io/gorm
3. go get -u gorm.io/driver/postgres
4. go get -u github.com/golang-jwt/jwt/v5
5. go get -u github.com/joho/godotenv
6. go get -u golang.org/x/crypto

复制代码

创建第一个API

一开始我们可以在项目的根目次中创建文件main.go

1. touch main.go

复制代码

添加以下内容

1. package main
3. import (
4.         "net/http"
6.         "github.com/gin-gonic/gin"
7. )
9. func main() {
10.         r := gin.Default()
11.         public := r.Group("/api")
12.         {
13.                 public.POST("/register", func(c *gin.Context) {
14.                         c.JSON(http.StatusOK, gin.H{
15.                                 "data": "test. register api",
16.                         })
17.                 })
18.         }
20.         r.Run("0.0.0.0:8000")
21. }

复制代码

测试运行

1. go run main.go

复制代码

客户端测试。正常的话会有以下输出

1. $ curl -X POST http://127.0.0.1:8000/api/register
2. {"data":"test. register api"}

复制代码

美满register接口

如今register接口已经预备好了，但一样平常来说我们会把接口业务逻辑放在单独的文件中，而不是和接口定义写在一块。
创建一个控制器的包目次，并添加文件

1. mkdir controllers
2. touch controllers/auth.go

复制代码

auth.go文件内容

1. package controllers
3. import (
4.         "net/http"
6.         "github.com/gin-gonic/gin"
7. )
9. func Register(c *gin.Context) {
10.         c.JSON(http.StatusOK, gin.H{
11.                 "data": "hello, this is register endpoint",
12.         })
13. }

复制代码

更新main.go文件

1. package main
3. import (
4.         "github.com/gin-gonic/gin"
6.         "gin-jwt/controllers"
7. )
9. func main() {
10.         r := gin.Default()
11.         public := r.Group("/api")
12.         {
13.                 public.POST("/register", controllers.Register)
14.         }
16.         r.Run("0.0.0.0:8000")
17. }

复制代码

重新运行测试

1. go run main.go

复制代码

客户端测试

1. $ curl -X POST http://127.0.0.1:8000/api/register
2. {"data":"hello, this is register endpoint"}

复制代码

解析register的客户端请求

客户端请求register api需要携带用户名和密码的参数，服务端对此做解析。编辑文件controllers/auth.go

1. package controllers
3. import (
4.         "net/http"
6.         "github.com/gin-gonic/gin"
7. )
9. // /api/register的请求体
10. type ReqRegister struct {
11.         Username string `json:"username" binding:"required"`
12.         Password string `json:"password" binding:"required"`
13. }
15. func Register(c *gin.Context) {
16.         var req ReqRegister
18.         if err := c.ShouldBindBodyWithJSON(&req); err != nil {
19.                 c.JSON(http.StatusBadRequest, gin.H{
20.                         "data": err.Error(),
21.                 })
22.                 return
23.         }
24.         c.JSON(http.StatusOK, gin.H{
25.                 "data": req,
26.         })
27. }

复制代码

客户端请求测试

1. $ curl -X POST http://127.0.0.1:8000/api/register -d '{"username": "zhangsan", "password": "123456"}' -H 'Content-Type=application/json'
3. {"data":{"username":"zhangsan","password":"123456"}}

复制代码

毗连关系型数据库

一样平常会将数据保存到专门的数据库中，这里用PostgreSQL来存储数据。Postgres使用docker来安装。安装完postgres后，创建用户和数据库：

1. create user ginjwt encrypted password 'ginjwt';
2. create database ginjwt owner = ginjwt;

复制代码

创建目次models，这个目次将包含毗连数据库和数据模型的代码。

1. mkdir models

复制代码

编辑文件models/setup.go

1. package models
3. import (
4.         "fmt"
5.         "log"
6.         "os"
8.         "github.com/joho/godotenv"
9.         "gorm.io/driver/postgres"
10.         "gorm.io/gorm"
11. )
13. var DB *gorm.DB
15. func ConnectDatabase() {
16.         err := godotenv.Load(".env")
17.         if err != nil {
18.                 log.Fatalf("Error loading .env file. %v\n", err)
19.         }
21.         // DbDriver := os.Getenv("DB_DRIVER")
22.         DbHost := os.Getenv("DB_HOST")
23.         DbPort := os.Getenv("DB_PORT")
24.         DbUser := os.Getenv("DB_USER")
25.         DbPass := os.Getenv("DB_PASS")
26.         DbName := os.Getenv("DB_NAME")
28.         dsn := fmt.Sprintf("host=%s port=%s user=%s dbname=%s sslmode=disable TimeZone=Asia/Shanghai password=%s", DbHost, DbPort, DbUser, DbName, DbPass)
30.         DB, err = gorm.Open(postgres.Open(dsn), &gorm.Config{})
31.         if err != nil {
32.                 log.Fatalf("Connect to database failed, %v\n", err)
33.         } else {
34.                 log.Printf("Connect to database success, host: %s, port: %s, user: %s, dbname: %s\n", DbHost, DbPort, DbUser, DbName)
35.         }
37.         // 迁移数据表
38.         DB.AutoMigrate(&User{})
39. }

复制代码

新建并编辑环境设置文件.env

1. DB_HOST=127.0.0.1
2. DB_PORT=5432
3. DB_USER=ginjwt
4. DB_PASS=ginjwt
5. DB_NAME=ginjwt

复制代码

创建用户模型，编辑代码文件models/user.go

1. package models
3. import (
4.         "html"
5.         "strings"
7.         "golang.org/x/crypto/bcrypt"
8.         "gorm.io/gorm"
9. )
11. type User struct {
12.         gorm.Model
13.         Username string `gorm:"size:255;not null;unique" json:"username"`
14.         Password string `gorm:"size:255;not null;" json:"password"`
15. }
17. func (u *User) SaveUser() (*User, error) {
18.         err := DB.Create(&u).Error
19.         if err != nil {
20.                 return &User{}, err
21.         }
22.         return u, nil
23. }
25. // 使用gorm的hook在保存密码前对密码进行hash
26. func (u *User) BeforeSave(tx *gorm.DB) error {
27.         hashedPassword, err := bcrypt.GenerateFromPassword([]byte(u.Password), bcrypt.DefaultCost)
28.         if err != nil {
29.                 return err
30.         }
31.         u.Password = string(hashedPassword)
32.         u.Username = html.EscapeString(strings.TrimSpace(u.Username))
33.         return nil
34. }

复制代码

更新main.go

1. package main
3. import (
4.         "github.com/gin-gonic/gin"
6.         "gin-jwt/controllers"
7.         "gin-jwt/models"
8. )
10. func init() {
11.         models.ConnectDatabase()
12. }
14. func main() {
15.         r := gin.Default()
16.         public := r.Group("/api")
17.         {
18.                 public.POST("/register", controllers.Register)
19.         }
21.         r.Run("0.0.0.0:8000")
22. }

复制代码

更新controllers/auth.go

1. package controllers
3. import (
4.         "net/http"
6.         "gin-jwt/models"
8.         "github.com/gin-gonic/gin"
9. )
11. // /api/register的请求体
12. type ReqRegister struct {
13.         Username string `json:"username" binding:"required"`
14.         Password string `json:"password" binding:"required"`
15. }
17. func Register(c *gin.Context) {
18.         var req ReqRegister
20.         if err := c.ShouldBindBodyWithJSON(&req); err != nil {
21.                 c.JSON(http.StatusBadRequest, gin.H{
22.                         "data": err.Error(),
23.                 })
24.                 return
25.         }
27.         u := models.User{
28.                 Username: req.Username,
29.                 Password: req.Password,
30.         }
32.         _, err := u.SaveUser()
33.         if err != nil {
34.                 c.JSON(http.StatusBadRequest, gin.H{
35.                         "data": err.Error(),
36.                 })
37.                 return
38.         }
39.         c.JSON(http.StatusOK, gin.H{
40.                 "message": "register success",
41.                 "data":    req,
42.         })
43. }

复制代码

重新运行服务端后，客户端测试

1. $ curl -X POST http://127.0.0.1:8000/api/register -d '{"username": "zhangsan", "password": "123456"}' -H 'Content-Type=application/json'
3. {"data":{"username":"zhangsan","password":"123456"},"message":"register success"}

复制代码

添加login接口

登录接口实现的也非常简单，只需要提供用户名和密码参数。服务端接收到客户端的请求后到数据库中去匹配，确认用户是否存在和密码是否正确。假如验证通过则返回一个token，否则返回异常响应。
首先在main.go中注册API

1. // xxx
2. func main() {
3.         // xxx
4.         r := gin.Default()
5.         public := r.Group("/api")
6.         {
7.                 public.POST("/register", controllers.Register)
8.                 public.POST("/login", controllers.Login)
9.         }
10. }

复制代码

在auth.go中添加Login控制器函数

1. // api/login 的请求体
2. type ReqLogin struct {
3.         Username string `json:"username" binding:"required"`
4.         Password string `json:"password" binding:"required"`
5. }
7. func Login(c *gin.Context) {
8.         var req ReqLogin
9.         if err := c.ShouldBindBodyWithJSON(&req); err != nil {
10.                 c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
11.                 return
12.         }
14.         u := models.User{
15.                 Username: req.Username,
16.                 Password: req.Password,
17.         }
19.         // 调用 models.LoginCheck 对用户名和密码进行验证
20.         token, err := models.LoginCheck(u.Username, u.Password)
21.         if err != nil {
22.                 c.JSON(http.StatusBadRequest, gin.H{
23.                         "error": "username or password is incorrect.",
24.                 })
25.                 return
26.         }
27.         c.JSON(http.StatusOK, gin.H{
28.                 "token": token,
29.         })
30. }

复制代码

LoginCheck方法在models/user.go文件中实现

1. package models
3. import (
4.         "gin-jwt/utils/token"
5.         "html"
6.         "strings"
8.         "golang.org/x/crypto/bcrypt"
9.         "gorm.io/gorm"
10. )
12. func VerifyPassword(password, hashedPassword string) error {
13.         return bcrypt.CompareHashAndPassword([]byte(hashedPassword), []byte(password))
14. }
17. func LoginCheck(username, password string) (string, error) {
18.         var err error
19.         u := User{}
21.         err = DB.Model(User{}).Where("username = ?", username).Take(&u).Error
22.         if err != nil {
23.                 return "", err
24.         }
25.         err = VerifyPassword(password, u.Password)
26.         if err != nil && err == bcrypt.ErrMismatchedHashAndPassword {
27.                 return "", err
28.         }
30.         token, err := token.GenerateToken(u.ID)
31.         if err != nil {
32.                 return "", err
33.         }
34.         return token, nil
35. }

复制代码

这里将token相关的函数放到了单独的模块中，新增相关目次并编辑文件

1. mkdir -p utils/token
2. touch utils/token/token.go

复制代码

以下代码为token.go的内容，包含的几个函数在反面会用到

1. package token
3. import (
4.         "fmt"
5.         "os"
6.         "strconv"
7.         "strings"
8.         "time"
10.         "github.com/gin-gonic/gin"
11.         "github.com/golang-jwt/jwt/v5"
12. )
14. func GenerateToken(user_id uint) (string, error) {
15.         token_lifespan, err := strconv.Atoi(os.Getenv("TOKEN_HOUR_LIFESPAN"))
16.         if err != nil {
17.                 return "", err
18.         }
20.         claims := jwt.MapClaims{}
21.         claims["authorized"] = true
22.         claims["user_id"] = user_id
23.         claims["exp"] = time.Now().Add(time.Hour * time.Duration(token_lifespan)).Unix()
24.         token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
26.         return token.SignedString([]byte(os.Getenv("API_SECRET")))
27. }
29. func TokenValid(c *gin.Context) error {
30.         tokenString := ExtractToken(c)
31.         fmt.Println(tokenString)
32.         _, err := jwt.Parse(tokenString, func(token *jwt.Token) (any, error) {
33.                 if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
34.                         return nil, fmt.Errorf("unexpected signing method: %v", token.Header["alg"])
35.                 }
36.                 return []byte(os.Getenv("API_SECRET")), nil
37.         })
38.         if err != nil {
39.                 return err
40.         }
42.         return nil
43. }
45. // 从请求头中获取token
46. func ExtractToken(c *gin.Context) string {
47.         bearerToken := c.GetHeader("Authorization")
48.         if len(strings.Split(bearerToken, " ")) == 2 {
49.                 return strings.Split(bearerToken, " ")[1]
50.         }
51.         return ""
52. }
54. // 从jwt中解析出user_id
55. func ExtractTokenID(c *gin.Context) (uint, error) {
56.         tokenString := ExtractToken(c)
57.         token, err := jwt.Parse(tokenString, func(token *jwt.Token) (any, error) {
58.                 if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
59.                         return nil, fmt.Errorf("unexpected signing method: %v", token.Header["alg"])
60.                 }
61.                 return []byte(os.Getenv("API_SECRET")), nil
62.         })
63.         if err != nil {
64.                 return 0, err
65.         }
66.         claims, ok := token.Claims.(jwt.MapClaims)
67.         // 如果jwt有效，将user_id转换为浮点数字符串，然后再转换为 uint32
68.         if ok && token.Valid {
69.                 uid, err := strconv.ParseUint(fmt.Sprintf("%.0f", claims["user_id"]), 10, 32)
70.                 if err != nil {
71.                         return 0, err
72.                 }
73.                 return uint(uid), nil
74.         }
76.         return 0, nil
77. }

复制代码

在.env文件中添加两个环境变量的设置。TOKEN_HOUR_LIFESPAN设置token的过期时长，API_SECRET是jwt的密钥。

1. TOKEN_HOUR_LIFESPAN=1
2. API_SECRET="wP3-sN6&gG4-lV8>gJ9)"

复制代码

测试，这里改用python代码进行测试

1. import requests
2. import json
4. headers = {
5.     "Content-Type": "application/json",
6. }
8. resp = requests.get("http://127.0.0.1:8000/api/admin/user", headers=headers)
10. def register(username: str, password: str):
11.     req_body = {
12.         "username": username,
13.         "password": password,
14.     }
15.     resp = requests.post("http://127.0.0.1:8000/api/register", data=json.dumps(req_body), headers=headers)
16.     print(resp.text)
18. def login(username: str, password: str):
19.     req_body = {
20.         "username": username,
21.         "password": password,
22.     }
23.     resp = requests.post("http://127.0.0.1:8000/api/login", data=json.dumps(req_body), headers=headers)
24.     print(resp.text)
25.     if resp.status_code == 200:
26.         return resp.json()["token"]
27.     else:
28.         return ""
30. if __name__ == "__main__":
31.     username = "lisi"
32.     password = "123456"
33.     register(username, password)
34.     token = login(username, password)
35.         print(token)

复制代码

创建JWT认证中间件

创建中间件目次和代码文件

1. mkdir middlewares
2. touch middlewares/middlewares.go

复制代码

内容如下

1. package middlewares
3. import (
4.         "gin-jwt/utils/token"
5.         "net/http"
7.         "github.com/gin-gonic/gin"
8. )
10. func JwtAuthMiddleware() gin.HandlerFunc {
11.         return func(c *gin.Context) {
12.                 err := token.TokenValid(c)
13.                 if err != nil {
14.                         c.String(http.StatusUnauthorized, err.Error())
15.                         c.Abort()
16.                         return
17.                 }
18.                 c.Next()
19.         }
20. }

复制代码

在main.go文件中注册路由的时候使用中间件

1. func main() {
2.         models.ConnectDatabase()
3.         r := gin.Default()
4.         public := r.Group("/api")
5.         {
6.                 public.POST("/register", controllers.Register)
7.                 public.POST("/login", controllers.Login)
8.         }
10.         protected := r.Group("/api/admin")
11.         {
12.                 protected.Use(middlewares.JwtAuthMiddleware())
13.                 protected.GET("/user", func(c *gin.Context) {
14.                         c.JSON(http.StatusOK, gin.H{
15.                                 "status":  "success",
16.                                 "message": "authorized",
17.                         })
18.                 })
19.         }
21.         r.Run("0.0.0.0:8000")
22. }

复制代码

在controllers/auth.go文件中实现CurrentUser

1. func CurrentUser(c *gin.Context) {
2.         // 从token中解析出user_id
3.         user_id, err := token.ExtractTokenID(c)
4.         if err != nil {
5.                 c.JSON(http.StatusBadRequest, gin.H{
6.                         "error": err.Error(),
7.                 })
8.                 return
9.         }
11.         // 根据user_id从数据库查询数据
12.         u, err := models.GetUserByID(user_id)
13.         if err != nil {
14.                 c.JSON(http.StatusBadRequest, gin.H{
15.                         "error": err.Error(),
16.                 })
17.                 return
18.         }
20.         c.JSON(http.StatusOK, gin.H{
21.                 "message": "success",
22.                 "data": u,
23.         })
24. }

复制代码

在models/user.go文件中实现GetUserByID

1. // 返回前将用户密码置空
2. func (u *User) PrepareGive() {
3.         u.Password = ""
4. }
6. func GetUserByID(uid uint) (User, error) {
7.         var u User
8.         if err := DB.First(&u, uid).Error; err != nil {
9.                 return u, errors.New("user not found")
10.         }
12.         u.PrepareGive()
13.         return u, nil
14. }

复制代码

至此，一个简单的gin-jwt应用就完成了。
客户端测试python脚本

服务端的三个接口这里用python脚本来测试

1. import requests
2. import json
4. headers = {
5.     # "Authorization": f"Bearer {token}",
6.     "Content-Type": "application/json",
7. }
9. resp = requests.get("http://127.0.0.1:8000/api/admin/user", headers=headers)
11. def register(username: str, password: str):
12.     req_body = {
13.         "username": username,
14.         "password": password,
15.     }
16.     resp = requests.post("http://127.0.0.1:8000/api/register", data=json.dumps(req_body), headers=headers)
17.     print(resp.text)
19. def login(username: str, password: str):
20.     req_body = {
21.         "username": username,
22.         "password": password,
23.     }
24.     resp = requests.post("http://127.0.0.1:8000/api/login", data=json.dumps(req_body), headers=headers)
25.     print(resp.text)
26.     if resp.status_code == 200:
27.         return resp.json()["token"]
28.     else:
29.         return ""
31. def test_protect_api(token: str):
32.     global headers
33.     headers["Authorization"] = f"Bearer {token}"
35.     resp = requests.get("http://127.0.0.1:8000/api/admin/user", headers=headers)
36.     print(resp.text)
38. if __name__ == "__main__":
39.     username = "lisi"
40.     password = "123456"
41.     register(username, password)
42.     token = login(username, password)
43.     test_protect_api(token)

复制代码

运行脚本效果

1. {"message":"register success"}
2. {"token":"eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJhdXRob3JpemVkIjp0cnVlLCJleHAiOjE3MTk5NDA0NjAsInVzZXJfaWQiOjZ9.qkzn0Ot9hAb54l3RFbGUohHJ9oezGia5x_oXppbD2jQ"}
3. {"data":{"ID":6,"CreatedAt":"2024-07-03T00:14:20.187725+08:00","UpdatedAt":"2024-07-03T00:14:20.187725+08:00","DeletedAt":null,"username":"wangwu","password":""},"message":"success"}

复制代码

完整示例代码

目次结构

1. ├── client.py  # 客户端测试脚本
2. ├── controllers  # 控制器相关包
3. │   └── auth.go  # 控制器方法实现
4. ├── gin-jwt.bin  # 编译的二进制文件
5. ├── go.mod  # go 项目文件
6. ├── go.sum  # go 项目文件
7. ├── main.go  # 程序入口文件
8. ├── middlewares  # 中间件相关包
9. │   └── middlewares.go  # 中间件代码文件
10. ├── models  # 存储层相关包
11. │   ├── setup.go  # 配置数据库连接
12. │   └── user.go  # user模块相关数据交互的代码文件
13. ├── README.md  # git repo的描述文件
14. └── utils  # 工具类包
15.     └── token  # token相关工具类包
16.         └── token.go  # token工具的代码文件

复制代码

main.go

1. package main
3. import (
4.         "log"
6.         "github.com/gin-gonic/gin"
8.         "gin-jwt/controllers"
9.         "gin-jwt/middlewares"
10.         "gin-jwt/models"
12.         "github.com/joho/godotenv"
13. )
15. func init() {
16.         err := godotenv.Load(".env")
17.         if err != nil {
18.                 log.Fatalf("Error loading .env file. %v\n", err)
19.         }
20. }
22. func main() {
23.         models.ConnectDatabase()
24.         r := gin.Default()
25.         public := r.Group("/api")
26.         {
27.                 public.POST("/register", controllers.Register)
28.                 public.POST("/login", controllers.Login)
29.         }
31.         protected := r.Group("/api/admin")
32.         {
33.                 protected.Use(middlewares.JwtAuthMiddleware()) // 在路由组中使用中间件
34.                 protected.GET("/user", controllers.CurrentUser)
35.         }
37.         r.Run("0.0.0.0:8000")
38. }

复制代码

controllers

• auth.go
  

1. package controllersimport (        "net/http"        "gin-jwt/models"        "gin-jwt/utils/token"        "github.com/gin-gonic/gin")// /api/register的请求体type ReqRegister struct {        Username string `json:"username" binding:"required"`        Password string `json:"password" binding:"required"`}// api/login 的请求体
2. type ReqLogin struct {
3.         Username string `json:"username" binding:"required"`
4.         Password string `json:"password" binding:"required"`
5. }
7. func Login(c *gin.Context) {
8.         var req ReqLogin
9.         if err := c.ShouldBindBodyWithJSON(&req); err != nil {
10.                 c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
11.                 return
12.         }
14.         u := models.User{
15.                 Username: req.Username,
16.                 Password: req.Password,
17.         }
19.         // 调用 models.LoginCheck 对用户名和密码进行验证
20.         token, err := models.LoginCheck(u.Username, u.Password)
21.         if err != nil {
22.                 c.JSON(http.StatusBadRequest, gin.H{
23.                         "error": "username or password is incorrect.",
24.                 })
25.                 return
26.         }
27.         c.JSON(http.StatusOK, gin.H{
28.                 "token": token,
29.         })
30. }func Register(c *gin.Context) {        var req ReqRegister        if err := c.ShouldBindBodyWithJSON(&req); err != nil {                c.JSON(http.StatusBadRequest, gin.H{                        "data": err.Error(),                })                return        }        u := models.User{                Username: req.Username,                Password: req.Password,        }        _, err := u.SaveUser()        if err != nil {                c.JSON(http.StatusBadRequest, gin.H{                        "data": err.Error(),                })                return        }        c.JSON(http.StatusOK, gin.H{                "message": "register success",        })}func CurrentUser(c *gin.Context) {
31.         // 从token中解析出user_id
32.         user_id, err := token.ExtractTokenID(c)
33.         if err != nil {
34.                 c.JSON(http.StatusBadRequest, gin.H{
35.                         "error": err.Error(),
36.                 })
37.                 return
38.         }
40.         // 根据user_id从数据库查询数据
41.         u, err := models.GetUserByID(user_id)
42.         if err != nil {
43.                 c.JSON(http.StatusBadRequest, gin.H{
44.                         "error": err.Error(),
45.                 })
46.                 return
47.         }
49.         c.JSON(http.StatusOK, gin.H{
50.                 "message": "success",
51.                 "data": u,
52.         })
53. }

复制代码

models

• setup.go
  

1. package models
3. import (
4.         "fmt"
5.         "log"
6.         "os"
8.         "gorm.io/driver/postgres"
9.         "gorm.io/gorm"
10. )
12. var DB *gorm.DB
14. func ConnectDatabase() {
15.         var err error
16.         DbHost := os.Getenv("DB_HOST")
17.         DbPort := os.Getenv("DB_PORT")
18.         DbUser := os.Getenv("DB_USER")
19.         DbPass := os.Getenv("DB_PASS")
20.         DbName := os.Getenv("DB_NAME")
22.         dsn := fmt.Sprintf("host=%s port=%s user=%s dbname=%s sslmode=disable TimeZone=Asia/Shanghai password=%s", DbHost, DbPort, DbUser, DbName, DbPass)
24.         DB, err = gorm.Open(postgres.Open(dsn), &gorm.Config{})
25.         if err != nil {
26.                 log.Fatalf("Connect to database failed, %v\n", err)
27.         } else {
28.                 log.Printf("Connect to database success, host: %s, port: %s, user: %s, dbname: %s\n", DbHost, DbPort, DbUser, DbName)
29.         }
31.         // 迁移数据表
32.         DB.AutoMigrate(&User{})
33. }

复制代码

• user.go
  

1. package models
3. import (
4.         "errors"
5.         "gin-jwt/utils/token"
6.         "html"
7.         "strings"
9.         "golang.org/x/crypto/bcrypt"
10.         "gorm.io/gorm"
11. )
13. type User struct {
14.         gorm.Model
15.         Username string `gorm:"size:255;not null;unique" json:"username"`
16.         Password string `gorm:"size:255;not null;" json:"password"`
17. }
19. func (u *User) SaveUser() (*User, error) {
20.         err := DB.Create(&u).Error
21.         if err != nil {
22.                 return &User{}, err
23.         }
24.         return u, nil
25. }
27. // 使用gorm的hook在保存密码前对密码进行hash
28. func (u *User) BeforeSave(tx *gorm.DB) error {
29.         hashedPassword, err := bcrypt.GenerateFromPassword([]byte(u.Password), bcrypt.DefaultCost)
30.         if err != nil {
31.                 return err
32.         }
33.         u.Password = string(hashedPassword)
34.         u.Username = html.EscapeString(strings.TrimSpace(u.Username))
35.         return nil
36. }
38. // 返回前将用户密码置空
39. func (u *User) PrepareGive() {
40.         u.Password = ""
41. }
43. // 对哈希加密的密码进行比对校验
44. func VerifyPassword(password, hashedPassword string) error {
45.         return bcrypt.CompareHashAndPassword([]byte(hashedPassword), []byte(password))
46. }
49. func LoginCheck(username, password string) (string, error) {
50.         var err error
51.         u := User{}
53.         err = DB.Model(User{}).Where("username = ?", username).Take(&u).Error
54.         if err != nil {
55.                 return "", err
56.         }
57.         err = VerifyPassword(password, u.Password)
58.         if err != nil && err == bcrypt.ErrMismatchedHashAndPassword {
59.                 return "", err
60.         }
62.         token, err := token.GenerateToken(u.ID)
63.         if err != nil {
64.                 return "", err
65.         }
66.         return token, nil
67. }
69. func GetUserByID(uid uint) (User, error) {
70.         var u User
71.         if err := DB.First(&u, uid).Error; err != nil {
72.                 return u, errors.New("user not found")
73.         }
75.         u.PrepareGive()
76.         return u, nil
77. }

复制代码

utils

• token/token.go
  

1. package token
3. import (
4.         "fmt"
5.         "os"
6.         "strconv"
7.         "strings"
8.         "time"
10.         "github.com/gin-gonic/gin"
11.         "github.com/golang-jwt/jwt/v5"
12. )
14. func GenerateToken(user_id uint) (string, error) {
15.         token_lifespan, err := strconv.Atoi(os.Getenv("TOKEN_HOUR_LIFESPAN"))
16.         if err != nil {
17.                 return "", err
18.         }
20.         claims := jwt.MapClaims{}
21.         claims["authorized"] = true
22.         claims["user_id"] = user_id
23.         claims["exp"] = time.Now().Add(time.Hour * time.Duration(token_lifespan)).Unix()
24.         token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
26.         return token.SignedString([]byte(os.Getenv("API_SECRET")))
27. }
29. func TokenValid(c *gin.Context) error {
30.         tokenString := ExtractToken(c)
31.         fmt.Println(tokenString)
32.         _, err := jwt.Parse(tokenString, func(token *jwt.Token) (any, error) {
33.                 if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
34.                         return nil, fmt.Errorf("unexpected signing method: %v", token.Header["alg"])
35.                 }
36.                 return []byte(os.Getenv("API_SECRET")), nil
37.         })
38.         if err != nil {
39.                 return err
40.         }
42.         return nil
43. }
45. // 从请求头中获取token
46. func ExtractToken(c *gin.Context) string {
47.         bearerToken := c.GetHeader("Authorization")
48.         if len(strings.Split(bearerToken, " ")) == 2 {
49.                 return strings.Split(bearerToken, " ")[1]
50.         }
51.         return ""
52. }
54. // 从jwt中解析出user_id
55. func ExtractTokenID(c *gin.Context) (uint, error) {
56.         tokenString := ExtractToken(c)
57.         token, err := jwt.Parse(tokenString, func(token *jwt.Token) (any, error) {
58.                 if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
59.                         return nil, fmt.Errorf("unexpected signing method: %v", token.Header["alg"])
60.                 }
61.                 return []byte(os.Getenv("API_SECRET")), nil
62.         })
63.         if err != nil {
64.                 return 0, err
65.         }
66.         claims, ok := token.Claims.(jwt.MapClaims)
67.         // 如果jwt有效，将user_id转换为浮点数字符串，然后再转换为 uint32
68.         if ok && token.Valid {
69.                 uid, err := strconv.ParseUint(fmt.Sprintf("%.0f", claims["user_id"]), 10, 32)
70.                 if err != nil {
71.                         return 0, err
72.                 }
73.                 return uint(uid), nil
74.         }
76.         return 0, nil
77. }

复制代码

middlewares

• middlewares.go
  

1. package middlewares
3. import (
4.         "gin-jwt/utils/token"
5.         "net/http"
7.         "github.com/gin-gonic/gin"
8. )
10. func JwtAuthMiddleware() gin.HandlerFunc {
11.         return func(c *gin.Context) {
12.                 err := token.TokenValid(c)
13.                 if err != nil {
14.                         c.String(http.StatusUnauthorized, err.Error())
15.                         c.Abort()
16.                         return
17.                 }
18.                 c.Next()
19.         }
20. }

复制代码

参考

• Medium - Create your first Go REST API with JWT Authentication in Gin Framework
  

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。