Pembangunan Golang: Melaksanakan pengesahan pengguna berasaskan JWT

Pembangunan Golang: Melaksanakan pengesahan pengguna berasaskan JWT

Dengan perkembangan pesat Internet, pengesahan pengguna telah menjadi isu penting dalam web aplikasi. Kaedah pengesahan berasaskan kuki tradisional telah digantikan secara beransur-ansur dengan kaedah pengesahan berasaskan JWT (JSON Web Token). JWT ialah piawaian pengesahan ringan yang membolehkan pelayan menjana token yang disulitkan dan menghantar token kepada pelanggan Apabila pelanggan menghantar permintaan, ia meletakkan token ke dalam pengepala Kebenaran untuk pengesahan.

Artikel ini akan memperkenalkan cara menggunakan Golang untuk membangunkan sistem pengesahan pengguna berasaskan JWT untuk melindungi keselamatan aplikasi web. Kami akan menggunakan Gin sebagai rangka kerja web dan perpustakaan jwt-go Golang untuk melaksanakan penjanaan dan pengesahan JWT.

Pertama, kita perlu memasang perpustakaan Gin dan jwt-go. Jalankan arahan berikut dalam terminal untuk memasang dependensi yang diperlukan:

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

Selepas pemasangan selesai, kita boleh mula menulis kod. Mula-mula, cipta fail main.go dan import pakej yang diperlukan di dalamnya: 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

Seterusnya, kita perlu mentakrifkan struktur untuk mewakili maklumat pengguna. Dalam contoh ini, kami menggunakan struktur Pengguna yang mudah, mengandungi ID pengguna dan nama pengguna:

rrreee

Kemudian, kami mencipta kunci JWT untuk berpasangan Token disulitkan dan dinyahsulit . Anda boleh menentukan pemalar dalam kod atau menyimpannya dalam fail konfigurasi. #🎜🎜#rrreee#🎜🎜#Kini, kita boleh menulis fungsi pengendali laluan yang mengendalikan pendaftaran pengguna. Dalam fungsi pengendali ini kita akan menjana JWT dan mengembalikannya kepada pelanggan. Kodnya adalah seperti berikut: #🎜🎜#rrreee#🎜🎜#Seterusnya, kami menulis fungsi middleware untuk mengesahkan JWT. Fungsi middleware ini akan digunakan pada laluan yang memerlukan pengesahan. #🎜🎜#rrreee#🎜🎜#Akhir sekali, kami menentukan laluan yang memerlukan pengesahan dan menggunakan fungsi middleware di atas pada laluan. #🎜🎜#rrreee#🎜🎜#Kini kami boleh menjalankan program dan mengakses http://localhost:8080/signup dalam penyemak imbas untuk pendaftaran pengguna. Selepas pendaftaran berjaya, JWT akan dikembalikan, dan kemudian kami boleh melihat maklumat pengguna dengan mengakses http://localhost:8080/profile. #🎜🎜##🎜🎜#Di atas ialah kod sampel untuk menggunakan Golang untuk melaksanakan pengesahan pengguna berasaskan JWT. Dengan menggunakan JWT, kami boleh melaksanakan pengesahan pengguna yang mudah dan selamat serta melindungi keselamatan aplikasi web. Sudah tentu, dalam pembangunan sebenar, lebih banyak mekanisme pengendalian keselamatan dan ralat perlu dipertimbangkan, serta akses bahagian hadapan dan fungsi organisasi log masuk pengguna. Harap artikel ini membantu anda! #🎜🎜#

Atas ialah kandungan terperinci Pembangunan Golang: Melaksanakan pengesahan pengguna berasaskan JWT. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!