Utiliser JWT pour implémenter l'authentification dans Beego

Avec le développement rapide d'Internet et de l'Internet mobile, de plus en plus d'applications nécessitent une authentification et un contrôle des autorisations, et JWT (JSON Web Token), en tant que mécanisme léger d'authentification et d'autorisation, est largement utilisé dans les applications WEB.

Beego est un framework MVC basé sur le langage Go, qui présente les avantages d'efficacité, de simplicité et d'évolutivité. Cet article présentera comment utiliser JWT pour implémenter l'authentification dans Beego.

1. Introduction à JWT

JSON Web Token (JWT) est un standard ouvert (RFC 7519) permettant de transmettre des informations d'identité et de réclamation sur le réseau. Il peut transférer en toute sécurité des informations entre différents systèmes car il peut crypter et signer numériquement les informations. Un JWT se compose de trois parties : en-tête, revendication et signature. Lorsque les en-têtes et les revendications sont codés en base64, la signature utilise une clé pour chiffrer les données.

2. Beego intègre JWT

1. Installer les dépendances

Nous devons d'abord installer deux packages de dépendances :

aller chercher github.com/dgrijalva/jwt-go
aller chercher github.com/astaxie/beego

2. .Créer une classe d'outils JWT

Nous pouvons créer une classe d'outils JWT en encapsulant les opérations JWT, qui est utilisée pour générer et vérifier JWT et d'autres opérations. Celles-ci incluent des méthodes telles que l'émission de jetons, la vérification des jetons et l'obtention d'informations stockées dans les jetons. Le code est le suivant :

package utils

import (
    "errors"
    "github.com/dgrijalva/jwt-go"
    "time"
)

// JWT构造体
type JWT struct {
    signingKey []byte
}

// 定义JWT参数
type CustomClaims struct {
    UserID   string `json:"userId"`
    UserName string `json:"userName"`
    jwt.StandardClaims
}

// 构造函数
func NewJWT() *JWT {
    return &JWT{
        []byte("jwt-secret-key"),
    }
}

// 生成token
func (j *JWT) CreateToken(claims CustomClaims) (string, error) {
    token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)

    return token.SignedString(j.signingKey)
}

// 解析token
func (j *JWT) ParseToken(tokenString string) (*CustomClaims, error) {
    token, err := jwt.ParseWithClaims(tokenString, &CustomClaims{}, func(token *jwt.Token) (interface{}, error) {
        if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
            return nil, errors.New("签名方法不正确")
        }
        return j.signingKey, nil
    })

    if err != nil {
        return nil, err
    }

    if claims, ok := token.Claims.(*CustomClaims); ok && token.Valid {
        return claims, nil
    }

    return nil, errors.New("无效的token")
}

3. Utilisez JWT pour l'authentification

Dans Beego, nous pouvons utiliser un middleware pour vérifier l'identité de l'utilisateur, par exemple :

package controllers

import (
    "myProject/utils"
    "github.com/astaxie/beego"
    "github.com/dgrijalva/jwt-go"
)

type BaseController struct {
    beego.Controller
}

type CustomClaims struct {
    UserID   string `json:"userId"`
    UserName string `json:"userName"`
    jwt.StandardClaims
}

func (c *BaseController) Prepare() {
    // 获取请求头中的token
    tokenString := c.Ctx.Request.Header.Get("Authorization")

    // 创建JWT实例
    jwt := utils.NewJWT()

    // 解析token，获取token中存储的用户信息
    claims, err := jwt.ParseToken(tokenString)

    if err != nil {
        c.Data["json"] = "无效的token"
        c.ServeJSON()
        return
    }

    // 验证token中的用户信息
    if claims.UserID != "123456" || claims.UserName != "test" {
        c.Data["json"] = "用户信息验证失败"
        c.ServeJSON()
        return
    }
}

Dans le code ci-dessus, nous récupérons d'abord le token dans l'en-tête de la requête. , puis analysez le jeton via JWT pour obtenir les informations utilisateur qui y sont stockées. Enfin, nous vérifions les informations utilisateur contenues dans le jeton avec les informations utilisateur stockées dans notre base de données. Ce n'est qu'après avoir réussi la vérification que nous pouvons accéder normalement aux interfaces concernées.

3. Résumé

Grâce aux étapes ci-dessus, nous avons intégré avec succès le mécanisme d'authentification JWT et implémenté la vérification de l'identité des utilisateurs, le contrôle des autorisations et d'autres opérations dans l'application Beego. Cependant, il convient de noter que dans les applications réelles, nous devons garantir la sécurité de la clé JWT et nous devons également déterminer si les informations stockées dans le JWT sont raisonnables.

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!