feat: 登出接口

src/main/java/com/webgame/webgamebackend/common/dto/account/LogoutRequest.java

@@ -0,0 +1,15 @@
+package com.webgame.webgamebackend.common.dto.account;
+
+import com.webgame.webgamebackend.common.dto.base.BaseVo;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
+
+/**
+ * 登出请求
+ */
+public record LogoutRequest(
+        @NotNull(message = "刷新令牌不能为null")
+        @NotBlank(message = "刷新令牌不能为空")
+        String refreshToken
+) implements BaseVo {
+}

src/main/java/com/webgame/webgamebackend/common/utils/RedisCacheUtil.java

@@ -1,294 +0,0 @@
-package com.webgame.webgamebackend.common.utils;
-
-import com.alibaba.fastjson2.JSON;
-import lombok.RequiredArgsConstructor;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.cache.annotation.Cacheable;
-import org.springframework.data.redis.core.RedisTemplate;
-import org.springframework.stereotype.Component;
-
-import java.util.concurrent.TimeUnit;
-
-/**
- * Redis缓存工具类
- */
-@Slf4j
-@Component
-@RequiredArgsConstructor
-public class RedisCacheUtil {
-    /**
-     * Redis缓存前缀
-     */
-    private final static String CACHE_KEY_PREFIX = "xzg:";
-
-    /**
-     * Redis操作类
-     */
-    private final RedisTemplate redisTemplate;
-
-    /**
-     * 将值加入缓存
-     *
-     * @param k 键
-     * @param v 值
-     *
-     * @return 是否成功
-     */
-    public Boolean cacheValue(String k, Object v) {
-        return cacheValue(k.startsWith(":") ? k.substring(1) : k, v, -1);
-    }
-
-    /**
-     * 将值加入缓存，并添加过期时间。
-     *
-     * @param k          键
-     * @param v          值
-     * @param expireTime 过期时间（毫秒）
-     *
-     * @return 是否成功
-     */
-    public Boolean cacheValue(String k, Object v, long expireTime) {
-        return cacheValue(k.startsWith(":") ? k.substring(1) : k, v, expireTime, TimeUnit.MILLISECONDS);
-    }
-
-    /**
-     * 将值加入缓存，并添加过期时间。
-     *
-     * @param k          键
-     * @param v          值
-     * @param expireTime 过期时间
-     * @param expireUnit 过期时间单位
-     *
-     * @return 是否成功
-     */
-    public Boolean cacheValue(String k, Object v, long expireTime, TimeUnit expireUnit) {
-        if (k.startsWith(":")) k = k.substring(1);
-        var key = CACHE_KEY_PREFIX + k;
-
-        var json = "";
-        try {
-            json = JSON.toJSONString(v);
-        } catch (Exception e) {
-            log.error("写入缓存失败, 键: {}, 原因: {}", key, e.getMessage(), e);
-            return false;
-        }
-
-        try {
-            var valueOps = redisTemplate.opsForValue();
-            valueOps.set(key, json);
-
-            if (expireTime > 0) redisTemplate.expire(key, expireTime, expireUnit);
-
-            return true;
-        } catch (Exception e) {
-            log.error("写入缓存失败, 键: {}, 值: {}, 原因: {}", key, json, e.getMessage(), e);
-        }
-        return false;
-    }
-
-    /**
-     * 将值加入缓存，并添加过期时间
-     *
-     * @param prefix     键组前缀
-     * @param k          键
-     * @param v          值
-     * @param expireTime 过期时间（毫秒）
-     *
-     * @return 是否成功
-     */
-    public Boolean cacheValue(String prefix, String k, Object v, long expireTime) {
-        if (!prefix.endsWith(":")) prefix = prefix + ":";
-        if (k.startsWith(":")) k = k.substring(1);
-        return cacheValue(prefix + k, v, expireTime);
-    }
-
-    /**
-     * 将值加入缓存，并添加过期时间。
-     *
-     * @param prefix     键组前缀
-     * @param k          键
-     * @param v          值
-     * @param expireTime 过期时间（毫秒）
-     *
-     * @return 是否成功
-     */
-    public Boolean cacheValue(String prefix, Long k, Object v, long expireTime) {
-        if (prefix.startsWith(":")) prefix = prefix.substring(1);
-        if (!prefix.endsWith(":")) prefix = prefix + ":";
-        return cacheValue(prefix + k, v, expireTime);
-    }
-
-    /**
-     * 查询缓存
-     *
-     * @param k          键
-     * @param cls        序列化类型
-     * @param expireTime 查询后更新过期时间（毫秒）
-     * @param <T>        序列化类型
-     *
-     * @return 查询结果
-     */
-    public <T> T getCache(String k, Class<T> cls, long expireTime) {
-        return getCache(k.startsWith(":") ? k.substring(1) : k, cls, expireTime, TimeUnit.MILLISECONDS);
-    }
-
-    /**
-     * 查询缓存
-     *
-     * @param k          键
-     * @param cls        序列化类型
-     * @param expireTime 查询后更新过期时间
-     * @param expireUnit 时间单位
-     * @param <T>        序列化类型
-     *
-     * @return 查询结果
-     */
-    public <T> T getCache(String k, Class<T> cls, long expireTime, TimeUnit expireUnit) {
-        if (k.startsWith(":")) k = k.substring(1);
-        var key = CACHE_KEY_PREFIX + k;
-        try {
-            // 由于 ValueOperations 的 getAndExpire 查询命令 GETEX
-            // 在 Redis 6.2 以下版本不支持, 由于可能服务器环境使用 WindowsServer系统，
-            // 安装的Redis版本小于6.2版本，所以这里使用 get + expire。
-            var valueOps = redisTemplate.opsForValue();
-
-            // 查询缓存
-            var json = valueOps.get(key);
-            if (json == null) return null;
-
-            // 更新过期时间
-            redisTemplate.expire(key, expireTime, expireUnit);
-
-            // 返回结果
-            return JSON.to(cls, json);
-        } catch (Exception e) {
-            log.error("查询缓存失败, 键: {}", key, e);
-        }
-        return null;
-    }
-
-    /**
-     * 查询缓存
-     *
-     * @param prefix     键组前缀
-     * @param k          键
-     * @param cls        序列化类型
-     * @param expireTime 查询后更新过期时间（毫秒）
-     * @param <T>        序列化类型
-     *
-     * @return 查询结果
-     */
-    public <T> T getCache(String prefix, String k, Class<T> cls, long expireTime) {
-        if (prefix.startsWith(":")) prefix = prefix.substring(1);
-        if (!prefix.endsWith(":")) prefix = prefix + ":";
-        if (k.startsWith(":")) k = k.substring(1);
-        return getCache(prefix + k, cls, expireTime, TimeUnit.MILLISECONDS);
-    }
-
-    /**
-     * 查询缓存
-     *
-     * @param prefix     键组前缀
-     * @param k          键
-     * @param cls        序列化类型
-     * @param expireTime 查询后更新过期时间（毫秒）
-     * @param <T>        序列化类型
-     *
-     * @return 查询结果
-     */
-    public <T> T getCache(String prefix, Long k, Class<T> cls, long expireTime) {
-        if (prefix.startsWith(":")) prefix = prefix.substring(1);
-        if (!prefix.endsWith(":")) prefix = prefix + ":";
-        return getCache(prefix + k, cls, expireTime, TimeUnit.MILLISECONDS);
-    }
-
-    /**
-     * 查询缓存
-     *
-     * @param k   键
-     * @param cls 序列化类型
-     * @param <T> 序列化类型
-     *
-     * @return 查询结果
-     */
-    public <T> T getCache(String k, Class<T> cls) {
-        return getCache(k.startsWith(":") ? k.substring(1) : k, cls, false);
-    }
-
-    /**
-     * 查询缓存
-     *
-     * @param k      键
-     * @param cls    序列化类型
-     * @param remove 查询后是否移除
-     * @param <T>    序列化类型
-     *
-     * @return 查询结果
-     */
-    public <T> T getCache(String k, Class<T> cls, Boolean remove) {
-        if (k.startsWith(":")) k = k.substring(1);
-        var key = CACHE_KEY_PREFIX + k;
-        try {
-            var valueOps = redisTemplate.opsForValue();
-            var json     = remove ? valueOps.getAndDelete(key) : valueOps.get(key);
-            if (json == null) return null;
-
-            return JSON.to(cls, json);
-        } catch (Exception e) {
-            log.error("查询缓存失败, 键: {}", key, e);
-        }
-        return null;
-    }
-
-    /**
-     * 移除缓存
-     *
-     * @param prefix 键组前缀
-     * @param k      键
-     *
-     * @return 是否成功
-     */
-    public Boolean removeCache(String prefix, Long k) {
-        if (prefix.startsWith(":")) prefix = prefix.substring(1);
-        if (!prefix.endsWith(":")) prefix = prefix + ":";
-        return removeCache(prefix + k);
-    }
-
-    /**
-     * 移除缓存
-     *
-     * @param k 键
-     *
-     * @return 是否成功
-     */
-    public Boolean removeCache(String k) {
-        if (k.startsWith(":")) k = k.substring(1);
-        var key = CACHE_KEY_PREFIX + k;
-        try {
-            if (key.endsWith(":*")) {
-                var keys = redisTemplate.keys(key);
-                if (!keys.isEmpty())
-                    redisTemplate.delete(keys);
-                return true;
-            } else return redisTemplate.delete(key);
-        } catch (Exception e) {
-            log.error("移除缓存失败, 键: {}", key, e);
-        }
-        return false;
-    }
-
-    /**
-     * 移除缓存
-     *
-     * @param prefix 键组前缀
-     * @param k      键
-     *
-     * @return 是否成功
-     */
-    public Boolean removeCache(String prefix, String k) {
-        if (prefix.startsWith(":")) prefix = prefix.substring(1);
-        if (!prefix.endsWith(":")) prefix = prefix + ":";
-        if (k.startsWith(":")) k = k.substring(1);
-        return removeCache(prefix + k);
-    }
-}

src/main/java/com/webgame/webgamebackend/common/utils/RedisMqUtil.java

@@ -1,90 +0,0 @@
-package com.webgame.webgamebackend.common.utils;
-
-import com.alibaba.fastjson2.JSON;
-import io.micrometer.common.util.StringUtils;
-import lombok.RequiredArgsConstructor;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.data.redis.connection.MessageListener;
-import org.springframework.data.redis.core.RedisTemplate;
-import org.springframework.data.redis.listener.PatternTopic;
-import org.springframework.data.redis.listener.RedisMessageListenerContainer;
-import org.springframework.data.redis.listener.adapter.MessageListenerAdapter;
-import org.springframework.stereotype.Component;
-
-import java.util.function.Consumer;
-
-/**
- * Redis消息队列工具类
- * @author xzg
- */
-@Slf4j
-@Component
-@RequiredArgsConstructor
-public class RedisMqUtil {
-    private final RedisTemplate<String, String> redisTemplate;
-    private final RedisMessageListenerContainer redisMessageListenerContainer;
-
-    public void pub(String channel, Object message) {
-        try {
-            if (StringUtils.isBlank(channel)) {
-                log.warn("[REDIS消息队列] 发布信息失败: 通道名称为 null");
-                return;
-            }
-            if (message == null) {
-                log.warn("[REDIS消息队列] 发布信息至通道({})失败: 信息体为 null", channel);
-                return;
-            }
-
-            // 信息体转JSON
-            var json = "";
-            try {
-                json = JSON.toJSONString(message);
-            } catch (Exception e) {
-                log.warn("[REDIS消息队列] 发布信息至通道({})异常: 信息实体无法正确的序列化为JSON字符串, {}", channel, e.getMessage(), e);
-                return;
-            }
-
-            redisTemplate.convertAndSend(channel, json);
-        } catch (Exception e) {
-            log.warn("[REDIS消息队列] 发布信息至通道({})异常: {}", channel, e.getMessage(), e);
-        }
-    }
-
-    public <T> void sub(String channel, Class<T> clazz, Consumer<T> callback) {
-        if (StringUtils.isBlank(channel)) {
-            log.warn("[REDIS消息队列] 订阅通道失败, 通道名称不可为空");
-            return;
-        }
-        if (callback == null) {
-            log.warn("[REDIS消息队列] 订阅通道({})失败, 回调方法不可为空", channel);
-            return;
-        }
-
-        try {
-            var adapter = new MessageListenerAdapter((MessageListener) (message, pattern) -> {
-                var body        = message.getBody();
-                var channelName = new String(message.getChannel());
-
-                T dto;
-                try {
-                    dto = JSON.parseObject(new String(body), clazz);
-                } catch (Exception e) {
-                    log.error("[REDIS消息队列] 消费通道({})信息实体类型转换处理异常: {}, 信息: {}", channelName, e.getMessage(), body, e);
-                    return;
-                }
-                try {
-                    callback.accept(dto);
-                } catch (Exception e) {
-                    log.error("[REDIS消息队列] 消费通道({})信息回调处理异常: {}, 信息: {}", channelName, e.getMessage(), body, e);
-                }
-            });
-
-            redisMessageListenerContainer.addMessageListener(adapter, new PatternTopic(channel));
-        } catch (Exception e) {
-            log.error("[REDIS消息队列] 订阅通道({})异常: {}", channel, e.getMessage(), e);
-            return;
-        }
-
-        log.info("[REDIS消息队列] 订阅通道({})成功", channel);
-    }
-}

src/main/java/com/webgame/webgamebackend/controller/AccountController.java

@@ -4,6 +4,7 @@ import cn.dev33.satoken.annotation.SaIgnore;
 import com.webgame.webgamebackend.common.dto.ApiResponse;
 import com.webgame.webgamebackend.common.dto.account.LoginRequest;
 import com.webgame.webgamebackend.common.dto.account.LoginResponse;
+import com.webgame.webgamebackend.common.dto.account.LogoutRequest;
 import com.webgame.webgamebackend.common.dto.account.RefreshTokenRequest;
 import com.webgame.webgamebackend.common.dto.account.RegisterRequest;
 import com.webgame.webgamebackend.service.AccountService;
@@ -55,4 +56,13 @@ public class AccountController {
         LoginResponse result = accountService.refresh(request.refreshToken());
         return ApiResponse.ok(result);
     }
+
+    /**
+     * 登出，使 access token 和 refresh token 失效
+     */
+    @PostMapping("/logout")
+    public ApiResponse<Void> logout(@Valid @RequestBody LogoutRequest request) {
+        accountService.logout(request.refreshToken());
+        return ApiResponse.ok(null);
+    }
 }

src/main/java/com/webgame/webgamebackend/service/AccountService.java

@@ -32,4 +32,11 @@ public interface AccountService {
      * @return 新的双 token（accessToken + refreshToken）
      */
     LoginResponse refresh(String refreshToken);
+
+    /**
+     * 登出，使 access token 和 refresh token 失效
+     *
+     * @param refreshToken 刷新令牌
+     */
+    void logout(String refreshToken);
 }

src/main/java/com/webgame/webgamebackend/service/impl/AccountServiceImpl.java

@@ -89,6 +89,17 @@ public class AccountServiceImpl implements AccountService {
         return new LoginResponse(accessToken, refreshToken);
     }
 
+    @Override
+    public void logout(String refreshToken) {
+        // 获取当前登录用户ID（用于日志）
+        String loginId = (String) StpUtil.getLoginId();
+        // 登出 Sa-Token，使 access token 失效
+        StpUtil.logout();
+        // 撤销 refresh token，使其在 Redis 中删除
+        refreshTokenService.revoke(refreshToken);
+        log.info("用户已登出: userId={}", loginId);
+    }
+
     /**
      * 生成6位随机数字，用于默认昵称
      */

src/main/java/com/webgame/webgamebackend/service/impl/RefreshTokenServiceImpl.java

@@ -2,14 +2,14 @@ package com.webgame.webgamebackend.service.impl;
 
 import com.webgame.webgamebackend.common.exception.BusinessException;
 import com.webgame.webgamebackend.common.exception.ErrorCode;
-import com.webgame.webgamebackend.common.utils.RedisCacheUtil;
 import com.webgame.webgamebackend.service.RefreshTokenService;
-import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
+import org.springframework.data.redis.core.StringRedisTemplate;
 import org.springframework.stereotype.Service;
 
 import java.security.SecureRandom;
 import java.util.HexFormat;
+import java.util.concurrent.TimeUnit;
 
 /**
  * 刷新令牌服务实现，基于 Redis 存储
@@ -21,43 +21,47 @@ import java.util.HexFormat;
  * </ul>
  * <p>TTL: 30 天，由 Redis 自动过期</p>
  * <p>一个用户同一时间只保留一个有效的 refresh token，新登录会使旧 token 失效</p>
+ * <p>直接使用 StringRedisTemplate 存储纯字符串，避免 JSON 序列化导致的引号问题</p>
  */
 @Slf4j
 @Service
-@RequiredArgsConstructor
 public class RefreshTokenServiceImpl implements RefreshTokenService {
 
     /** Redis key 前缀 */
-    private static final String PREFIX = "refresh";
+    private static final String KEY_PREFIX = "xzg:refresh:";
 
     /** 用户→token 反向映射 key 前缀 */
-    private static final String USER_PREFIX = "refresh:user";
+    private static final String USER_KEY_PREFIX = "xzg:refresh:user:";
 
-    /** 刷新令牌有效期：30 天（毫秒） */
-    private static final long EXPIRE_MS = 2_592_000_000L;
+    /** 刷新令牌有效期：30 天 */
+    private static final long EXPIRE_DAYS = 30;
 
     /** 安全随机数生成器 */
     private static final SecureRandom RANDOM = new SecureRandom();
 
-    private final RedisCacheUtil redisCacheUtil;
+    private final StringRedisTemplate stringRedisTemplate;
+
+    public RefreshTokenServiceImpl(StringRedisTemplate stringRedisTemplate) {
+        this.stringRedisTemplate = stringRedisTemplate;
+    }
 
     @Override
     public String create(String userId) {
+        if (userId == null || userId.isBlank()) {
+            throw new BusinessException(ErrorCode.BAD_REQUEST, "用户ID不能为空");
+        }
         // 先清除该用户之前的 refresh token，确保一个用户只有一个有效 token
-        String oldToken = redisCacheUtil.getCache(USER_PREFIX, userId, String.class, EXPIRE_MS);
+        String oldToken = get(USER_KEY_PREFIX + userId);
         if (oldToken != null) {
-            redisCacheUtil.removeCache(PREFIX, oldToken);
+            delete(KEY_PREFIX + oldToken);
             log.debug("已清除旧的刷新令牌: userId={}", userId);
         }
         // 创建新 token
         String token = generateToken();
-        boolean ok = redisCacheUtil.cacheValue(PREFIX, token, userId, EXPIRE_MS);
-        if (!ok) {
-            log.error("刷新令牌写入 Redis 失败: userId={}", userId);
-            throw new BusinessException(ErrorCode.INTERNAL_ERROR, "刷新令牌生成失败");
-        }
+        log.debug("刷新令牌已生成: token={}", token);
+        set(KEY_PREFIX + token, userId);
         // 维护反向映射
-        redisCacheUtil.cacheValue(USER_PREFIX, userId, token, EXPIRE_MS);
+        set(USER_KEY_PREFIX + userId, token);
         log.debug("刷新令牌已创建: userId={}", userId);
         return token;
     }
@@ -67,7 +71,7 @@ public class RefreshTokenServiceImpl implements RefreshTokenService {
         if (token == null || token.isBlank()) {
             throw new BusinessException(ErrorCode.REFRESH_TOKEN_MISSING);
         }
-        String userId = redisCacheUtil.getCache(PREFIX, token, String.class, EXPIRE_MS);
+        String userId = get(KEY_PREFIX + token);
         if (userId == null) {
             throw new BusinessException(ErrorCode.REFRESH_TOKEN_INVALID);
         }
@@ -77,21 +81,75 @@ public class RefreshTokenServiceImpl implements RefreshTokenService {
     @Override
     public String rotate(String oldToken) {
         String userId = validate(oldToken);
-        redisCacheUtil.removeCache(PREFIX, oldToken);
-        redisCacheUtil.removeCache(USER_PREFIX, userId);
+        // 先删反向映射，再删正向映射：
+        // 若反向映射删除失败，正向映射仍存在，调用方可重试；
+        // 若反向已删除而正向删除失败，正向映射仍存在，重试仍可通过。
+        delete(USER_KEY_PREFIX + userId);
+        delete(KEY_PREFIX + oldToken);
         log.debug("旧刷新令牌已删除: userId={}", userId);
         return create(userId);
     }
 
     @Override
     public void revoke(String token) {
-        if (token != null && !token.isBlank()) {
-            String userId = redisCacheUtil.getCache(PREFIX, token, String.class, EXPIRE_MS);
+        if (token == null || token.isBlank()) {
+            return;
+        }
+        try {
+            String userId = get(KEY_PREFIX + token);
             if (userId != null) {
-                redisCacheUtil.removeCache(USER_PREFIX, userId);
+                delete(USER_KEY_PREFIX + userId);
             }
-            redisCacheUtil.removeCache(PREFIX, token);
+            delete(KEY_PREFIX + token);
             log.debug("刷新令牌已撤销");
+        } catch (BusinessException e) {
+            // 登出时 Redis 不可用，记录日志后放行，不影响用户登出
+            log.warn("撤销刷新令牌失败（Redis 不可用），跳过清理: token={}", token, e);
+        }
+    }
+
+    /**
+     * 写入字符串到 Redis（带过期时间）
+     */
+    private void set(String key, String value) {
+        try {
+            stringRedisTemplate.opsForValue().set(key, value, EXPIRE_DAYS, TimeUnit.DAYS);
+        } catch (Exception e) {
+            log.error("刷新令牌写入 Redis 失败: key={}", key, e);
+            throw new BusinessException(ErrorCode.INTERNAL_ERROR, "刷新令牌操作失败");
+        }
+    }
+
+    /**
+     * 从 Redis 读取字符串（读取时续期）
+     *
+     * @return 值，key 不存在时返回 null
+     * @throws BusinessException Redis 操作失败时抛出
+     */
+    private String get(String key) {
+        try {
+            String value = stringRedisTemplate.opsForValue().get(key);
+            if (value != null) {
+                stringRedisTemplate.expire(key, EXPIRE_DAYS, TimeUnit.DAYS);
+            }
+            return value;
+        } catch (Exception e) {
+            log.error("查询缓存失败: key={}", key, e);
+            throw new BusinessException(ErrorCode.INTERNAL_ERROR, "刷新令牌操作失败");
+        }
+    }
+
+    /**
+     * 从 Redis 删除 key
+     *
+     * @throws BusinessException Redis 操作失败时抛出
+     */
+    private void delete(String key) {
+        try {
+            stringRedisTemplate.delete(key);
+        } catch (Exception e) {
+            log.error("删除缓存失败: key={}", key, e);
+            throw new BusinessException(ErrorCode.INTERNAL_ERROR, "刷新令牌操作失败");
         }
     }
 

src/main/java/com/webgame/webgamebackend/service/impl/UserServiceImpl.java

@@ -24,6 +24,7 @@ public class UserServiceImpl implements UserService {
     @Override
     public UserInfoResponse getCurrentUserInfo() {
         String accountId = StpUtil.getLoginIdAsString();
+        log.info("[用户服务] 获取当前登录用户信息, accountId: {}", accountId);
         UserEntity user = userRepository.findByAccountId(accountId)
                 .orElseThrow(() -> new BusinessException(ErrorCode.USER_NOT_FOUND));
         return UserInfoResponse.from(user);