Golang JWT验证实战，gin-jwt库使用教程

如何在Golang中实现JWT身份验证？最常用的方法是使用gin-jwt库。步骤包括：1. 安装gin和gin-jwt库；2. 定义用户数据结构，如User；3. 创建JWT中间件并配置密钥、过期时间、PayloadFunc、IdentityHandler、Authenticator、Authorizator等参数；4. 配置路由，将LoginHandler和RefreshHandler绑定到对应路径，并对需认证的接口应用中间件；5. 选择合适的JWT库时应考虑性能、安全性、易用性和社区支持；6. 确保JWT安全需使用强密钥、避免敏感信息存储于payload、启用HTTPS；7. 实现刷新机制可通过gin-jwt内置的MaxRefresh参数与RefreshHandler完成。

JWT (JSON Web Token) 身份验证在 Golang 中可以通过多种方式实现，最常用的方法是结合第三方库，比如 gin-jwt。 这种方式简化了 JWT 的生成、验证和刷新过程，使得在 Gin 框架中集成 JWT 变得非常方便。

解决方案

1. 安装必要的库:

   首先，你需要安装 gin 框架和 gin-jwt 库。 使用 go modules 管理依赖：

   

   go get github.com/gin-gonic/gin
   go get github.com/appleboy/gin-jwt/v2

2. 定义数据结构:

   定义用户数据结构，用于存储用户信息。例如：

   type User struct {
       ID       int    `json:"id"`
       Username string `json:"username"`
       Password string `json:"password"`
   }

3. 创建 JWT 中间件:

   使用 gin-jwt 创建 JWT 中间件，配置密钥、过期时间、身份验证函数等。

   package main
   
   import (
       "fmt"
       "log"
       "net/http"
       "time"
   
       "github.com/gin-gonic/gin"
       jwt "github.com/appleboy/gin-jwt/v2"
   )
   
   func main() {
       r := gin.Default()
   
       // the jwt middleware
       authMiddleware, err := jwt.New(&jwt.GinJWTMiddleware{
           Key:        []byte("secret key"),
           Timeout:    time.Hour,
           MaxRefresh: time.Hour * 24,
           IdentityKey: "id",
           PayloadFunc: func(data interface{}) jwt.MapClaims {
               if v, ok := data.(*User); ok {
                   return jwt.MapClaims{
                       "id": v.ID,
                       "username": v.Username,
                   }
               }
               return jwt.MapClaims{}
           },
           IdentityHandler: func(c *gin.Context) interface{} {
               claims := jwt.ExtractClaims(c)
               return &User{
                   ID: int(claims["id"].(float64)),
                   Username: claims["username"].(string),
               }
           },
           Authenticator: func(c *gin.Context) (interface{}, error) {
               var loginVals struct {
                   Username string `form:"username" json:"username" binding:"required"`
                   Password string `form:"password" json:"password" binding:"required"`
               }
   
               if err := c.ShouldBind(&loginVals); err != nil {
                   return nil, jwt.ErrMissingLoginValues
               }
   
               // 模拟用户验证
               if loginVals.Username == "admin" && loginVals.Password == "password" {
                   return &User{ID: 1, Username: "admin"}, nil
               }
   
               return nil, jwt.ErrFailedAuthentication
           },
           Authorizator: func(data interface{}, c *gin.Context) bool {
               if v, ok := data.(*User); ok && v.Username == "admin" {
                   return true
               }
   
               return false
           },
           Unauthorized: func(c *gin.Context, code int, message string) {
               c.JSON(code, gin.H{
                   "code":    code,
                   "message": message,
               })
           },
           // TokenLookup is a string in the form of "header:Authorization:Bearer" that is used
           // to extract token from the request.
           // Optional. Default value "header:Authorization:Bearer".
           TokenLookup:   "header: Authorization, query: token",
           // TokenHeadName is a string in the header. Default value is "Bearer"
           TokenHeadName: "Bearer",
           TimeFunc:      time.Now,
       })
   
       if err != nil {
           log.Fatal("JWT Error:" + err.Error())
       }
   
       // When you use jwt.New(), the function is called during the initialization process.
       // However, you might want to call it manually such as:
       err = authMiddleware.MiddlewareInit()
   
       if err != nil {
           log.Fatal("authMiddleware.MiddlewareInit() Error:" + err.Error())
       }
   
       r.POST("/login", authMiddleware.LoginHandler)
   
       r.GET("/refresh_token", authMiddleware.RefreshHandler)
   
       auth := r.Group("/auth")
       // Refresh time can be longer than token timeout
       auth.GET("/hello", authMiddleware.MiddlewareFunc(), func(c *gin.Context) {
           claims := jwt.ExtractClaims(c)
           user, _ := c.Get(authMiddleware.IdentityKey)
           c.JSON(http.StatusOK, gin.H{
               "userID":   user.(*User).ID,
               "userName": user.(*User).Username,
               "claims":   claims,
           })
       })
   
       if err := r.Run(":8080"); err != nil {
           log.Fatal(err)
       }
   }

4. 配置路由:

   将 JWT 中间件应用到需要身份验证的路由上。

   r.POST("/login", authMiddleware.LoginHandler)
   r.GET("/refresh_token", authMiddleware.RefreshHandler)
   
   auth := r.Group("/auth")
   auth.Use(authMiddleware.MiddlewareFunc())
   {
       auth.GET("/hello", func(c *gin.Context) {
           claims := jwt.ExtractClaims(c)
           c.JSON(200, gin.H{
               "userID": claims["id"],
               "userName": claims["username"],
               "text":   "Hello World.",
           })
       })
   }

如何选择合适的JWT库？

选择 JWT 库时，要考虑几个关键因素：性能、安全性、易用性和社区支持。 gin-jwt 在 Gin 框架中集成非常方便，但可能不是最快的。 如果性能是首要考虑因素，可以考虑其他更底层的库，例如 dgrijalva/jwt-go，但需要更多的手动配置。

JWT 身份验证的安全性考量

JWT 本身是无状态的，这既是它的优点也是潜在的风险。 要确保 JWT 的安全性，务必使用强密钥，并定期更换密钥。 此外，要避免将敏感信息直接存储在 JWT 的 payload 中，因为 payload 是可以被解码的。 考虑使用 HTTPS 来保护 JWT 在传输过程中的安全。

JWT 刷新机制的实现方式

JWT 的刷新机制允许在 token 过期后，通过一个 refresh token 来获取新的 token，而无需用户重新登录。 gin-jwt 库已经内置了刷新功能，只需要配置 MaxRefresh 参数即可。 你需要创建一个 /refresh_token 路由，并使用 authMiddleware.RefreshHandler 处理刷新请求。