JWT优化方案

一、最初的困境：代码层面的3大核心问题

项目初期为了快速落地，JWT的实现仅满足了"生成-验证"的基础功能，但随着用户量和并发量提升，代码层面的缺陷直接暴露为线上问题：

1. 性能瓶颈：重复验证导致CPU和Redis双重压力

最初的ValidateToken方法没有缓存逻辑，每一次API请求都要完整解析令牌、校验签名、查数据库/Redis，核心代码如下：

// 优化前的ValidateToken（伪代码）
func (m *Manager) ValidateToken(ctx context.Context, tokenString string) (int64, error) {
    // 每次请求都解析令牌
    claims := &Claims{}
    token, err := jwt.ParseWithClaims(tokenString, claims, func(token *jwt.Token) (interface{}, error) {
        return []byte(m.secret), nil
    })
    if err != nil || !token.Valid {
        return 0, errors.New("invalid token")
    }
    // 每次请求都查黑名单
    isBlacklisted, _ := m.jwtCache.IsInBlacklist(ctx, claims.JTI)
    if isBlacklisted {
        return 0, errors.New("token revoked")
    }
    return claims.UserID, nil
}

线上压测数据显示：单实例并发1000 req/s时，该方法耗时3-5ms，占整个请求耗时60%以上；Redis因频繁的Exists查询，QPS直接打满，CPU也因重复的SHA256签名计算飙升至80%。

2. 安全漏洞：代码层面的"致命疏漏"

• 令牌无法吊销 ：最初的代码中没有RevokeToken方法，也无黑名单逻辑，员工离职后令牌仍能访问系统，只能等24小时过期；
• 签名校验缺失 ：解析令牌时未校验签名算法，存在"none算法"绕过风险（代码中未判断token.Method类型）；
• 刷新令牌逻辑缺陷：刷新时未吊销旧令牌，一旦刷新令牌泄露，攻击者可无限刷新新令牌。

3. 代码耦合：认证逻辑"散养"，维护成本极高

初期JWT生成逻辑分散在user.go的登录、注册、更新用户等多个方法中，甚至存在重复代码：

// 优化前user.go中重复的令牌生成逻辑
func (h *userHandler) Login(c *gin.Context) {
    // 登录时生成令牌（重复代码1）
    token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
    signedToken, _ := token.SignedString([]byte("hardcode-secret"))
}

func (h *userHandler) Register(c *gin.Context) {
    // 注册时生成令牌（重复代码2）
    token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
    signedToken, _ := token.SignedString([]byte("hardcode-secret"))
}

改一个过期时间要改遍所有生成逻辑，甚至出现过"改了登录生成逻辑，漏改注册生成逻辑"导致的线上令牌过期异常。

二、为什么必须优化？------ 代码缺陷已触达系统底线

1. 性能层面：重复验证导致的Redis和CPU瓶颈，直接让API响应时间从10ms涨到50ms，用户反馈操作卡顿；
2. 安全层面：令牌无法吊销、签名校验缺失，属于高危漏洞，一旦被利用会导致数据泄露；
3. 维护层面：耦合的代码让每次迭代都要反复核对，新增"多端登录"需求时，根本无法快速适配；
4. 扩展层面：硬编码的密钥、固定的过期时间，无法支持开发/生产环境隔离，测试环境频繁踩坑。

三、结合代码的优化落地：从"单点修补"到"体系化重构"

我以"模块化解耦+缓存提效+安全加固"为核心，从代码层面逐一解决问题，每一处优化都有明确的代码改动支撑：

第一步：解耦重构，把JWT逻辑封装为统一管理器

核心目标是将分散的JWT逻辑收敛到apiserver/jwt/jwt.go的Manager结构体中，对外暴露统一接口：

1. 定义Manager结构体：聚合密钥、缓存、过期时间等核心配置，实现配置统一管理：

// apiserver/jwt/jwt.go
type Manager struct {
    secret     string          // JWT签名密钥
    jwtCache   cache.JWTCache  // 缓存接口
    tokenTTL   time.Duration   // 访问令牌过期时间（24h）
    refreshTTL time.Duration   // 刷新令牌过期时间（7天）
}

// 提供构造函数，统一初始化
func NewManager(secret string, cache cache.JWTCache) *Manager {
    return &Manager{
        secret:     secret,
        jwtCache:   cache,
        tokenTTL:   24 * time.Hour,
        refreshTTL: 7 * 24 * time.Hour,
    }
}

2. 封装核心方法 ：将生成、验证、吊销、刷新逻辑全部封装为Manager的方法，user.go等业务层只调用接口：

// user.go中简化后的调用逻辑
func (h *userHandler) Login(c *gin.Context) {
    // 不再重复写生成逻辑，直接调用管理器
    token, err := h.jwtManager.GenerateToken(user.ID)
    refreshToken, err := h.jwtManager.GenerateRefreshToken(user.ID)
    // 业务层只关注响应，无需关心JWT细节
    resp.User.Token = token
    resp.User.RefreshToken = refreshToken
}

至此，所有JWT相关改动只需在jwt.go中调整，业务层无需修改，维护成本直接降80%。

第二步：性能优化，给ValidateToken加缓存逻辑

核心思路是"缓存已验证的令牌结果，减少重复解析和Redis查询"，具体代码改动如下：

// apiserver/jwt/jwt.go 优化后的ValidateToken
func (m *Manager) ValidateToken(ctx context.Context, tokenString string) (int64, error) {
    // 1. 生成令牌哈希作为缓存Key（SHA256）
    tokenHash := m.generateTokenHash(tokenString)
    
    // 2. 优先查缓存，命中则直接返回（核心优化点）
    if m.jwtCache != nil {
        userID, err := m.jwtCache.GetValidationResult(ctx, tokenHash)
        if err == nil && userID > 0 {
            return userID, nil // 缓存命中，耗时0.5-1ms
        }
    }
    
    // 3. 缓存未命中时才解析令牌（原有逻辑）
    claims := &Claims{}
    token, err := jwt.ParseWithClaims(tokenString, claims, func(token *jwt.Token) (interface{}, error) {
        // 新增：校验签名算法，防止none算法绕过
        if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
            return nil, errors.New("unexpected signing method")
        }
        return []byte(m.secret), nil
    })
    if err != nil || !token.Valid {
        return 0, errors.New("invalid token")
    }
    
    // 4. 检查黑名单（仅缓存未命中时执行）
    if m.jwtCache != nil {
        isBlacklisted, err := m.jwtCache.IsInBlacklist(ctx, claims.JTI)
        if err == nil && isBlacklisted {
            return 0, errors.New("token has been revoked")
        }
        // 5. 缓存验证结果（1小时过期）
        _ = m.jwtCache.SetValidationResult(ctx, tokenHash, claims.UserID)
    }
    
    return claims.UserID, nil
}

配套的缓存层jwt_cache.go定义了明确的缓存策略：

// apiserver/cache/jwt_cache.go
const (
    jwtValidationKeyPrefix = "jwt:validation:"
    jwtValidationTTL       = 1 * time.Hour // 验证结果缓存1小时
    jwtBlacklistTTL        = 24 * time.Hour // 黑名单缓存24小时
)

// 缓存验证结果
func (c *jwtCache) SetValidationResult(ctx context.Context, tokenHash string, userID int64) error {
    key := fmt.Sprintf("%s%s", jwtValidationKeyPrefix, tokenHash)
    return c.client.Set(ctx, key, userID, jwtValidationTTL).Err()
}

优化后性能数据：缓存命中时验证耗时从3-5ms降到0.5-1ms，Redis QPS下降70%，单实例并发能力从1000 req/s提升到5000 req/s。

第三步：安全加固，补全令牌全生命周期管控

针对安全漏洞，新增/优化核心方法，从代码层面堵死漏洞：

1. 新增RevokeToken方法，实现令牌吊销：

// apiserver/jwt/jwt.go
func (m *Manager) RevokeToken(ctx context.Context, tokenString string) error {
    // 解析令牌获取JTI（唯一标识）
    claims := &Claims{}
    token, err := jwt.ParseWithClaims(tokenString, claims, func(token *jwt.Token) (interface{}, error) {
        return []byte(m.secret), nil
    })
    if err != nil || !token.Valid {
        return errors.New("invalid token")
    }
    
    // 将JTI加入黑名单（Redis）
    if m.jwtCache != nil {
        err = m.jwtCache.AddToBlacklist(ctx, claims.JTI)
        if err != nil {
            return err
        }
        // 使该令牌的验证缓存失效
        tokenHash := m.generateTokenHash(tokenString)
        _ = m.jwtCache.InvalidateValidationCache(ctx, tokenHash)
    }
    return nil
}

2. 优化RefreshToken方法，刷新时吊销旧令牌：

func (m *Manager) RefreshToken(ctx context.Context, refreshToken string) (string, error) {
    // 验证刷新令牌有效性
    userID, err := m.ValidateToken(ctx, refreshToken)
    if err != nil {
        return "", err
    }
    
    // 核心优化：吊销旧刷新令牌，防止复用
    _ = m.RevokeToken(ctx, refreshToken)
    
    // 生成新的访问令牌
    return m.GenerateToken(userID)
}

3. 认证中间件加固，规范令牌格式：

// apiserver/middleware/auth.go
func Auth(jwtManager *jwt.Manager) gin.HandlerFunc {
    return func(c *gin.Context) {
        authHeader := c.GetHeader("Authorization")
        if authHeader == "" {
            c.JSON(http.StatusUnauthorized, gin.H{"error": "Authorization header is required"})
            c.Abort()
            return
        }
        // 强制校验令牌格式：Token {token}
        parts := strings.SplitN(authHeader, " ", 2)
        if len(parts) != 2 || parts[0] != "Token" {
            c.JSON(http.StatusUnauthorized, gin.H{"error": "Authorization header format must be 'Token {token}'"})
            c.Abort()
            return
        }
        // 调用管理器验证令牌
        userID, err := jwtManager.ValidateToken(c.Request.Context(), parts[1])
        if err != nil {
            // 通用错误提示，避免泄露敏感信息
            c.JSON(http.StatusUnauthorized, gin.H{"error": "Invalid or expired token"})
            c.Abort()
            return
        }
        c.Set("userID", userID)
        c.Next()
    }
}

第四步：环境适配，解决配置硬编码问题

在main.go中区分开发/生产环境，避免密钥硬编码和缓存环境混用：

// apiserver/main.go
var jwtManager *jwt.Manager
if !useMock {
    // 生产环境：从配置文件读密钥，使用Redis缓存
    jwtSecret := cfg.JWT.Secret
    jwtManager = jwt.NewManager(jwtSecret, storeInstance.Cache().JWT())
} else {
    // 开发环境：使用Mock密钥，内存缓存（无需Redis）
    jwtManager = jwt.NewManager("mock-jwt-secret-for-testing", nil)
}