Verwendung von JWT zur Implementierung der Authentifizierung in Beego

Mit der rasanten Entwicklung des Internets und des mobilen Internets erfordern immer mehr Anwendungen eine Authentifizierung und Berechtigungskontrolle, und JWT (JSON Web Token) ist als einfacher Authentifizierungs- und Autorisierungsmechanismus in WEB-Anwendungen weit verbreitet.

Beego ist ein MVC-Framework, das auf der Go-Sprache basiert und die Vorteile von Effizienz, Einfachheit und Skalierbarkeit bietet. In diesem Artikel wird die Verwendung von JWT zur Implementierung der Authentifizierung in Beego vorgestellt.

1. Einführung in JWT

JSON Web Token (JWT) ist ein offener Standard (RFC 7519) zur Übertragung von Identitäts- und Anspruchsinformationen über das Netzwerk. Es kann Informationen sicher zwischen verschiedenen Systemen übertragen, da es Informationen verschlüsseln und digital signieren kann. Ein JWT besteht aus drei Teilen: Header, Claim und Signatur. Wenn Header und Ansprüche mit Base64 codiert werden, verwendet die Signatur einen Schlüssel zum Verschlüsseln der Daten. 2. Beego integriert JWT .JWT-Toolklasse erstellen

Wir können eine JWT-Toolklasse erstellen, indem wir JWT-Operationen kapseln, die zum Generieren und Überprüfen von JWT und anderen Operationen verwendet wird. Dazu gehören Methoden wie das Ausstellen von Token, das Verifizieren von Token und das Erhalten von in Token gespeicherten Informationen. Der Code lautet wie folgt:

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. Verwenden Sie JWT zur Authentifizierung

In Beego können wir Middleware verwenden, um die Identität des Benutzers zu überprüfen, zum Beispiel:

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
    }
}

Im obigen Code erhalten wir zuerst das Token im Anforderungsheader , und analysieren Sie dann das Token über JWT, um die darin gespeicherten Benutzerinformationen abzurufen. Abschließend überprüfen wir die Benutzerinformationen im Token mit den in unserer Datenbank gespeicherten Benutzerinformationen. Erst nach bestandener Überprüfung können wir normal auf die relevanten Schnittstellen zugreifen.

3. Zusammenfassung

Durch die oben genannten Schritte haben wir den JWT-Authentifizierungsmechanismus erfolgreich integriert und die Überprüfung der Benutzeridentität, die Berechtigungskontrolle und andere Vorgänge in der Beego-Anwendung implementiert. Es ist jedoch zu beachten, dass wir in tatsächlichen Anwendungen die Sicherheit des JWT-Schlüssels gewährleisten und auch prüfen müssen, ob die im JWT gespeicherten Informationen angemessen sind.

Das obige ist der detaillierte Inhalt vonVerwendung von JWT zur Implementierung der Authentifizierung in Beego. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!