3.访问授权

Rich2026-03-012026-03-18

在现代 Web 应用程序中，确保用户只能访问他们被授权的资源是至关重要的。Spring Security 是一个功能强大的框架，专注于为 Java 应用提供全面的安全解决方案。除了用户认证之外，访问授权是 Spring Security 的另一核心功能，它决定了用户可以访问哪些资源。在这篇文章中，我们将深入探讨 Spring Security 的访问授权机制，从基础概念到高级应用，逐步解析其背后的工作原理和配置方法。

1. 什么是访问授权？

访问授权（Authorization）是确定用户是否有权访问特定资源的过程。与认证（Authentication）不同，认证是确定用户身份，而授权是决定用户在系统中的访问权限。在实际应用中，授权可以基于用户的角色、特定的权限或其他自定义的规则。

授权的主要目的是保护系统资源，确保只有经过授权的用户才能访问敏感数据或执行特定操作。

2. Spring Security 简介

Spring Security 是一个为 Java 应用程序提供全面安全解决方案的框架。它最初作为 Acegi Security 的扩展，现在已经成为 Spring 框架生态系统中不可或缺的一部分。Spring Security 提供了丰富的功能和高度的可配置性，使开发者可以根据应用的具体需求进行定制。

Spring Security 的主要功能包括：

身份验证（Authentication）：确定用户的身份。
授权（Authorization）：控制用户对资源的访问。
保护应用（Protecting Applications）：防止常见的安全攻击，如跨站点请求伪造（CSRF）、会话固定攻击等。

在本文中，我们将重点介绍 Spring Security 的访问授权功能，深入解析其各个方面。

3. Spring Security 的访问授权机制

Spring Security 提供了多种访问授权机制，满足不同应用的需求。以下是几种常见的授权方式：

基于角色的授权

基于角色的授权是最常见的授权方式，用户被分配一个或多个角色，每个角色具有不同的权限。系统根据用户的角色决定其访问权限。

配置示例

以下是一个简单的基于角色的授权配置示例：

@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
            .antMatchers("/admin/**").hasRole("ADMIN")
            .antMatchers("/user/**").hasRole("USER")
            .anyRequest().authenticated()
            .and()
            .formLogin()
            .loginPage("/login")
            .permitAll()
            .and()
            .logout()
            .permitAll();
    }

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.inMemoryAuthentication()
            .withUser("user").password("{noop}password").roles("USER")
            .and()
            .withUser("admin").password("{noop}admin").roles("ADMIN");
    }
}

在这个示例中，我们定义了两个角色（USER 和 ADMIN），并配置了不同 URL 的访问权限。

基于权限的授权

基于权限的授权更加细粒度，用户被授予特定的权限，而不是角色。每个权限可以对应一个或多个操作，系统根据用户的权限决定其访问权限。

配置示例

以下是一个基于权限的授权配置示例：

@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
            .antMatchers("/admin/**").hasAuthority("ROLE_ADMIN")
            .antMatchers("/user/**").hasAuthority("ROLE_USER")
            .anyRequest().authenticated()
            .and()
            .formLogin()
            .loginPage("/login")
            .permitAll()
            .and()
            .logout()
            .permitAll();
    }

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.inMemoryAuthentication()
            .withUser("user").password("{noop}password").authorities("ROLE_USER")
            .and()
            .withUser("admin").password("{noop}admin").authorities("ROLE_ADMIN");
    }
}

在这个示例中，我们使用了 hasAuthority 方法来配置基于权限的访问控制。

基于表达式的授权

Spring Security 提供了基于 Spring 表达式语言（SpEL）的授权机制，使得授权规则更加灵活和强大。开发者可以使用 SpEL 来定义复杂的授权规则。

配置示例

以下是一个基于表达式的授权配置示例：

@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
            .antMatchers("/admin/**").access("hasRole('ADMIN') and hasIpAddress('192.168.1.0/24')")
            .antMatchers("/user/**").access("hasRole('USER') and @customSecurityService.hasPermission(request, authentication)")
            .anyRequest().authenticated()
            .and()
            .formLogin()
            .loginPage("/login")
            .permitAll()
            .and()
            .logout()
            .permitAll();
    }

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.inMemoryAuthentication()
            .withUser("user").password("{noop}password").roles("USER")
            .and()
            .withUser("admin").password("{noop}admin").roles("ADMIN");
    }
}

在这个示例中，我们使用了 access 方法来配置基于表达式的访问控制。表达式可以结合用户角色、请求 IP 地址、以及自定义的安全服务逻辑。

4. Spring Security 的授权配置

使用注解进行授权

Spring Security 提供了多种注解，开发者可以在代码中使用这些注解来实现访问控制。这些注解包括 @Secured、@PreAuthorize 和 @PostAuthorize 等。

配置示例

以下是使用注解进行授权的示例：

@Service
public class MyService {

    @Secured("ROLE_ADMIN")
    public void adminMethod() {
        // 只有拥有 ROLE_ADMIN 权限的用户才能访问
    }

    @PreAuthorize("hasRole('USER')")
    public void userMethod() {
        // 只有拥有 ROLE_USER 权限的用户才能访问
    }

    @PostAuthorize("returnObject.username == authentication.name")
    public User getUserDetails(Long id) {
        // 方法返回后检查权限
        return userRepository.findById(id).orElse(null);
    }
}

在配置类中启用方法级别的安全注解：

@EnableWebSecurity
@EnableGlobalMethodSecurity(securedEnabled = true, prePostEnabled = true)
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
            .anyRequest().authenticated()
            .and()
            .formLogin()
            .loginPage("/login")
            .permitAll()
            .and()
            .logout()
            .permitAll();
    }

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.inMemoryAuthentication()
            .withUser("user").password("{noop}password").roles("USER")
            .and()
            .withUser("admin").password("{noop}admin").roles("ADMIN");
    }
}

基于 URL 的授权

基于 URL 的授权是通过配置文件或代码控制 URL 的访问权限。开发者可以使用 HttpSecurity 对象配置 URL 的访问权限。

配置示例

以下是一个基于 URL 的授权配置示例：

@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
            .antMatchers("/admin/**").hasRole("ADMIN")
            .antMatchers("/user/**").hasRole("USER")
            .anyRequest().authenticated()
            .and()
            .formLogin()
            .loginPage("/login")
            .permitAll()
            .and()
            .logout()
            .permitAll();
    }

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.inMemoryAuthentication()
            .withUser("user").password("{noop}password").roles("USER")
            .and()
            .withUser("admin").password("{noop}admin").roles("ADMIN");
    }


}

在这个示例中，我们通过 antMatchers 方法配置了不同 URL 的访问权限。

基于方法的授权

基于方法的授权是通过注解控制方法的访问权限。开发者可以使用 @Secured、@PreAuthorize 和 @PostAuthorize 注解来控制方法的访问权限。

配置示例

以下是一个基于方法的授权配置示例：

@Service
public class MyService {

    @Secured("ROLE_ADMIN")
    public void adminMethod() {
        // 只有拥有 ROLE_ADMIN 权限的用户才能访问
    }

    @PreAuthorize("hasRole('USER')")
    public void userMethod() {
        // 只有拥有 ROLE_USER 权限的用户才能访问
    }

    @PostAuthorize("returnObject.username == authentication.name")
    public User getUserDetails(Long id) {
        // 方法返回后检查权限
        return userRepository.findById(id).orElse(null);
    }
}

在配置类中启用方法级别的安全注解：

@EnableWebSecurity
@EnableGlobalMethodSecurity(securedEnabled = true, prePostEnabled = true)
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
            .anyRequest().authenticated()
            .and()
            .formLogin()
            .loginPage("/login")
            .permitAll()
            .and()
            .logout()
            .permitAll();
    }

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.inMemoryAuthentication()
            .withUser("user").password("{noop}password").roles("USER")
            .and()
            .withUser("admin").password("{noop}admin").roles("ADMIN");
    }
}

5. 高级授权配置

自定义访问决策管理器

Spring Security 的访问决策管理器（AccessDecisionManager）负责做出最终的访问决策。开发者可以实现自定义的 AccessDecisionManager 来支持复杂的授权逻辑。

配置示例

以下是一个自定义 AccessDecisionManager 的示例：

@Component
public class CustomAccessDecisionManager implements AccessDecisionManager {

    @Override
    public void decide(Authentication authentication, Object object, Collection<ConfigAttribute> configAttributes) throws AccessDeniedException, InsufficientAuthenticationException {
        for (ConfigAttribute attribute : configAttributes) {
            if (this.supports(attribute)) {
                // 自定义访问决策逻辑
                if (authentication.getAuthorities().stream().noneMatch(grantedAuthority -> grantedAuthority.getAuthority().equals(attribute.getAttribute()))) {
                    throw new AccessDeniedException("Access denied");
                }
            }
        }
    }

    @Override
    public boolean supports(ConfigAttribute attribute) {
        return true;
    }

    @Override
    public boolean supports(Class<?> clazz) {
        return FilterInvocation.class.isAssignableFrom(clazz);
    }
}

在配置类中注册自定义的 AccessDecisionManager：

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    private CustomAccessDecisionManager customAccessDecisionManager;

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
            .anyRequest().authenticated()
            .accessDecisionManager(customAccessDecisionManager)
            .and()
            .formLogin()
            .loginPage("/login")
            .permitAll()
            .and()
            .logout()
            .permitAll();
    }

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.inMemoryAuthentication()
            .withUser("user").password("{noop}password").roles("USER")
            .and()
            .withUser("admin").password("{noop}admin").roles("ADMIN");
    }
}

ACL（访问控制列表）

访问控制列表（ACL）是一种细粒度的授权机制，允许开发者为每个域对象配置访问权限。Spring Security 提供了对 ACL 的支持，可以实现基于对象的访问控制。

配置示例

以下是一个使用 Spring Security 配置 ACL 的示例：

首先，配置 ACL 所需的 Bean：

@Configuration
public class AclConfig {

    @Bean
    public LookupStrategy lookupStrategy(DataSource dataSource) {
        return new BasicLookupStrategy(dataSource, aclCache(), aclAuthorizationStrategy(), new ConsoleAuditLogger());
    }

    @Bean
    public JdbcMutableAclService aclService(DataSource dataSource) {
        return new JdbcMutableAclService(dataSource, lookupStrategy(dataSource), aclCache());
    }

    @Bean
    public EhCacheBasedAclCache aclCache() {
        return new EhCacheBasedAclCache(aclEhCacheFactoryBean().getObject(), permissionGrantingStrategy(), aclAuthorizationStrategy());
    }

    @Bean
    public EhCacheFactoryBean aclEhCacheFactoryBean() {
        EhCacheFactoryBean ehCacheFactoryBean = new EhCacheFactoryBean();
        ehCacheFactoryBean.setCacheName("aclCache");
        return ehCacheFactoryBean;
    }

    @Bean
    public AclAuthorizationStrategy aclAuthorizationStrategy() {
        return new AclAuthorizationStrategyImpl(new SimpleGrantedAuthority("ROLE_ADMIN"));
    }

    @Bean
    public PermissionGrantingStrategy permissionGrantingStrategy() {
        return new DefaultPermissionGrantingStrategy(new ConsoleAuditLogger());
    }

    @Bean
    public MutableAclService mutableAclService() {
        return aclService(dataSource());
    }
}

然后，在服务类中使用 ACL 进行授权控制：

@Service
public class MyService {

    @Autowired
    private MutableAclService mutableAclService;

    public void createAclObject(Long id, String owner) {
        ObjectIdentity oid = new ObjectIdentityImpl(MyDomainObject.class, id);
        Sid sid = new PrincipalSid(owner);

        MutableAcl acl = mutableAclService.createAcl(oid);
        acl.setOwner(sid);
        mutableAclService.updateAcl(acl);
    }

    public void addPermission(Long id, Permission permission, String recipient) {
        ObjectIdentity oid = new ObjectIdentityImpl(MyDomainObject.class, id);
        Sid sid = new PrincipalSid(recipient);

        MutableAcl acl = (MutableAcl) mutableAclService.readAclById(oid);
        acl.insertAce(acl.getEntries().size(), permission, sid, true);
        mutableAclService.updateAcl(acl);
    }

    public boolean hasPermission(Long id, Permission permission) {
        ObjectIdentity oid = new ObjectIdentityImpl(MyDomainObject.class, id);
        Sid sid = new PrincipalSid(SecurityContextHolder.getContext().getAuthentication().getName());

        Acl acl = mutableAclService.readAclById(oid);
        return acl.isGranted(Collections.singletonList(permission), Collections.singletonList(sid), false);
    }
}

在这个示例中，我们使用 ACL 来控制对域对象的访问权限。

动态权限管理

在某些应用中，权限可能会随着时间和用户操作动态变化。Spring Security 提供了灵活的配置方式，允许开发者实现动态权限管理。

配置示例

以下是一个动态权限管理的示例：

@Service
public class PermissionService {

    private final Map<String, Set<String>> userPermissions = new ConcurrentHashMap<>();

    public void grantPermission(String username, String permission) {
        userPermissions.computeIfAbsent(username, k -> new HashSet<>()).add(permission);
    }

    public void revokePermission(String username, String permission) {
        userPermissions.computeIfPresent(username, (k, v) -> {
            v.remove(permission);
            return v.isEmpty() ? null : v;
        });
    }

    public boolean hasPermission(String username, String permission) {
        return userPermissions.getOrDefault(username, Collections.emptySet()).contains(permission);
    }
}

在安全配置类中使用自定义的权限服务：

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    private PermissionService permissionService;

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
            .antMatchers("/admin/**").access("@permissionService.hasPermission(authentication.name, 'ADMIN')")
            .antMatchers("/user/**").access("@permissionService.hasPermission(authentication.name, 'USER')")
            .anyRequest().authenticated()
            .and()
            .formLogin()
            .loginPage("/login")
            .permitAll()
            .and()
            .logout()
            .permitAll();
    }

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.inMemoryAuthentication()
            .withUser("user").password("{noop}password").roles("USER")
            .and()
            .withUser("admin").password("{noop}admin").roles("ADMIN");
    }
}

在这个示例中，我们实现了一个简单的动态权限管理服务，并在 Spring Security 配置中使用该服务进行授权控制。

6. 授权机制的安全性

防止权限提升攻击

权限提升攻击是指用户通过某些手段获取比其原有权限更高的权限。为了防止权限提升攻击，必须确保授权机制的安全性和可靠性。

配置示例

以下是一些防止权限提升攻击的措施：

使用最小权限原则：确保用户只拥有完成任务所需的最小权限。
定期审查权限：定期审查用户权限，确保权限设置的合理性。
日志记录和审计：记录用户的操作日志，定期审计用户行为，及时发现异常操作。

审计和日志记录

审计和日志记录是保障授权机制安全性的重要手段。通过记录用户的操作日志，可以帮助发现和分析安全事件，及时采取措施应对潜在威胁。

配置示例

以下是一个记录用户操作日志的示例：

@Component
public class CustomAuditLogger implements AuditLogger {

    private static final Logger logger = LoggerFactory.getLogger(CustomAuditLogger.class);

    @Override
    public void log(boolean granted, Authentication authentication, ConfigAttribute configAttribute, Object resource) {
        String username = authentication.getName();
        String resourceName = resource.toString();
        String accessDecision = granted ? "GRANTED" : "DENIED";

        logger.info("User '{}' {} access to resource '{}'", username, accessDecision, resourceName);
    }
}

在配置类中注册自定义的审计日志记录器：

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    private CustomAuditLogger customAuditLogger;

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
            .anyRequest().authenticated()
            .and()
            .formLogin()
            .loginPage("/login")
            .permitAll()
            .and()
            .logout()
            .permitAll();

        // 配置审计日志记录器
        http.authorizeRequests().accessDecisionManager(accessDecisionManager());
    }

    @Bean
    public AccessDecisionManager accessDecisionManager() {
        List<AccessDecisionVoter<?>> decisionVoters = Arrays.asList(new RoleVoter(), new AuthenticatedVoter());
        return new UnanimousBased(decisionVoters);
    }
}

在这个示例中，我们实现了一个自定义的审计日志记录器，并在 Spring Security 配置中注册该记录器。

7. 实战案例分析

案例 1：大型企业应用的访问授权

一个大型企业应用需要保护多个微服务之间的通信，并确保只有授权用户才能访问敏感数据。通过使用 Spring Security，可以实现强大的访问控制机制，确保系统的安全性。

需求

保护多个微服务之间的通信。
提供细粒度的访问控制。
记录用户操作日志，定期审计用户行为。

解决方案

使用 Spring Security 配置 OAuth2 登录，实现无状态认证和授权。配置自定义的访问决策管理器，确保只有授权用户才能访问敏感数据。实现审计日志记录器，记录用户操作日志。

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    private CustomAccessDecisionManager customAccessDecisionManager;

    @Autowired
    private CustomAuditLogger customAuditLogger;

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
            .anyRequest().authenticated()
            .accessDecisionManager(customAccessDecisionManager)
            .and()
            .oauth2Login()
            .loginPage("/oauth2/authorization/login-client")
            .and()
            .audit()
            .auditLogger(customAuditLogger);
    }

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.inMemoryAuthentication()
            .withUser("user").password("{noop}password").roles("USER")
            .and()
            .withUser("admin").password("{noop}admin").roles("ADMIN");
    }
}

在这个案例中，我们实现了一个复杂的访问控制和审计机制，确保了大型企业应用的安全性。

案例 2：电子商务网站的访问授权

一个电子商务网站需要保护用户数据和交易信息，防止常见的安全攻击。通过使用 Spring Security，可以实现全面的访问控制和安全保护。

需求

保护用户数据和交易信息。
提供细粒度的访问控制。
防止常见的安全攻击，如 CSRF、XSS 等。

解决方案

使用 Spring Security 实现表单登录和基于角色的访问控制。启用 CSRF 保护和 HTTPS 加密通信。配置自定义的权限服务，实现动态权限管理。

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    private PermissionService permissionService;

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.csrf().disable() // 示例中禁用 CSRF，实际应用中应启用 CSRF 保护
            .authorizeRequests()
            .antMatchers("/checkout/**").access("@permissionService.hasPermission(authentication.name, 'CHECKOUT')")
            .antMatchers("/admin/**").access("@permissionService.hasPermission(authentication.name, 'ADMIN')")
            .anyRequest().authenticated()
            .and()
            .formLogin()
            .loginPage("/login")
            .permitAll()
            .and()
            .logout()
            .permitAll()
            .and()
            .requiresChannel()
            .anyRequest().requiresSecure(); // 启用 HTTPS
    }

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.inMemoryAuthentication()
            .withUser("user").password("{noop}password").roles("USER")
            .and()
            .withUser("admin").password("{noop}admin").roles("ADMIN");
    }
}

在这个案例中，我们实现了一个全面的访问控制和安全保护机制，确保了电子商务网站的安全性。

8. Spring Security 授权的最佳实践

使用最小权限原则

确保用户只拥有完成任务所需的最小权限。避免授予用户不必要的权限，降低潜在的安全风险。

定期审查权限

定期审查用户权限，确保权限设置的合理性。特别是在用户角色或职责发生变化时，及时更新权限设置。

启用 HTTPS 加密通信

启用 HTTPS 加密通信，确保数据在传输过程中不被窃取或篡改。通过配置 Spring Security 的通道安全功能，可以强制所有请求使用 HTTPS。

@Override
protected void configure(HttpSecurity http) throws Exception {
    http.requiresChannel()
        .anyRequest()
        .requiresSecure();
}

实现详细的日志记录

实现详细的安全日志记录，监控和审计用户行为，及时发现和响应安全事件。

@Bean
public LoggerListener loggerListener() {
    return new LoggerListener();
}

防止 CSRF 攻击

启用 CSRF 保护，防止跨站点请求伪造攻击。Spring Security 默认启用 CSRF 保护，开发者可以通过配置 CsrfTokenRepository 来自定义 CSRF 令牌存储和验证逻辑。

@Override
protected void configure(HttpSecurity http) throws Exception {
    http.csrf().csrfTokenRepository(CookieCsrfTokenRepository.withHttpOnlyFalse());
}

9. 总结

Spring Security 是一个功能强大且灵活的安全框架，提供了全面的访问授权解决方案。通过本文的深入介绍，我们探讨了 Spring Security 的各种访问授权机制，包括基于角色的授权、基于权限的授权和基于表达式的授权。我们还详细介绍了 Spring Security 的授权配置和高级授权配置，分析了授权机制的安全性，并通过实战案例展示了 Spring Security 在实际应用中的应用。

通过遵循最佳实践，开发者可以充分利用 Spring Security 的强大功能，为应用构建坚实的安全屏障，确保用户只能访问他们被授权的资源。

开始使用 Spring Security 吧，为你的应用程序构筑坚不可摧的访问授权机制，确保系统资源的安全性和可靠性！