Spring Security 2026 构建安全、可靠的企业应用实践指南

Spring Security 2026 构建安全、可靠的企业应用实践指南

一、Spring Security 2026 概述

Spring Security 作为 Spring 生态中的安全框架，提供了一套完整的安全解决方案。随着版本不断演进，2026 版本带来了诸多新特性和改进。从架构视角来看，它不仅是技术工具，更是构建安全、可靠企业应用的关键能力。

1.1 版本演进

Spring Security 从早期的 Acegi Security 发展到如今的 2026 版本，经历了从简单认证授权到完整安全生态系统的蜕变。每一个版本的更新，都在追求更全面、更灵活的安全方案。

1.2 核心特性

Spring Security 2026 的核心特性包括：

• 认证：支持多种认证方式，如用户名密码、OAuth 2.0、OpenID Connect 等
• 授权：基于角色、权限的细粒度授权
• 安全防护：防止 CSRF、XSS、SQL 注入等安全攻击
• 会话管理：管理用户会话和令牌
• 集成：与 Spring 生态系统的无缝集成

二、认证最佳实践

2.1 多因素认证

核心策略：

• 启用 MFA：为敏感操作启用多因素认证
• 多种验证方式：支持信息、邮件、TOTP 等多种验证方式
• 渐进式认证：根据操作的敏感程度要求不同级别的认证

示例：

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
            .antMatchers("/api/public/**").permitAll()
            .antMatchers("/api/user/**").authenticated()
            .antMatchers("/api/admin/**").hasRole("ADMIN")
            .antMatchers("/api/payment/**").hasRole("USER").and()
            .mfa()
            .withAuthenticationMethods(
                mfa -> mfa
                    .sms()
                    .email()
                    .totp()
            )
            .requireMfaFor("/api/payment/**");
    }
}

坦白说，这里可以优化得更优雅。多因素认证能显著提升系统的安全性，防止未授权访问。

2.2 OAuth 2.0 与 OpenID Connect

核心策略：

• 使用 OAuth 2.0：实现第三方应用的授权
• 使用 OpenID Connect：实现单点登录
• 安全配置：正确配置 OAuth 2.0 客户端和服务端

示例：

@Configuration
public class OAuth2Config {
    @Bean
    public ClientRegistrationRepository clientRegistrationRepository() {
        return new InMemoryClientRegistrationRepository(
            ClientRegistration.withRegistrationId("google")
                .clientId("client-id")
                .clientSecret("client-secret")
                .redirectUri("{baseUrl}/login/oauth2/code/{registrationId}")
                .authorizationUri("https://accounts.google.com/o/oauth2/v2/auth")
                .tokenUri("https://www.googleapis.com/oauth2/v4/token")
                .userInfoUri("https://www.googleapis.com/oauth2/v3/userinfo")
                .userNameAttributeName(IdTokenClaimNames.SUB)
                .clientName("Google")
                .build()
        );
    }
    @Bean
    public OAuth2AuthorizedClientService authorizedClientService(ClientRegistrationRepository clientRegistrationRepository) {
        return new InMemoryOAuth2AuthorizedClientService(clientRegistrationRepository);
    }
}
@RestController
public class OAuth2Controller {
    @Autowired
    private OAuth2AuthorizedClientService authorizedClientService;
    @GetMapping("/user")
    public Map user(@AuthenticationPrincipal OAuth2User principal) {
        return principal.getAttributes();
    }
}

2.3 密码管理

核心策略：

• 使用强密码哈希：如 BCrypt、Argon2 等
• 密码策略：制定合理的密码复杂度要求
• 密码重置：安全的密码重置流程
• 密码过期：定期密码过期策略

示例：

@Configuration
public class PasswordConfig {
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder(12); // 12 轮哈希
    }
}
@Service
public class UserService {
    @Autowired
    private PasswordEncoder passwordEncoder;
    @Autowired
    private UserRepository userRepository;
    public User createUser(User user) {
        // 加密密码
        user.setPassword(passwordEncoder.encode(user.getPassword()));
        return userRepository.sa ve(user);
    }
    public boolean checkPassword(User user, String rawPassword) {
        return passwordEncoder.matches(rawPassword, user.getPassword());
    }
}

三、授权最佳实践

3.1 基于角色的访问控制

核心策略：

• 角色定义：合理定义角色和权限
• 权限分配：基于最小权限原则分配权限
• 角色继承：使用角色继承简化权限管理

示例：

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
            .antMatchers("/api/public/**").permitAll()
            .antMatchers("/api/user/**").hasRole("USER")
            .antMatchers("/api/admin/**").hasRole("ADMIN")
            .anyRequest().authenticated();
    }
}
@Service
public class RoleService {
    public void assignRoleToUser(Long userId, String roleName) {
        // 分配角色给用户
    }
}

3.2 基于权限的访问控制

核心策略：

• 权限粒度：细粒度的权限控制
• 权限检查：使用 @PreAuthorize 等注解进行权限检查
• 动态权限：支持动态权限管理

示例：

@RestController
@RequestMapping("/api")
public class ProductController {
    @PreAuthorize("hasAuthority('PRODUCT_READ')")
    @GetMapping("/products")
    public List getProducts() {
        // 获取产品列表
    }
    @PreAuthorize("hasAuthority('PRODUCT_CREATE')")
    @PostMapping("/products")
    public Product createProduct(@RequestBody Product product) {
        // 创建产品
    }
    @PreAuthorize("hasAuthority('PRODUCT_UPDATE')")
    @PutMapping("/products/{id}")
    public Product updateProduct(@PathVariable Long id, @RequestBody Product product) {
        // 更新产品
    }
    @PreAuthorize("hasAuthority('PRODUCT_DELETE')")
    @DeleteMapping("/products/{id}")
    public void deleteProduct(@PathVariable Long id) {
        // 删除产品
    }
}

3.3 基于表达式的访问控制

核心策略：

• 使用 SpEL：使用 Spring 表达式语言进行复杂的权限检查
• 自定义表达式：扩展 SpEL 表达式，实现自定义权限检查
• 细粒度控制：基于业务逻辑的细粒度访问控制

示例：

@RestController
@RequestMapping("/api")
public class OrderController {
    @PreAuthorize("hasRole('USER') and #userId == principal.id")
    @GetMapping("/users/{userId}/orders")
    public List getOrders(@PathVariable Long userId) {
        // 获取用户的订单
    }
    @PreAuthorize("hasRole('USER') and @orderService.isOrderOwner(#id, principal.id)")
    @GetMapping("/orders/{id}")
    public Order getOrder(@PathVariable Long id) {
        // 获取订单
    }
}
@Service("orderService")
public class OrderService {
    public boolean isOrderOwner(Long orderId, Long userId) {
        // 检查订单是否属于用户
        Order order = orderRepository.findById(orderId).orElse(null);
        return order != null && order.getUserId().equals(userId);
    }
}

四、安全防护最佳实践

4.1 CSRF 防护

核心策略：

• 启用 CSRF 保护：为所有修改操作启用 CSRF 保护
• CSRF 令牌：正确使用 CSRF 令牌
• 例外处理：为 API 接口合理设置 CSRF 例外

示例：

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .csrf()
            .csrfTokenRepository(CookieCsrfTokenRepository.withHttpOnlyFalse())
            .ignoringAntMatchers("/api/**"); // API 接口使用其他方式保护
    }
}
// 前端使用 CSRF 令牌
// 

//   
//   
// 

4.2 XSS 防护

核心策略：

• 输入验证：验证和清理所有用户输入
• 输出编码：对输出进行适当的编码
• 内容安全策略：设置内容安全策略（CSP）

示例：

@Configuration
public class WebConfig implements WebMvcConfigurer {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new XssInterceptor());
    }
}
public class XssInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 清理请求参数中的 XSS 攻击
        Enumeration parameterNames = request.getParameterNames();
        while (parameterNames.hasMoreElements()) {
            String parameterName = parameterNames.nextElement();
            String parameterValue = request.getParameter(parameterName);
            if (parameterValue != null) {
                String cleanedValue = XssUtils.clean(parameterValue);
                // 替换参数值
                // 注意：这需要自定义 HttpServletRequestWrapper
            }
        }
        return true;
    }
}

4.3 SQL 注入防护

核心策略：

• 使用参数化查询：使用 JPA、MyBatis 等 ORM 框架的参数化查询
• 输入验证：验证用户输入，防止 SQL 注入
• 最小权限：数据库用户使用最小权限原则

示例：

// 使用 JPA 防止 SQL 注入
@Repository
public interface UserRepository extends JpaRepository {
    // 使用参数化查询
    List findByUsername(String username);
    // 使用 @Query 注解，同样是参数化查询
    @Query("SELECT u FROM User u WHERE u.email = :email")
    User findByEmail(@Param("email") String email);
}
// 避免使用原生 SQL 拼接
// 错误示例
// String sql = "SELECT * FROM users WHERE username = '" + username + "'";
// 正确示例
// String sql = "SELECT * FROM users WHERE username = ?";
// preparedStatement.setString(1, username);

五、会话管理最佳实践

5.1 会话配置

核心策略：

• 会话超时：设置合理的会话超时时间
• 会话固定保护：启用会话固定保护
• 会话并发控制：限制用户的并发会话数

示例：

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .sessionManagement()
            .sessionFixation().migrateSession() // 会话固定保护
            .maximumSessions(1) // 每个用户最多一个会话
            .expiredUrl("/login?expired")
            .maxSessionsPreventsLogin(true); // 达到最大会话数时阻止登录
    }
    @Bean
    public HttpSessionEventPublisher httpSessionEventPublisher() {
        return new HttpSessionEventPublisher();
    }
}

5.2 令牌管理

核心策略：

• 使用 JWT：使用 JSON Web Token 进行无状态认证
• 令牌过期：设置合理的令牌过期时间
• 令牌刷新：实现令牌刷新机制
• 令牌撤销：支持令牌撤销

示例：

@Configuration
public class JwtConfig {
    @Bean
    public JwtTokenProvider jwtTokenProvider() {
        return new JwtTokenProvider("secret-key", 3600000); // 1小时过期
    }
}
@Service
public class JwtTokenProvider {
    private final String secretKey;
    private final long validityInMilliseconds;
    public JwtTokenProvider(String secretKey, long validityInMilliseconds) {
        this.secretKey = secretKey;
        this.validityInMilliseconds = validityInMilliseconds;
    }
    public String createToken(String username, List roles) {
        Claims claims = Jwts.claims().setSubject(username);
        claims.put("roles", roles);
        Date now = new Date();
        Date validity = new Date(now.getTime() + validityInMilliseconds);
        return Jwts.builder()
            .setClaims(claims)
            .setIssuedAt(now)
            .setExpiration(validity)
            .signWith(SignatureAlgorithm.HS256, secretKey)
            .compact();
    }
    public boolean validateToken(String token) {
        try {
            Jwts.parser().setSigningKey(secretKey).parseClaimsJws(token);
            return true;
        } catch (JwtException | IllegalArgumentException e) {
            return false;
        }
    }
    public String getUsername(String token) {
        return Jwts.parser().setSigningKey(secretKey).parseClaimsJws(token).getBody().getSubject();
    }
}

六、Spring Security 与微服务

6.1 微服务安全架构

核心策略：

• API 网关：使用 API 网关统一处理认证和授权
• 服务间通信：使用 OAuth 2.0 或 JWT 进行服务间通信
• 分布式会话：使用 Redis 等实现分布式会话

示例：

// API 网关配置
@Configuration
public class GatewaySecurityConfig {
    @Bean
    public SecurityWebFilterChain securityWebFilterChain(ServerHttpSecurity http) {
        http
            .authorizeExchange()
            .pathMatchers("/api/public/**").permitAll()
            .anyExchange().authenticated()
            .and()
            .oauth2Login()
            .and()
            .oauth2ResourceServer()
            .jwt();
        return http.build();
    }
}
// 服务间通信
@Configuration
public class RestTemplateConfig {
    @Bean
    public RestTemplate restTemplate(OAuth2AuthorizedClientManager authorizedClientManager) {
        OAuth2AuthorizedClientHttpRequestInterceptor interceptor = new OAuth2AuthorizedClientHttpRequestInterceptor(
            authorizedClientManager, clientRegistrationId -> {
                OAuth2AuthorizeRequest request = OAuth2AuthorizeRequest.withClientRegistrationId("service-to-service")
                    .principal(new AnonymousAuthenticationToken("anonymous", "anonymousUser", Collections.emptyList()))
                    .build();
                return authorizedClientManager.authorize(request);
            }
        );
        return new RestTemplate(Collections.singletonList(interceptor));
    }
}

6.2 安全服务

核心策略：

• 认证服务：集中式的认证服务
• 授权服务：集中式的授权服务
• 用户服务：集中式的用户管理服务

示例：

// 认证服务
@RestController
@RequestMapping("/auth")
public class AuthController {
    @Autowired
    private AuthenticationManager authenticationManager;
    @Autowired
    private JwtTokenProvider jwtTokenProvider;
    @PostMapping("/login")
    public ResponseEntity login(@RequestBody LoginRequest request) {
        Authentication authentication = authenticationManager.authenticate(
            new UsernamePasswordAuthenticationToken(request.getUsername(), request.getPassword())
        );
        SecurityContextHolder.getContext().setAuthentication(authentication);
        List roles = authentication.getAuthorities().stream()
            .map(GrantedAuthority::getAuthority)
            .collect(Collectors.toList());
        String token = jwtTokenProvider.createToken(request.getUsername(), roles);
        return ResponseEntity.ok(new JwtResponse(token));
    }
}
// 授权服务
@Service
public class AuthorizationService {
    public boolean hasPermission(String userId, String resourceId, String action) {
        // 检查用户是否有权限执行操作
    }
}

七、安全监控与审计

7.1 安全日志

核心策略：

• 审计日志：记录所有安全相关的操作
• 日志级别：合理设置日志级别
• 日志存储：安全存储日志，防止篡改

示例：

@Configuration
public class AuditConfig {
    @Bean
    public AuditEventRepository auditEventRepository() {
        return new InMemoryAuditEventRepository();
    }
    @Bean
    public AuditListener auditListener() {
        return new AuditListener(auditEventRepository());
    }
}
@Service
public class AuditService {
    @Autowired
    private AuditEventRepository auditEventRepository;
    public void logEvent(String principal, String type, Map data) {
        AuditEvent event = new AuditEvent(principal, type, data);
        auditEventRepository.add(event);
    }
}
// 使用审计服务
@Service
public class UserService {
    @Autowired
    private AuditService auditService;
    public void changePassword(String username, String newPassword) {
        // 更改密码
        auditService.logEvent(username, "PASSWORD_CHANGED", Collections.singletonMap("username", username));
    }
}

7.2 安全监控

核心策略：

• 安全指标：监控安全相关的指标
• 异常检测：检测异常的安全行为
• 告警机制：设置安全告警机制

示例：

@Configuration
public class MetricsConfig {
    @Bean
    public MeterRegistryCustomizer metricsCommonTags() {
        return registry -> registry.config()
            .commonTags("application", "security-service");
    }
    @Bean
    public SecurityMetrics securityMetrics() {
        return new SecurityMetrics();
    }
}
@Service
public class SecurityMetrics {
    private final Counter failedLoginAttempts;
    private final Counter successfulLogins;
    public SecurityMetrics(MeterRegistry meterRegistry) {
        this.failedLoginAttempts = Counter.builder("security.login.failed")
            .description("Number of failed login attempts")
            .register(meterRegistry);
        this.successfulLogins = Counter.builder("security.login.successful")
            .description("Number of successful logins")
            .register(meterRegistry);
    }
    public void recordFailedLogin() {
        failedLoginAttempts.increment();
    }
    public void recordSuccessfulLogin() {
        successfulLogins.increment();
    }
}
// 使用安全指标
@Service
public class AuthService {
    @Autowired
    private SecurityMetrics securityMetrics;
    public boolean authenticate(String username, String password) {
        try {
            // 认证逻辑
            securityMetrics.recordSuccessfulLogin();
            return true;
        } catch (AuthenticationException e) {
            securityMetrics.recordFailedLogin();
            return false;
        }
    }
}

八、安全最佳实践

8.1 安全配置

核心策略：

• 最小权限原则：只授予必要的权限
• 默认拒绝：默认拒绝所有请求，只允许明确授权的请求
• 定期审查：定期审查安全配置

示例：

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
            .antMatchers("/api/public/**").permitAll()
            .anyRequest().authenticated() // 默认拒绝
            .and()
            .formLogin()
            .and()
            .httpBasic();
    }
}

8.2 安全测试

核心策略：

• 单元测试：测试安全相关的单元
• 集成测试：测试安全配置的集成
• 渗透测试：定期进行渗透测试

示例：

@SpringBootTest
@AutoConfigureMockMvc
public class SecurityTest {
    @Autowired
    private MockMvc mockMvc;
    @Test
    public void testPublicEndpoint() throws Exception {
        mockMvc.perform(get("/api/public/health"))
            .andExpect(status().isOk());
    }
    @Test
    public void testProtectedEndpointWithoutAuthentication() throws Exception {
        mockMvc.perform(get("/api/user/profile"))
            .andExpect(status().isUnauthorized());
    }
    @Test
    public void testProtectedEndpointWithAuthentication() throws Exception {
        mockMvc.perform(get("/api/user/profile")
            .with(httpBasic("user", "password")))
            .andExpect(status().isOk());
    }
}

8.3 安全培训

核心策略：

• 开发人员培训：培训开发人员的安全意识
• 安全编码：培训安全编码实践
• 安全审查：定期进行安全代码审查

示例：

// 安全编码规范
public class SecurityUtils {
    // 防止 XSS 攻击
    public static String escapeHtml(String input) {
        return HtmlUtils.htmlEscape(input);
    }
    // 防止 SQL 注入
    public static String escapeSql(String input) {
        // 实现 SQL 注入防护
    }
    // 安全的密码生成
    public static String generateSecurePassword() {
        // 生成安全的密码
    }
}

九、未来展望

9.1 Spring Security 2027 预览

Spring Security 团队已经开始规划 2027 版本，预计将带来更多创新特性：

• AI 辅助安全：使用 AI 检测和防止安全攻击
• 零信任架构：实现零信任安全模型
• 更深度的云集成：更好地支持云原生环境
• 更简化的配置：提供更简洁的安全配置方式

9.2 技术趋势

发展方向：

• 生物识别：集成生物识别认证
• 区块链：使用区块链技术增强安全
• 量子安全：应对量子计算的安全挑战
• 边缘安全：加强边缘设备的安全

十、结语

Spring Security 2026 是一个功能强大、设计优雅的安全框架，它为我们提供了全面的安全解决方案。通过合理应用这些最佳实践，可以构建更安全、更可靠的企业应用。

这里其实可以做得更优雅一些。借助 Spring Security 2026，能够以更简洁、更灵活的方式实现安全功能，为业务创造更大的价值。