在现代Web应用中，安全性是一个非常重要的课题。JWT（JSON Web Token）作为一种常用的认证与授权机制，已被广泛应用于各种系统中。它的优势在于轻量级、跨平台，并且非常适合分布式系统。在本文中，我们将通过Golang实现JWT认证与授权，帮助你构建更安全的API。

什么是JWT？

JWT（JSON Web Token）是一种开放标准（RFC 7519），用于在网络应用环境间以一个简短的字符串安全地传输信息。JWT通常用于用户认证和授权，它由三个部分组成：
1.头部（Header）：通常包含两部分信息，类型（JWT）和签名算法（如HMAC SHA256或RSA）。
2.有效载荷（Payload）：包含我们要传递的数据，通常是用户的身份信息或权限等。
3.签名（Signature）：确保消息的完整性和防止篡改。它是通过头部和有效载荷用私钥签名生成的。
JWT的结构如下：

1. header.payload.signature

复制代码

为什么选择JWT？

无状态性：JWT是自包含的，因此不需要存储会话信息，适合分布式系统。
跨平台：JWT的结构标准化，几乎所有语言都可以生成和解析JWT。
灵活性：可以将任意信息存储在JWT中，如用户ID、权限、过期时间等。

在Golang中实现JWT认证与授权


1. 安装所需的库

我们将使用github.com/dgrijalva/jwt-go库来生成和验证JWT。首先，使用go get安装该库：

1. go get github.com/dgrijalva/jwt-go

复制代码

2. 创建JWT生成与解析功能

我们将创建一个简单的JWT生成和验证模块，允许用户通过用户名和密码登录，并获取一个JWT进行后续请求。
生成JWT
在auth.go文件中，编写JWT生成函数：

1. package main
   
2. 
   
3. import (
   
4.     "github.com/dgrijalva/jwt-go"
   
5.     "time"
   
6.     "log"
   
7. )
   
8. 
   
9. // 密钥用于签名和验证JWT
   
10. var jwtKey = []byte("secret")
    
11. 
    
12. // 用户信息结构体
    
13. type Claims struct {
    
14.     Username string `json:"username"`
    
15.     jwt.StandardClaims
    
16. }
    
17. 
    
18. // 生成JWT
    
19. func GenerateJWT(username string) (string, error) {
    
20.     expirationTime := time.Now().Add(1 * time.Hour) // 设置JWT过期时间为1小时
    
21.     claims := &Claims{
    
22.         Username: username,
    
23.         StandardClaims: jwt.StandardClaims{
    
24.             ExpiresAt: expirationTime.Unix(),
    
25.         },
    
26.     }
    
27. 
    
28.     // 创建一个新的JWT对象，使用HMAC SHA256算法签名
    
29.     token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
    
30. 
    
31.     // 使用密钥签名并返回生成的JWT字符串
    
32.     return token.SignedString(jwtKey)
    
33. }

复制代码

解析JWT
然后，编写JWT解析函数，验证其有效性并提取用户信息：

1. // 解析JWT并返回用户名
   
2. func ParseJWT(tokenStr string) (string, error) {
   
3.     claims := &Claims{}
   
4.     token, err := jwt.ParseWithClaims(tokenStr, claims, func(token *jwt.Token) (interface{}, error) {
   
5.         // 返回签名时使用的密钥
   
6.         return jwtKey, nil
   
7.     })
   
8. 
   
9.     if err != nil {
   
10.         return "", err
    
11.     }
    
12. 
    
13.     if !token.Valid {
    
14.         return "", err
    
15.     }
    
16. 
    
17.     return claims.Username, nil
    
18. }

复制代码

3. 实现登录接口

接下来，我们实现一个登录接口，用户可以通过提供用户名和密码来获取JWT。

1. package main
   
2. 
   
3. import (
   
4.     "github.com/gin-gonic/gin"
   
5.     "net/http"
   
6. )
   
7. 
   
8. // 假设的用户数据，实际应用中应使用数据库
   
9. var users = map[string]string{
   
10.     "user1": "password1",
    
11.     "user2": "password2",
    
12. }
    
13. 
    
14. func main() {
    
15.     r := gin.Default()
    
16. 
    
17.     // 登录接口
    
18.     r.POST("/login", func(c *gin.Context) {
    
19.         var loginData map[string]string
    
20.         if err := c.ShouldBindJSON(&loginData); err != nil {
    
21.             c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid input"})
    
22.             return
    
23.         }
    
24. 
    
25.         username, password := loginData["username"], loginData["password"]
    
26. 
    
27.         // 验证用户名和密码
    
28.         if correctPassword, exists := users[username]; exists && correctPassword == password {
    
29.             // 生成JWT
    
30.             token, err := GenerateJWT(username)
    
31.             if err != nil {
    
32.                 c.JSON(http.StatusInternalServerError, gin.H{"error": "Could not generate token"})
    
33.                 return
    
34.             }
    
35. 
    
36.             c.JSON(http.StatusOK, gin.H{"token": token})
    
37.         } else {
    
38.             c.JSON(http.StatusUnauthorized, gin.H{"error": "Invalid username or password"})
    
39.         }
    
40.     })
    
41. 
    
42.     r.Run(":8080")
    
43. }

复制代码

4. 实现受保护的路由

为了保护需要授权的路由，我们需要编写中间件来验证JWT。只有通过验证的请求才能访问这些路由。

1. // JWT验证中间件
   
2. func JWTMiddleware() gin.HandlerFunc {
   
3.     return func(c *gin.Context) {
   
4.         // 获取Authorization头部
   
5.         tokenStr := c.GetHeader("Authorization")
   
6.         if tokenStr == "" {
   
7.             c.JSON(http.StatusUnauthorized, gin.H{"error": "Missing token"})
   
8.             c.Abort()
   
9.             return
   
10.         }
    
11. 
    
12.         // 解析JWT并获取用户名
    
13.         username, err := ParseJWT(tokenStr)
    
14.         if err != nil {
    
15.             c.JSON(http.StatusUnauthorized, gin.H{"error": "Invalid token"})
    
16.             c.Abort()
    
17.             return
    
18.         }
    
19. 
    
20.         // 将用户名添加到上下文中，以便后续使用
    
21.         c.Set("username", username)
    
22.         c.Next()
    
23.     }
    
24. }
    
25. 
    
26. func main() {
    
27.     r := gin.Default()
    
28. 
    
29.     // 登录接口
    
30.     r.POST("/login", func(c *gin.Context) {
    
31.         var loginData map[string]string
    
32.         if err := c.ShouldBindJSON(&loginData); err != nil {
    
33.             c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid input"})
    
34.             return
    
35.         }
    
36. 
    
37.         username, password := loginData["username"], loginData["password"]
    
38. 
    
39.         if correctPassword, exists := users[username]; exists && correctPassword == password {
    
40.             token, err := GenerateJWT(username)
    
41.             if err != nil {
    
42.                 c.JSON(http.StatusInternalServerError, gin.H{"error": "Could not generate token"})
    
43.                 return
    
44.             }
    
45. 
    
46.             c.JSON(http.StatusOK, gin.H{"token": token})
    
47.         } else {
    
48.             c.JSON(http.StatusUnauthorized, gin.H{"error": "Invalid username or password"})
    
49.         }
    
50.     })
    
51. 
    
52.     // 受保护的路由，必须通过JWT验证
    
53.     authorized := r.Group("/protected")
    
54.     authorized.Use(JWTMiddleware())
    
55.     authorized.GET("/hello", func(c *gin.Context) {
    
56.         username := c.MustGet("username").(string)
    
57.         c.JSON(http.StatusOK, gin.H{
    
58.             "message": "Hello, " + username,
    
59.         })
    
60.     })
    
61. 
    
62.     r.Run(":8080")
    
63. }

复制代码

5. 测试JWT认证

##16bWaaVUGAdS8d39CilS9PXEtEptU809NqHfKBuiVYk=##
首先，通过/login接口获取JWT：

1. curl -X POST http://localhost:8080/login -H "Content-Type: application/json" -d '{"username":"user1", "password":"password1"}'

复制代码

返回结果：

1. { "token": "your-jwt-token" }

复制代码

然后，使用返回的JWT访问受保护的路由：

1. curl -X GET http://localhost:8080/protected/hello -H "Authorization: your-jwt-token"

复制代码

返回结果：

1. { "message": "Hello, user1" }

复制代码

结语

通过本文的讲解，你应该已经掌握了如何在Golang中使用JWT进行认证与授权。JWT凭借其无状态性和跨平台的特点，成为了分布式系统中实现认证与授权的理想选择。你可以将这个基本的认证系统进一步扩展，如支持权限控制、刷新令牌等功能。
以上就是一文详解如何在Golang中实现JWT认证与授权的详细内容，更多关于Golang JWT认证与授权的资料请关注脚本之家其它相关文章！

来源：互联网
免责声明：如果侵犯了您的权益，请联系站长（1277306191@qq.com），我们会及时删除侵权内容，谢谢合作！