# Spring Boot JWT 安全使用 Spring Security 6.x 和 JJWT 库的 Spring Boot 3.5.x 应用程序的综合 JWT（JSON Web 令牌）身份验证和授权模式。该技能为无状态身份验证、基于角色的访问控制以及与现代身份验证提供程序的集成提供了生产就绪的实现。 ## 概述 JWT 身份验证为 Spring Boot 应用程序提供无状态、可扩展的安全性。该技能涵盖完整的 JWT 生命周期管理，包括令牌生成、验证、刷新策略以及与数据库支持和 OAuth2 身份验证提供商的集成模式。实现遵循 Spring Security 6.x 最佳实践和现代 SecurityFilterChain 配置。 ## 何时使用在以下情况下使用此技能： * 为 REST API 实现无状态身份验证 * 使用 JWT 构建 SPA（单页应用程序）后端 * 通过基于令牌的身份验证保护微服务 * 与 OAuth2 提供商集成（Google、GitHub 等） * 实施基于角色或基于权限的访问控制 * 设置 JWT 刷新令牌策略 * 从基于会话的身份验证迁移到基于令牌的身份验证 * 构建移动API后端 * 使用CORS实现跨域认证 ## 先决条件 * Java 17+（用于记录和模式匹配） * Spring Boot 3.5.x（用于 Spring Security 6.x 集成） * 用于 JWT 操作的 JJWT 库 (io.jsonwebtoken) * Maven 或 Gradle 构建系统 * Spring Security概念的基本了解 ## 依赖关系 ### Maven <依赖关系> <依赖关系> org.springframework.boot spring-boot-starter-security <依赖关系> org.springframework.boot spring-boot-starter-web <依赖关系> org.springframework.boot spring-boot-starter-data-jpa <依赖关系> org.springframework.boot spring-boot-starter-validation <依赖关系> org.springframework.boot spring-boot-starter-oauth2-resource-server <依赖关系> io.jsonwebtoken jjwt-api <版本>0.12.6 <依赖关系> io.jsonwebtoken jjwt-impl <版本>0.12.6 <范围>运行时 <依赖关系> io.jsonwebtoken jjwt-jackson <版本>0.12.6 <范围>运行时 <依赖关系> com.h2database h2 <范围>运行时 <依赖关系> org.postgresql postgresql <范围>运行时 <依赖关系> org.springframework.boot spring-boot-starter-test <范围>测试 <依赖关系> org.springframework.security spring-security-test <范围>测试 <依赖关系> org.testcontainers junit-jupiter <范围>测试 <依赖关系> org.springframework.security spring-security-test <范围>测试 ### 摇篮依赖项{ // 弹簧安全实现（“org.springframework.boot：spring-boot-starter-security”）实现（“org.springframework.boot：spring-boot-starter-web”）实现（“org.springframework.boot：spring-boot-starter-data-jpa”）实现（“org.springframework.boot：spring-boot-starter-validation”）实现（“org.springframework.boot：spring-boot-starter-oauth2-resource-server”） // JWT 库实现（“io.jsonwebtoken：jjwt-api：0.12.6”）实现（“io.jsonwebtoken：jjwt-impl：0.12.6”）实现（“io.jsonwebtoken：jjwt-jackson：0.12.6”） // 数据库 runtimeOnly("com.h2database:h2") runtimeOnly("org.postgresql:postgresql") // 测试 testImplementation("org.springframework.boot:spring-boot-starter-test") testImplementation（“org.springframework.security：spring-security-test”） testImplementation("org.testcontainers:junit-jupiter") } ## 说明按照以下步骤在 Spring Boot 中实现 JWT 身份验证： ### 1\.添加依赖项在您的项目中包含 spring-boot-starter-security、spring-boot-starter-oauth2-resource-server 和 JJWT 库（jjwt-api、jjwt-impl、jjwt-jackson）。 ### 2\.配置 JWT 属性在 application.yml 中设置 JWT 密钥、访问令牌过期、刷新令牌过期和颁发者。切勿在版本控制中对秘密进行硬编码。 ### 3\.创建 JWT 服务使用生成令牌、提取声明、验证令牌和检查过期的方法来实现 JwtService。使用 Jwts.builder() 进行令牌创建。 ### 4\.实施 JWT 过滤器创建扩展 OncePerRequestFilter 的 JwtAuthenticationFilter。从 Authorization 标头或 cookie 中提取 JWT，对其进行验证，然后设置 SecurityContext 身份验证。 ### 5\.配置安全过滤器链使用@EnableWebSecurity 和@EnableMethodSecurity 设置SecurityConfig。配置无状态会话管理、CSRF 禁用和授权规则。 ### 6\.创建身份验证端点实现 /register、/authenticate、/refresh 和 /logout 端点。身份验证成功后返回访问和刷新令牌。 ### 7\.实施刷新令牌策略将刷新令牌存储在数据库中，并包含过期和撤销状态。实施令牌轮换以增强安全性。 ### 8\.添加授权规则将带有基于角色 (hasRole) 或基于权限 (hasAuthority) 检查的 @PreAuthorize 注释应用于受保护的端点。 ### 9\.测试安全配置编写身份验证成功/失败、授权访问控制和令牌验证场景的测试。 ## 快速入门 ### 1\.应用程序配置 # 应用程序.yml 春天：安全： oauth2: 客户：注册：谷歌：客户端 ID：${GOOGLE_CLIENT_ID} 客户端秘密：${GOOGLE_CLIENT_SECRET} 范围：openid、个人资料、电子邮件智威汤逊：秘密：${JWT_SECRET：我的非常秘密的密钥至少为 256 位长} access-token-expiration: 86400000 # 24 小时（以毫秒为单位） fresh-token-expiration: 604800000 # 7 天（以毫秒为单位）发行者：spring-boot-jwt-example cookie 名称：jwt 令牌 cookie-secure: false # 在使用 HTTPS 的生产中设置为 true cookie-http-only：true cookie 同一站点：宽松 ### 2\.现代 Spring Security 6.x 配置 @配置 @EnableWebSecurity @EnableMethodSecurity @RequiredArgsConstructor 公共类安全配置{ 私有最终 JwtAuthenticationFilter jwtAuthFilter; 私有最终 AuthenticationProvider 身份验证提供程序；私有最终 LogoutHandler logoutHandler; @豆子公共SecurityFilterChain securityFilterChain（HttpSecurity http）抛出异常{ http .csrf(csrf -> csrf.disable()) .cors(cors -> cors.configurationSource(corsConfigurationSource())) .sessionManagement(会话 -> session.sessionCreationPolicy(SessionCreationPolicy.STATELESS)) .authorizeHttpRequests（authz - > authz .requestMatchers("/api/auth/**").permitAll() .requestMatchers("/api/public/**").permitAll() .requestMatchers(HttpMethod.GET, "/api-docs/**").permitAll() .requestMatchers(HttpMethod.GET, "/swagger-ui/**").permitAll() .anyRequest().authenticated() ） .authenticationProvider(authenticationProvider) .addFilterBefore(jwtAuthFilter, UsernamePasswordAuthenticationFilter.class) .logout(注销->注销 .logoutUrl("/api/auth/logout") .addLogoutHandler(logoutHandler) .logoutSuccessHandler((请求、响应、身份验证)-> SecurityContextHolder.clearContext()) ）；返回 http.build(); } @豆子公共 CorsConfigurationSource corsConfigurationSource() { CorsConfiguration 配置 = new CorsConfiguration(); 配置.setAllowedOriginPatterns(List.of("*")); 配置.setAllowedMethods(List.of("GET", "POST", "PUT", "DELETE", "OPTIONS")); 配置.setAllowedHeaders(List.of("*")); 配置.setAllowCredentials(true); UrlBasedCorsConfigurationSource 源 = new UrlBasedCorsConfigurationSource(); source.registerCorsConfiguration("/**", 配置); 返回源； } } ### 3\.智威汤逊服务实施 @服务 @RequiredArgsConstructor @Slf4j 公共类 JwtService { @Value("${jwt.secret}") 私有字符串秘密； @Value("${jwt.access-token-expiration}") 私有长 accessTokenExpiration； @Value("${jwt.refresh-token-expiration}") 私有长refreshTokenExpiration； @Value("${jwt.issuer}") 私有字符串发行者；私有最终 RefreshTokenService 刷新令牌服务； /** * 为用户生成访问令牌 */ 公共字符串generateAccessToken（UserDetails userDetails）{ 返回generateToken(userDetails, accessTokenExpiration); } /** * 为用户生成刷新令牌 */ 公共字符串generateRefreshToken（UserDetails userDetails）{ 返回refreshTokenService.createRefreshToken(userDetails.getUsername()); } /** * 从 JWT 令牌中提取用户名 */ 公共字符串提取用户名（字符串标记）{ 返回 extractClaims(token).getSubject(); } /** * 从 JWT 令牌中提取声明 */ 私有声明 extractClaims(String token) { 返回 Jwts.parser() .verifyWith(getSigningKey()) .build() .parseSignedClaims（令牌） .getPayload(); } /** * 验证 JWT 令牌 */ 公共布尔 isTokenValid（字符串令牌，UserDetails userDetails）{ 尝试{ 最终字符串用户名 = extractUsername(token); return (用户名.equals(userDetails.getUsername()) && !isTokenExpired(令牌) && extractClaims(token).getIssuer().equals(issuer)); } catch (JwtException | IllegalArgumentException e) { log.debug("无效的 JWT 令牌：{}", e.getMessage()); 返回假； } } /** * 检查token是否过期 */ 私人布尔 isTokenExpired（字符串令牌）{ 返回 extractClaims(token).getExpiration().before(new Date()); } /** * 生成带有效期的token */ 私有字符串generateToken（UserDetails userDetails，长过期）{ 现在的日期 = new Date(); 日期 expiryDate = new Date(now.getTime() + expiry); 返回 Jwts.builder() .setSubject(userDetails.getUsername()) .setIssuer(发行者) .setIssuedAt(现在) .setExpiration(过期日期) .claim("权威机构", getAuthorities(userDetails)) .claim("类型", "访问权限") .signWith(getSigningKey()) .compact(); } /** * 从秘密中获取签名密钥 */ 私有 SecretKey getSigningKey() { byte[] keyBytes = Secret.getBytes(StandardCharsets.UTF_8); 返回 Keys.hmacShaKeyFor(keyBytes); } /** * 从用户详细信息中提取权限 */ 私有列表 getAuthorities(UserDetails userDetails) { 返回 userDetails.getAuthorities().stream() .map(GrantedAuthority::getAuthority) .collect(Collectors.toList()); } } ### 3\. JWT 身份验证过滤器 @组件 @RequiredArgsConstructor 公共类 JwtAuthenticationFilter 扩展 OncePerRequestFilter { 私有最终 JwtService jwtService; 私人最终 UserDetailsService userDetailsService; @覆盖受保护的无效 doFilterInternal( @NonNull HttpServletRequest 请求， @NonNull HttpServletResponse 响应， @NonNull FilterChain filterChain) 抛出 ServletException, IOException { 最终 String authHeader = request.getHeader("授权"); 最终字符串jwt；最终字符串用户电子邮件； // 检查不记名令牌 if (authHeader == null || !authHeader.startsWith("Bearer")) { // 检查 JWT cookie String jwtCookie = WebUtils.getCookie(request, "jwt-token") != null ？ WebUtils.getCookie(request, "jwt-token").getValue() ：空； if (jwtCookie != null) { jwt = jwtCookie； userEmail = jwtService.extractUsername(jwt); if (userEmail != null && SecurityContextHolder.getContext().getAuthentication() == null) { UserDetails userDetails = userDetailsService.loadUserByUsername(userEmail); if (jwtService.isTokenValid(jwt, userDetails)) { 用户名密码验证令牌 authToken = 新的用户名密码验证令牌（用户详细信息，空， userDetails.getAuthorities() ）； authToken.setDetails( 新的 WebAuthenticationDetailsSource().buildDetails(request) ）； SecurityContextHolder.getContext().setAuthentication(authToken); } } } filterChain.doFilter(请求，响应); 返回; } jwt = authHeader.substring(7); userEmail = jwtService.extractUsername(jwt); if (userEmail != null && SecurityContextHolder.getContext().getAuthentication() == null) { UserDetails userDetails = userDetailsService.loadUserByUsername(userEmail); if (jwtService.isTokenValid(jwt, userDetails)) { 用户名密码验证令牌 authToken = 新的用户名密码验证令牌（用户详细信息，空， userDetails.getAuthorities() ）； authToken.setDetails( 新的 WebAuthenticationDetailsSource().buildDetails(request) ）； SecurityContextHolder.getContext().setAuthentication(authToken); } } filterChain.doFilter(请求，响应); } } ### 4\.安全配置 @配置 @EnableWebSecurity @RequiredArgsConstructor @EnableMethodSecurity(prePostEnabled = true) 公共类安全配置{ 私有最终 JwtAuthenticationFilter jwtAuthFilter; 私有最终 AuthenticationProvider 身份验证提供程序；私有最终 LogoutHandler logoutHandler; @豆子公共SecurityFilterChain securityFilterChain（HttpSecurity http）抛出异常{ http .csrf(AbstractHttpConfigurer::禁用) .authorizeHttpRequests(身份验证->身份验证 // 公共端点 .requestMatchers("/api/v1/auth/**").permitAll() .requestMatchers("/api/v1/oauth2/**").permitAll() .requestMatchers("/swagger-ui/**", "/v3/api-docs/**").permitAll() .requestMatchers("/health").permitAll() // 管理端点 .requestMatchers("/api/v1/admin/**").hasRole("ADMIN") // 受保护的端点 .anyRequest().authenticated() ） .sessionManagement(sess -> sess .sessionCreationPolicy(SessionCreationPolicy.STATELESS) ） .authenticationProvider(authenticationProvider) .addFilterBefore(jwtAuthFilter, UsernamePasswordAuthenticationFilter.class) .oauth2Login(oauth2 -> oauth2 .loginPage("/oauth2/authorization/google") .defaultSuccessUrl("/api/v1/auth/oauth2/success", true) .failureUrl("/api/v1/auth/oauth2/failure") ） .logout(注销->注销 .logoutUrl("/api/v1/auth/logout") .addLogoutHandler(logoutHandler) .logoutSuccessHandler((请求、响应、身份验证)-> SecurityContextHolder.clearContext()) ）；返回 http.build(); } @豆子公共 AuthenticationProvider 身份验证提供程序（UserDetailsService userDetailsService，PasswordEncoder 密码Encoder）{ DaoAuthenticationProvider authProvider = new DaoAuthenticationProvider(); authProvider.setUserDetailsService(userDetailsService); authProvider.setPasswordEncoder(passwordEncoder); 返回 authProvider； } @豆子公共密码编码器密码编码器（）{ 返回新的 BCryptPasswordEncoder(); } @豆子公共 AuthenticationManager 身份验证管理器（AuthenticationConfiguration config）抛出异常 { 返回 config.getAuthenticationManager(); } } ## 身份验证控制器 @RestController @RequestMapping(“/api/v1/auth”) @RequiredArgsConstructor @Slf4j 公共类 AuthenticationController { 私有最终 AuthenticationService 身份验证服务； @PostMapping("/注册") 公共 ResponseEntity 注册（ @Valid @RequestBody RegisterRequest请求）{ log.info("注册新用户：{}", request.getEmail()); 返回 ResponseEntity.ok(authenticationService.register(request)); } @PostMapping("/验证") 公共 ResponseEntity 验证（ @Valid @RequestBody AuthenticationRequest 请求）{ log.info("正在验证用户：{}", request.getEmail()); AuthenticationResponse 响应=authenticationService.authenticate(请求); 返回 ResponseEntity.ok() .header("设置 Cookie", createJwtCookie(response.getAccessToken())) .body（响应）； } @PostMapping(“/刷新”) 公共 ResponseEntity 刷新令牌（ @RequestBody RefreshTokenRequest 请求）{ log.info("正在刷新用户令牌"); 返回 ResponseEntity.ok(authenticationService.refreshToken(request)); } @GetMapping(“/我”) 公共 ResponseEntity getCurrentUser() { 返回 ResponseEntity.ok(authenticationService.getCurrentUser()); } 私有字符串createJwtCookie（字符串令牌）{ 返回字符串.format( “jwt-token=%s；Path=/；HttpOnly；SameSite=Lax；Max-Age=%d”，令牌， 86400 // 24小时）； } } ## 授权模式 ### 基于角色的访问控制 (RBAC) @RestController @RequestMapping(“/api/v1/admin”) @RequiredArgsConstructor @PreAuthorize("hasRole('ADMIN')") 公共类 AdminController { 私有最终 AdminService adminService； @GetMapping(“/用户”) @PreAuthorize("hasAuthority('ADMIN_READ')") 公共 ResponseEntity> getAllUsers(Pageable 可分页) { 返回 ResponseEntity.ok(adminService.getAllUsers(可分页)); } @DeleteMapping("/users/{id}") @PreAuthorize("hasAuthority('ADMIN_DELETE')") 公共 ResponseEntity deleteUser(@PathVariable Long id) { adminService.deleteUser(id); 返回 ResponseEntity.noContent().build(); } @PostMapping("/users/{id}/roles") @PreAuthorize("hasAuthority('ADMIN_MANAGE_ROLES')") 公共 ResponseEntity 分配角色（ @PathVariable长id， @Valid@RequestBodyAssignRoleRequest 请求）{ 返回 ResponseEntity.ok(adminService.assignRole(id, request)); } } ### 基于权限的访问控制 @服务 @RequiredArgsConstructor 公共类文档服务{ @PreAuthorize("hasPermission(#documentId, '文档', '读')") 公共文档 getDocument(Long documentId) { 返回 documentRepository.findById(documentId) .orElseThrow(() -> new DocumentNotFoundException(documentId)); } @PreAuthorize("hasPermission(#documentId, 'Document', 'WRITE') 或 hasRole('ADMIN')") 公共文档 updateDocument（长文档 ID，UpdateDocumentRequest 请求）{ 文档文档 = getDocument(documentId); document.setContent(request.content()); 返回 documentRepository.save(document); } @PreAuthorize("@documentSecurityService.canAccess(#userEmail, #documentId)") 公共文档 shareDocument(String userEmail, Long documentId) { // 实现 } } ### 自定义权限评估器 @组件 @RequiredArgsConstructor 公共类 DocumentPermissionEvaluator 实现 PermissionEvaluator { 私有最终 DocumentRepository documentRepository; @覆盖公共布尔值具有权限（认证认证，对象目标域对象，对象权限）{ if (authentication == null || !(targetDomainObject instanceof Document)) { 返回假； } 文档文档 = (文档) targetDomainObject; 字符串用户名=authentication.getName(); String requiredPermission = (String) 权限； // 管理员可以做任何事情 if (hasRole(身份验证, "ADMIN")) { 返回真； } // 所有者可以读写 if (document.getOwner().getUsername().equals(用户名)) { 返回“READ”.equals(requiredPermission) || "WRITE".equals(requiredPermission); } // 检查共享权限返回 document.getSharedWith().stream() .anyMatch(共享 -> share.getUser().getUsername().equals(用户名) && share.getPermission().name().equals(requiredPermission)); } @覆盖公共布尔值具有权限（认证认证，可序列化的targetId，字符串目标类型，对象权限）{ if (!"Document".equals(targetType)) { 返回假； } 文档 document = documentRepository.findById((Long) targetId).orElse(null); return document != null && hasPermission(身份验证、文档、权限); } private boolean hasRole（身份验证authentication，字符串角色）{ 返回authentication.getAuthorities().stream() .anyMatch(auth -> auth.getAuthority().equals("ROLE_" + role)); } } ## 数据库实体 @实体 @Table(名称=“用户”) @数据 @NoArgs构造函数 @AllArgsConstructor @Builder 公共类用户{ @Id @GenerateValue(策略 = GenerationType.IDENTITY) 私人长ID； @Column（唯一= true，可为空= false）私有字符串用户名； @Column（唯一= true，可为空= false）私人字符串电子邮件； @Column(可为空 = false) 私有字符串密码； @Builder.Default @Enumerated(EnumType.STRING) 私有角色角色 = Role.USER; @Builder.Default 私有布尔值启用= true； @Builder.Default 私人布尔帐户NonExpired = true; @Builder.Default 私人布尔帐户NonLocked = true; @Builder.Default 私有布尔凭证NonExpired = true; @OneToMany(mappedBy = "用户", 级联 = CascadeType.ALL, fetch = FetchType.LAZY) 私有 Set refreshTokens = new HashSet<>(); @CreationTimestamp @Column（名称=“created_at”，可更新= false）私有 LocalDateTime 创建于； @更新时间戳 @Column(名称 = "updated_at") 私有 LocalDateTime 更新时间； } @实体 @Table(名称 = "refresh_tokens") @数据 @NoArgs构造函数 @AllArgsConstructor @Builder 公共类刷新令牌{ @Id @GenerateValue(策略 = GenerationType.IDENTITY) 私人长ID； @Column(nullable = false, unique = true) 私有字符串令牌； @ManyToOne(fetch = FetchType.LAZY) @JoinColumn(name = "user_id", nullable = false) 私人用户用户； @Builder.Default 私有布尔值撤销= false； @Builder.Default 私有布尔值已过期= false； @Column（名称=“到期日期”）私有 LocalDateTime 到期日期； @CreationTimestamp @Column（名称=“created_at”，可更新= false）私有 LocalDateTime 创建于； } ## 测试 JWT 安全性 @SpringBootTest @AutoConfigureMockMvc @TestPropertySource（属性= { “jwt.secret =测试秘密密钥仅用于测试”， “jwt.access-token-expiration=3600000” }) 类 AuthenticationControllerTest { @Autowired 私人 MockMvc 模拟Mvc； @Autowired 私有 ObjectMapper 对象映射器； @Autowired 私人 JwtService jwtService; @测试 void shouldAuthenticateUser() 抛出异常 { AuthenticationRequest 请求 = AuthenticationRequest.builder() .email("test@example.com") .password("密码123") .build(); mockMvc.perform(post("/api/v1/auth/authenticate") .contentType(MediaType.APPLICATION_JSON) .content(objectMapper.writeValueAsString(请求))) .andExpect(status().isOk()) .andExpect(jsonPath("$.accessToken").exists()) .andExpect(jsonPath("$.refreshToken").exists()) .andExpect(jsonPath("$.user.email").value("test@example.com")); } @测试 void shouldDenyAccessWithoutToken() 抛出异常 { mockMvc.perform(get("/api/v1/admin/users")) .andExpect(status().isUnauthorized()); } @测试 @WithMockUser(角色=“管理员”) void shouldAllowAdminAccess() 抛出异常 { mockMvc.perform(get("/api/v1/admin/users")) .andExpect(status().isOk()); } @测试 void shouldValidateJwtToken() 抛出异常 { UserDetails userDetails = User.withUsername("test@example.com") .password("密码") .角色（“用户”） .build(); 字符串令牌 = jwtService.generateAccessToken(userDetails); mockMvc.perform(get("/api/v1/auth/me") .header("授权", "承载者" + 令牌)) .andExpect(status().isOk()); } } ## 最佳实践 ### 1\.现代 JWT 模式 #### 密钥轮换策略 @组件 @RequiredArgsConstructor 公共类 JwtKeyRotationService { 私有最终 SecretKeyRepository keyRepository；私有最终 CacheManager 缓存管理器； @Scheduled(cron = "0 0 0 * * ?") // 每天午夜公共无效旋转键（）{ SecretKey newKey = Keys.secretKeyFor(SignatureAlgorithm.HS256); keyRepository.save(new SecretKeyEntity(newKey, LocalDateTime.now())); cacheManager.getCache("jwt-keys").clear(); } } #### 令牌黑名单 @服务 @RequiredArgsConstructor 公共类 TokenBlacklistService { 私有最终RedisTemplate <字符串，字符串> redisTemplate; 私有静态最终字符串 BLACKLIST_PREFIX = "blacklist:jwt:"; 公共无效blacklistToken（字符串令牌，长过期时间）{ 字符串 tokenId = extractTokenId(token); redisTemplate.opsForValue().set( BLACKLIST_PREFIX + tokenId， “1”, 过期时间，时间单位.毫秒）； } 公共布尔 isBlacklisted（字符串标记）{ 字符串 tokenId = extractTokenId(token); return Boolean.TRUE.equals(redisTemplate.hasKey(BLACKLIST_PREFIX + tokenId)); } } ### 2\.安全配置 * **在生产中始终使用 HTTPS** 进行 JWT 令牌传输 * **设置适当的 cookie 标志**：`HttpOnly`、`Secure`、`SameSite` * **使用强密钥**：HMAC 算法至少 256 位 * **实现令牌过期** ：不要使用具有无限生命周期的令牌 * **验证所有输入**：切勿在未经验证的情况下信任 JWT 声明 * **实施密钥轮换** ：定期轮换签名密钥 * **使用令牌黑名单**：用于注销和安全事件 ### 2\.代币管理 // 实现刷新令牌轮换公共类 RefreshTokenService { @事务性公共字符串rotateRefreshToken（字符串oldToken）{ RefreshToken刷新令牌=refreshTokenRepository.findByToken(oldToken) .orElseThrow(() -> new RefreshTokenException("无效的刷新令牌")); // 撤销旧令牌 freshToken.setRevoked(true); 刷新TokenRepository.save(refreshToken); // 生成新的令牌返回 createRefreshToken(refreshToken.getUser().getUsername()); } } ### 3\.性能优化 // 缓存用户详细信息以避免数据库命中 @服务 @RequiredArgsConstructor 公共类 CachedUserDetailsService 实现 UserDetailsService { 私有最终 UserRepository userRepository; 私有最终 CacheManager 缓存管理器； @覆盖 @Cacheable（值=“用户”，键=“#用户名”）公共 UserDetails loadUserByUsername（字符串用户名）{ 用户 user = userRepository.findByEmail(用户名) .orElseThrow(() -> new UsernameNotFoundException(用户名)); 返回新的 CustomUserDetails(用户); } } ### 4\.监控和审计 @组件 @RequiredArgsConstructor @Slf4j 公共类SecurityAuditService { @EventListener 公共无效handleAuthenticationSuccess（AuthenticationSuccessEvent事件）{ log.info("用户身份验证成功：{}", event.getAuthentication().getName()); // 存储审计事件 } @EventListener 公共无效handleAuthenticationFailure（AuthenticationFailureEvent事件）{ log.warn("用户身份验证失败：{}", event.getAuthentication().getName()); // 存储安全事件 } @EventListener 公共无效handleAuthorizationFailure（AuthorizationFailureEvent事件）{ log.warn("用户：{} 对资源：{} 的授权被拒绝", event.getAuthentication().getName(), event.getConfigAttributes()); } } ## 限制和警告 ### 1\.代币大小限制 * JWT 令牌应保持在 HTTP 标头大小限制范围内（通常为 8KB） * 避免在 JWT 声明中存储大量数据 * 使用引用而不是嵌入完整的对象 ### 2\.安全考虑 * 切勿将敏感信息存储在 JWT 令牌中 * 实施适当的令牌撤销策略 * 针对不同的环境（dev、staging、prod）使用不同的密钥 * 定期轮换签名密钥 * 在生产环境中始终使用HTTPS * 设置适当的 cookie 标志：`HttpOnly`、`Secure`、`SameSite` * 使用强密钥：HMAC 算法至少 256 位 ### 3\.令牌过期 * 实施令牌过期以限制漏洞窗口 * 使用带有刷新令牌轮换的短期访问令牌 * 切勿使用具有无限生命周期的代币 ### 4\.性能考虑因素 * 缓存用户详细信息以避免每个请求都命中数据库 * 考虑将令牌列入黑名单以处理注销和安全事件 * 监控生产中的令牌验证延迟 ### 5\.常见陷阱 * 不在客户端验证 JWT 签名 * 绝不接受来自不可信来源的代币 * 始终验证令牌发行者 (`iss`) 和受众 (`aud`) 声明 * 请注意，JWT 声明未加密，仅签名 ## 示例 ### 输入：登录请求 { “电子邮件”：“user@example.com”， “密码”：“SecurePass123！” } ### 输出：身份验证响应 { "accessToken": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...", "refreshToken": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...", "tokenType": "承载者", “过期”：86400， “用户”：{ “id”：1， “电子邮件”：“user@example.com”， “角色”：“用户” } } ### 输入：注册请求 { “用户名”：“新用户”， “电子邮件”：“newuser@example.com”， "密码": "SecurePass123!", "confirmPassword": "SecurePass123!" } ### 输出：注册响应 { “id”：2， “用户名”：“新用户”， “电子邮件”：“newuser@example.com”， “角色”：“用户”， “创建于”：“2024-01-15T10:30:00Z” } ### 输入：无令牌的受保护 API 请求卷曲 -X GET http://localhost:8080/api/v1/orders ### 输出：401 未经授权 { "时间戳": "2024-01-15T10:35:00Z", “状态”：401， "error": "未经授权", "message": "访问此资源需要完全身份验证" } ### 输入：带有令牌的受保护 API 请求 curl -X GET http://localhost:8080/api/v1/orders \ -H“授权：持有者 eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...” ### 输出：200 OK { “内容”：[ { “id”：1， "订单号": "ORD-001", “状态”：“已完成”， “总计”：99.99 } ], “可分页”：{ “页”：0， “尺寸”：20， “总计”：1 } } ### 输入：刷新令牌请求 { “refreshToken”：“eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...” } ### 输出：新的访问令牌 { "accessToken": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...", "refreshToken": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...", "tokenType": "承载者", “过期”：86400 } ## 参考资料 * [完整的 JWT 配置指南]() \- Spring Security 6.x 的统一配置模式 * [JWT 测试指南]() \- 全面的测试策略 * [JWT 快速参考]() \- 常见模式和快速示例 * [完整实现示例]() * [安全强化清单]() * [Spring Security 6.x 迁移指南]() ## 相关技能 * `spring-boot-dependency-injection` \- 整个过程中使用的构造函数注入模式 * `spring-boot-rest-api-standards` \- REST API 安全模式和错误处理 * `unit-test-security-authorization` \- 测试 Spring Security 配置 * `spring-data-jpa` \- 用户实体和存储库模式 * `spring-boot-actuator` \- 安全监控和健康端点

Spring Boot 安全 Jwt

包含技能