Spring Security中JWT认证为何每次请求都需从DB加载用户详情？

核心疑问拆解 #

你提到的点非常关键：既然JWT已经通过签名验证，理论上用户身份已确认，为什么还要每次请求都调用UserDetailsService.loadUserByUsername查询数据库？这涉及JWT的无状态特性和Spring Security认证模型要求两个核心层面的问题。

为什么多数教程会每次查数据库？ #

教程采用这种实现主要有两个原因：

1. 同步用户实时状态：JWT是无状态令牌，一旦签发就无法主动作废（除非等待过期）。如果用户在token有效期内被禁用、权限被修改，只有通过查询数据库才能获取最新的用户状态和权限，避免用过期的权限信息处理请求。
2. 快速适配Spring Security模型：Spring Security的Authentication对象要求必须持有UserDetails实例，而UserDetails包含用户权限、状态等核心认证信息——教程为了快速适配该模型，直接从数据库加载完整用户信息填充。

能不能跳过数据库查询？ #

可以，但需要满足两个前提：

1. 接受JWT的无状态局限性：用户在token有效期内的状态/权限变更无法实时生效，必须等token过期后重新登录才能更新信息。
2. 将必要用户信息提前嵌入JWT的Claims：比如用户名、权限列表、用户启用状态等，验证token时直接从Claims提取信息，无需查库。

高效实现建议 #

方案1：跳过数据库查询，直接从JWT构建Authentication #

修改JwtService，生成token时将用户权限、状态等信息存入Claims；过滤器中直接从token提取信息构建UserDetails，完全避免数据库查询。

修改后的JwtService：

@Service
public class JwtService {
    private static final int TOKEN_VALIDITY_HOURS = 1;
    private static final int SECONDS_PER_HOUR = 3600;
    private static final int TOKEN_VALIDITY_SECONDS = TOKEN_VALIDITY_HOURS * SECONDS_PER_HOUR;
    private static final String ALGORITHM = "HmacSHA256";

    @Value("${secret.key}")
    private String secretKey;

    public String generateToken(final UserDetails userDetails) {
        // 将权限和启用状态存入Claims
        Map<String, Object> claims = new HashMap<>();
        claims.put("authorities", userDetails.getAuthorities().stream()
                .map(GrantedAuthority::getAuthority)
                .collect(Collectors.toList()));
        claims.put("enabled", userDetails.isEnabled());
        return generateToken(claims, userDetails);
    }

    public String generateToken(final Map<String, ?> claims, final UserDetails userDetails) {
        Instant currentTime = Instant.now();
        Instant expirationTime = currentTime.plusSeconds(TOKEN_VALIDITY_SECONDS);

        return Jwts
                .builder()
                .claims(claims)
                .subject(userDetails.getUsername())
                .issuedAt(Date.from(currentTime))
                .expiration(Date.from(expirationTime))
                .signWith(getSecretKey(), Jwts.SIG.HS256)
                .compact();
    }

    public boolean isTokenValid(final String token) {
        // 仅验证签名和过期时间
        try {
            extractClaim(token, Claims::getSubject);
            return !isTokenExpired(token);
        } catch (JwtException | IllegalArgumentException e) {
            return false;
        }
    }

    private boolean isTokenExpired(final String token) {
        return extractExpiration(token).before(new Date());
    }

    public String extractUsername(final String token) {
        return extractClaim(token, Claims::getSubject);
    }

    public Date extractExpiration(final String token) {
        return extractClaim(token, Claims::getExpiration);
    }

    // 从token提取权限列表
    public List<GrantedAuthority> extractAuthorities(final String token) {
        List<String> authorityStrings = extractClaim(token, claims -> claims.get("authorities", List.class));
        return authorityStrings.stream()
                .map(SimpleGrantedAuthority::new)
                .collect(Collectors.toList());
    }

    // 从token提取用户启用状态
    public boolean extractEnabled(final String token) {
        return extractClaim(token, claims -> claims.get("enabled", Boolean.class));
    }

    private <T> T extractClaim(final String token, final Function<Claims, T> extractor) {
        Claims claims = Jwts.parser()
                .verifyWith(getSecretKey())
                .build()
                .parseSignedClaims(token)
                .getPayload();

        return extractor.apply(claims);
    }

    private SecretKey getSecretKey() {
        byte[] decodedKey = Base64.getDecoder().decode(secretKey);
        return new SecretKeySpec(decodedKey, 0, decodedKey.length, ALGORITHM);
    }
}

修改后的JwtAuthFilter：

@Component
@RequiredArgsConstructor
public class JwtAuthFilter extends OncePerRequestFilter {
    private static final String BEARER_PREFIX = "Bearer ";
    private static final String AUTHORIZATION_HEADER = "Authorization";
    private static final int TOKEN_START_INDEX = 7;

    private final JwtService jwtService;

    @Override
    protected void doFilterInternal(final HttpServletRequest request,
                                    final HttpServletResponse response,
                                    final FilterChain filterChain) throws ServletException, IOException {
        String authHeader = request.getHeader(AUTHORIZATION_HEADER);
        if (hasBearerHeader(authHeader)) {
            String token = extractToken(authHeader);
            String username = jwtService.extractUsername(token);

            if (username != null && !isUserAuthenticated()) {
                if (jwtService.isTokenValid(token)) {
                    // 直接从token提取信息构建UserDetails
                    List<GrantedAuthority> authorities = jwtService.extractAuthorities(token);
                    boolean enabled = jwtService.extractEnabled(token);

                    UserDetails userDetails = User.builder()
                            .username(username)
                            .password("") // JWT已验证身份，无需存储密码
                            .authorities(authorities)
                            .enabled(enabled)
                            .build();

                    UsernamePasswordAuthenticationToken authToken = new UsernamePasswordAuthenticationToken(
                            userDetails,
                            null,
                            userDetails.getAuthorities()
                    );
                    authToken.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
                    SecurityContextHolder.getContext().setAuthentication(authToken);
                }
            }
        }

        filterChain.doFilter(request, response);
    }

    private boolean hasBearerHeader(final String authHeader) {
        return StringUtils.hasText(authHeader) && authHeader.startsWith(BEARER_PREFIX);
    }

    private String extractToken(String authHeader) {
        return Optional.of(authHeader)
                .filter(s -> s.length() > TOKEN_START_INDEX)
                .map(s -> s.substring(TOKEN_START_INDEX))
                .orElseThrow(() -> new BadCredentialsException("Invalid Authorization header: Bearer token is missing or invalid."));
    }

    private boolean isUserAuthenticated() {
        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
        return authentication != null && authentication.isAuthenticated();
    }
}

方案2：缓存用户信息，减少数据库查询 #

如果需要实时同步用户状态，但不想每次都查库，可以用Redis缓存用户信息，设置较短的过期时间（比如5分钟），平衡性能和状态实时性。

实现思路：

• 在UserDetailsService.loadUserByUsername中优先查询缓存，缓存不存在时再查数据库，然后将结果存入缓存。
• 当用户状态/权限变更时，主动删除对应缓存条目。

总结 #

• 若业务可接受token有效期内用户状态不实时更新，方案1是最优解，完全无数据库查询，性能最高。
• 若需要实时同步用户状态，方案2可在性能和实时性之间取得平衡。
• 教程中的实现是最稳妥但性能一般的方案，适合快速开发，不适合高并发场景。

内容的提问来源于stack exchange，提问作者SorryForAsking