SpringSecurity授权机制的实现(AccessDecisionManager与投票决策)

目录

• 引言
• 一、Spring Security授权架构
• 二、AccessDecisionManager接口设计
• 三、投票决策实现
• 四、AccessDecisionVoter机制
• 五、自定义访问控制规则
• 六、方法级安全控制
• 总结

引言

在企业级应用开发中，安全控制不仅包括认证（Authentication）——确认用户身份，还包括授权（Authorization）——确定用户是否有权执行特定操作。Spring Security提供了一套精心设计的授权机制，其核心是AccessDecisionManager和投票系统。与简单的角色检查相比，这种机制提供了更细粒度、更灵活的访问控制能力。本文将深入探讨Spring Security授权框架的内部工作原理，重点分析AccessDecisionManager如何通过投票机制做出授权决策，以及如何根据业务需求进行定制化配置。通过这些知识，开发者可以构建既安全又灵活的访问控制系统。

一、Spring Security授权架构

Spring Security的授权架构采用了责任链和投票模式相结合的设计，使授权决策过程模块化且可扩展。授权过程始于SecurityFilterChain中的FilterSecurityInterceptor，它拦截受保护资源的请求，收集安全元数据（如所需权限），然后委托给AccessDecisionManager进行授权判断。AccessDecisionManager通过组合多个AccessDecisionVoter实现复杂的授权策略，每个投票者根据自己的逻辑对授权请求投赞成、反对或弃权票。这种分层设计使得授权逻辑与业务代码完全分离，便于维护和扩展。

// FilterSecurityInterceptor 关键部分
public class FilterSecurityInterceptor extends AbstractSecurityInterceptor {
    
    private final FilterInvocationSecurityMetadataSource securityMetadataSource;
    
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) 
            throws IOException, ServletException {
        // 封装HTTP请求
        FilterInvocation fi = new FilterInvocation(request, response, chain);
        
        // 进行安全拦截
        invoke(fi);
    }
    
    public void invoke(FilterInvocation fi) throws IOException, ServletException {
        // 检查安全拦截器是否应该被应用
        if ((fi.getRequest() != null) && (fi.getRequest().getAttribute(FILTER_APPLIED) != null)) {
            // 安全拦截器已应用，继续执行过滤器链
            fi.getChain().doFilter(fi.getRequest(), fi.getResponse());
            return;
        }
        
        // 标记拦截器已应用
        fi.getRequest().setAttribute(FILTER_APPLIED, Boolean.TRUE);
        
        // 执行安全拦截
        InterceptorStatusToken token = super.beforeInvocation(fi);
        
        try {
            // 继续执行过滤器链
            fi.getChain().doFilter(fi.getRequest(), fi.getResponse());
        } finally {
            // 清理安全上下文
            super.finallyInvocation(token);
        }
        
        // 执行后处理
        super.afterInvocation(token, null);
    }
    
    @Override
    public Class<?> getSecureObjectClass() {
        return FilterInvocation.class;
    }
    
    @Override
    public SecurityMetadataSource obtainSecurityMetadataSource() {
        return th编程is.securityMetadataSource;
    }
}

二、AccessDecisionManager接口设计

AccessDecisionManager是Spring Security授权体系的核心接口，负责协调多个AccessDecisionVoter并做出最终授权决策。它定义了三个关键方法：decide()执行授权判断，supports(ConfigAttribute)检查是否支持特定配置属性，supports(Class)检查是否支持特定安全对象类型。通过这些方法，AccessDecisionManager可以灵活处理不同类型的授权请求，如Web请求、方法调用或特定领域对象的访问。Spring Security提供了三种内置实现：AffirmativeBased（只要有一票赞成即通过）、ConsensusBased（多数票决定）和UnanimousBased（要求全票通过）。

// AccessDecisionManager接口定义
public interface AccessDecisionManager {
    /**
     * 对给定的安全对象做出访问控制决策
     * @param authentication 当前用户的认证信息
     * @param object 要访问的安全对象
     * @param configAttributes 安全对象的安全配置属性
     * @throws AccessDeniedException 如果拒绝访问
     * @throws InsufficientAuthenticationException 如果认证不足
     */
    void decide(Authentication authentication, Object object, 
            Collection<ConfigAttribute> configAttributes) 
            throws AccessDeniedException, InsufficientAuthenticationException;
    
    /**
     * 检查此AccessDecisionManager是否支持指定的ConfigAttribute
     * @param attribute 要检查的配置属性
     * @return 如果支持该属性返回true
     */
    boolean supports(ConfigAttribute attribute);
    
    /**
     * 检查此AccessDecisionManager是否支持指定的安全对象类型
     * @param clazz 安全对象的类型
     * @return 如果支持该类型返回true
     */
    boolean supports(Class<?> clazz);
}

三、投票决策实现

Spring Security提供了三种不同的AccessDecisionManager实现，每种实现代表不同的投票策略。AffirmativeBased采用"一票通过"策略，只要有一个投票者投赞成票就允许访问，这是最宽松的策略。ConsensusBased基于"多数票"原则，根据赞成票与反对票的比较结果做出决策。UnanimousBased要求所有投票者都投赞成票（或弃权）才允许访问，是最严格的策略。这三种实现覆盖了从宽松到严格的不同安全需求，开发者可以根据业务场景选择合适的策略。

// AffirmativeBased实现关键代码
public class AffirmativeBased extends AbstractAccessDecisionManager {
    
    public AffirmativeBased(List<AccessDecisionVoter<?>> decisionVoters) {
        super(decisionVoters);
    }
    
    @Override
    public void decide(Authentication authentication, Object object, 
            Collection<ConfigAttribute> attributes) 
            throws AccessDeniedException {
        int deny = 0;
        
        // 遍历所有投票者
        for (AccessDecisionVoter voter : getDecisionVoters()) {
            // 获取投票结果
            int result = voter.vote(authentication, object, attributes);
            
            switch (result) {
            case AccessDecisionVoter.ACCESS_GRANTED: // 投票通过
                return; // 立即返回允许访问
            case AccessDecisionVoter.ACCESS_DENIED: // 投票拒绝
                deny++; // 计数拒绝票
                break;
            default: // 弃权
                break;
            }
        }
        
        // 如果有拒绝票且没有通过票，则拒绝访问
        if (deny > 0) {
            throw new AccessDeniedException("访问被拒绝，安全投票失败");
        }
        
        // 所有投票者弃权，根据配置决定（默认允许）
        if (getAllowIfAllAbstainDecisions()) {
            return;
        }
        
        // 默认拒绝访问
        throw new AccessDeniedException("访问被拒绝，没有投票者同意");
    }
}

四、AccessDecisionVoter机制

AccessDecisionVoter是Spring Security授权机制中的投票者角色，负责对特定授权请求投票。每个投票者实现vote()方法，返回ACCESS_GRANTED（赞成）、ACCESS_DENIED（反对）或ACCESS_ABSTAIN（弃权）。常用的投票者包括：RoleVoter（基于角色投票）、AuthenticatedVoter（基于认证状态投票）和WebExpressionVoter（基于SpEL表达式投票）。投票者的灵活性在于它可以基于任何条件做出决策，不仅限于用户角色，还可以考虑时间、位置、资源属性等因素。

// AccessDecisionVoter接口
public interface AccessDecisionVoter<S> {
    /**
     * 赞成访问的常量
     */
    int ACCESS_GRANTED = 1;
    
    /**
     * 拒绝访问的常量
     */
    int ACCESS_DENIED = -1;
    
    /**
     * 弃权的常量
     */
    int ACCESS_ABSTAIN = 0;
    
    /**
     * 对访问请求进行投票
     * @param authentication 当前用户的认证信息
     * @param object 要访问的安全对象
     * @param attributes 安全对象的配置属性
     * @return 投票结果：ACCESS_GRANTED、ACCESS_DENIED或ACCESS_ABSTAIN
     */
    int vote(Authentication authentication, S object, Collection<ConfigAttribute> attributes);
    
    /**
     * 检查此投票者是否支持指定的配置属性
     * @param attribute 要检查的配置属性
     * @return 如果支持该属性返回true
     */
    boolean supports(ConfigAttribute attribute);
    
    /**
     * 检查此投票者是否支持指定的安全对象类型
     * @param clazz 安全对象的类型
     * @return 如果支持该类型返回true
     */
    boolean supports(Class<?> clazz);
}

// RoleVoter实现
public class RoleVoter implements AccessDecisionVoter<Object> {
    
    private String rolePrefix = "ROLE_";
    
    public int vote(Authentication authentication, Object object, 
            Collection<ConfigAttribute> attributes) {
        // 如果没有属性，弃权
        if (attributes.isEmpty()) {
            return ACCESS_ABSTAIN;
        }
        
        // 获取用户权限
        Collection<? extends GrantedAuthority> authorities = 
                authentication.getAuthorities();
        
        // 检查每个配置属性
        for (ConfigAttribute attribute : attributes) {
            if (this.supports(attribute)) {
                // 属性值作为需要的角色
                String role = attribute.getAttribute();
                
                // 检查用户是否拥有该角色
                for (GrantedAuthority authority : authorities) {
                    if (role.equals(authority.getAuthority())) {
                        return ACCESS_GRANTED; // 用户有所需角色，允许访问
                    }
                }
                
                // 走到这里说明用户没有所需角色，返回拒绝
                return ACCESS_DENIED;
            }
        }
        
        // 没有可支持的属性，弃权
        return ACCESS_ABSTAIN;
    }
    
    @Override
    public boolean supports(ConfigAttribute attribute) {
        // 检查属性是否以角色前缀开头
        return (attribute.getAttribute() != null) && 
                attribute.getAttribute().startsWith(rolePrefix);
    }
    
    @Override
    public boolean supports(Class<?> clazz) {
     js   return true; // 支持所有类型的安全对象
    }
}

五、自定义访问控制规则

Spring Security的授权机制最大的优势在于其可扩展性，开发者可以轻松实现自定义的访问控制规则。通过创建自定义的AccessDecisionVoter，可以基于业务特定逻辑进行授权决策，如限制特定时间段的访问、根据用户属性控制权限或实现数据行级安全。自定义投票者只需实现AccessDecisionVoter接口的三个方法，然后将其添加到AccessDecisionManager的投票者列表中即可。这种方式使复杂的授权需求变得易于实现且可维护。

// 自定义的工作时间投票者，只允许在工作时间访问
public class BusinessHoursVoter implements AccessDecisionVoter<Object> {
    
    private final int startHour = 9;  // 工作开始时间
    private final int endHour = 17;   // 工作结束时间
    
    @Override
    public int vote(Authentication authentication, Object object, 
            Collection<ConfigAttribute> attributes) {
        // 检查是否有工作时间限制的属性
        boolean businessHoursRequired = attributes.stream()
                .anyMatch(a -> "BUSINESS_HOURS_ONLY".equals(a.getAttribute()));
        
        // 如果没有时间限制，弃权
        if (!businessHoursRequired) {
            return ACCESS_ABSTAIN;
        }
        
        // 获取当前时间
        LocalTime now = LocalTime.now();
        int currentHour = now.getHour();
        
        // 检查是否在工作时间内
        if (currentHour >= startHour && currentHour < endHour) {
            return ACCESS_GRANTED;
        } else {
            return ACCESS_DENIED;
        }
    }
    
    @Override
    public boolean supports(ConfigAttribute attribute) {
        return attribute != null && "BUSINESS_HOURS_ONLY".equals(attribute.getAttribute());
    }
    
    @Override
    public boolean supports(Class<?> clazz) {
        return true;
    }
}

// 自定义配置
@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
                .antMatchers("/public/**").permitAll()
                .antMatchers("/admin/**").access("hasRole('ADMIN') and hasAuthority('BUSINESS_HOURS_ONLY')")
                .anyRequest().authenticated()
            .and()
                .formLogin()
                .loginPage("/login").permitAll();
        
        // 替换默认的AccessDecisionManager
        http.authorizeRequests()
                .accessDecisionManager(accessDecisionManager());
    }
    
    @Bean
    public AccessDecisionManager accessDecisionManager() {
        List<AccessDecisionVoter<?>> voters = new ArrayList<>();
        voters.add(new WebExpressionVoter());
        voters.add(new RoleVoter());
        voters.add(new AuthenticatedVoter());
        voters.add(new BusinessHoursVoter());  // 添加自定义投票者
        
        // 使用"一票通过"策略
        return new AffirmativeBased(voters);
    }
}

六、方法级安全控制

除了Web请求的授权控制外，Spring Security还提供了方法级别的安全控制，使开发者能够直接在业务方法上应用授权规则。通过@PreAuthorize、@PostAuthorize等注解，可以使用SpEL表达式定义复杂的访问条件。这些注解由MethodSecurityInterceptor处理，它同样使用AccessDecisionManager进行授权决策。方法级安全与Web安全共享相同的授权架构，但提供了更精细的控制粒度，特别适合业务逻辑层的权限管理。

// 启用方法级安全
@Configuration
@EnableGlobalMethodSecurity(prePostEnabled = true, securedEnabled = true)
public class MethodSecurityConfig extends GlobalMethodSecurityConfiguration {
    
    @Override
    protected AccessDecisionManager accessDecisionManager() {
        // 自定义方法级安全的AccessDecisionManager
        AffirmativeBased accessDecisionManager = (AffirmativeBased) super.accessDecisionManager();
        
        // 获取现有的投票者并添加自定义投票者
        List<AccessDecisionVoter<?>> voters = new ArrayList<>(
                accessDecisionManager.getDecisionVoters());
        voters.add(new BusinessHoursVoter());
        
        // 创建新的AccessDecisionManager
        return new AffirmativeBased(voters);
javascript    }
}

// 在服务类中使用方法级安全
@Service
public class UserService {
    
    @PreAuthorize("hasRole('ADMIN') and hasAuthority('BUSINESS_HOURS_ONLY')")
    public void deleteUser(Long userId) {
        // 删除用户的逻辑
    }
    
    @PreAuthorize("hasRole('USER') or hasRole('ADMIN')")
    public UserDetails viewUserProfile(Long userId) {
        // 查看用户资料的逻辑
        return userProfile;
    }
    
    @PostAuthorize("returnObject.username == authentication.name or hasRole('ADMIN')")
    public UserDetails loadUserById(Long userId) {
        // 只允许查看自己的详细信息或者管理员查看
        return userDetails;
    }
}

总结

Spring Security的授权机制以AccessDecisionManager和投票决策系统为核心，提供了一套灵活而php强大的访问控制框架。通过责任链模式和策略模式的结合，它实现了授权逻辑的模块化和可扩展性。AccessDecisionManager协调多个AccessDecisionVoter，根据不同的投票策略做出最终授权决策，支持从宽松到严格的各种安全需求。内置的投票者如RoleVoter和WebExpressionVoter满足了基本授权场景，而自定义投票者则使复杂的业务规则得以实现。方法级安全控制进一步扩展了授权能力，使开发者能够在业务方法层面应用精细的权限管理。理解并掌握这套授权机制，开发者可以构建既安全又灵活的企业级应用，有效平衡安全需求与用户体验。在安全威胁日益复杂的今天，Spring Security的授权框架为开发者提供了应对挑战的有力工具，使复杂的授权逻辑变得清晰可维护，为应用系统的安全基础奠定了坚实基础。

到此这篇关于SpringSecurity授权机制的实现(AccessDecisionManager与投票决策)的文章就介绍到这了,更多相关SpringSepythoncurity授权机制内容请搜索编程客栈(www.devze.com)以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程客栈(www.devze.com)！