首页 > Golang > Go教程

Golang如何实现JWT身份验证结合gin-jwt库的实战案例

时间：2025-07-01 17:30:31 453浏览收藏

欢迎各位小伙伴来到golang学习网，相聚于此都是缘哈哈哈！今天我给大家带来《Golang如何实现JWT身份验证结合gin-jwt库的实战案例》，这篇文章主要讲到等等知识，如果你对Golang相关的知识非常感兴趣或者正在自学，都可以关注我，我会持续更新相关文章！当然，有什么建议也欢迎在评论留言提出！一起学习！

如何在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 变得非常方便。

解决方案

安装必要的库:
首先，你需要安装 gin 框架和 gin-jwt 库。使用 go modules 管理依赖：
```
go get github.com/gin-gonic/gin
go get github.com/appleboy/gin-jwt/v2
```

定义数据结构:

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

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

创建 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)
    }
}

配置路由:

将 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 处理刷新请求。

今天关于《Golang如何实现JWT身份验证结合gin-jwt库的实战案例》的内容就介绍到这里了，是不是学起来一目了然！想要了解更多关于Gin,jwt的内容请关注golang学习网公众号！

Gin jwt

Golang如何实现JWT身份验证 结合gin-jwt库的实战案例

Golang如何实现JWT身份验证结合gin-jwt库的实战案例