SpringSecurity JWT基于令牌的无状态认证实现

2025-04-14 10:26 开发作者：程序媛学姐

引言

在微服务架构与分布式系统日益普及的今天，传统的基于会话（Session）的认证方式面临着诸多挑战。jsON Web Token（JWT）作为一种基于令牌的认证机制，因其无状态、自包含以及易于跨服务传递的特性，已成为现代应用认证的优选方案。Spring Security作为Java生态系统中最流行的安全框架，提供了对JWT的全面支持。本文将深入探讨如何在Spring Security中实现基于JWT的无状态认证，包括令牌生成、验证、续期等核心环节，帮助开发者构建安全、高效的身份认证系统。通过采用JWT认证，系统可以更好地支持水平扩展、减轻服务器存储负担，并简化跨服务认证的复杂性。

一、JWT基本原理与结构

JWT（JSON Web Token）是一种开放标准（RFC 7519），它定义了一种紧凑且自包含的方式，用于在各方之间安全地传输信息。每个JWT由三部分组成：头部（Header）、载荷（Payload）和签名（Signature）。头部描述令牌类型和使用的算法，载荷包含需要传递的数据（如用户ID、角色等），签名则确保令牌的完整性和真实性。JWT的设计理念是服务端不存储令牌状态，而是通过验证签名和检查内置的过期时间来判断令牌有效性，这种方式特别适合分布式系统和微服务架构。

// JWT结构示例
public class JwtStructure {
    
    // 头部示例（实际使用时会进行Base64URL编码）
    String header = "{\n" +
                    "  \"alg\": \"HS256\",\n" +  // 签名算法
                    "  \"typ\": \"JWT\"\n" +     // 令牌类型
                    "}";
    
    // 载荷示例（实际使用时会进行Base64URL编码）
    String payload = "{\n" +
                     "  \"sub\": \"1234567890\",\n" +  // 主题（通常是用户ID）
                     "  \"name\": \"John Doe\",\n" +   // 用户名
                     "  \"admin\": true,\n" +           // 自定义声明
                     "  \"iat\": 1516239022,\n" +      // 令牌签发时间
                     "  \"exp\": 1516242622\n" +       // 令牌过期时间
                     "}";
    
    // 签名过程伪代码
    String signatureAlgorithm = "HMACSHA256";
    String signature = HMACSHA256(
        base64UrlEncode(header) + "." + base64UrlEncode(payload),
        secret
    );
    
    // 最终的JWT形式：Header.Payload.Signature
    String jwt = base64UrlEncode(header) + "." +
                 base64UrlEncode(payload) + "." +
                 signature;
}

二、Spring Security JWT依赖配置

实现JWT认证首先需要引入相关依赖。主要包括Spring Security核心库以及处理JWT的库，如jjwt或java-jwt。此外，还需要添加JSON处理库以及Spring Boot相关依赖。在Spring Boot项目中，通过Maven或Gradle可以方便地管理这些依赖。配置好依赖后，可以进一步设置JWT的参数，如密钥、令牌有效期等，这些通常在应用的配置文件中定义。

// Maven依赖配置（pom.XML片段）
public class Dependencies {
    
    String mavenDependencies = 
        "<!-- Spring Boot安全依赖 -->\n" +
        "<dependency>\n" +
        "    <groupId>org.springframework.boot</groupId>\n" +
        "    <artifactId>spring-boot-starter-security</artifactId>\n" +
        "</dependency>\n" +
        "\n" +
        "<!-- Spring Boot Web依赖 -->\n" +
        "<dependency>\n" +
        "    <groupId>org.springframework.boot</groupId>\n" +
        "    <artifactId>spring-boot-starter-web</artifactId>\n" +
        "</dependency>\n" +
        "\n" +
        "<!-- JWT依赖 - JJWT -->\n" +
        "<dependency>\n" +
        "    <groupId>io.jsonwebtoken</groupId>\n" +
        "    <artifactId>jjwt-api</artifactId>\n" +
        "    <version>0.11.5</version>\n" +
        "</dependency>\n" +
        "<dependency>\n" +
        "    <groupId>io.jsonwebtoken</groupId>\n" +
        "    <artifactId>jjwt-impl</artifactId>\n" +
        "    <version>0.11.5</version>\n" +
        "    <scope>runtime</scope>\n" +
        "</dependency>\n" +
        "<dependency>\n" +
        "    <groupId>io.jsonwebtoken</groupId>\n" +
        "    <artifactId>jjwt-jackson</artifactId>\n" +
        "    <version>0.11.5</version>\n" +
 www.devze.com       "    <scope>runtime</scope>\n" +
        "</dependency>";
    
    // 应用配置文件（application.yml片段）
    String applicationConfig = 
        "jwt:\n" +
        "  secret: mySecretKey123456789012345678901234567890\n" +
        "  expiration: 86400000  # 24小时，单位毫秒\n" +
        "  header: Authorization\n" +
        "  prefix: Bearer ";
}

三、JWT令牌生成与处理

JWT令牌的生成是认证流程的核心环节。在用户成功通过身份验证后，系统需要创建包含用户身份和权限信息的JWT，并将其发送给客户端。令牌处理服务负责JWT的创建、签名和验证等操作。通过合理封装JWT操作，可以确保令牌的安全性和一致性。在实际项目中，通常将JWT相关操作封装在专门的服务类中，该类负责令牌的生成、解析和验证。

@Service
public class JwtTokenProvider {
    
    @Value("${jwt.secret}")
    private String jwtSecret;
    
    @Value("${jwt.expiration}")
    private long jwtExpiration;
    
    @Autowired
    private UserDetailsService userDetailsService;
    
    // 生成令牌
    public String generateToken(Authentication authentication) {
        UserDetails userDetails = (UserDetails) aut编程客栈hentication.getPrincipal();
        Date now = new Date();
        Date expiryDate = new Date(now.getTime() + jwtExpiration);
        
        return Jwts.builder()
                .setSubject(userDetails.getUsername())
                .setIssuedAt(now)
                .setExpiration(expiryDate)
                // 添加用户角色信息
                .claim("roles", userDetails.getAuthorities().stream()
                        .map(GrantedAuthority::getAuthority)
                        .collect(Collectors.toList()))
                // 可添加额外的自定义声明
                .claim("additional", "custom value")
                // 使用HS512算法和密钥签名JWT
                .signWith(Keys.hmacShaKeyFor(jwtSecret.getBytes()), SignatureAlgorithm.HS512)
                .compact();
    }
    
    // 从令牌中获取用户名
    public String getUsernameFromToken(String token) {
        Claims claims = Jwts.parserBuilder()
                .setSigningKey(Keys.hmacShaKeyFor(jwtSecret.getBytes()))
                .build()
                .parseClaimsJws(token)
                .getBody();
        
        returpythonn claims.getSubject();
    }
    
    // 获取令牌中的所有声明
    public Claims getAllClaimsFromToken(String token) {
        return Jwts.parserBuilder()
                .setSigningKey(Keys.hmacShaKeyFor(jwtSecret.getBytes()))
                .build()
                .parseClaimsJws(token)
                .getBody();
    }
    
    // 验证令牌
    public boolean validateToken(String token) {
       javascript try {
            Jwts.parserBuilder()
                .setSigningKey(Keys.hmacShaKeyFor(jwtSecret.getBytes()))
                .build()
                .parseClaimsJws(token);
            return true;
        } catch (MalformedJwtException | ExpiredJwtException | UnsupportedJwtException | IllegalArgumentException e) {
            // 捕获各种JWT异常并记录日志
            return false;
        }
    }
    
    // 从令牌解析认证信息
    public Authentication getAuthentication(String token) {
        String username = getUsernameFromToken(token);
        UserDetails userDetails = userDetailsService.loadUserByUsername(username);
        
        return new UsernamePasswordAuthenticationToken(userDetails, "", userDetails.getAuthorities());
    }
}

四、Spring Security配置与过滤器实现

在Spring Security中集成JWT认证需要自定义安全配置和过滤器。首先，需要创建JWT认证过滤器，拦截请求并验证JWT的有效性。其次，配置安全规则，定义哪些URL需要认证，哪些可以匿名访问。最后，禁用会话管理，因为JWT是无状态的，不需要在服务器端维护会话。通过这些配置，js可以将JWT认证机制无缝集成到Spring Security框架中。

// JWT认证过滤器
@Component
public class JwtAuthenticationFilter extends OncePerRequestFilter {
    
    @Autowired
    private JwtTokenProvider tokenProvider;
    
    @Value("${jwt.header}")
    private String tokenHeader;
    
    @Value("${jwt.prefix}")
    private String tokenPrefix;
    
    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
            throws ServletException, IOException {
        
        try {
            // 从请求中提取JWT
            String jwt = getJwtFromRequest(request);
            
            // 验证JWT是否存在且有效
            if (StringUtils.hasText(jwt) && tokenProvider.validateToken(jwt)) {
                // 从JWT中获取用户认证信息
                Authentication authentication = tokenProvider.getAuthentication(jwt);
                
                // 将认证信息设置到Spring Security上下文
                SecurityContextHolder.getContext().setAuthentication(authentication);
            }
        } catch (Exception ex) {
            // 记录解析JWT时的异常，但不中断过滤器链
            logger.error("Could not set user authentication in security context", ex);
        }
        
        // 继续执行过滤器链
        filterChain.doFilter(request, response);
    }
    
    // 从请求头中提取JWT
    private String getJwtFromRequest(HttpServletRequest request) {
        String bearerToken = request.getHeader(tokenHeader);
        if (StringUtils.hasText(bearerToken) && bearerToken.startsWith(tokenPrefix)) {
            return bearerToken.substring(tokenPrefix.length());
        }
        return null;
    }
}

// Spring Security配置
@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class SecurityConfig {
    
    @Autowired
    private JwtAuthenticationFilter jwtAuthenticationFilter;
    
    @Autowired
    private UserDetailsService userDetailsService;
    
    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http
            // 禁用CSRF保护，因为JWT是无状态的
            .csrf().disable()
            
            // 配置异常处理
            .exceptionHandling()
            .authenticationEntryPoint((request, response, authException) -> {
                response.setContentType(MediaType.APPLICATION_JSON_VALUE);
                response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
                response.getWriter().write("{\"error\":\"Unauthorized\",\"message\":\"" + 
                                         authException.getMessage() + "\"}");
            })
            .and()
            
            // 禁用会话管理，使用JWT我们不需要会话
            .sessionManagement()
            .sessionCreationPolicy(SessionCreationPolicy.STATELESS)
            .and()
            
            // 配置请求授权
            .authorizeRequests()
            // 允许所有人访问登录和注册接口
            .antMatchers("/api/auth/**").permitAll()
            // 允许所有人访问静态资源
            .antMatchers("/static/**").permitAll()
            // 所有其他请求需要认证
            .anyRequest().authenticated();
        
        // 添加JWT过滤器
        http.addFilterBefore(jwtAuthenticationFilter, UsernamePasswordAuthenticationFilter.class);
        
        return http.build();
    }
    
    @Bean
    public AuthenticationManager authenticationManager(
            AuthenticationConfiguration authConfig) throws Exception {
        return authConfig.getAuthenticationManager();
    }
    
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}

五、认证控制器与登录流程实现

为实现完整的JWT认证流程，需要创建认证控制器处理登录请求。控制器接收用户凭据，验证身份后生成JWT令牌并返回给客户端。此外，还可以实现刷新令牌、注销等功能。在前后端分离的架构中，控制器通常返回JSON格式的响应，包含令牌和基本用户信息。

@RestController
@RequestMapping("/api/auth")
public class AuthController {
    
    @Autowired
    private AuthenticationManager authenticationManager;
    
    @Autowired
    private JwtTokenProvider tokenProvider;
    
    @PostMapping("/login")
    public ResponseEntity<?> authenticateUser(@Valid @RequestBody LoginRequest loginRequest) {
        try {
            // 验证用户凭据
            Authentication authentication = authenticationManager.authenticate(
                new UsernamePasswordAuthenticationToken(
                    loginRequest.getUsername(),
                    loginRequest.getPassword()
                )
            );
            
            // 设置认证信息到安全上下文
            SecurityContextHolder.getContext().setAuthentication(authentication);
            
            // 生成JWT令牌
            String jwt = tokenProvider.generateToken(authentication);
            
            // 获取用户详情
            UserDetails userDetails = (UserDetails) authentication.getPrincipal();
            List<String> roles = userDetails.getAuthorities().stream()
                .map(GrantedAuthority::getAuthority)
                .collect(Collectors.toList());
            
            // 构建并返回响应
            JwtAuthResponse response = new JwtAuthResponse();
            response.setToken(jwt);
            response.setUsername(userDetails.getUsername());
            response.setRoles(roles);
            
            return ResponseEntity.ok(response);
        } catch (BadCredentialsException e) {
            return ResponseEntity.status(HttpStatus.UNAUTHORIZED)
                .body(new ErrorResponse("Invalid username or password"));
        }
    }
    
    // 用于刷新令牌的端点
    @PostMapping("/refresh")
    public ResponseEntity<?> refreshToken(@RequestBody TokenRefreshRequest request) {
        // 验证刷新令牌（实际项目中应使用专门的刷新令牌）
        String requestRefreshToken = request.getRefreshToken();
        
        try {
            // 验证刷新令牌有效性（简化示例）
            if (!tokenProvider.validateToken(requestRefreshToken)) {
                return ResponseEntity.status(HttpStatus.UNAUTHORIZED)
                    .body(new ErrorResponse("Invalid refresh token"));
            }
            
            // 从刷新令牌中获取用户信息
            String username = tokenProvider.getUsernameFromToken(requestRefreshToken);
            
            // 创建新的认证对象
            UserDetails userDetails = customUserDetailsService.loadUserByUsername(username);
            UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(
                userDetails, null, userDetails.getAuthorities());
            
            // 生成新的访问令牌
            String newAccessToken = tokenProvider.generateToken(authentication);
            
            return ResponseEntity.ok(new JwtAuthResponse(newAccessToken, username, null));
        } catch (Exception e) {
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                .body(new ErrorResponse("Could not refresh token"));
        }
    }
}

// 登录请求DTO
class LoginRequest {
    private String username;
    private String password;
    
    // getters and setters
}

// JWT认证响应DTO
class JwtAuthResponse {
    private String token;
    private String type = "Bearer";
    private String username;
    private List<String> roles;
    
    // constructors, getters and setters
}

总结

基于JWT的无状态认证为现代应用提供了高效、灵活的安全机制。通过Spring Security与JWT的结合，可以实现既符合标准又易于维护的认证系统。JWT的无状态特性使其特别适合微服务和分布式环境，无需在服务器端存储会话状态，大大减轻了服务器负担，同时支持系统的水平扩展。在实现过程中，关键环节包括JWT令牌的生成与验证、安全过滤器的配置、认证流程的设计等。通过本文介绍的实现方法，开发者可以构建安全可靠的JWT认证系统，满足现代应用的认证需求。需要注意的是，虽然JWT提供了许多优势，但也存在一些局限，如令牌撤销困难、令牌大小限制等。在实际项目中，应根据具体需求选择适合的认证机制，并遵循安全最佳实践，确保系统的安全性和可靠性。随着应用架构的不断演进，基于令牌的无状态认证将继续发挥重要作用，成为构建安全分布式系统的基础。

到此这篇关于SpringSecurity JWT基于令牌的无状态认证实现的文章就介绍到这了,更多相关SpringSecurity JWT令牌无状态认证内容请搜索编程客栈(www.devze.com)以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程客栈(www.devze.com)！

继续阅读：SpringSecurity JWT令牌无状态认证 SpringSecurity JWT无状态认证

SpringSecurity JWT基于令牌的无状态认证实现

目录

引言

一、JWT基本原理与结构

二、Spring Security JWT依赖配置

三、JWT令牌生成与处理

四、Spring Security配置与过滤器实现

五、认证控制器与登录流程实现

总结

更多精彩内容

精彩评论

最新开发

如何使用Golang打包jar应用

Java中实现Redis管道技术的代码详解

SpringBoot优雅实现计算方法执行时间

SpringBatch数据读取的实现(ItemReader与自定义读取逻辑)

通过Spring层面进行事务回滚的实现

开发排行榜

springboot后端存储富文本内容的思路与步骤(含图片内容)

PyCharm运行python测试,报错“没有发现测试”/“空套件”的解决

return base64.b64encode(b).decode(

基于C语言实现钻石棋游戏的示例代码

Sublime Text 3解决中文乱码问题（实测可用）