Développement Golang : implémentation de l'authentification utilisateur basée sur JWT

Développement Golang : mise en œuvre de l'authentification des utilisateurs basée sur JWT

Avec le développement rapide d'Internet, l'authentification des utilisateurs est devenue un élément crucial des applications Web. La méthode d'authentification traditionnelle basée sur les cookies a été progressivement remplacée par la méthode d'authentification basée sur JWT (JSON Web Token). JWT est une norme d'authentification légère qui permet au serveur de générer un jeton chiffré et d'envoyer le jeton au client. Lorsque le client envoie une demande, il place le jeton dans l'en-tête d'autorisation pour vérification.

Cet article expliquera comment utiliser Golang pour développer un système d'authentification utilisateur basé sur JWT afin de protéger la sécurité des applications Web. Nous utiliserons Gin comme framework Web et la bibliothèque jwt-go de Golang pour implémenter la génération et la vérification JWT.

Tout d'abord, nous devons installer les bibliothèques Gin et jwt-go. Exécutez la commande suivante dans le terminal pour installer les dépendances requises :

go get -u github.com/gin-gonic/gin
go get -u github.com/dgrijalva/jwt-go

Une fois l'installation terminée, nous pouvons commencer à écrire du code. Tout d'abord, créez un fichier main.go et importez-y les packages requis : main.go文件，并在其中导入所需的包：

package main

import (
    "fmt"
    "github.com/dgrijalva/jwt-go"
    "github.com/gin-gonic/gin"
    "net/http"
    "time"
)

接下来，我们需要定义一个结构体来表示用户信息。在本例中，我们使用一个简单的User结构体，包含用户ID和用户名：

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

然后，我们创建一个JWT的密钥，用于对令牌进行加密和解密。可以在代码中定义一个常量，或者将其存储在配置文件中。

const SecretKey = "YourSecretKey"

现在，我们可以编写一个处理用户注册的路由处理函数。在该处理函数中，我们将生成一个JWT并返回给客户端。代码如下：

func signUpHandler(c *gin.Context) {
    // 获取请求体中的用户名
    username := c.PostForm("username")

    // 创建用户
    user := User{
        ID:       1,
        Username: username,
    }

    // 生成JWT
    token := jwt.NewWithClaims(jwt.SigningMethodHS256, jwt.MapClaims{
        "userId":   user.ID,
        "username": user.Username,
        "exp":      time.Now().Add(time.Hour * 24).Unix(),
    })

    // 使用密钥对JWT进行签名
    tokenString, err := token.SignedString([]byte(SecretKey))
    if err != nil {
        c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
        return
    }

    // 返回JWT给客户端
    c.JSON(http.StatusOK, gin.H{"token": tokenString})
}

接下来，我们编写一个中间件函数来进行JWT的验证。该中间件函数将会被应用到需要进行身份验证的路由上。

func authMiddleware() gin.HandlerFunc {
    return func(c *gin.Context) {
        // 从请求头中获取JWT
        tokenString := c.GetHeader("Authorization")
        if tokenString == "" {
            c.JSON(http.StatusUnauthorized, gin.H{"error": "未授权"})
            c.Abort()
            return
        }

        // 解析JWT
        token, err := jwt.Parse(tokenString, func(token *jwt.Token) (interface{}, error) {
            // 验证密钥是否一致
            if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
                return nil, fmt.Errorf("无效的签名方法: %v", token.Header["alg"])
            }
            return []byte(SecretKey), nil
        })

        // 验证JWT是否有效
        if err != nil {
            c.JSON(http.StatusUnauthorized, gin.H{"error": err.Error()})
            c.Abort()
            return
        }

        // 将用户信息存储在上下文中
        if claims, ok := token.Claims.(jwt.MapClaims); ok && token.Valid {
            c.Set("userId", claims["userId"])
            c.Set("username", claims["username"])
        } else {
            c.JSON(http.StatusUnauthorized, gin.H{"error": "无效的JWT"})
            c.Abort()
            return
        }
    }
}

最后，我们定义一个需要进行身份验证的路由，并在路由上应用上述的中间件函数。

func main() {
    // 创建Gin引擎
    router := gin.Default()

    // 注册用户注册路由
    router.POST("/signup", signUpHandler)

    // 添加身份验证中间件
    router.Use(authMiddleware())

    // 需要进行身份验证的路由
    router.GET("/profile", func(c *gin.Context) {
        userId := c.MustGet("userId").(float64)
        username := c.MustGet("username").(string)

        c.JSON(http.StatusOK, gin.H{"userId": userId, "username": username})
    })

    // 启动服务器
    router.Run(":8080")
}

现在我们可以运行该程序，并在浏览器中访问 http://localhost:8080/signup 进行用户注册。注册成功后会返回一个JWT，然后我们可以通过访问 http://localhost:8080/profilerrreee

Ensuite, nous devons définir une structure pour représenter les informations utilisateur. Dans cet exemple, nous utilisons une simple structure User contenant l'ID utilisateur et le nom d'utilisateur :

rrreee

Nous créons ensuite une clé JWT qui est utilisée pour crypter et déchiffrer le token. Vous pouvez définir une constante dans le code ou la stocker dans un fichier de configuration. 🎜rrreee🎜Maintenant, nous pouvons écrire une fonction de gestionnaire de route qui gère l'enregistrement des utilisateurs. Dans cette fonction de gestionnaire, nous générerons un JWT et le renverrons au client. Le code est le suivant : 🎜rrreee🎜Ensuite, nous écrivons une fonction middleware pour vérifier JWT. Cette fonction middleware sera appliquée aux routes qui nécessitent une authentification. 🎜rrreee🎜Enfin, nous définissons une route qui nécessite une authentification et appliquons la fonction middleware ci-dessus sur la route. 🎜rrreee🎜Nous pouvons maintenant exécuter le programme et accéder à http://localhost:8080/signup dans le navigateur pour l'enregistrement des utilisateurs. Une fois l'enregistrement réussi, un JWT sera renvoyé, puis nous pourrons afficher les informations utilisateur en accédant à http://localhost:8080/profile. 🎜🎜Ce qui précède est un exemple de code permettant d'utiliser Golang pour implémenter l'authentification utilisateur basée sur JWT. En utilisant JWT, nous pouvons mettre en œuvre une authentification simple et sécurisée des utilisateurs et protéger la sécurité des applications Web. Bien entendu, dans le développement réel, davantage de mécanismes de sécurité et de gestion des erreurs doivent être pris en compte, ainsi que des fonctions d'organisation de l'accès frontal et de la connexion des utilisateurs. J'espère que cet article vous sera utile ! 🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!