前后端无感 Token 刷新：原理与 Spring Boot 实战

实现细节说明：

• subscribers 数组用于缓存等待中的请求，防止并发 401 导致多次刷新。
• _retry 标记防止刷新后的重试再次触发 401 循环。
• 刷新失败必须清理本地缓存，否则会导致死循环。

后端实现

后端主要提供登录、刷新接口以及 Token 的生成与校验逻辑。这里使用 Spring Boot + MyBatis-Plus + Redis 作为技术栈。

基础依赖

<dependencies>
    <!-- Spring Boot Web -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- MyBatis-Plus -->
    <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatis-plus-boot-starter</artifactId>
        <version>3.5.3.1</version>
    </dependency>
    <!-- MySQL -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>
    <!-- Redis -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    <!-- JWT -->
    <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>
        <scope>runtime</scope>
    </dependency>
    <dependency>
        <groupId>io.jsonwebtoken</groupId>
        <artifactId>jjwt-jackson</artifactId>
        <version>0.11.5</version>
        <scope>runtime</scope>
    </dependency>
</dependencies>

数据库设计

仅需一张用户表即可，无需专门存储 Refresh Token，因为我们将使用 Redis 进行动态管理。

CREATE TABLE user_account (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    username VARCHAR(50) UNIQUE NOT NULL,
    password VARCHAR(255) NOT NULL
);

JWT 工具类

负责生成和解析 Token。注意密钥的安全存储。

@Component
public class JwtUtil {
    @Value("${jwt.secret}")
    private String secret;

    @Value("${jwt.access.expire}")
    private long accessExpire; // ms

    @Value("${jwt.refresh.expire}")
    private long refreshExpire; // ms

    public String generateAccessToken(Long userId) {
        return Jwts.builder()
                .setSubject(userId.toString())
                .setIssuedAt(new Date())
                .setExpiration(new Date(System.currentTimeMillis() + accessExpire))
                .signWith(Keys.hmacShaKeyFor(secret.getBytes()))
                .compact();
    }

    public String generateRefreshToken(Long userId) {
        return Jwts.builder()
                .setSubject(userId.toString())
                .setIssuedAt(new Date())
                .setExpiration(new Date(System.currentTimeMillis() + refreshExpire))
                .signWith(Keys.hmacShaKeyFor(secret.getBytes()))
                .compact();
    }

    public Claims parseToken(String token) {
        return Jwts.parserBuilder()
                .setSigningKey(secret.getBytes())
                .build()
                .parseClaimsJws(token)
                .getBody();
    }
}

刷新服务

这是核心逻辑所在。每次刷新时，不仅要验证旧 Token，还要检查 Redis 中是否匹配，防止 Token 被劫持复用。

@Service
public class AuthService {
    @Autowired
    private JwtUtil jwtUtil;
    
    @Autowired
    private StringRedisTemplate redis;

    public Tokens login(String username, String password) {
        // 1. 验证用户名密码（此处省略具体查询逻辑）
        Long userId = 1L; // 示例 ID

        // 2. 生成双 Token
        String accessToken = jwtUtil.generateAccessToken(userId);
        String refreshToken = jwtUtil.generateRefreshToken(userId);

        // 3. 保存到 Redis，Key 为 refresh:{userId}
        String key = "refresh:" + userId;
        redis.opsForValue().set(key, refreshToken, jwtUtil.getRefreshExpire(), TimeUnit.MILLISECONDS);

        return new Tokens(accessToken, refreshToken);
    }

    public Tokens refresh(String refreshToken) {
        // 1. 解析 Claims
        Claims claims = jwtUtil.parseToken(refreshToken);
        Long userId = Long.parseLong(claims.getSubject());

        // 2. Redis 校验：确保 Token 存在且一致
        String key = "refresh:" + userId;
        String cached = redis.opsForValue().get(key);
        if (cached == null || !cached.equals(refreshToken)) {
            throw new RuntimeException("Refresh Token 无效或已过期");
        }

        // 3. 生成新 Token
        String newAccess = jwtUtil.generateAccessToken(userId);
        String newRefresh = jwtUtil.generateRefreshToken(userId);

        // 4. 覆盖 Redis 中的旧 Token
        redis.opsForValue().set(key, newRefresh, jwtUtil.getRefreshExpire(), TimeUnit.MILLISECONDS);

        return new Tokens(newAccess, newRefresh);
    }
}

控制器

@RestController
@RequestMapping("/api/auth")
public class AuthController {
    @Autowired
    private AuthService authService;

    @PostMapping("/login")
    public Tokens login(@RequestBody LoginReq req) {
        return authService.login(req.getUsername(), req.getPassword());
    }

    @PostMapping("/refresh")
    public Tokens refresh(@RequestBody Map<String, String> body) {
        return authService.refresh(body.get("refreshToken"));
    }
}

@Data
class LoginReq {
    private String username, password;
}

@Data
@AllArgsConstructor
class Tokens {
    private String accessToken;
    private String refreshToken;
}

过滤器

JWT 验证过滤器是标准组件，主要负责解析 Access Token 并将用户信息放入 SecurityContext。如果 Token 过期，Spring Security 会抛出异常，此时由前端的 401 拦截器接管刷新逻辑。具体实现可参考 Spring Security 官方文档或相关安全专栏。

结语

无感 Token 刷新是提升现代 Web 应用用户体验的关键手段。通过前端拦截器与后端 Redis 校验的配合，我们既保证了令牌的时效性，又避免了用户的重复登录操作。

在实际落地时，还可以考虑以下优化方向：

• 滑动过期：每次刷新时延长 Refresh Token 的有效期。
• 一次性使用：Refresh Token 使用后立即失效，增强安全性。
• 多 Tab 协调：同域下共享刷新状态，避免标签页间冲突。
• 风控加固：结合 IP 或设备指纹，识别异常刷新行为。

希望这套方案能为你的项目提供可靠的安全保障。