经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » 程序设计 » Go语言 » 查看文章
[golang]在Gin框架中使用JWT鉴权
来源：cnblogs　　作者：花酒锄作田　　时间：2024/7/3 14:38:28　　对本文有异议

什么是JWT

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

JWT主要由三部分组成，通过.连接：

  1. Header（头部）：描述JWT的元数据，通常包括类型（通常是JWT）和使用的签名算法（如HS256、RS256等）。
  2. Payload（载荷）：包含声明（claims），即用户的相关信息。这些信息可以是公开的，也可以是私有的，但应避免放入敏感信息，因为该部分可以被解码查看。载荷中的声明可以验证，但不加密。
  3. 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 controllers
  3. import (
  4. 	"net/http"
  6. 	"gin-jwt/models"
  7. 	"gin-jwt/utils/token"
  9. 	"github.com/gin-gonic/gin"
  10. )
  12. // /api/register的请求体
  13. type ReqRegister struct {
  14. 	Username string `json:"username" binding:"required"`
  15. 	Password string `json:"password" binding:"required"`
  16. }
  18. // api/login 的请求体
  19. type ReqLogin struct {
  20. 	Username string `json:"username" binding:"required"`
  21. 	Password string `json:"password" binding:"required"`
  22. }
  24. func Login(c *gin.Context) {
  25. 	var req ReqLogin
  26. 	if err := c.ShouldBindBodyWithJSON(&req); err != nil {
  27. 		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
  28. 		return
  29. 	}
  31. 	u := models.User{
  32. 		Username: req.Username,
  33. 		Password: req.Password,
  34. 	}
  36. 	// 调用 models.LoginCheck 对用户名和密码进行验证
  37. 	token, err := models.LoginCheck(u.Username, u.Password)
  38. 	if err != nil {
  39. 		c.JSON(http.StatusBadRequest, gin.H{
  40. 			"error": "username or password is incorrect.",
  41. 		})
  42. 		return
  43. 	}
  44. 	c.JSON(http.StatusOK, gin.H{
  45. 		"token": token,
  46. 	})
  47. }
  49. func Register(c *gin.Context) {
  50. 	var req ReqRegister
  52. 	if err := c.ShouldBindBodyWithJSON(&req); err != nil {
  53. 		c.JSON(http.StatusBadRequest, gin.H{
  54. 			"data": err.Error(),
  55. 		})
  56. 		return
  57. 	}
  59. 	u := models.User{
  60. 		Username: req.Username,
  61. 		Password: req.Password,
  62. 	}
  64. 	_, err := u.SaveUser()
  65. 	if err != nil {
  66. 		c.JSON(http.StatusBadRequest, gin.H{
  67. 			"data": err.Error(),
  68. 		})
  69. 		return
  70. 	}
  71. 	c.JSON(http.StatusOK, gin.H{
  72. 		"message": "register success",
  73. 	})
  74. }
  77. func CurrentUser(c *gin.Context) {
  78. 	// 从token中解析出user_id
  79. 	user_id, err := token.ExtractTokenID(c)
  80. 	if err != nil {
  81. 		c.JSON(http.StatusBadRequest, gin.H{
  82. 			"error": err.Error(),
  83. 		})
  84. 		return
  85. 	}
  87. 	// 根据user_id从数据库查询数据
  88. 	u, err := models.GetUserByID(user_id)
  89. 	if err != nil {
  90. 		c.JSON(http.StatusBadRequest, gin.H{
  91. 			"error": err.Error(),
  92. 		})
  93. 		return
  94. 	}
  96. 	c.JSON(http.StatusOK, gin.H{
  97. 		"message": "success",
  98. 		"data": u,
  99. 	})
  100. }

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. }

参考

原文链接：https://www.cnblogs.com/XY-Heruo/p/18280787

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

Go语言热门文章

  • Golang从文件服务器获取图片显示到客户端
  • 谈谈Go语言中的内存重排
  • Golang 模块引入及表格读写业务快速实现示例
  • 创建并使用https证书
  • golang的reflection（转）
  • TICK技术栈（一）TICK技术栈介绍
  • beego解读Cache之MemoryCache
  • go语言reflect包最佳实践之struct操作（遍历、赋值与方法调用）
  • golang中gin框架接入jwt使用token验证身份
  • Golang解析、验证、修改URL之Host、Port、Path

    • Go语言推荐文章

  • Go 互斥锁 Mutex 源码分析(二)
  • golang对遍历目录操作的优化
  • 美团VS饿了么，到底谁更胜一筹？
  • 解码 xsync 的 map 实现
  • [golang]在Gin框架中使用JWT鉴权
  • Golang 依赖注入设计哲学｜12.6K 🌟 的依赖注入库 wire
  • 这么简单的问题都不会，那还面试什么！？
  • golang select 和外层的 for 搭配
  • Go语言的100个错误使用场景（61-68）｜并发实践
  • 实战：如何优雅的从 Skywalking 切换到 OpenTelemetry

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号