JWT双令牌认证已经成为现代Web应用安全架构的核心组件，特别是无感刷新和黑名单机制的组合方案，能够有效平衡安全性与用户体验。这次我们深入分析大厂标配的双令牌认证方案，重点讲解如何实现无感刷新流程和基于Redis的黑名单即时失效机制。

这套方案的核心价值在于：用户登录后获得access_token和refresh_token两个令牌，access_token用于日常API调用（有效期较短），refresh_token专门用于令牌刷新（有效期较长）。当access_token过期时，系统自动使用refresh_token获取新令牌，用户完全无感知。同时，通过Redis黑名单机制确保被撤销的令牌立即失效，防止令牌被盗用。

1. 核心能力速览

2. 适用场景与使用边界

双令牌认证特别适合需要高安全标准的业务场景。对于金融应用、电商平台、企业管理系统等涉及敏感数据的系统，这种方案能够在保持用户登录状态的同时，有效控制安全风险。

适合场景：

• 需要长时间保持登录状态的Web应用
• 移动端APP的持久化登录
• 微服务架构下的统一认证
• 对安全性要求较高的业务系统

不适合场景：

• 简单的静态网站或博客系统
• 内部工具类应用（可使用单令牌简化方案）
• 对性能要求极高的实时系统（Redis操作有轻微开销）

安全边界提醒：虽然双令牌方案提升了安全性，但仍需配合HTTPS传输、合理的令牌有效期设置、安全的密钥管理等措施。涉及用户敏感信息时，必须确保Redis服务器的安全配置和访问控制。

3. 环境准备与前置条件

在开始实现双令牌认证前，需要准备以下技术环境：

基础环境要求：

• Java 8+ 或 Node.js 14+ 运行环境
• Redis 5.0+ 服务器（本地或远程）
• 项目构建工具：Maven 3.6+ 或 npm 6.0+

依赖组件清单：对于Spring Boot项目，需要在pom.xml中添加：

<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> <dependency> <groupId>io.jsonwebtoken</groupId> <artifactId>jjwt-api</artifactId> <version>0.11.5</version> </dependency> <dependency> <groupId>io.jsonwebtoken</groupId> <artifactId>jjwt-impl</artifactId> <version>0.11.5</version> </dependency> <dependency> <groupId>io.jsonwebtoken</groupId> <artifactId>jjwt-jackson</artifactId> <version>0.11.5</version> </dependency>

对于Node.js项目，package.json依赖：

{ "dependencies": { "jsonwebtoken": "^9.0.0", "ioredis": "^5.3.0", "express": "^4.18.0" } }

Redis配置检查：确保Redis服务正常运行，并测试连接：

# 检查Redis服务状态 redis-cli ping # 如果返回PONG表示连接正常

4. 双令牌生成与签发逻辑

双的核心在于同时生成两个不同用途的JWT令牌，设置合理的有效期差异。

令牌生成示例（Java）：

public class JwtTokenProvider { private final String jwtSecret = "your-secret-key"; private final long accessTokenExpiration = 15 * 60 * 1000; // 15分钟 private final long refreshTokenExpiration = 7 * 24 * 60 * 60 * 1000; // 7天 public TokenPair generateTokenPair(String username) { Date now = new Date(); Date accessTokenExpiry = new Date(now.getTime() + accessTokenExpiration); Date refreshTokenExpiry = new Date(now.getTime() + refreshTokenExpiration); // 生成access_token String accessToken = Jwts.builder() .setSubject(username) .setIssuedAt(now) .setExpiration(accessTokenExpiry) .signWith(SignatureAlgorithm.HS512, jwtSecret) .compact(); // 生成refresh_token String refreshToken = Jwts.builder() .setSubject(username) .setIssuedAt(now) .setExpiration(refreshTokenExpiry) .signWith(SignatureAlgorithm.HS512, jwtSecret) .compact(); return new TokenPair(accessToken, refreshToken); } }

令牌响应结构：

{ "access_token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...", "refresh_token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...", "token_type": "Bearer", "expires_in": 900, "refresh_expires_in": 604800 }

5. 无感刷新实现机制

无感刷新的核心是前端自动检测access_token过期，并在用户无感知的情况下完成令牌刷新。

前端拦截器实现（JavaScript）：

class AuthInterceptor { constructor() { this.isRefreshing = false; this.requests = []; } async requestInterceptor(config) { const token = localStorage.getItem('access_token'); if (token) { config.headers.Authorization = `Bearer ${token}`; } return config; } async responseInterceptor(error) { const originalRequest = error.config; // 检测到401错误且不是刷新令牌的请求 if (error.response.status === 401 && !originalRequest._retry) { if (this.isRefreshing) { // 如果正在刷新，将请求加入队列 return new Promise((resolve) => { this.requests.push(() => { originalRequest.headers.Authorization = `Bearer ${localStorage.getItem('access_token')}`; resolve(axios(originalRequest)); }); }); } originalRequest._retry = true; this.isRefreshing = true; try { // 使用refresh_token获取新access_token const refreshToken = localStorage.getItem('refresh_token'); const response = await axios.post('/api/auth/refresh', { refresh_token: refreshToken }); const newAccessToken = response.data.access_token; localStorage.setItem('access_token', newAccessToken); // 重试原始请求 originalRequest.headers.Authorization = `Bearer ${newAccessToken}`; // 执行队列中的等待请求 this.requests.forEach(callback => callback()); this.requests = []; return axios(originalRequest); } catch (refreshError) { // 刷新失败，跳转到登录页 localStorage.removeItem('access_token'); localStorage.removeItem('refresh_token'); window.location.href = '/login'; return Promise.reject(refreshError); } finally { this.isRefreshing = false; } } return Promise.reject(error); } }

后端刷新接口实现（Spring Boot）：

@RestController @RequestMapping("/api/auth") public class AuthController { @Autowired private RedisTemplate<String, String> redisTemplate; @PostMapping("/refresh") public ResponseEntity<?> refreshToken(@RequestBody RefreshRequest request) { try { // 验证refresh_token有效性 Claims claims = Jwts.parser() .setSigningKey(jwtSecret) .parseClaimsJws(request.getRefreshToken()) .getBody(); String username = claims.getSubject(); // 检查refresh_token是否在黑名单中 if (redisTemplate.hasKey("blacklist:" + request.getRefreshToken())) { return ResponseEntity.status(401).body("Token revoked"); } // 生成新的令牌对 TokenPair newTokens = jwtTokenProvider.generateTokenPair(username); // 将旧的refresh_token加入黑名单 redisTemplate.opsForValue().set( "blacklist:" + request.getRefreshToken(), "revoked", Duration.ofMillis(getRemainingTime(claims)) ); return ResponseEntity.ok(newTokens); } catch (ExpiredJwtException e) { return ResponseEntity.status(401).body("Refresh token expired"); } catch (JwtException e) { return ResponseEntity.status(401).body("Invalid token"); } } private long getRemainingTime(Claims claims) { return claims.getExpiration().getTime() - System.currentTimeMillis(); } }

6. Redis黑名单即时失效机制

黑名单机制的核心思路是：在令牌被撤销或刷新后，将其标识符存入Redis，并在每次令牌验证时检查黑名单。

黑名单服务设计：

@Service public class TokenBlacklistService { @Autowired private RedisTemplate<String, String> redisTemplate; // 将令牌加入黑名单 public void addToBlacklist(String token, long expirationTime) { String key = "blacklist:" + token; redisTemplate.opsForValue().set(key, "revoked", Duration.ofMillis(expirationTime)); } // 检查令牌是否在黑名单中 public boolean isBlacklisted(String token) { return Boolean.TRUE.equals(redisTemplate.hasKey("blacklist:" + token)); } // 用户登出时，将当前access_token和refresh_token都加入黑名单 public void logout(String accessToken, String refreshToken) { Claims accessClaims = parseToken(accessToken); Claims refreshClaims = parseToken(refreshToken); if (accessClaims != null) { addToBlacklist(accessToken, getRemainingTime(accessClaims)); } if (refreshClaims != null) { addToBlacklist(refreshToken, getRemainingTime(refreshClaims)); } } }

令牌验证过滤器增强：

@Component public class JwtAuthenticationFilter extends OncePerRequestFilter { @Autowired private TokenBlacklistService blacklistService; @Override protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException { String token = getJwtFromRequest(request); if (token != null && validateToken(token)) { // 检查令牌是否在黑名单中 if (blacklistService.isBlacklisted(token)) { response.setStatus(HttpServletResponse.SC_UNAUTHORIZED); return; } // 正常的认证逻辑... } filterChain.doFilter(request, response); } }

7. 完整登录/刷新/登出流程测试

为了验证双令牌方案的实际效果，需要完整测试整个认证流程。

测试用例1：正常登录流程

# 1. 用户登录 curl -X POST http://localhost:8080/api/auth/login \ -H "Content-Type: application/json" \ -d '{"username":"testuser","password":"password123"}' # 预期响应：包含access_token和refresh_token { "access_token": "eyJ...", "refresh_token": "eyJ...", "expires_in": 900, "refresh_expires_in": 604800 }

测试用例2：access_token过期自动刷新

// 模拟前端请求：先使用有效token，然后模拟过期场景 // 第一次请求成功 await api.getUserInfo(); // 手动修改本地token为过期值，模拟token过期 localStorage.setItem('access_token', 'expired_token_here'); // 第二次请求应该触发自动刷新 await api.getUserInfo(); // 应该成功，且控制台显示刷新过程

测试用例3：主动登出测试

// 登出接口测试 @PostMapping("/logout") public ResponseEntity<?> logout(HttpServletRequest request) { String accessToken = getJwtFromRequest(request); String refreshToken = request.getHeader("Refresh-Token"); blacklistService.logout(accessToken, refreshToken); return ResponseEntity.ok("Logged out successfully"); }

8. 性能优化与资源管理

双令牌方案虽然提升了安全性，但也带来了额外的Redis操作开销，需要合理优化。

Redis内存优化策略：

@Configuration public class RedisConfig { @Bean public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory factory) { RedisTemplate<String, String> template = new RedisTemplate<>(); template.setConnectionFactory(factory); // 使用String序列化，节省空间 template.setKeySerializer(new StringRedisSerializer()); template.setValueSerializer(new StringRedisSerializer()); template.setHashKeySerializer(new StringRedisSerializer()); template.setHashValueSerializer(new StringRedisSerializer()); return template; } }

黑名单数据清理策略：

@Component public class BlacklistCleanupTask { @Scheduled(cron = "0 0 2 * * ?") // 每天凌晨2点执行 public void cleanupExpiredBlacklists() { // Redis的过期key会自动清理，这里主要处理异常情况 log.info("Starting blacklist cleanup task"); } }

缓存预热策略：对于高并发系统，可以考虑在应用启动时预加载频繁使用的黑名单数据到本地缓存，减少Redis访问压力。

9. 常见问题与排查方法

在实际部署过程中，可能会遇到各种问题，以下是典型问题及解决方案。

典型错误排查示例：

// 错误的黑名单检查时机 public boolean validateToken(String token) { try { Claims claims = Jwts.parser().setSigningKey(secret).parseClaimsJws(token).getBody(); // 错误：先验证JWT有效性，后检查黑名单 // 应该先检查黑名单，再验证JWT if (blacklistService.isBlacklisted(token)) { return false; } return !claims.getExpiration().before(new Date()); } catch (Exception e) { return false; } }

10. 安全最佳实践

在实施双令牌方案时，需要遵循以下安全最佳实践：

密钥管理安全：

• 使用足够复杂的密钥（至少256位）
• 定期轮换签名密钥
• 不同环境使用不同密钥（开发、测试、生产）

传输安全：

• 强制使用HTTPS协议
• 设置安全的Cookie属性（HttpOnly、Secure、SameSite）
• 避免在URL中传递令牌

令牌安全：

• 设置合理的有效期（access_token: 15-30分钟，refresh_token: 7-30天）
• 实现令牌撤销机制
• 监控异常令牌使用模式

Redis安全：

• 设置Redis访问密码
• 配置网络访问限制
• 定期备份和监控Redis数据

通过这套完整的双令牌认证方案，不仅能够实现用户无感刷新体验，还能通过Redis黑名单机制确保令牌安全。在实际项目中，建议根据具体业务需求调整令牌有效期和黑名单策略，在安全性和性能之间找到最佳平衡点。

关键实施要点：前端需要完善请求拦截和自动刷新逻辑，后端要确保黑名单检查的高效性，Redis配置要优化内存使用和访问性能。这套方案经过多个大厂项目验证，能够有效提升Web应用的安全防护水平。