Java安全认证系统实战：基于Spring Security与JWT的RBAC架构设计

1. 项目概述：为什么我们需要“强大”的安全认证系统？

在Java开发领域，尤其是涉及用户数据、交易或内部管理的企业级应用中，“安全认证”这四个字的分量，远比我们想象的要重。它不仅仅是登录时的一个用户名密码框，而是守护整个应用数据疆域的第一道，也是最重要的一道防线。我见过太多项目，初期为了快速上线，认证逻辑写得极其简陋，一个简单的MD5加密用户密码就敢直接存数据库，权限校验全靠几个if-else。等到用户量起来，或者不幸被“拖库”、遭遇撞库攻击时，才追悔莫及，不得不投入数倍的人力物力进行重构和“打补丁”。

所以，当我们谈论“设计和实现强大的安全认证系统”时，我们到底在谈论什么？强大，意味着它不仅仅是“能用”，而是具备防御性、可扩展性、可维护性和合规性。它要能抵御常见的网络攻击（如密码爆破、会话劫持、CSRF），要能优雅地支撑业务从单体架构演进到微服务，要能让后续的开发者清晰地理解其脉络并进行维护，还要能满足日益严格的数据安全法规要求。

这个系统适合所有正在或计划使用Java构建严肃Web应用、API服务或后端管理系统的开发者。无论你是刚入行，正在为面试中的“安全八股文”头疼，还是资深工程师，负责为团队搭建统一的安全基座，理解并实践一套完整的安全认证体系，都是不可或缺的核心技能。接下来，我将结合多年的踩坑经验，为你拆解如何从零开始，构建这样一个系统。

2. 核心架构设计与技术选型

构建安全认证系统，切忌一上来就埋头写代码。一个好的设计蓝图，能让你在后续的开发中事半功倍，避免陷入“拆东墙补西墙”的窘境。

2.1 认证与授权的核心思想：RBAC模型

首先必须厘清两个核心概念：认证（Authentication）和授权（Authorization）。认证解决“你是谁？”的问题，即验证用户的身份，比如通过账号密码登录。授权解决“你能干什么？”的问题，即验证用户是否有权限执行某个操作或访问某个资源。

目前最主流、最实用的授权模型是RBAC（Role-Based Access Control，基于角色的访问控制）。它的核心思想是：将权限分配给角色，再将角色分配给用户。用户通过扮演角色来获得权限，而不是直接拥有权限。这样做的好处是权限管理变得清晰、灵活。当需要调整一批用户的权限时，只需修改他们所属角色的权限即可，无需逐个修改用户。

一个基础的RBAC模型通常包含以下实体：

• 用户（User）：系统的使用者。
• 角色（Role）：一组权限的集合，如“管理员”、“普通用户”、“访客”。
• 权限（Permission）：对资源的具体操作许可，通常用“资源:操作”的形式表示，如user:read,order:delete。
• 用户-角色关系：一个用户可以拥有多个角色。
• 角色-权限关系：一个角色可以包含多个权限。

在我们的系统中，我们将严格遵循这一模型进行数据库设计和业务逻辑实现。

2.2 技术栈选型与考量

Java生态中安全框架的选择，直接决定了我们系统的实现路径和复杂度。

1. Spring Security：不二之选对于绝大多数Java Web项目，Spring Security是构建认证授权系统的基石。它功能强大、模块化清晰，并且与Spring生态无缝集成。它抽象了认证和授权的核心流程，我们只需要通过配置和扩展点，就能实现复杂的安全逻辑。放弃手写Filter链和Session管理，拥抱Spring Security，是迈向“强大”系统的第一步。

2. 认证令牌：JWT vs. Session这是现代认证系统设计的一个关键抉择。

   • 传统Session：用户登录后，服务器生成一个Session ID存储在服务端（如Redis），并返回给浏览器（通常通过Cookie）。后续请求携带此ID，服务器进行校验。优点是服务端有完全控制力，可以随时让某个会话失效。缺点是服务器需要存储状态，在分布式环境下需要Session共享方案，增加了复杂度。
   • JWT（JSON Web Token）：一种无状态的令牌。用户登录后，服务器用密钥生成一个包含用户身份信息的JSON对象（Token），直接返回给客户端。客户端后续在请求头（如Authorization: Bearer <token>）中携带此Token。服务器只需验证Token的签名即可确认其有效性，无需存储。

   如何选择？

   • 如果你的系统是纯API服务、需要跨域认证、或者追求极致的无状态和水平扩展性，JWT是更好的选择。
   • 如果你的系统是传统的Web应用（服务器渲染页面）、对即时吊销令牌有强需求（如用户修改密码后立即踢出所有设备），或者担心Token泄露后的安全问题（JWT在有效期内无法主动作废），那么基于Redis的Session方案更稳妥。
   • 折中方案：采用“有状态的JWT”，即将JWT的ID（jti）存入Redis，校验时不仅验签，也检查Redis中该jti是否存在（是否被加入黑名单）。这结合了JWT的自包含性和Session的可控性。

   在本设计中，为了覆盖更广泛的场景，我们将以“JWT + Redis存储Token黑名单/白名单”作为核心方案进行详解，这既能满足API服务的需求，也提供了主动吊销令牌的能力。

3. 密码存储：必须使用BCrypt绝对禁止使用MD5、SHA-1等快速哈希算法存储密码！这些算法在当今的算力下极易被暴力破解或通过彩虹表反推。BCrypt是专门为密码哈希设计的算法，它内置了盐（Salt）来防止彩虹表攻击，并且可以通过调整工作因子（work factor）来增加哈希计算的成本，从而有效抵御暴力破解。Spring Security的PasswordEncoder接口默认就提供了BCrypt的实现，我们直接使用即可。

4. 数据库与缓存

   • 数据库：用于持久化存储用户、角色、权限等核心数据。MySQL/PostgreSQL皆可。
   • 缓存（Redis）：核心作用有两个：一是作为分布式Session存储或JWT黑名单存储；二是缓存用户的权限信息，避免每次请求都查询数据库，极大提升性能。

2.3 系统架构蓝图

基于以上选型，我们的系统高层级架构如下：

1. 客户端：Web、App等，发起登录请求，获取JWT，并在后续请求中携带。
2. 认证过滤器：一个自定义的Spring SecurityOncePerRequestFilter，拦截所有请求，从请求头中提取JWT，进行验签、过期检查，并查询Redis确认令牌是否有效（未被加入黑名单）。
3. 认证管理器：过滤器验证通过后，会根据JWT中的用户标识（如username），加载用户的详细信息（UserDetails）和权限列表。这里可以从数据库查，但更优的做法是从Redis缓存中获取。
4. 授权决策器：在访问受保护资源时，Spring Security的AccessDecisionManager会调用我们的逻辑，判断当前用户拥有的权限是否满足访问该资源所需的权限。
5. 安全上下文：认证成功后，用户信息和权限会被存入SecurityContextHolder，在整个请求线程内可随时获取。

注意：这个架构是一个经典的、可落地的方案。它清晰地分离了关注点，每一层都有明确的职责。

3. 数据库与核心实体设计

设计良好的数据模型是系统的骨架。这里我们给出核心表的设计，并解释其关联关系。

3.1 数据表设计

-- 用户表 CREATE TABLE `sys_user` ( `id` BIGINT PRIMARY KEY AUTO_INCREMENT, `username` VARCHAR(50) UNIQUE NOT NULL COMMENT '用户名，唯一', `password` VARCHAR(100) NOT NULL COMMENT '加密后的密码', `email` VARCHAR(100) COMMENT '邮箱', `phone` VARCHAR(20) COMMENT '手机号', `status` TINYINT DEFAULT 1 COMMENT '状态：0-禁用，1-启用', `last_login_time` DATETIME COMMENT '最后登录时间', `create_time` DATETIME DEFAULT CURRENT_TIMESTAMP, `update_time` DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP ) COMMENT='系统用户表'; -- 角色表 CREATE TABLE `sys_role` ( `id` BIGINT PRIMARY KEY AUTO_INCREMENT, `role_code` VARCHAR(50) UNIQUE NOT NULL COMMENT '角色编码，如ADMIN, USER', `role_name` VARCHAR(50) NOT NULL COMMENT '角色名称', `description` VARCHAR(200) COMMENT '角色描述' ) COMMENT='系统角色表'; -- 权限表（或称为资源表） CREATE TABLE `sys_permission` ( `id` BIGINT PRIMARY KEY AUTO_INCREMENT, `perm_code` VARCHAR(100) NOT NULL COMMENT '权限标识，如user:add, order:query', `perm_name` VARCHAR(50) NOT NULL COMMENT '权限名称', `resource_type` VARCHAR(20) COMMENT '资源类型：MENU, BUTTON, API', `url` VARCHAR(200) COMMENT '对应API路径或前端路由', `parent_id` BIGINT DEFAULT 0 COMMENT '父权限ID，用于树形结构', `create_time` DATETIME DEFAULT CURRENT_TIMESTAMP ) COMMENT='系统权限表'; -- 用户-角色关联表 CREATE TABLE `sys_user_role` ( `user_id` BIGINT NOT NULL, `role_id` BIGINT NOT NULL, PRIMARY KEY (`user_id`, `role_id`), FOREIGN KEY (`user_id`) REFERENCES `sys_user`(`id`) ON DELETE CASCADE, FOREIGN KEY (`role_id`) REFERENCES `sys_role`(`id`) ON DELETE CASCADE ) COMMENT='用户角色关联表'; -- 角色-权限关联表 CREATE TABLE `sys_role_permission` ( `role_id` BIGINT NOT NULL, `perm_id` BIGINT NOT NULL, PRIMARY KEY (`role_id`, `perm_id`), FOREIGN KEY (`role_id`) REFERENCES `sys_role`(`id`) ON DELETE CASCADE, FOREIGN KEY (`perm_id`) REFERENCES `sys_permission`(`id`) ON DELETE CASCADE ) COMMENT='角色权限关联表';

设计要点解析：

• sys_user.password字段长度建议设为100，BCrypt哈希后的字符串长度是固定的60位，留足余量。
• sys_permission.perm_code是权限的核心标识，我们约定使用资源:操作的格式（如user:read,order:delete），这在后续的注解鉴权中非常方便。
• 通过sys_user_role和sys_role_permission两张关联表，实现了灵活的RBAC模型。一个用户可以有多个角色，一个角色可以有多个权限。

3.2 实体类与关系映射

在Java中，我们使用JPA（或MyBatis）来映射这些表。以JPA为例，核心实体类的关系映射需要注意避免循环引用和N+1查询问题。通常，在查询用户时，我们会通过单独的Service方法或@EntityGraph注解来主动加载其角色和权限，而不是在实体关系上设置急加载（FetchType.EAGER）。

4. 核心模块实现详解

接下来，我们进入代码实战环节。假设我们使用Spring Boot + Spring Security + JPA + Redis的技术栈。

4.1 密码编码器与用户详情服务

首先，配置一个全局的密码编码器Bean，强制所有密码使用BCrypt。

@Configuration public class SecurityConfig { @Bean public PasswordEncoder passwordEncoder() { // 使用BCrypt，强度因子默认为10 return new BCryptPasswordEncoder(); } }

然后，实现Spring Security的核心接口UserDetailsService，用于根据用户名加载用户信息。

@Service public class UserDetailsServiceImpl implements UserDetailsService { @Autowired private UserRepository userRepository; @Autowired private RoleService roleService; @Override @Transactional(readOnly = true) public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException { SysUser user = userRepository.findByUsername(username) .orElseThrow(() -> new UsernameNotFoundException("用户不存在: " + username)); if (user.getStatus() == 0) { throw new DisabledException("用户已被禁用"); } // 查询用户拥有的所有权限标识符（perm_code） List<String> permissionCodes = roleService.getUserPermissions(user.getId()); // 将权限字符串转换为Spring Security需要的GrantedAuthority对象 List<SimpleGrantedAuthority> authorities = permissionCodes.stream() .map(SimpleGrantedAuthority::new) .collect(Collectors.toList()); // 构建UserDetails对象返回 return new org.springframework.security.core.userdetails.User( user.getUsername(), user.getPassword(), // 数据库里存的是BCrypt加密后的密码 authorities ); } }

实操心得：UserDetailsService的loadUserByUsername方法会被频繁调用（每次认证时）。务必确保其高效，特别是权限查询。这里通过roleService.getUserPermissions一次性查出所有权限码，这个Service内部应该做缓存优化（如使用Redis），避免复杂的多表关联查询拖慢性能。

4.2 JWT工具类与认证过滤器

创建JWT工具类，负责Token的生成、解析和验证。

@Component public class JwtTokenProvider { @Value("${jwt.secret}") private String jwtSecret; // 密钥，从配置读取，务必复杂且保密 @Value("${jwt.expiration}") private long jwtExpirationInMs; // 过期时间，如3600000 (1小时) // 生成Token public String generateToken(String username, List<String> roles) { Date now = new Date(); Date expiryDate = new Date(now.getTime() + jwtExpirationInMs); return Jwts.builder() .setSubject(username) // 主题，通常放用户名 .claim("roles", roles) // 自定义声明，存放角色 .setIssuedAt(now) .setExpiration(expiryDate) .signWith(SignatureAlgorithm.HS512, jwtSecret) // 使用HS512算法签名 .compact(); } // 从Token中获取用户名 public String getUsernameFromToken(String token) { Claims claims = Jwts.parser() .setSigningKey(jwtSecret) .parseClaimsJws(token) .getBody(); return claims.getSubject(); } // 验证Token public boolean validateToken(String token) { try { Jwts.parser().setSigningKey(jwtSecret).parseClaimsJws(token); // 额外检查：可以在这里查询Redis，看此Token的jti是否在黑名单中 return true; } catch (SignatureException ex) { log.error("Invalid JWT signature"); } catch (MalformedJwtException ex) { log.error("Invalid JWT token"); } catch (ExpiredJwtException ex) { log.error("Expired JWT token"); } catch (UnsupportedJwtException ex) { log.error("Unsupported JWT token"); } catch (IllegalArgumentException ex) { log.error("JWT claims string is empty."); } return false; } }

接着，创建核心的认证过滤器。这个过滤器会拦截所有请求，尝试提取并验证JWT。

@Component public class JwtAuthenticationFilter extends OncePerRequestFilter { @Autowired private JwtTokenProvider tokenProvider; @Autowired private UserDetailsServiceImpl userDetailsService; @Autowired private RedisTemplate<String, String> redisTemplate; @Override protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException { try { // 1. 从请求头中获取JWT String jwt = getJwtFromRequest(request); // 2. 如果Token存在且有效 if (StringUtils.hasText(jwt) && tokenProvider.validateToken(jwt)) { // 3. 从Token中解析用户名 String username = tokenProvider.getUsernameFromToken(jwt); // 4. 关键步骤：检查Redis中该Token是否在黑名单（如用户已登出） String blackListKey = "jwt:blacklist:" + DigestUtils.md5DigestAsHex(jwt.getBytes()); if (Boolean.TRUE.equals(redisTemplate.hasKey(blackListKey))) { // Token已被加入黑名单，视为无效 throw new AuthenticationCredentialsNotFoundException("Token已失效"); } // 5. 加载用户详情，Spring Security会自动完成权限注入 UserDetails userDetails = userDetailsService.loadUserByUsername(username); UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(userDetails, null, userDetails.getAuthorities()); authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails(request)); // 6. 将认证信息设置到Security上下文中 SecurityContextHolder.getContext().setAuthentication(authentication); } } catch (Exception ex) { log.error("Could not set user authentication in security context", ex); // 这里不要直接抛出异常导致请求失败，而是交给Spring Security的异常处理器 // 可以设置一个特殊的请求属性，供后续的AuthenticationEntryPoint处理 request.setAttribute("jwtAuthenticationException", ex); } // 7. 继续过滤器链 filterChain.doFilter(request, response); } private String getJwtFromRequest(HttpServletRequest request) { String bearerToken = request.getHeader("Authorization"); if (StringUtils.hasText(bearerToken) && bearerToken.startsWith("Bearer ")) { return bearerToken.substring(7); } return null; } }

4.3 Spring Security 核心配置

现在，我们将所有组件串联起来，通过一个配置类来定义Spring Security的行为。

@Configuration @EnableWebSecurity @EnableGlobalMethodSecurity(prePostEnabled = true) // 启用方法级安全注解，如@PreAuthorize public class WebSecurityConfig extends WebSecurityConfigurerAdapter { @Autowired private UserDetailsServiceImpl userDetailsService; @Autowired private JwtAuthenticationFilter jwtAuthenticationFilter; @Autowired private JwtAuthenticationEntryPoint jwtAuthenticationEntryPoint; // 自定义的认证失败处理器 @Autowired private AccessDeniedHandlerImpl accessDeniedHandler; // 自定义的授权失败处理器 @Bean public AuthenticationManager authenticationManagerBean() throws Exception { return super.authenticationManagerBean(); } @Override protected void configure(AuthenticationManagerBuilder auth) throws Exception { auth.userDetailsService(userDetailsService) .passwordEncoder(passwordEncoder()); } @Override protected void configure(HttpSecurity http) throws Exception { http // 禁用CSRF，因为使用JWT无状态认证，但需确保API无XSS风险。如果混合Web应用，需谨慎。 .csrf().disable() // 启用CORS，配置跨域 .cors().and() .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS).and() // 无状态会话 .authorizeRequests() .antMatchers("/api/auth/**").permitAll() // 认证相关接口放行 .antMatchers("/api/public/**").permitAll() // 公开接口放行 .anyRequest().authenticated() // 其他所有接口都需要认证 .and() // 添加我们自定义的JWT过滤器，在UsernamePasswordAuthenticationFilter之前 .addFilterBefore(jwtAuthenticationFilter, UsernamePasswordAuthenticationFilter.class) // 配置异常处理 .exceptionHandling() .authenticationEntryPoint(jwtAuthenticationEntryPoint) // 处理未认证访问 .accessDeniedHandler(accessDeniedHandler); // 处理已认证但权限不足 } @Bean public PasswordEncoder passwordEncoder() { return new BCryptPasswordEncoder(); } }

关键配置解析：

• @EnableGlobalMethodSecurity(prePostEnabled = true)：这个注解至关重要，它允许我们在Controller的方法上使用@PreAuthorize("hasAuthority('user:read')")这样的注解进行细粒度的方法级权限控制。
• sessionCreationPolicy(SessionCreationPolicy.STATELESS)：声明为无状态，告诉Spring Security不要创建和使用HttpSession，完全依赖Token。
• .addFilterBefore(jwtAuthenticationFilter, UsernamePasswordAuthenticationFilter.class)：将我们的JWT过滤器插入到Spring Security默认的用户名密码认证过滤器之前，这样我们的过滤器会先执行，尝试进行JWT认证。

4.4 认证与授权API实现

最后，我们实现提供登录、登出、刷新Token等功能的API端点。

@RestController @RequestMapping("/api/auth") public class AuthController { @Autowired private AuthenticationManager authenticationManager; @Autowired private JwtTokenProvider tokenProvider; @Autowired private RedisTemplate<String, String> redisTemplate; @PostMapping("/login") public ResponseEntity<?> login(@Valid @RequestBody LoginRequest loginRequest) { // 1. 使用Spring Security的AuthenticationManager进行认证 Authentication authentication = authenticationManager.authenticate( new UsernamePasswordAuthenticationToken( loginRequest.getUsername(), loginRequest.getPassword() ) ); // 2. 认证成功，将认证信息存入上下文（可选，但建议做） SecurityContextHolder.getContext().setAuthentication(authentication); // 3. 获取当前用户详情，用于生成Token UserDetails userDetails = (UserDetails) authentication.getPrincipal(); List<String> roles = userDetails.getAuthorities().stream() .map(GrantedAuthority::getAuthority) .collect(Collectors.toList()); // 4. 生成JWT String jwt = tokenProvider.generateToken(userDetails.getUsername(), roles); // 5. 可以将Token的指纹（如MD5）存入Redis白名单（可选，用于实现单点登录或Token管理） String tokenKey = "jwt:user:" + userDetails.getUsername(); redisTemplate.opsForValue().set(tokenKey, DigestUtils.md5DigestAsHex(jwt.getBytes()), 1, TimeUnit.HOURS); // 6. 返回Token和用户基本信息 return ResponseEntity.ok(new JwtAuthenticationResponse(jwt, userDetails.getUsername(), roles)); } @PostMapping("/logout") @PreAuthorize("isAuthenticated()") // 需要登录才能登出 public ResponseEntity<?> logout(HttpServletRequest request) { String jwt = getJwtFromRequest(request); // 复用过滤器中的提取方法 if (StringUtils.hasText(jwt)) { // 将当前Token加入黑名单，直到其自然过期 String blackListKey = "jwt:blacklist:" + DigestUtils.md5DigestAsHex(jwt.getBytes()); long expiration = tokenProvider.getExpirationFromToken(jwt); // 需要实现此方法，获取Token剩余有效期 long ttl = expiration - System.currentTimeMillis(); if (ttl > 0) { redisTemplate.opsForValue().set(blackListKey, "logout", ttl, TimeUnit.MILLISECONDS); } // 同时清理白名单（如果用了的话） String username = tokenProvider.getUsernameFromToken(jwt); redisTemplate.delete("jwt:user:" + username); } SecurityContextHolder.clearContext(); // 清理安全上下文 return ResponseEntity.ok("登出成功"); } @PostMapping("/refresh") public ResponseEntity<?> refreshToken(HttpServletRequest request) { String oldToken = getJwtFromRequest(request); // 验证旧Token有效性（但允许过期一点点，比如在刷新窗口期内） // 从旧Token中解析用户信息 // 检查旧Token是否在黑名单（如果已登出则不能刷新） // 生成新Token，并使旧Token加入短期黑名单（防止被重复使用） // 返回新Token // 具体实现略，逻辑较为复杂，需仔细设计刷新策略 } }

5. 高级特性与最佳实践

一个“强大”的系统，必须考虑超越基础功能的进阶场景和防御措施。

5.1 细粒度方法级权限控制

使用Spring Security的@PreAuthorize和@PostAuthorize注解，可以轻松实现方法级别的权限校验。

@RestController @RequestMapping("/api/users") public class UserController { @GetMapping("/{id}") @PreAuthorize("hasAuthority('user:read') or #id == authentication.principal.username") public ResponseEntity<UserInfo> getUserById(@PathVariable Long id) { // 只有拥有'user:read'权限的用户，或者查询的是自己的信息，才能访问 // ... } @PostMapping @PreAuthorize("hasAuthority('user:add')") public ResponseEntity<?> createUser(@RequestBody @Valid CreateUserRequest request) { // 只有拥有'user:add'权限的用户才能创建 // ... } @DeleteMapping("/{id}") @PreAuthorize("hasAuthority('user:delete')") public ResponseEntity<?> deleteUser(@PathVariable Long id) { // 只有拥有'user:delete'权限的用户才能删除 // ... } }

SpEL表达式非常强大，#id可以引用方法参数，authentication.principal可以获取当前认证的主体（我们的UserDetails对象），这使得权限规则可以非常灵活。

5.2 限流与防暴力破解

登录接口是攻击的重灾区。必须实施限流措施。

1. 基于IP的登录限流：使用Redis记录每个IP地址在时间窗口内的登录失败次数。

@Service public class LoginAttemptService { @Autowired private RedisTemplate<String, Integer> redisTemplate; private static final int MAX_ATTEMPT = 5; private static final long LOCK_TIME_DURATION = 15 * 60 * 1000; // 锁定15分钟 public void loginFailed(String ipAddress) { String key = "login:attempts:" + ipAddress; Integer attempts = redisTemplate.opsForValue().get(key); if (attempts == null) { redisTemplate.opsForValue().set(key, 1, 1, TimeUnit.HOURS); // 1小时内计数 } else if (attempts < MAX_ATTEMPT) { redisTemplate.opsForValue().increment(key); } else { // 超过最大尝试次数，锁定该IP String lockKey = "login:locked:" + ipAddress; redisTemplate.opsForValue().set(lockKey, "LOCKED", LOCK_TIME_DURATION, TimeUnit.MILLISECONDS); } } public boolean isBlocked(String ipAddress) { String lockKey = "login:locked:" + ipAddress; return Boolean.TRUE.equals(redisTemplate.hasKey(lockKey)); } public void loginSuccess(String ipAddress) { // 登录成功，清除失败记录 String key = "login:attempts:" + ipAddress; redisTemplate.delete(key); } }

然后在登录逻辑中，先检查IP是否被锁定，登录失败时调用loginFailed，成功时调用loginSuccess。

2. 使用Spring Security的认证失败处理器：可以自定义AuthenticationFailureHandler，在认证失败时触发上述限流逻辑。

5.3 安全响应头与CORS配置

通过配置HttpSecurity或使用过滤器，添加重要的安全HTTP头，如：

• Strict-Transport-Security (HSTS)：强制浏览器使用HTTPS。
• X-Content-Type-Options: nosniff：防止浏览器MIME类型嗅探。
• X-Frame-Options: DENY：防止点击劫持。
• X-XSS-Protection: 1; mode=block：启用浏览器XSS过滤。

CORS配置务必精确，避免使用allowedOrigins("*")。

@Bean public CorsFilter corsFilter() { UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource(); CorsConfiguration config = new CorsConfiguration(); config.setAllowCredentials(true); config.addAllowedOrigin("https://your-trusted-domain.com"); // 指定具体前端域名 config.addAllowedHeader("*"); config.addAllowedMethod("*"); source.registerCorsConfiguration("/api/**", config); return new CorsFilter(source); }

5.4 审计日志

记录关键的安全事件，如登录成功/失败、权限变更、敏感操作（删除、导出）等。这不仅是合规要求，也是事后追溯和分析攻击的宝贵资料。可以使用Spring AOP或自定义注解，在关键方法上记录操作日志，包含操作人、时间、IP、动作和结果。

6. 部署、监控与常见问题排查

系统上线不是终点，持续的监控和维护才能保证其长期稳定运行。

6.1 密钥管理与配置

JWT的签名密钥（jwt.secret）是系统的命门。绝对不要将其硬编码在代码中或提交到版本库。

• 生产环境：使用环境变量、配置中心（如Spring Cloud Config、Apollo）或云服务商提供的密钥管理服务（如AWS KMS, Azure Key Vault）来注入。
• 定期轮换：制定密钥轮换策略。由于JWT是无状态的，轮换密钥会使所有已颁发的Token立即失效，因此需要配合Token刷新机制或让用户重新登录。一种平滑的方式是使用密钥ID（Kid），在验证时根据Kid选择对应的密钥。

6.2 性能监控与告警

• 监控Redis：监控Redis的内存使用率、连接数、命令延迟。Token黑名单/白名单都存储在Redis，它的可用性直接影响认证系统。
• 监控认证接口：关注/api/auth/login的响应时间、调用频率和错误率。异常飙升可能意味着暴力破解攻击。
• 日志聚合：将应用日志、安全审计日志集中收集到ELK或Splunk等平台，方便检索和分析安全事件。

6.3 常见问题排查速查表

6.4 我踩过的坑与心得

1. Token过期时间设置：访问令牌（Access Token）不宜过长（如1-2小时），刷新令牌（Refresh Token）可以设置较长时间（如7天）。通过Refresh Token来获取新的Access Token，可以在安全性和用户体验间取得平衡。千万不要把Refresh Token也放到前端localStorage里，最好设为HttpOnly的Cookie，减少被XSS盗取的风险。
2. 权限缓存更新：当管理员修改了用户的角色或权限后，如何让已登录用户的权限立即生效？因为权限信息可能被缓存在Redis或用户的JWT里。我们的做法是，在权限变更时，发布一个事件，清理对应用户的权限缓存。对于JWT，由于其不可变性，只能等待Token过期或强制其登出（将Token加入黑名单）。
3. 不要过度设计：在项目初期，如果业务模型简单，可以直接使用用户-权限的简单模型，跳过角色层。等业务复杂后再引入RBAC。一开始就设计五张表（用户、角色、权限、用户角色、角色权限）可能会增加不必要的复杂度。
4. 测试！测试！测试！：务必为安全相关的逻辑编写全面的单元测试和集成测试。特别是边界情况：禁用用户登录、过期Token、错误格式Token、权限不足访问等。安全无小事，一个疏忽就可能造成漏洞。