go-zero框架实现双token无感刷新机制的核心做法是:在网关层拦截请求,解析并校验access token的有效性;若access token过期但refresh token有效,则调用后端服务生成新的access token和refresh token,并在响应头中更新这两个token,同时允许请求继续处理。具体实现依赖于自定义的中间件(middleware)来统一处理鉴权和刷新逻辑,结合redis存储token状态以支持快速验证和黑名单管理。

如何设计双Token的结构与存储策略
双Token机制通常包含Access Token(短期有效,用于接口访问)和Refresh Token(长期有效,用于获取新Access Token)。在Go-Zero中,建议将Access Token作为JWT格式存储在客户端Header中,而Refresh Token可存储在HTTP Only Cookie或客户端本地存储中。服务端需使用Redis存储Token的元数据(如用户ID、过期时间、设备指纹),以便快速验证和撤销。这种设计确保了即使Access Token泄露,攻击者也无法直接刷新或维持长期会话。

package main
import (
"context"
"fmt"
"time"
"github.com/golang-jwt/jwt/v5"
"github.com/zeromicro/go-zero/core/logx"
"github.com/zeromicro/go-zero/rest/httpx"
)
type Config struct {
JwtSecret string `json:"JwtSecret"`
RedisAddr string `json:"RedisAddr"`
}
type UserClaims struct {
UserId int64 `json:"user_id"`
IsAdmin bool `json:"is_admin"`
jwt.RegisteredClaims
}
func GenerateTokens(userId int64, isAdmin bool, secret string) (string, string, error) {
// 生成Access Token (1小时)
accessClaims := UserClaims{
UserId: userId,
IsAdmin: isAdmin,
RegisteredClaims: jwt.RegisteredClaims{
ExpiresAt: jwt.NewNumericDate(time.Now().Add(1 * time.Hour)),
Issuer: "go-zero-app",
},
}
accessToken := jwt.NewWithClaims(jwt.SigningMethodHS256, accessClaims)
accessStr, err := accessToken.SignedString([]byte(secret))
if err != nil {
return "", "", err
}
// 生成Refresh Token (7天,简单UUID模拟)
refreshStr := fmt.Sprintf("rt_%d_%s", userId, time.Now().Format(time.RFC3339))
return accessStr, refreshStr, nil
}
func ParseAccessToken(tokenStr, secret string) (*UserClaims, error) {
token, err := jwt.ParseWithClaims(tokenStr, &UserClaims{}, func(t *jwt.Token) (interface{}, error) {
return []byte(secret), nil
})
if err != nil {
return nil, err
}
claims, ok := token.Claims.(*UserClaims)
if !ok {
return nil, fmt.Errorf("invalid claims")
}
return claims, nil
}
func main() {
cfg := Config{JwtSecret: "your-secret-key", RedisAddr: "localhost:6379"}
logx.Info("Starting Go-Zero JWT Middleware Example")
// 模拟生成Token
at, rt, _ := GenerateTokens(1001, false, cfg.JwtSecret)
fmt.Printf("Access Token: %s\nRefresh Token: %s\n", at, rt)
// 模拟解析
claims, err := ParseAccessToken(at, cfg.JwtSecret)
if err != nil {
logx.Error(err)
} else {
logx.Infof("Parsed User ID: %d, Admin: %v", claims.UserId, claims.IsAdmin)
}
}
如何在Go-Zero中间件中实现无感刷新逻辑
在Go-Zero中,通过编写自定义Middleware来实现无感刷新。该中间件首先尝试解析Access Token,如果解析失败且错误类型为“TokenExpired”,则检查Refresh Token是否有效。若Refresh Token有效,则调用后端服务生成新的Access Token和Refresh Token,并通过httpx.SetHeader将新Token写入响应头,最后重新执行Handler。这种流程对用户透明,无需前端手动处理刷新逻辑。

package middleware
import (
"net/http"
"strings"
"time"
"github.com/golang-jwt/jwt/v5"
"github.com/zeromicro/go-zero/core/logx"
"github.com/zeromicro/go-zero/rest/handler"
)
type JwtAuthMiddleware struct {
Secret string
}
func (m *JwtAuthMiddleware) Handle(next http.HandlerFunc) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
authHeader := r.Header.Get("Authorization")
if authHeader == "" {
http.Error(w, "Missing Authorization Header", http.StatusUnauthorized)
return
}
tokenStr := strings.TrimPrefix(authHeader, "Bearer ")
claims, err := parseToken(tokenStr, m.Secret)
if err != nil {
// 检查是否是过期错误
if e, ok := err.(*jwt.ValidationError); ok && e.Errors&jwt.ValidationErrorExpired != 0 {
logx.Info("Access Token expired, attempting refresh")
// 这里应检查Refresh Token,若有效则生成新Token并写入Response Header
// 为简化示例,假设刷新成功并设置新Token
newToken, _ := generateNewToken(r.Context()) // 伪代码
w.Header().Set("X-New-Access-Token", newToken)
// 继续执行后续Handler
} else {
http.Error(w, "Invalid Token", http.StatusUnauthorized)
return
}
}
// 将claims存入Context供后续Handler使用
ctx := context.WithValue(r.Context(), "userId", claims.UserId)
next(w, r.WithContext(ctx))
}
}
func parseToken(tokenStr, secret string) (*jwt.Claims, error) {
// 简化的解析逻辑
return nil, nil
}
func generateNewToken(ctx context.Context) (string, error) {
// 伪代码:从Redis获取Refresh Token,验证后生成新JWT
return "new-token-string", nil
}
当Refresh Token失效时如何处理并发刷新冲突
当Refresh Token失效(如被撤销、过期或重复使用)时,系统应强制用户重新登录。在并发场景下,多个请求可能同时检测到Access Token过期并尝试刷新,导致生成多个新Token。为避免此问题,可采用分布式锁(如Redis SETNX)确保同一用户的刷新操作串行化。此外,建议在Refresh Token中使用一次性标记(One-Time Use),每次使用后更新Redis中的Token版本,确保旧Token立即失效。这样既能保证安全性,又能避免并发冲突。


















