Spring Security实战(二) 动态权限

发表于 | 分类于

好消息好消息！Security系列终于有了第二期，最近在看项目源码忍不住又搞起来Spring Security，来给大家分享一下，虽然和上一节说好的内容不同🤭

回顾

上节我们介绍了如何进行简单的权限配置，包括url权限和方法权限，还有如何授予用户权限。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
protected void configure(HttpSecurity http) throws Exception {
    http
        .authorizeRequests()
            .antMatchers("/", "/home").permitAll()
            // 测试配置URL权限
            .antMatchers("/match/**").hasAuthority("sys:match")
            // 对某URL添加多个权限，可以多次配置
            .antMatchers("/match/**").hasAuthority("sys:mm")
            .anyRequest().authenticated()
            .and()
        .formLogin()
            .loginPage("/login")
            .permitAll()
            .and()
        .logout()
            .permitAll()
            .and()
    ;
}

但是如果现在你的业务系统要求动态权限呢？

比如用户权限变更了，我们可以重新构建Security上下文中Authentication 对象，这还好说。如果说某个接口的权限修改了，如果按照上述的方法来做的话，是不可能实现动态修改的。

本节我们来介绍一下Spring Security 如何实现动态权限

实现原理

FilterSecurityInterceptor 负责 Security中的权限控制，其核心代码在父类AbstractSecurityInterceptor中，我们来看一下

这里我删了一些与核心逻辑无关的代码，我们只需要关注红框里的内容

这时候聪明的你应该已经明白了FilterSecurityInterceptor是如何管理权限的，我们完全可以自己实现上面的AccessDecisionManager和SecurityMetadataSource来实现我们的动态权限

但是先别急，先看看AccessDecisionManager的默认实现AffirmativeBased

这代码写的有意思了，通过遍历所有的Voter，每个Voter实现具体的判断逻辑，返回 1，0，-1（分别代表同意、弃权、拒绝），当存在拒绝时直接抛出AccessDeniedException

非常的民主，我们只需要实现一个Voter即可

注：AccessDecisionManager 还有其他的默认实现，感兴趣的同学可以自行查看源码

Coding

OK，首先我们先捋一下思路

  1. 实现SecurityMetadataSource，提供当前资源要求的权限
  2. 实现AccessDecisionVoter，用于判断当前用户是否有权限访问
  3. 将我们自己的实现注册到FilterSecurityInterceptor中

OK，可以开搞了

SecurityService

实现一个Service，用于从数据库加载数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
@Service
public class SecurityService {
    @Autowired
    private JdbcTemplate jdbcTemplate;

    /**
     * 加载资源要求的权限
     *
     * @param resource
     * @return
     */
    public List<String> getPermByResource(String resource) {
        return jdbcTemplate.queryForList(Sql.getPermByResource, String.class, resource);
    }

    /**
     * 当前用户的权限
     *
     * @param username
     * @return
     */
    public List<String> getPermByUsername(String username) {
        return jdbcTemplate.queryForList(Sql.getPermByUsername, String.class, username);
    }

}

注：这里两个方法都可以加上缓存，由于demo演示，我就没有这么做

实现SecurityMetadataSource

MySecurityMetadataSource 很简单，就是通过SecurityService加载一下数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
public class MySecurityMetadataSource implements FilterInvocationSecurityMetadataSource {
    private SecurityService securityService;

    public MySecurityMetadataSource(SecurityService securityService) {
        this.securityService = securityService;
    }

    @Override
    public Collection<ConfigAttribute> getAttributes(Object object) throws IllegalArgumentException {
        String uri = ((FilterInvocation) object).getHttpRequest().getRequestURI();
        List<String> list = securityService.getPermByResource(uri);
        if (list != null && list.size() != 0) {
            return SecurityConfig.createList(list.toArray(new String[0]));
        }

        return null;
    }

    @Override
    public Collection<ConfigAttribute> getAllConfigAttributes() {
        return null;
    }

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

实现AccessDecisionVoter

这里加载一下当前用户的权限，判断用户是否满足当前资源所要求的权限

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
public class MyAccessDecisionVoter implements AccessDecisionVoter<Object> {
    private SecurityService securityService;

    public MyAccessDecisionVoter(SecurityService securityService) {
        this.securityService = securityService;
    }

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

    @Override
    public boolean supports(Class<?> clazz) {
        return true;
    }

    @Override
    public int vote(Authentication authentication, Object object, Collection<ConfigAttribute> attributes) {
        Object principal = authentication.getPrincipal();

        if ("anonymousUser".equals(principal)) {
            // 当前用户未登录，如果不要求权限->允许访问，否则拒绝访问
            return CollectionUtils.isEmpty(attributes) ? ACCESS_GRANTED : ACCESS_DENIED;

        } else {
            // 这里我的逻辑是，当前资源的要求权限，用户必须全部满足时才可以访问
            User user = (User) principal;
            List<String> permitList = securityService.getPermByUsername(user.getUsername());
            List<String> stringAttributes = attributes.stream().map(ConfigAttribute::getAttribute).collect(Collectors.toList());
            return permitList.containsAll(stringAttributes) ? ACCESS_GRANTED : ACCESS_DENIED;
        }
    }
}

注册到FilterSecurityInterceptor

我们核心的业务已经实现完了，现在需要把MySecurityMetadataSource和MyAccessDecisionVoter注册到FilterSecurityInterceptor中

需要注意的是，FilterSecurityInterceptor并不可以通过@Bean的方式来声明，该对象是在WebSecurityConfigurerAdapter的初始化方法中默认创建的

但是Spring Security为我们提供了ObjectPostProcessor，用于解决上述问题，具体用法如下

1
2
3
4
5
6
7
8
9
10
11
12
13
http
    .authorizeRequests()
        .antMatchers("/", "/home", "/403").permitAll()
        .anyRequest().authenticated()
        .withObjectPostProcessor(new ObjectPostProcessor<FilterSecurityInterceptor>() {
            @Override
            public <O extends FilterSecurityInterceptor> O postProcess(
                    O fsi) {
                fsi.setSecurityMetadataSource(new MySecurityMetadataSource(securityService));
                fsi.setAccessDecisionManager(new AffirmativeBased(getDecisionVoters()));
                return fsi;
            }
        })

完整Demo

Github 👉 https://github.com/TavenYin/security-example/tree/master/dynamic-permissions