java实现认证与授权的jwt与token+redis，哪种方案更好用？

header.payload.signature

import io.jsonwebtoken.*;
import io.jsonwebtoken.security.Keys;
import java.security.Key;
import java.util.Date;

public class JwtUtil {
    // 密钥，实际项目中应从配置中读取
    private static final Key key = Keys.secretKeyFor(SignatureAlgorithm.HS256);
    
    // 过期时间：2小时
    private static final long EXPIRATION_TIME = 2 * 60 * 60 * 1000;
    
    /**
     * 生成JWT
     */
    public static String generateToken(String userId, String username, List<String> roles) {
        return Jwts.builder()
                .setSubject(userId)
                .claim("username", username)
                .claim("roles", roles)
                .setIssuedAt(new Date())
                .setExpiration(new Date(System.currentTimeMillis() + EXPIRATION_TIME))
                .signWith(key)
                .compact();
    }
    
    /**
     * 验证并解析JWT
     */
    public static Claims parseToken(String token) {
        try {
            return Jwts.parserBuilder()
                    .setSigningKey(key)
                    .build()
                    .parseClaimsJws(token)
                    .getBody();
        } catch (ExpiredJwtException e) {
            thrownew RuntimeException("Token已过期", e);
        } catch (JwtException e) {
            thrownew RuntimeException("Token无效", e);
        }
    }
    
    /**
     * 刷新Token
     */
    public static String refreshToken(String token) {
        Claims claims = parseToken(token);
        return generateToken(claims.getSubject(), 
                           claims.get("username", String.class), 
                           claims.get("roles", List.class));
    }
}

import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import java.util.UUID;
import java.util.concurrent.TimeUnit;

@Component
public class RedisSessionManager {
    
    private final RedisTemplate<String, Object> redisTemplate;
    
    // 会话过期时间：2小时
    private static final long SESSION_EXPIRE_TIME = 2 * 60 * 60;
    
    public RedisSessionManager(RedisTemplate<String, Object> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }
    
    /**
     * 创建会话
     */
    public String createSession(User user) {
        String token = generateToken();
        SessionInfo sessionInfo = new SessionInfo(user.getId(), user.getUsername(), user.getRoles());
        
        redisTemplate.opsForValue().set(
            getRedisKey(token), 
            sessionInfo, 
            SESSION_EXPIRE_TIME, 
            TimeUnit.SECONDS
        );
        
        return token;
    }
    
    /**
     * 获取会话信息
     */
    public SessionInfo getSession(String token) {
        return (SessionInfo) redisTemplate.opsForValue().get(getRedisKey(token));
    }
    
    /**
     * 删除会话
     */
    public void deleteSession(String token) {
        redisTemplate.delete(getRedisKey(token));
    }
    
    /**
     * 刷新会话有效期
     */
    public void refreshSession(String token) {
        redisTemplate.expire(getRedisKey(token), SESSION_EXPIRE_TIME, TimeUnit.SECONDS);
    }
    
    /**
     * 生成随机token
     */
    private String generateToken() {
        return UUID.randomUUID().toString().replace("-", "");
    }
    
    /**
     * 获取Redis key
     */
    private String getRedisKey(String token) {
        return "session:" + token;
    }
    
    /**
     * 会话信息类
     */
    @Data
    @AllArgsConstructor
    public static class SessionInfo {
        private String userId;
        private String username;
        private List<String> roles;
        private long createTime;
        
        public SessionInfo(String userId, String username, List<String> roles) {
            this.userId = userId;
            this.username = username;
            this.roles = roles;
            this.createTime = System.currentTimeMillis();
        }
    }
}

public class HybridAuthManager {
    
    private final JwtUtil jwtUtil;
    private final RedisTemplate<String, Object> redisTemplate;
    
    // JWT短期有效期：15分钟
    private static final long SHORT_EXPIRATION = 15 * 60 * 1000;
    // 刷新令牌有效期：7天
    private static final long REFRESH_EXPIRATION = 7 * 24 * 60 * 60 * 1000;
    
    /**
     * 生成访问令牌和刷新令牌
     */
    public AuthResponse generateTokenPair(User user) {
        // 生成短期访问令牌
        String accessToken = jwtUtil.generateToken(
            user.getId(), user.getUsername(), user.getRoles(), SHORT_EXPIRATION);
        
        // 生成长期刷新令牌
        String refreshToken = UUID.randomUUID().toString();
        
        // 存储刷新令牌到Redis
        storeRefreshToken(refreshToken, user.getId());
        
        returnnew AuthResponse(accessToken, refreshToken);
    }
    
    /**
     * 刷新访问令牌
     */
    public String refreshAccessToken(String refreshToken) {
        // 验证刷新令牌有效性
        String userId = validateRefreshToken(refreshToken);
        if (userId == null) {
            thrownew RuntimeException("刷新令牌无效");
        }
        
        // 获取用户信息
        User user = userService.getUserById(userId);
        
        // 生成新的访问令牌
        return jwtUtil.generateToken(
            user.getId(), user.getUsername(), user.getRoles(), SHORT_EXPIRATION);
    }
    
    /**
     * 注销令牌
     */
    public void logout(String accessToken, String refreshToken) {
        // 将访问令牌加入黑名单（剩余有效期内）
        Claims claims = jwtUtil.parseToken(accessToken);
        long expiration = claims.getExpiration().getTime() - System.currentTimeMillis();
        if (expiration > 0) {
            redisTemplate.opsForValue().set(
                "blacklist:" + accessToken, 
                "logout", 
                expiration, 
                TimeUnit.MILLISECONDS
            );
        }
        
        // 删除刷新令牌
        if (refreshToken != null) {
            redisTemplate.delete("refresh_token:" + refreshToken);
        }
    }
    
    /**
     * 验证令牌是否在黑名单中
     */
    public boolean isTokenBlacklisted(String token) {
        return redisTemplate.hasKey("blacklist:" + token);
    }
}