public static String createToken(Map<String, Object> claims, String secret) {
    SecretKey key = Keys.hmacShaKeyFor(secret.getBytes(java.nio.charset.StandardCharsets.UTF_8));
    return Jwts.builder().setClaims(claims).signWith(key, SignatureAlgorithm.HS512).compact();
}

public static Claims parseToken(String token, String secret) {
    SecretKey key = Keys.hmacShaKeyFor(secret.getBytes(java.nio.charset.StandardCharsets.UTF_8));
    return Jwts.parser().setSigningKey(key).parseClaimsJws(token).getBody();
}

public static String getToken(HttpServletRequest request) {
    String token = request.getHeader(SecurityConstants.AUTHENTICATION);
    return replaceTokenPrefix(token);
}

public static String replaceTokenPrefix(String token) {
    // 假如前端设置了令牌的前缀，需要替换裁剪
    if (StringUtil.isNotEmpty(token) && token.startsWith(TokenConstants.PREFIX)) {
        // 把前缀换成空串
        token = token.replaceFirst(TokenConstants.PREFIX, "");
    }
    return token;
}

private final static long MILLIS_SECOND = 1000;
private final static long MILLIS_MINUTE = 60 * MILLIS_SECOND;
// 续期阈值：120 分钟（CacheConstants.REFRESH_TIME * MILLIS_MINUTE）
private final static Long MILLIS_MINUTE_TEN = CacheConstants.REFRESH_TIME * MILLIS_MINUTE;
// 过期时间：720 分钟（CacheConstants.EXPIRATION）
private final static Long EXPIRE_TIME = CacheConstants.EXPIRATION;
// Redis Key 前缀（TokenConstants.LOGIN_TOKEN_KEY）
private final static String ACCESS_TOKEN = TokenConstants.LOGIN_TOKEN_KEY;

public TokenDTO createToken(LoginUserDTO loginUserDTO, String secret) {
    // 给用户创建一个 uuid 作为唯一标识
    String token = UUID.randomUUID().toString();
    loginUserDTO.setToken(token); // 设置用户的唯一标识
    // 设置到缓存中
    refreshToken(loginUserDTO);
    // 生成原始数据的声明
    Map<String, Object> claimsMap = new HashMap<>();
    claimsMap.put(SecurityConstants.USER_KEY, token);
    claimsMap.put(SecurityConstants.USER_ID, loginUserDTO.getUserId());
    claimsMap.put(SecurityConstants.USERNAME, loginUserDTO.getUserName());
    claimsMap.put(SecurityConstants.USER_FROM, loginUserDTO.getUserFrom());
    // 创建令牌返回
    TokenDTO tokenDTO = new TokenDTO();
    tokenDTO.setAccessToken(JwtUtil.createToken(claimsMap, secret));
    tokenDTO.setExpires(EXPIRE_TIME);
    return tokenDTO;
}

private void refreshToken(LoginUserDTO loginUserDTO) {
    loginUserDTO.setLoginTime(System.currentTimeMillis());
    // 表示设置用户的过期时间是，用户当前登陆的时间加上 720 * 1 分钟的时间，就是 720 分钟
    loginUserDTO.setExpireTime(loginUserDTO.getLoginTime() + EXPIRE_TIME * MILLIS_MINUTE);
    // 根据随机产生用户标识生成 redis 的 key
    String userKey = getTokenKey(loginUserDTO.getToken());
    // 生成 loginUserDTO 缓存, 720 单位分钟
    redisService.setCacheObject(userKey, loginUserDTO, EXPIRE_TIME, TimeUnit.MINUTES);
}

public void verifyToken(LoginUserDTO loginUserDTO) {
    // 原先设定好的过期的时间
    long expireTime = loginUserDTO.getExpireTime();
    // 现在的时间
    long currentTime = System.currentTimeMillis();
    // 如果说设定好的时间减去现在的时间在 120 分钟之内的话就续期
    if (expireTime - currentTime <= MILLIS_MINUTE_TEN) {
        // 刷新缓存
        refreshToken(loginUserDTO);
    }
}

// 1. 直接传入 JWT
public LoginUserDTO getLoginUser(String token, String secret)

// 2. 传入 HttpServletRequest，内部调用 SecurityUtil.getToken(request)
public LoginUserDTO getLoginUser(HttpServletRequest request, String secret)

// 3. 便捷方法，从当前线程请求中获取
public LoginUserDTO getLoginUser(String secret)

// 1. 根据 JWT 删除（用户主动登出）
public void delLoginUser(String token, String secret)

// 2. 根据 userId + userFrom 删除（管理员强制下线）
public void delLoginUser(Long userId, String userFrom)

public void setLoginUser(LoginUserDTO loginUserDTO) {
    if (loginUserDTO != null && StringUtil.isNotEmpty(loginUserDTO.getToken())) {
        refreshToken(loginUserDTO);
    }
}

// 再判断用户来源是否合法
String userFrom = JwtUtil.getUserFrom(claims);
if (
        url.contains(HttpConstants.SYS_USER_PATH) && // 如果路径是系统路径
        !UserConstants.USER_FROM_TU_B.equals(userFrom) // 但是用户不是系统来源的话
                                                              // （相当于 C端用户在 C端拿到的 jwt 想在 B端使用）
) {
    return unauthorizedResponse(exchange, ResultCode.TOKEN_CHECK_FAILED);
}

private void setResponseCode(HttpServletResponse response, Integer errCode) {
    // 把前面三个拿出来返回给前端，设置 http 响应码
    int httpCode = Integer.parseInt(String.valueOf(errCode).substring(0, 3));
    response.setStatus(httpCode);
}

private String joinMessage(MethodArgumentNotValidException e) {
    // 先获取所有异常信息的列表
    List<ObjectError> allErrors = e.getAllErrors();
    if (CollectionUtils.isEmpty(allErrors)) {
        return CommonConstants.EMPTY_STR;
    }
    // 流处理获取异常信息
    return allErrors
            .stream() // 获取所有错误信息
            .map(ObjectError::getDefaultMessage) // 获取所有错误信息
            .collect(Collectors.joining(CommonConstants.DEFAULT_DELIMITER)); // 转换成字符串, 用分号隔开
}

// 1. 通过 ResultCode 构造（推荐）
throw new ServiceException(ResultCode.INVALID_PARA);

// 2. 仅消息构造（错误码默认取 ResultCode.ERROR = 500000）
throw new ServiceException("用户不存在");

// 3. 消息 + 错误码定制
throw new ServiceException("用户不存在", ResultCode.INVALID_PARA.getCode());

@Value("${jwt.token.secret}")
private String secret;

@Service
public class SysUserServiceImpl implements SysUserService {

    @Autowired
    private TokenService tokenService;

    @Value("${jwt.token.secret}")
    private String secret;

    @Override
    public TokenDTO login(SysUserLoginDTO loginDTO) {
        // 1. 校验用户名密码（略）
        SysUser sysUser = doLogin(loginDTO);

        // 2. 构建登录上下文
        LoginUserDTO loginUserDTO = new LoginUserDTO();
        loginUserDTO.setUserId(sysUser.getId());
        loginUserDTO.setUserName(sysUser.getNickName());
        loginUserDTO.setUserFrom(UserConstants.USER_FROM_TU_B);  // B 端来源

        // 3. 创建 Token，内部已写入 Redis
        return tokenService.createToken(loginUserDTO, secret);
    }
}

@Component
public class AuthInterceptor implements HandlerInterceptor {

    @Autowired
    private TokenService tokenService;

    @Value("${jwt.token.secret}")
    private String secret;

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
        // 1. 从请求头获取 Token（自动去除 Bearer 前缀）
        LoginUserDTO user = tokenService.getLoginUser(request, secret);
        if (user == null) {
            // Token 无效或已过期
            response.setStatus(HttpStatus.UNAUTHORIZED.value());
            return false;
        }
        // 2. 自动续期（剩余时间 <= 120 分钟才会真正续期）
        tokenService.verifyToken(user);
        // 3. 将用户上下文放入 ThreadLocal 供后续使用（略）
        return true;
    }
}

@Service
public class SomeService {

    @Autowired
    private TokenService tokenService;

    @Value("${jwt.token.secret}")
    private String secret;

    public void doSomething() {
        // 便捷方法：内部从当前线程请求中提取 Token
        LoginUserDTO user = tokenService.getLoginUser(secret);
        Long userId = user.getUserId();
        String userFrom = user.getUserFrom();
        // ...
    }
}

@PostMapping("/logout")
public Result<String> logout(HttpServletRequest request) {
    String token = SecurityUtil.getToken(request);
    tokenService.delLoginUser(token, secret);
    return Result.success("登出成功");
}

// 禁用用户后立即让其 Token 失效
if (sysUserDTO.getStatus().equals(UserConstants.USER_DISABLE)) {
    tokenService.delLoginUser(sysUserDTO.getUserId(), UserConstants.USER_FROM_TU_B);
}

// 直接抛出，全局异常处理器会自动转换为标准 Result 响应
if (user == null) {
    throw new ServiceException(ResultCode.INVALID_PARA, "用户不存在");
}

// 1. 白名单放行
if (StringUtil.matches(url, ignoreWhiteProperties.getWhites())) {
    return chain.filter(exchange);
}
// 2. 提取 Token
String token = getToken(request);
if (StringUtil.isEmpty(token)) {
    return unauthorizedResponse(exchange, ResultCode.TOKEN_EMPTY);
}
// 3. 解析 JWT
Claims claims = JwtUtil.parseToken(token, secret);
String userKey = JwtUtil.getUserKey(claims);
// 4. 校验 Redis 中是否仍存在（用于主动失效）
if (!redisService.hasKey(getTokenKey(userKey))) {
    return unauthorizedResponse(exchange, ResultCode.LOGIN_STATUS_OVERTIME);
}
// 5. 校验用户来源
String userFrom = JwtUtil.getUserFrom(claims);
if (url.contains(HttpConstants.SYS_USER_PATH)
        && !UserConstants.USER_FROM_TU_B.equals(userFrom)) {
    return unauthorizedResponse(exchange, ResultCode.TOKEN_CHECK_FAILED);
}
// 6. 透传用户信息到下游
String userId = JwtUtil.getUserId(claims);
String userName = JwtUtil.getUserName(claims);
ServerHttpRequest.Builder mutate = request.mutate();
addHeader(mutate, SecurityConstants.USER_KEY, userKey);
addHeader(mutate, SecurityConstants.USER_ID, userId);
addHeader(mutate, SecurityConstants.USERNAME, userName);
addHeader(mutate, SecurityConstants.USER_FROM, userFrom);
return chain.filter(exchange);