我来为你详细介绍在 Go 语言中使用 JWT 的实践方案。
Go 语言 JWT 库推荐
Go 生态中最流行的 JWT 库是 `github.com/golang-jwt/jwt/v5`（原 `dgrijalva/jwt-go` 的社区维护分支，更安全可靠）。
快速开始
1. 安装依赖
```bash
go get github.com/golang-jwt/jwt/v5
```
2. 基础使用示例
生成 Token（登录时）
```go
package main
import (
"time"
"github.com/golang-jwt/jwt/v5"
)
// 定义密钥（生产环境应从环境变量读取）
var jwtSecret = []byte("your-256-bit-secret")
// 自定义 Claims 结构
type UserClaims struct {
UserID uint `json:"user_id"`
Username string `json:"username"`
jwt.RegisteredClaims // 内嵌标准声明
}
// 生成 JWT
func GenerateToken(userID uint, username string) (string, error) {
claims := UserClaims{
UserID: userID,
Username: username,
RegisteredClaims: jwt.RegisteredClaims{
ExpiresAt: jwt.NewNumericDate(time.Now().Add(24 * time.Hour)), // 24小时过期
IssuedAt: jwt.NewNumericDate(time.Now()),
Subject: "user_token",
},
}
token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
return token.SignedString(jwtSecret)
}
```
解析和验证 Token（中间件中）
```go
// 解析 JWT
func ParseToken(tokenString string) (*UserClaims, error) {
token, err := jwt.ParseWithClaims(tokenString, &UserClaims{}, func(token *jwt.Token) (interface{}, error) {
// 验证签名算法
if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
return nil, jwt.ErrSignatureInvalid
}
return jwtSecret, nil
})
if err != nil {
return nil, err
}
if claims, ok := token.Claims.(*UserClaims); ok && token.Valid {
return claims, nil
}
return nil, jwt.ErrInvalidKey
}
```
Gin 框架集成示例
这是实际项目中最常见的使用场景：
```go
package main
import (
"net/http"
"strings"
"time"
"github.com/gin-gonic/gin"
"github.com/golang-jwt/jwt/v5"
)
var jwtSecret = []byte("your-secret-key")
// JWT 中间件
func JWTAuthMiddleware() gin.HandlerFunc {
return func(c *gin.Context) {
authHeader := c.GetHeader("Authorization")
if authHeader == "" {
c.JSON(http.StatusUnauthorized, gin.H{"error": "缺少认证头"})
c.Abort()
return
}
// 提取 Bearer token
parts := strings.SplitN(authHeader, " ", 2)
if !(len(parts) == 2 && parts[0] == "Bearer") {
c.JSON(http.StatusUnauthorized, gin.H{"error": "认证头格式错误"})
c.Abort()
return
}
// 解析 token
claims, err := ParseToken(parts[1])
if err != nil {
c.JSON(http.StatusUnauthorized, gin.H{"error": "无效的token"})
c.Abort()
return
}
// 将用户信息存入上下文
c.Set("userID", claims.UserID)
c.Set("username", claims.Username)
c.Next()
}
}
func main() {
r := gin.Default()
// 公开路由
r.POST("/login", loginHandler)
// 需要认证的路由组
api := r.Group("/api")
api.Use(JWTAuthMiddleware())
{
api.GET("/profile", profileHandler)
api.POST("/logout", logoutHandler)
}
r.Run(":8080")
}
// 登录处理
func loginHandler(c *gin.Context) {
var req struct {
Username string `json:"username"`
Password string `json:"password"`
}
if err := c.ShouldBindJSON(&req); err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
}
// 验证用户名密码（示例，实际应查数据库）
if req.Username != "admin" || req.Password != "123456" {
c.JSON(http.StatusUnauthorized, gin.H{"error": "认证失败"})
return
}
// 生成 token
token, err := GenerateToken(1, req.Username)
if err != nil {
c.JSON(http.StatusInternalServerError, gin.H{"error": "生成token失败"})
return
}
c.JSON(http.StatusOK, gin.H{
"token": token,
"type": "Bearer",
})
}
// 获取个人信息（需要认证）
func profileHandler(c *gin.Context) {
userID, _ := c.Get("userID")
username, _ := c.Get("username")
c.JSON(http.StatusOK, gin.H{
"user_id": userID,
"username": username,
})
}
```
高级特性
使用 RSA 非对称加密（更安全的微服务场景）
```go
// 生成 Token（使用私钥）
func GenerateTokenWithRSA(userID uint, privateKey *rsa.PrivateKey) (string, error) {
claims := jwt.MapClaims{
"user_id": userID,
"exp": time.Now().Add(time.Hour * 24).Unix(),
}
token := jwt.NewWithClaims(jwt.SigningMethodRS256, claims)
return token.SignedString(privateKey)
}
// 验证 Token（使用公钥）
func ParseTokenWithRSA(tokenString string, publicKey *rsa.PublicKey) (*jwt.Token, error) {
return jwt.Parse(tokenString, func(token *jwt.Token) (interface{}, error) {
if _, ok := token.Method.(*jwt.SigningMethodRSA); !ok {
return nil, fmt.Errorf("unexpected signing method: %v", token.Header["alg"])
}
return publicKey, nil
})
}
```
Token 刷新机制
```go
// RefreshToken 在 token 即将过期时生成新 token
func RefreshToken(tokenString string) (string, error) {
claims, err := ParseToken(tokenString)
if err != nil {
return "", err
}
// 检查是否需要刷新（例如剩余时间小于30分钟）
if time.Until(claims.ExpiresAt.Time) > 30*time.Minute {
return "", errors.New("token 尚未需要刷新")
}
// 生成新 token
return GenerateToken(claims.UserID, claims.Username)
}
```
目录结构建议
```
project/
├── internal/
│ ├── middleware/
│ │ └── jwt.go # JWT 中间件
│ └── utils/
│ └── jwt.go # JWT 工具函数
├── pkg/
│ └── config/
│ └── config.go # 密钥配置
└── cmd/
└── server/
└── main.go
```
安全最佳实践
实践 说明
密钥管理 使用环境变量或密钥管理服务（KMS），不要硬编码
算法选择 优先使用 `HS256` 或 `RS256`，避免 `none` 算法
过期时间 设置合理的过期时间（建议 15分钟-2小时）
HTTPS 传输 生产环境必须使用 HTTPS
Token 存储 前端存储在 `httpOnly` Cookie 或内存中，避免 LocalStorage XSS 风险
需要了解更具体的场景实现（如 Redis 存储黑名单实现登出、多设备登录控制等）吗？
