String jti = IdUtil.fastSimpleUUID();
JwtBuilder builder = Jwts.builder()
		// ...
		.id(jti) // JWT ID

// 从 Token 中提取过期时间
Claims claims = jwtUtil.parseToken(token);
Date expiration = claims.getExpiration();

// 计算剩余有效期（秒）
long remainingSeconds = (expiration.getTime() - System.currentTimeMillis()) / 1000;

// 存入黑名单，设置过期时间
redisTemplate.

opsForValue().

set(
    "auth:token:black:"+jti,
    "1",
    remainingSeconds,
    TimeUnit.SECONDS
    );

Boolean isBlacklisted = redisTemplate.hasKey("auth:token:black:" + jti);

// 1. 先验证签名（本地操作，无网络开销）
Claims claims = jwtUtil.parseToken(token);

// 2. 再检查黑名单（需要访问 Redis）
String jti = claims.getId();
if(

isInBlacklist(jti)){
		throw new

RuntimeException("Token 已被注销");
}

package com.example.auth.core.constant;

public class RedisKeyConstants {

	/**
	 * 刷新令牌映射 Key 前缀
	 */
	public static final String TOKEN_REFRESH_PREFIX = "auth:token:refresh:";

	/**
	 * 用户在线设备索引 Key 前缀
	 */
	public static final String USER_ONLINE_TOKENS_PREFIX = "auth:user:tokens:";

	/**
	 * Token 黑名单 Key 前缀
	 */
	public static final String TOKEN_BLACKLIST_PREFIX = "auth:token:black:";

	/**
	 * 构建刷新令牌 Key
	 */
	public static String buildRefreshTokenKey(String refreshToken) {
		return TOKEN_REFRESH_PREFIX + refreshToken;
	}

	/**
	 * 构建用户在线设备 Key
	 */
	public static String buildUserOnlineKey(Long userId) {
		return USER_ONLINE_TOKENS_PREFIX + userId;
	}

	/**
	 * 构建黑名单 Key
	 */
	public static String buildBlacklistKey(String jti) {
		return TOKEN_BLACKLIST_PREFIX + jti;
	}
}

package com.example.auth.core.manager;

import com.example.auth.core.constant.RedisKeyConstants;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

import java.util.Date;
import java.util.concurrent.TimeUnit;

/**
 * 黑名单 Redis 管理器（基础设施层）
 * <p>
 * 职责：只负责黑名单在 Redis 中的 CRUD 操作，不包含业务逻辑判断。
 * 这是一个"底层苦力"，只有存取方法，没有复杂的 if-else。
 * </p>
 */
@Slf4j
@Component
@RequiredArgsConstructor
public class BlacklistRedisManager {

	private static final String BLACKLISTED_MARKER = "REVOKED";

	private final StringRedisTemplate redisTemplate;

	/**
	 * 将 JTI 加入黑名单
	 *
	 * @param jti        JWT ID
	 * @param expiration Token 的过期时间
	 */
	public void add(String jti, Date expiration) {
		// 计算剩余有效期（秒）
		long remainingSeconds = (expiration.getTime() - System.currentTimeMillis()) / 1000;

		// 如果 Token 已经过期，无需加入黑名单
		if (remainingSeconds <= 0) {
			log.debug("Token 已过期，无需加入黑名单: jti={}", jti);
			return;
		}

		// 存入黑名单
		String key = RedisKeyConstants.buildBlacklistKey(jti);
		redisTemplate.opsForValue().set(key, BLACKLISTED_MARKER, remainingSeconds, TimeUnit.SECONDS);

		log.debug("JTI 已加入黑名单: jti={}, 剩余有效期={}秒", jti, remainingSeconds);
	}

	/**
	 * 将 JTI 加入黑名单（指定过期秒数）
	 *
	 * @param jti           JWT ID
	 * @param expireSeconds 过期时间（秒）
	 */
	public void add(String jti, long expireSeconds) {
		if (expireSeconds <= 0) {
			log.debug("过期时间无效，无需加入黑名单: jti={}", jti);
			return;
		}

		String key = RedisKeyConstants.buildBlacklistKey(jti);
		redisTemplate.opsForValue().set(key, BLACKLISTED_MARKER, expireSeconds, TimeUnit.SECONDS);

		log.debug("JTI 已加入黑名单: jti={}, 过期时间={}秒", jti, expireSeconds);
	}

	/**
	 * 检查 JTI 是否在黑名单中
	 */
	public boolean exists(String jti) {
		String key = RedisKeyConstants.buildBlacklistKey(jti);
		return Boolean.TRUE.equals(redisTemplate.hasKey(key));
	}
}

package com.example.auth.core.service;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.util.IdUtil;
import com.example.auth.core.config.properties.JwtProperties;
import com.example.auth.core.manager.BlacklistRedisManager;
import com.example.auth.core.manager.TokenRedisManager;
import com.example.auth.core.model.AuthToken;
import com.example.auth.core.util.JwtUtil;
import io.jsonwebtoken.Claims;
import io.jsonwebtoken.ExpiredJwtException;
import io.jsonwebtoken.JwtException;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import java.util.Date;
import java.util.Set;

/**
 * 认证服务（Facade 层 / 应用服务层）
 * <p>
 * 职责：作为"大管家"，负责编排所有认证相关的业务流程。
 * Controller 只需要注入这一个 Service，不需要关心底层的实现细节。
 * </p>
 */
@Slf4j
@Service
@RequiredArgsConstructor
public class AuthService {

	private final JwtUtil jwtUtil;
	private final JwtProperties jwtProperties;
	private final TokenRedisManager tokenRedisManager;
	private final BlacklistRedisManager blacklistRedisManager;

	// ==================== 登录相关 ====================

	/**
	 * 登录：创建双令牌
	 */
	public AuthToken login(Long userId, String username) {
		log.info("用户登录: userId={}, username={}", userId, username);

		// 1. 生成 Access Token (JWT) - 纯内存操作
		String accessToken = jwtUtil.createToken(userId, username, null);

		// 2. 从 Access Token 中提取 JTI
		String jti = jwtUtil.getJtiFromToken(accessToken);

		// 3. 生成 Refresh Token（随机字符串）
		String refreshToken = IdUtil.fastSimpleUUID();

		// 4. 计算 Refresh Token 的过期时间（秒）
		long expireSeconds = jwtProperties.getRefreshTokenExpireDays() * 86400L;

		// 5. 将 Refresh Token 存入 Redis - IO 操作
		tokenRedisManager.saveRefreshToken(userId, refreshToken, jti, expireSeconds);

		log.info("用户登录成功: userId={}, jti={}", userId, jti);

		// 6. 打包返回
		return AuthToken.builder()
				.accessToken(accessToken)
				.refreshToken(refreshToken)
				.expiresIn((long) jwtProperties.getAccessTokenExpireMinutes() * 60)
				.build();
	}

	// ==================== 令牌刷新 ====================

	/**
	 * 刷新令牌：使用 Refresh Token 换取新的令牌对
	 */
	public AuthToken refresh(String oldRefreshToken) {
		log.info("刷新令牌请求");

		// 1. 验证 Refresh Token 并获取用户 ID
		Long userId = tokenRedisManager.getUserIdByRefreshToken(oldRefreshToken);

		if (userId == null) {
			log.warn("Refresh Token 无效或已过期");
			throw new RuntimeException("刷新令牌无效或已过期，请重新登录");
		}

		// 2. 查询用户信息（实际业务中应该从数据库查询）
		String username = "User-" + userId;

		// 3. 令牌轮换 - 生成一对全新的令牌
		AuthToken newTokenPair = login(userId, username);

		// 4. 立即销毁旧的 Refresh Token（防止重放攻击）
		tokenRedisManager.deleteRefreshToken(oldRefreshToken);

		log.info("令牌刷新成功: userId={}", userId);
		return newTokenPair;
	}

	// ==================== 令牌验证（集成黑名单检查） ====================

	/**
	 * 验证 Token（集成黑名单检查）
	 */
	public Claims validateToken(String token) {
		try {
			// 1. 验证签名和过期时间（本地操作，无网络开销）
			Claims claims = jwtUtil.parseToken(token);

			// 2. 检查是否在黑名单中（Redis 查询，O(1) 复杂度）
			String jti = claims.getId();
			if (blacklistRedisManager.exists(jti)) {
				log.warn("Token 已被注销: jti={}", jti);
				throw new RuntimeException("Token 已被注销，请重新登录");
			}

			return claims;

		} catch (ExpiredJwtException e) {
			log.debug("Token 已过期: {}", e.getMessage());
			throw new RuntimeException("Token 已过期，请重新登录");
		} catch (JwtException e) {
			log.warn("Token 验证失败: {}", e.getMessage());
			throw new RuntimeException("Token 无效");
		}
	}

	/**
	 * 快速验证（只返回布尔值）
	 */
	public boolean isTokenValid(String token) {
		try {
			validateToken(token);
			return true;
		} catch (Exception e) {
			return false;
		}
	}

	// ==================== 注销相关 ====================

	/**
	 * 单设备注销（用户主动退出）
	 */
	public void logout(String accessToken, String refreshToken) {
		log.info("单设备注销请求");

		try {
			// 1. 解析 Token 获取必要信息
			Claims claims = jwtUtil.parseToken(accessToken);
			String jti = claims.getId();
			Date expiration = claims.getExpiration();
			Long userId = Long.parseLong(claims.getSubject());

			// 2. 将 Access Token 加入黑名单
			blacklistRedisManager.add(jti, expiration);
			log.info("Token 已加入黑名单: jti={}, 过期时间={}", jti, DateUtil.formatDateTime(expiration));

			// 3. 删除 Refresh Token
			tokenRedisManager.deleteRefreshToken(refreshToken);

			// 4. 从用户在线设备列表中移除
			tokenRedisManager.removeUserDevice(userId, jti);

			log.info("单设备注销成功: userId={}, jti={}", userId, jti);

		} catch (Exception e) {
			log.error("单设备注销失败", e);
			throw new RuntimeException("注销失败", e);
		}
	}

	/**
	 * 全设备注销（密码修改、管理员强制下线）
	 */
	public void logoutAll(Long userId) {
		log.info("全设备注销请求: userId={}", userId);

		try {
			// 1. 获取用户的所有在线设备
			Set<String> jtiSet = tokenRedisManager.getUserOnlineDevices(userId);

			if (CollUtil.isEmpty(jtiSet)) {
				log.info("用户没有在线设备: userId={}", userId);
				return;
			}

			// 2. 将所有 JTI 加入黑名单
			long maxExpireSeconds = jwtProperties.getAccessTokenExpireMinutes() * 60L;
			jtiSet.forEach(jti -> blacklistRedisManager.add(jti, maxExpireSeconds));

			// 3. 清空用户的在线设备列表
			tokenRedisManager.clearUserDevices(userId);

			log.info("全设备注销成功: userId={}, 设备数量={}", userId, jtiSet.size());

		} catch (Exception e) {
			log.error("全设备注销失败: userId={}", userId, e);
			throw new RuntimeException("全设备注销失败", e);
		}
	}

	/**
	 * 踢出指定设备（远程注销）
	 */
	public void kickout(Long userId, String jti) {
		log.info("踢出设备请求: userId={}, jti={}", userId, jti);

		try {
			// 1. 将 JTI 加入黑名单
			long maxExpireSeconds = jwtProperties.getAccessTokenExpireMinutes() * 60L;
			blacklistRedisManager.add(jti, maxExpireSeconds);

			// 2. 从用户在线设备列表中移除
			tokenRedisManager.removeUserDevice(userId, jti);

			log.info("踢出设备成功: userId={}, jti={}", userId, jti);

		} catch (Exception e) {
			log.error("踢出设备失败: userId={}, jti={}", userId, jti, e);
			throw new RuntimeException("踢出设备失败", e);
		}
	}

	// ==================== 辅助方法 ====================

	/**
	 * 从 Token 中提取用户 ID
	 */
	public Long getUserIdFromToken(String token) {
		Claims claims = validateToken(token);
		return Long.parseLong(claims.getSubject());
	}
}

package com.example.auth.web.controller;

import com.example.auth.common.model.Result;
import com.example.auth.core.model.AuthToken;
import com.example.auth.core.service.AuthService;
import io.jsonwebtoken.Claims;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.*;

import java.util.HashMap;
import java.util.Map;

/**
 * 认证控制器
 * <p>
 * 设计理念：Controller 只注入一个"大管家" AuthService，
 * 不需要关心底层的 TokenRedisManager、BlacklistRedisManager 等实现细节。
 * </p>
 */
@Slf4j
@RestController
@RequestMapping("/auth")
@RequiredArgsConstructor
public class AuthController {

	// ✅ 只注入一个 Facade 服务
	private final AuthService authService;

	/**
	 * 双令牌登录接口
	 */
	@PostMapping("/login")
	public Result<AuthToken> login(@RequestParam Long userId,
	                               @RequestParam String username) {
		log.info("收到登录请求: userId={}, username={}", userId, username);
		AuthToken authToken = authService.login(userId, username);
		return Result.ok(authToken);
	}

	/**
	 * 刷新令牌接口
	 */
	@PostMapping("/refresh")
	public Result<AuthToken> refresh(@RequestParam String refreshToken) {
		log.info("收到刷新令牌请求");
		try {
			AuthToken authToken = authService.refresh(refreshToken);
			return Result.ok(authToken);
		} catch (Exception e) {
			log.error("刷新令牌失败", e);
			return Result.fail(401, e.getMessage());
		}
	}

	/**
	 * 单设备注销接口
	 */
	@PostMapping("/logout")
	public Result<Void> logout(@RequestHeader("Authorization") String authHeader,
	                           @RequestParam String refreshToken) {
		log.info("收到注销请求");
		try {
			String accessToken = extractToken(authHeader);
			authService.logout(accessToken, refreshToken);
			return Result.ok();
		} catch (Exception e) {
			log.error("注销失败", e);
			return Result.fail(500, "注销失败：" + e.getMessage());
		}
	}

	/**
	 * 全设备注销接口（需要管理员权限或用户本人）
	 */
	@PostMapping("/logout/all")
	public Result<Void> logoutAll(@RequestHeader("Authorization") String authHeader) {
		log.info("收到全设备注销请求");
		try {
			String accessToken = extractToken(authHeader);
			Long userId = authService.getUserIdFromToken(accessToken);
			authService.logoutAll(userId);
			return Result.ok();
		} catch (Exception e) {
			log.error("全设备注销失败", e);
			return Result.fail(500, "全设备注销失败：" + e.getMessage());
		}
	}

	/**
	 * 验证令牌接口（集成黑名单检查）
	 */
	@GetMapping("/validate")
	public Result<Map<String, Object>> validate(@RequestHeader("Authorization") String authHeader) {
		log.info("收到验证令牌请求");
		try {
			String token = extractToken(authHeader);
			Claims claims = authService.validateToken(token);

			Map<String, Object> data = new HashMap<>();
			data.put("valid", true);
			data.put("userId", claims.getSubject());
			data.put("username", claims.get("username"));

			return Result.ok(data);
		} catch (Exception e) {
			log.debug("Token 验证失败: {}", e.getMessage());
			Map<String, Object> data = new HashMap<>();
			data.put("valid", false);
			data.put("reason", e.getMessage());
			return Result.ok(data);
		}
	}

	/**
	 * 从 Authorization Header 中提取 Token
	 */
	private String extractToken(String authHeader) {
		if (authHeader != null && authHeader.startsWith("Bearer ")) {
			return authHeader.substring(7);
		}
		return authHeader;
	}
}