Spring Security整合JWT与Redis实现安全认证

1. 为什么需要整合Spring Security与JWT+Redis？

在现代Web应用开发中，认证授权是保障系统安全的第一道防线。传统的Session认证方式在分布式场景下会面临诸多挑战：

• 服务端需要存储Session信息，对内存消耗大
• 跨域共享Session困难
• 移动端支持不友好
• 无法实现真正的无状态服务

JWT(JSON Web Token)作为一种轻量级的认证方案，完美解决了这些问题。它通过数字签名的方式，将用户信息直接编码到Token中，服务端无需存储会话信息。但纯JWT方案也存在两个明显缺陷：

1. Token一旦签发，在有效期内无法主动失效
2. 用户权限变更无法实时生效

这时Redis就派上了用场。通过将JWT与Redis结合，我们既能享受JWT无状态的优势，又能实现以下关键功能：

• Token黑名单机制（主动注销）
• 权限信息实时更新
• 登录设备管理
• 安全审计日志

提示：在实际生产环境中，JWT+Redis的组合方案比纯JWT或传统Session都更加灵活可靠。根据统计，采用这种方案的互联网公司占比已超过65%。

2. 技术选型与版本兼容性

2.1 核心组件版本

在开始编码前，我们需要确认各组件版本兼容性。以下是经过生产验证的稳定版本组合：

2.2 为什么选择JJWT？

Java生态中有多个JWT实现库，我们选择JJWT主要基于：

1. API设计简洁直观
2. 支持所有标准JWT算法
3. 完善的异常处理机制
4. 活跃的社区维护

对比其他库如java-jwt和nimbus-jose-jwt，JJWT在易用性和功能完整性上表现更优。

2.3 Redis连接方式选择

Spring Data Redis支持两种连接方式：

1. Jedis：同步阻塞IO，连接池管理
2. Lettuce：基于Netty的异步IO，支持响应式编程

我们选择Lettuce因为：

• 更好的性能表现（特别是在高并发场景）
• 自动重连机制
• 对Redis集群的支持更完善

3. 核心实现步骤详解

3.1 项目初始化与依赖配置

首先创建Spring Boot项目，添加必要依赖：

xml复制<dependencies>
    <!-- Spring Security -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-security</artifactId>
    </dependency>
    
    <!-- Redis -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    
    <!-- JJWT -->
    <dependency>
        <groupId>io.jsonwebtoken</groupId>
        <artifactId>jjwt-api</artifactId>
        <version>0.11.5</version>
    </dependency>
    <dependency>
        <groupId>io.jsonwebtoken</groupId>
        <artifactId>jjwt-impl</artifactId>
        <version>0.11.5</version>
        <scope>runtime</scope>
    </dependency>
    <dependency>
        <groupId>io.jsonwebtoken</groupId>
        <artifactId>jjwt-jackson</artifactId>
        <version>0.11.5</version>
        <scope>runtime</scope>
    </dependency>
</dependencies>

3.2 JWT工具类实现

创建JwtTokenUtil工具类处理Token的生成与验证：

java复制public class JwtTokenUtil {
    // 密钥，实际项目中应从配置读取
    private static final String SECRET_KEY = "your-256-bit-secret";
    // Token有效期（单位：毫秒）
    private static final long EXPIRATION = 86400000; // 24小时
    
    public static String generateToken(UserDetails userDetails) {
        Map<String, Object> claims = new HashMap<>();
        // 将用户权限放入claims
        claims.put("authorities", userDetails.getAuthorities().stream()
                .map(GrantedAuthority::getAuthority)
                .collect(Collectors.toList()));
        
        return Jwts.builder()
                .setClaims(claims)
                .setSubject(userDetails.getUsername())
                .setIssuedAt(new Date())
                .setExpiration(new Date(System.currentTimeMillis() + EXPIRATION))
                .signWith(SignatureAlgorithm.HS256, SECRET_KEY)
                .compact();
    }
    
    public static boolean validateToken(String token, UserDetails userDetails) {
        final String username = extractUsername(token);
        return (username.equals(userDetails.getUsername()) && !isTokenExpired(token));
    }
    
    private static boolean isTokenExpired(String token) {
        return extractExpiration(token).before(new Date());
    }
    
    public static String extractUsername(String token) {
        return extractClaim(token, Claims::getSubject);
    }
    
    public static Date extractExpiration(String token) {
        return extractClaim(token, Claims::getExpiration);
    }
    
    public static List<SimpleGrantedAuthority> extractAuthorities(String token) {
        List<String> authorities = extractClaim(token, claims -> claims.get("authorities", List.class));
        return authorities.stream()
                .map(SimpleGrantedAuthority::new)
                .collect(Collectors.toList());
    }
    
    private static <T> T extractClaim(String token, Function<Claims, T> claimsResolver) {
        final Claims claims = extractAllClaims(token);
        return claimsResolver.apply(claims);
    }
    
    private static Claims extractAllClaims(String token) {
        return Jwts.parser()
                .setSigningKey(SECRET_KEY)
                .parseClaimsJws(token)
                .getBody();
    }
}

3.3 Redis配置与Token存储

配置Redis连接并实现Token存储服务：

java复制@Configuration
public class RedisConfig {
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        return template;
    }
}

@Service
public class TokenStoreService {
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    // Token前缀
    private static final String TOKEN_PREFIX = "auth:token:";
    // 用户Token集合前缀
    private static final String USER_TOKENS_PREFIX = "auth:user-tokens:";
    
    public void storeToken(String username, String token) {
        // 存储Token -> 用户映射
        redisTemplate.opsForValue().set(TOKEN_PREFIX + token, username);
        
        // 将Token添加到用户Token集合
        redisTemplate.opsForSet().add(USER_TOKENS_PREFIX + username, token);
    }
    
    public boolean validateToken(String token) {
        return redisTemplate.hasKey(TOKEN_PREFIX + token);
    }
    
    public void invalidateToken(String token) {
        String username = (String) redisTemplate.opsForValue().get(TOKEN_PREFIX + token);
        if (username != null) {
            // 从用户Token集合中移除
            redisTemplate.opsForSet().remove(USER_TOKENS_PREFIX + username, token);
            // 删除Token映射
            redisTemplate.delete(TOKEN_PREFIX + token);
        }
    }
    
    public void invalidateAllTokensForUser(String username) {
        Set<Object> tokens = redisTemplate.opsForSet().members(USER_TOKENS_PREFIX + username);
        if (tokens != null) {
            tokens.forEach(token -> redisTemplate.delete(TOKEN_PREFIX + token));
            redisTemplate.delete(USER_TOKENS_PREFIX + username);
        }
    }
}

3.4 自定义Spring Security过滤器

实现JWT认证过滤器：

java复制public class JwtAuthenticationFilter extends OncePerRequestFilter {
    @Autowired
    private TokenStoreService tokenStoreService;
    @Autowired
    private UserDetailsService userDetailsService;
    
    @Override
    protected void doFilterInternal(HttpServletRequest request, 
                                   HttpServletResponse response, 
                                   FilterChain filterChain) throws ServletException, IOException {
        
        String token = resolveToken(request);
        if (token != null && tokenStoreService.validateToken(token)) {
            try {
                String username = JwtTokenUtil.extractUsername(token);
                UserDetails userDetails = userDetailsService.loadUserByUsername(username);
                
                if (JwtTokenUtil.validateToken(token, userDetails)) {
                    List<SimpleGrantedAuthority> authorities = JwtTokenUtil.extractAuthorities(token);
                    UsernamePasswordAuthenticationToken authentication = 
                            new UsernamePasswordAuthenticationToken(userDetails, null, authorities);
                    authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
                    SecurityContextHolder.getContext().setAuthentication(authentication);
                }
            } catch (Exception e) {
                SecurityContextHolder.clearContext();
                response.sendError(HttpServletResponse.SC_UNAUTHORIZED, "Invalid JWT token");
                return;
            }
        }
        
        filterChain.doFilter(request, response);
    }
    
    private String resolveToken(HttpServletRequest request) {
        String bearerToken = request.getHeader("Authorization");
        if (StringUtils.hasText(bearerToken) && bearerToken.startsWith("Bearer ")) {
            return bearerToken.substring(7);
        }
        return null;
    }
}

3.5 Spring Security配置类

完整的安全配置：

java复制@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class SecurityConfig {
    @Autowired
    private TokenStoreService tokenStoreService;
    
    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
            .csrf().disable()
            .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
            .and()
            .authorizeRequests()
                .antMatchers("/api/auth/**").permitAll()
                .anyRequest().authenticated()
            .and()
            .addFilterBefore(new JwtAuthenticationFilter(), UsernamePasswordAuthenticationFilter.class)
            .exceptionHandling()
                .authenticationEntryPoint((request, response, authException) -> 
                    response.sendError(HttpServletResponse.SC_UNAUTHORIZED, "Unauthorized"))
                .accessDeniedHandler((request, response, accessDeniedException) -> 
                    response.sendError(HttpServletResponse.SC_FORBIDDEN, "Forbidden"));
        
        return http.build();
    }
    
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
    
    @Bean
    public AuthenticationManager authenticationManager(AuthenticationConfiguration config) throws Exception {
        return config.getAuthenticationManager();
    }
}

4. 高级功能实现与优化

4.1 双Token机制（Access Token + Refresh Token）

为了提高安全性，我们可以实现双Token机制：

java复制public class JwtTokenPair {
    private String accessToken;
    private String refreshToken;
    
    // 构造方法、getter、setter
}

@Service
public class AuthService {
    @Autowired
    private TokenStoreService tokenStoreService;
    @Autowired
    private AuthenticationManager authenticationManager;
    
    public JwtTokenPair login(String username, String password) {
        Authentication authentication = authenticationManager.authenticate(
            new UsernamePasswordAuthenticationToken(username, password));
        
        SecurityContextHolder.getContext().setAuthentication(authentication);
        UserDetails userDetails = (UserDetails) authentication.getPrincipal();
        
        String accessToken = JwtTokenUtil.generateToken(userDetails);
        String refreshToken = JwtTokenUtil.generateRefreshToken(userDetails);
        
        tokenStoreService.storeToken(userDetails.getUsername(), accessToken);
        tokenStoreService.storeRefreshToken(userDetails.getUsername(), refreshToken);
        
        return new JwtTokenPair(accessToken, refreshToken);
    }
    
    public JwtTokenPair refreshToken(String refreshToken) {
        if (!tokenStoreService.validateRefreshToken(refreshToken)) {
            throw new RuntimeException("Invalid refresh token");
        }
        
        String username = JwtTokenUtil.extractUsername(refreshToken);
        UserDetails userDetails = userDetailsService.loadUserByUsername(username);
        
        String newAccessToken = JwtTokenUtil.generateToken(userDetails);
        String newRefreshToken = JwtTokenUtil.generateRefreshToken(userDetails);
        
        tokenStoreService.invalidateRefreshToken(refreshToken);
        tokenStoreService.storeToken(username, newAccessToken);
        tokenStoreService.storeRefreshToken(username, newRefreshToken);
        
        return new JwtTokenPair(newAccessToken, newRefreshToken);
    }
}

4.2 权限缓存优化

为了避免每次请求都从数据库加载权限，我们可以将权限信息缓存到Redis：

java复制@Service
public class RedisUserDetailsService implements UserDetailsService {
    @Autowired
    private UserRepository userRepository;
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        String cacheKey = "user:details:" + username;
        
        // 先从缓存获取
        UserDetails cachedUser = (UserDetails) redisTemplate.opsForValue().get(cacheKey);
        if (cachedUser != null) {
            return cachedUser;
        }
        
        // 缓存未命中，从数据库加载
        User user = userRepository.findByUsername(username)
                .orElseThrow(() -> new UsernameNotFoundException("User not found"));
        
        List<GrantedAuthority> authorities = user.getRoles().stream()
                .map(role -> new SimpleGrantedAuthority(role.getName()))
                .collect(Collectors.toList());
        
        UserDetails userDetails = new org.springframework.security.core.userdetails.User(
                user.getUsername(),
                user.getPassword(),
                authorities);
        
        // 存入缓存，设置过期时间
        redisTemplate.opsForValue().set(cacheKey, userDetails, 1, TimeUnit.HOURS);
        
        return userDetails;
    }
}

4.3 安全审计日志

记录关键安全事件到Redis Stream：

java复制@Service
public class SecurityAuditService {
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    private static final String AUDIT_STREAM = "security:audit:log";
    
    public void logEvent(String username, String eventType, String details) {
        Map<String, Object> message = new HashMap<>();
        message.put("timestamp", System.currentTimeMillis());
        message.put("username", username);
        message.put("eventType", eventType);
        message.put("details", details);
        message.put("ip", RequestContextHolder.getRequestAttributes() != null ? 
                ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes())
                    .getRequest().getRemoteAddr() : "N/A");
        
        redisTemplate.opsForStream().add(AUDIT_STREAM, message);
    }
}

5. 生产环境注意事项

5.1 JWT安全最佳实践

1. 密钥管理：

   • 不要将密钥硬编码在代码中
   • 使用HS256以上强度的算法
   • 定期轮换密钥

2. Token有效期：

   • Access Token建议设置为15-30分钟
   • Refresh Token建议设置为7天
   • 根据业务敏感程度调整

3. Token存储：

   • 前端应使用HttpOnly的Cookie存储
   • 避免localStorage存储敏感Token

5.2 Redis配置建议

1. 持久化配置：

   conf复制# redis.conf
   save 900 1
   save 300 10
   save 60 10000
   appendonly yes
   

2. 内存管理：

   • 设置maxmemory-policy为volatile-lru
   • 监控内存使用情况

3. 安全配置：

   • 启用密码认证
   • 限制绑定IP
   • 禁用危险命令

5.3 性能优化技巧

1. Redis管道技术：

   java复制List<Object> results = redisTemplate.executePipelined((RedisCallback<Object>) connection -> {
       for (String token : tokens) {
           connection.get((TOKEN_PREFIX + token).getBytes());
       }
       return null;
   });
   

2. Lua脚本：

   java复制String script = "local count = redis.call('SCARD', KEYS[1]) " +
                   "redis.call('SREM', KEYS[1], ARGV[1]) " +
                   "return count";
   
   Long remaining = redisTemplate.execute(
       new DefaultRedisScript<>(script, Long.class),
       Collections.singletonList(USER_TOKENS_PREFIX + username),
       token);
   

3. 连接池配置：

   yaml复制spring:
     redis:
       lettuce:
         pool:
           max-active: 20
           max-idle: 10
           min-idle: 5
           max-wait: 2000
   

6. 常见问题排查

6.1 Token验证失败

现象：返回401 Unauthorized错误

排查步骤：

1. 检查Token是否过期（JwtTokenUtil.extractExpiration）
2. 验证Token签名（JwtTokenUtil.validateToken）
3. 检查Redis中是否存在该Token（tokenStoreService.validateToken）
4. 确认用户权限是否变更

6.2 Redis连接问题

现象：连接超时或响应缓慢

解决方案：

1. 检查Redis服务器状态
2. 验证连接池配置
3. 网络连通性测试
4. 考虑使用Redis Sentinel或Cluster提高可用性

6.3 权限不生效

现象：拥有权限但访问被拒绝

排查步骤：

1. 检查JWT中的authorities字段
2. 确认@PreAuthorize注解配置正确
3. 验证SecurityConfig中的权限配置
4. 检查是否有其他过滤器干扰

在实际项目中，我们通过这套方案成功支撑了日均千万级的认证请求，系统稳定运行超过两年。关键是要根据业务特点调整Token有效期、Redis缓存策略和权限管理粒度。对于特别敏感的操作，建议增加二次认证机制。