十、Spring Boot 安全管理（3）

本章概要

• 高级配置

10.3 高级配置

10.3.1 角色继承

10.2 节中定义了三种角色，但是这三种角色之间不具备任何关系，一般来说角色之间是有关系的，例如 ROLE_admin 一般既具有 admin 权限，又具有 user 权限。那么如何配置这种角色继承关系呢？只需要开发者在 Spring Security 的配置类中提供一个 RoleHierarchy 即可

@Bean
RoleHierarchy roleHierarchy() {
    RoleHierarchyImpl roleHierarchy = new RoleHierarchyImpl();
    String hierarchy = "ROLE_dba > ROLE_admin ROLE_admin > ROLE_user";
    roleHierarchy.setHierarchy(hierarchy);
    return roleHierarchy;
}
1
2
3
4
5
6
7

配置完 RoleHierarchy 之后，具有 ROLE_dba 角色的用户就可以访问 所有资源了，具有 ROLE_admin 角色的用户也可以访问具有 ROLE_user 角色才能访问的资源。

10.3.2 动态权限配置

使用 HttpSecurity 配置的认证授权规则还是不够灵活，无法实现资源和角色之间的动态调整，要实现动态配置 URL 权限，需要开发者自定义权限配置，配置步骤如下（在 10.2 节的基础上完成，详见《十、Spring Boot 安全管理（2）》）

1. 数据库设计

在 10.2节 数据库的基础上再增加一张资源表和资源角色关联表，资源表中定义了用户能够访问的 URL 模式，资源角色表则定义了访问该模式的 URL 需要什么样的角色

建表语句

CREATE TABLE `menu` (
  `id` int(11) NOT NULL,
  `pattern` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
CREATE TABLE `menu_role` (
  `id` int(11) NOT NULL,
  `mid` int(11) DEFAULT NULL,
  `rid` int(11) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
1
2
3
4
5
6
7
8
9
10
11

初始化数据

INSERT INTO `menu`(`id`, `pattern`) VALUES (1, '/db/**');
INSERT INTO `menu`(`id`, `pattern`) VALUES (2, '/admin/**');
INSERT INTO `menu`(`id`, `pattern`) VALUES (3, '/user/**');
INSERT INTO `menu_role`(`id`, `mid`, `rid`) VALUES (1, 1, 1);
INSERT INTO `menu_role`(`id`, `mid`, `rid`) VALUES (2, 2, 2);
INSERT INTO `menu_role`(`id`, `mid`, `rid`) VALUES (3, 3, 3);
1
2
3
4
5
6

Menu 实体类

public class Menu {
    private Integer id;
    private String pattern;
    private List<Role> roles;

    public List<Role> getRoles() {
        return roles;
    }

    public void setRoles(List<Role> roles) {
        this.roles = roles;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getPattern() {
        return pattern;
    }

    public void setPattern(String pattern) {
        this.pattern = pattern;
    }
}
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

MenuMapper

@Mapper
public interface MenuMapper {
    List<Menu> getAllMenus();
}
1
2
3
4

MenuMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="org.sang.mapper.MenuMapper">
    <resultMap id="BaseResultMap" type="org.sang.model.Menu">
        <id property="id" column="id"/>
        <result property="pattern" column="pattern"/>
        <collection property="roles" ofType="org.sang.model.Role">
            <id property="id" column="rid"/>
            <result property="name" column="rname"/>
            <result property="nameZh" column="rnameZh"/>
        </collection>
    </resultMap>
    <select id="getAllMenus" resultMap="BaseResultMap">
        SELECT m.*,r.id AS rid,r.name AS rname,r.nameZh AS rnameZh FROM menu m LEFT JOIN menu_role mr ON m.`id`=mr.`mid` LEFT JOIN role r ON mr.`rid`=r.`id`
    </select>
</mapper>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

2. 自定义 FilterInvocationSecurityMetadataSource

Spring Security 中通过 FilterInvocationSecurityMetadataSource 接口中的 getAttributes 方法来确定一个请求需要哪些角色，FilterInvocationSecurityMetadataSource 接口默认实现类是 DefaultFilterInvocationSecurityMetadataSource ，参考 DefaultFilterInvocationSecurityMetadataSource 的实现，开发者可以定义自己的 FilterInvocationSecurityMetadataSource ，如下：

@Component
public class CustomFilterInvocationSecurityMetadataSource
        implements FilterInvocationSecurityMetadataSource {
    AntPathMatcher antPathMatcher = new AntPathMatcher();
    @Autowired
    MenuMapper menuMapper;
    @Override
    public Collection<ConfigAttribute> getAttributes(Object object)
            throws IllegalArgumentException {
        String requestUrl = ((FilterInvocation) object).getRequestUrl();
        List<Menu> allMenus = menuMapper.getAllMenus();
        for (Menu menu : allMenus) {
            if (antPathMatcher.match(menu.getPattern(), requestUrl)) {
                List<Role> roles = menu.getRoles();
                String[] roleArr = new String[roles.size()];
                for (int i = 0; i < roleArr.length; i++) {
                    roleArr[i] = roles.get(i).getName();
                }
                return SecurityConfig.createList(roleArr);
            }
        }
        return SecurityConfig.createList("ROLE_LOGIN");
    }
    @Override
    public Collection<ConfigAttribute> getAllConfigAttributes() {
        return null;
    }
    @Override
    public boolean supports(Class<?> clazz) {
        return FilterInvocation.class.isAssignableFrom(clazz);
    }
}
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

代码解释：

• 开发者自定义 FilterInvocationSecurityMetadataSource 主要实现接口中的 getAttributes 方法，该方法的参数是一个 FilterInvocation ，开发者可以从 FilterInvocation 中提取当前请求的 URL ，返回值是 Collection，表示当前请求 URL 所需角色
• 创建一个 AntPathMatcher 主要用来实现 ant 风格的 URL 匹配
• ((FilterInvocation) object).getRequestUrl(); 从参数中提取当前请求的 URL
• menuMapper.getAllMenus(); 从数据库中获取所有的资源信息，即 menu 表以及 menu 所对应的 role，在真实项目环境中，开发者可以将资源信息缓存在 Redis 或者其他缓存数据库中
• 然后遍历资源信息，遍历过程中获取当前请求的 URL 所需要的角色信息并返回。如果当前请求的 URL 在资源表中不存在相应的模式，就假设该请求登录后即可访问，即直接返回 ROLE_LOGIN
• getAllConfigAttributes 方法用来返回所有定义好的权限资源，Spring Security 在启动时会校验相关配置是否正确，如果不需要校验，那么该方法直接返回 null 即可
• supports 方法返回 类对象是否支持校验

3. 自定义 AccessDecisionManager

当一个请求走完 FilterInvocationSecurityMetadataSource 中的 getAttributes 方法后，接下来就会来到 AccessDecisionManager 类中进行角色信息的比对，自定义 AccessDecisionManager 如下：

@Component
public class CustomAccessDecisionManager implements AccessDecisionManager {
    @Override
    public void decide(Authentication auth,
                       Object object,
                       Collection<ConfigAttribute> ca) {
        Collection<? extends GrantedAuthority> auths = auth.getAuthorities();
        for (ConfigAttribute configAttribute : ca) {
            if ("ROLE_LOGIN".equals(configAttribute.getAttribute())
                    && auth instanceof UsernamePasswordAuthenticationToken) {
                return;
            }
            for (GrantedAuthority authority : auths) {
                if (configAttribute.getAttribute().equals(authority.getAuthority())) {
                    return;
                }
            }
        }
        throw new AccessDeniedException("权限不足");
    }

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

    @Override
    public boolean supports(Class<?> clazz) {
        return true;
    }
}
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

代码解释：

• 自定义 AccessDecisionManager 并重写 decide 方法，在该方法中判断当前登录的用户是否具备当前请求 URL 所需要的角色信息，如果不具备，就抛出 AccessDeniedException 异常，否则不做任何事情
• decide 有三个参数，第一个参数包含当前登录用户的信息；第二个参数则是一个 FilterInvocation 对象，可以获取当前请求对象等；第三个参数就是 UsernamePasswordAuthenticationToken 的实例，说明当前用户已登录，该方法到此结束，否则进入正常的判断流程，如果当前用户具备当前请求需要的角色，那么方法结束

4. 配置

最后，在 Spring Security 中配置上边的两个自定义类，代码如下：

@Configuration
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
    @Autowired
    UserService userService;
    @Bean
    PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(userService);
    }

    @Bean
    RoleHierarchy roleHierarchy() {
        RoleHierarchyImpl roleHierarchy = new RoleHierarchyImpl();
        String hierarchy = "ROLE_dba > ROLE_admin ROLE_admin > ROLE_user";
        roleHierarchy.setHierarchy(hierarchy);
        return roleHierarchy;
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
                .withObjectPostProcessor(new ObjectPostProcessor<FilterSecurityInterceptor>() {
                    @Override
                    public <O extends FilterSecurityInterceptor> O postProcess(O object) {
                        object.setSecurityMetadataSource(cfisms());
                        object.setAccessDecisionManager(cadm());
                        return object;
                    }
                })
                .and()
                .formLogin()
                .loginProcessingUrl("/login").permitAll()
                .and()
                .csrf().disable();
    }

    @Bean
    CustomFilterInvocationSecurityMetadataSource cfisms() {
        return new CustomFilterInvocationSecurityMetadataSource();
    }
    @Bean
    CustomAccessDecisionManager cadm() {
        return new CustomAccessDecisionManager();
    }
}
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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

代码解释：

• 此处 WebSecurityConfig 类的定义是对 10.2节 中 WebSecurityConfig 定义的补充，主要修改了 configure(HttpSecurity http) 方法的实现并添加了两个 Bean
• object.setSecurityMetadataSource(cfisms()); object.setAccessDecisionManager(cadm());将定义的两个实例设置进去