SpringSecurity实战教程（五）基于数据库的动态用户认证：传统RBAC角色模型实战开发

1. 前言#

在上一章节中，我们讲解了Spring Security基于内存的用户认证，也提到了实际开发生产中更多使用的还是基于数据库的动态用户认证，因为在企业应用中，用户、角色、权限管理通常都存储在数据库中。

本章节博主将带着大家以MySQL数据库为例，从用户（sys_user）、角色（sys_role）、用户角色（sys_user_role）、系统菜单资源（sys_menu）、角色菜单（sys_role_menu）表出发，演示如何使用Spring Security动态加载用户信息、角色，实现基于数据库的RBAC角色模型认证。

2. 数据库表结构说明#

本文示例基于整理的MySQL表结构，其中主要表结构如下（大家可以根据自己的业务需求进行扩展）：

sys_user：存储用户信息，字段包括user_id、login_name、password等
sys_role：存储角色信息，字段包括role_id、role_name（角色名称）、role_key（角色标识）等
sys_user_role：关联用户和角色的中间表
sys_menu：系统菜单资源表，字段包括menu_id、menu_name（菜单名称）、perms（权限标识）等
sys_role_menu：角色和菜单资源的中间表

整体数据库表结构如下：

以下是为大家整理好的建表语句，数据库中的用户表：用户名和密码一致：

1
SET NAMES utf8mb4;
2
SET FOREIGN_KEY_CHECKS = 0;
3

4
-- ----------------------------
5
-- Table structure for sys_menu
6
-- ----------------------------
7
DROP TABLE IF EXISTS `sys_menu`;
8
CREATE TABLE `sys_menu` (
9
  `menu_id` bigint NOT NULL AUTO_INCREMENT COMMENT '菜单ID',
10
  `menu_name` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '菜单名称',
11
  `perms` varchar(100) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci DEFAULT NULL COMMENT '权限标识',
12
  PRIMARY KEY (`menu_id`) USING BTREE
13
) ENGINE=InnoDB AUTO_INCREMENT=2045 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci COMMENT='菜单权限表';
14

15
-- ----------------------------
16
-- Records of sys_menu
17
-- ----------------------------
18
BEGIN;
19
INSERT INTO `sys_menu` (`menu_id`, `menu_name`, `perms`) VALUES (1, '管理员菜单', 'admin:menu');
20
INSERT INTO `sys_menu` (`menu_id`, `menu_name`, `perms`) VALUES (2, '管理员添加', 'admin:menu:add');
21
INSERT INTO `sys_menu` (`menu_id`, `menu_name`, `perms`) VALUES (3, '管理员删除', 'admin:menu:delete');
22
INSERT INTO `sys_menu` (`menu_id`, `menu_name`, `perms`) VALUES (4, '普通用户菜单', 'user:menu');
23
INSERT INTO `sys_menu` (`menu_id`, `menu_name`, `perms`) VALUES (5, '普通用户添加', 'user:menu:add');
24
INSERT INTO `sys_menu` (`menu_id`, `menu_name`, `perms`) VALUES (6, '普通用户删除', 'user:menu:delete');
25
INSERT INTO `sys_menu` (`menu_id`, `menu_name`, `perms`) VALUES (7, '开发者菜单', 'developers:menu');
26
INSERT INTO `sys_menu` (`menu_id`, `menu_name`, `perms`) VALUES (8, '开发者添加', 'developers:menu:add');
27
COMMIT;
28

29
-- ----------------------------
30
-- Table structure for sys_role
31
-- ----------------------------
32
DROP TABLE IF EXISTS `sys_role`;
33
CREATE TABLE `sys_role` (
34
  `role_id` bigint NOT NULL AUTO_INCREMENT COMMENT '角色ID',
35
  `role_name` varchar(30) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '角色名称',
36
  `role_key` varchar(100) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '角色权限字符串',
37
  PRIMARY KEY (`role_id`) USING BTREE
38
) ENGINE=InnoDB AUTO_INCREMENT=100 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci COMMENT='角色信息表';
39

40
-- ----------------------------
41
-- Records of sys_role
42
-- ----------------------------
43
BEGIN;
44
INSERT INTO `sys_role` (`role_id`, `role_name`, `role_key`) VALUES (1, '管理员', 'ADMIN');
45
INSERT INTO `sys_role` (`role_id`, `role_name`, `role_key`) VALUES (2, '普通用户', 'USER');
46
INSERT INTO `sys_role` (`role_id`, `role_name`, `role_key`) VALUES (3, '开发者', 'DEVELOPERS');
47
COMMIT;
48

49
-- ----------------------------
50
-- Table structure for sys_role_menu
51
-- ----------------------------
52
DROP TABLE IF EXISTS `sys_role_menu`;
53
CREATE TABLE `sys_role_menu` (
54
  `role_id` bigint NOT NULL COMMENT '角色ID',
55
  `menu_id` bigint NOT NULL COMMENT '菜单ID',
56
  PRIMARY KEY (`role_id`,`menu_id`) USING BTREE
57
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci COMMENT='角色和菜单关联表';
58

59
-- ----------------------------
60
-- Records of sys_role_menu
61
-- ----------------------------
62
BEGIN;
63
INSERT INTO `sys_role_menu` (`role_id`, `menu_id`) VALUES (1, 1);
64
INSERT INTO `sys_role_menu` (`role_id`, `menu_id`) VALUES (1, 2);
65
INSERT INTO `sys_role_menu` (`role_id`, `menu_id`) VALUES (1, 3);
66
INSERT INTO `sys_role_menu` (`role_id`, `menu_id`) VALUES (2, 4);
67
INSERT INTO `sys_role_menu` (`role_id`, `menu_id`) VALUES (2, 5);
68
INSERT INTO `sys_role_menu` (`role_id`, `menu_id`) VALUES (2, 6);
69
INSERT INTO `sys_role_menu` (`role_id`, `menu_id`) VALUES (3, 7);
70
INSERT INTO `sys_role_menu` (`role_id`, `menu_id`) VALUES (3, 8);
71
COMMIT;
72

73
-- ----------------------------
74
-- Table structure for sys_user
75
-- ----------------------------
76
DROP TABLE IF EXISTS `sys_user`;
77
CREATE TABLE `sys_user` (
78
  `user_id` bigint NOT NULL AUTO_INCREMENT COMMENT '用户ID',
79
  `login_name` varchar(30) NOT NULL COMMENT '登录账号',
80
  `password` varchar(64) DEFAULT NULL COMMENT '登陆密码',
81
  `status` char(1) DEFAULT '0' COMMENT '帐号状态（0正常 1停用）',
82
  `del_flag` char(1) DEFAULT '0' COMMENT '删除标志（0代表存在 2代表删除）',
83
  PRIMARY KEY (`user_id`)
84
) ENGINE=InnoDB AUTO_INCREMENT=101 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci COMMENT='用户信息表';
85

86
-- ----------------------------
87
-- Records of sys_user
88
-- ----------------------------
89
BEGIN;
90
INSERT INTO `sys_user` (`user_id`, `login_name`, `password`, `status`, `del_flag`) VALUES (1, 'admin', '$2a$10$SnMMruuWQmEEKNMqREDb0e4jfaqJeZviOFjxQRwq.9A7PM6Z0xo5W', '0', '0');
91
INSERT INTO `sys_user` (`user_id`, `login_name`, `password`, `status`, `del_flag`) VALUES (2, 'user', '$2a$10$96vbFKuEmMlObg1bPqevdOJybTp2cAesJZ5uJBqR797qxnVWx12Wi', '0', '0');
92
INSERT INTO `sys_user` (`user_id`, `login_name`, `password`, `status`, `del_flag`) VALUES (3, 'developers', '$2a$10$BOpzjv4hmZQB1ydsaDTvZ.Cvyq4.kDty2/ghrcVKhetsTD1sKJaIu', '0', '0');
93
COMMIT;
94

95
-- ----------------------------
96
-- Table structure for sys_user_role
97
-- ----------------------------
98
DROP TABLE IF EXISTS `sys_user_role`;
99
CREATE TABLE `sys_user_role` (
100
  `user_id` bigint NOT NULL COMMENT '用户ID',
101
  `role_id` bigint NOT NULL COMMENT '角色ID',
102
  PRIMARY KEY (`user_id`,`role_id`)
103
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci COMMENT='用户和角色关联表';
104

105
-- ----------------------------
106
-- Records of sys_user_role
107
-- ----------------------------
108
BEGIN;
109
INSERT INTO `sys_user_role` (`user_id`, `role_id`) VALUES (1, 1);
110
INSERT INTO `sys_user_role` (`user_id`, `role_id`) VALUES (1, 3);
111
INSERT INTO `sys_user_role` (`user_id`, `role_id`) VALUES (2, 2);
112
INSERT INTO `sys_user_role` (`user_id`, `role_id`) VALUES (3, 3);
113
COMMIT;
114

115
SET FOREIGN_KEY_CHECKS = 1;

3. 完成初始配置#

接下来在之前的Maven项目中创建第四个子模块db-spring-security：

由于需要操作数据库，在Maven主目录pom文件中，追加mysql数据库驱动以及mybatis-plus。博主使用的是HikariCP连接池，直接引入spring-boot-starter-data-jpa即可，Spring官方默认支持：

1
        <!--Lombok-->
2
        <dependency>
3
            <groupId>org.projectlombok</groupId>
4
            <artifactId>lombok</artifactId>
5
            <scope>provided</scope>
6
        </dependency>
7
        <!--使用 HikariCP 连接池-->
8
        <dependency>
9
            <groupId>org.springframework.boot</groupId>
10
            <artifactId>spring-boot-starter-data-jpa</artifactId>
11
        </dependency>
12
        <!-- mysql驱动 -->
13
        <dependency>
14
            <groupId>mysql</groupId>
15
            <artifactId>mysql-connector-java</artifactId>
16
            <version>8.0.30</version>
17
        </dependency>
18
        <!-- mybatis-plus -->
19
        <dependency>
20
            <groupId>com.baomidou</groupId>
21
            <artifactId>mybatis-plus-spring-boot3-starter</artifactId>
22
            <version>3.5.9</version>
23
        </dependency>

最后配置yml文件，运行项目确保项目能正常连接数据库且启动成功：

1
server:
2
  port: 8083
3

4
spring:
5
  application:
6
    name: db-spring-security # 最新Spring Security实战教程（五）基于数据库的动态用户认证
7
  datasource:
8
    url: jdbc:mysql://localhost:3306/slave_db?useSSL=false&serverTimezone=UTC
9
    username: root
10
    password: root
11
    driver-class-name: com.mysql.cj.jdbc.Driver
12
    hikari:
13
      maximum-pool-size: 5
14

15
mybatis-plus:
16
  configuration:
17
    map-underscore-to-camel-case: true # 开启驼峰转换
18
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl # 打印SQL
19
    cache-enabled: true # 开启二级缓存
20
  global-config:
21
    db-config:
22
      logic-delete-field: delFlag # 逻辑删除字段
23
      logic-delete-value: 1 # 删除值
24
      logic-not-delete-value: 0 # 未删除值

4. MyBatis-Plus实体定义#

在确保数据库能正常连接后，接下来就跟着博主一起编写业务代码吧。

❶ 用户实体（实现UserDetails）#

博主为了方便，直接使用数据库映射的SysUser对象直接实现UserDetails，大家在开发过程中建议单独构建实现对象！

1
@Data
2
@TableName("sys_user")
3
public class SysUser implements UserDetails {
4

5
    @TableId(type = IdType.AUTO)
6
    private Long userId;
7

8
    @TableField("login_name")
9
    private String username; // Spring Security认证使用的字段
10

11
    private String password;
12

13
    private String status; // 状态（0正常 1锁定）
14

15
    private String delFlag; // 删除标志（0代表存在 1代表删除）
16

17
    @TableField(exist = false)
18
    private List<SysRole> roles;
19

20
    // 实现UserDetails接口
21
    @Override
22
    public Collection<? extends GrantedAuthority> getAuthorities() {
23
        // 组装 GrantedAuthority 集合，将角色和菜单权限都加入
24
        Set<GrantedAuthority> authorities = new HashSet<>();
25
        // 加入角色
26
        authorities.addAll(roles.stream()
27
                .map(role -> new SimpleGrantedAuthority("ROLE_" + role.getRoleKey()))
28
                .collect(Collectors.toList()));
29
        // 加入菜单资源
30
        authorities.addAll(roles.stream()
31
                .flatMap(role -> role.getMenus().stream())
32
                .map(menu -> new SimpleGrantedAuthority(menu.getPerms()))
33
                .collect(Collectors.toList()));
34
        return authorities;
35
    }
36

37
    @Override
38
    public boolean isAccountNonExpired() { return true; }
39

40
    @Override
41
    public boolean isAccountNonLocked() {
42
        return "0".equals(status);
43
    }
44

45
    @Override
46
    public boolean isCredentialsNonExpired() { return true; }
47

48
    @Override
49
    public boolean isEnabled() {
50
        return "0".equals(delFlag);
51
    }
52
}

❷ 角色实体#

1
@Data
2
@TableName("sys_role")
3
public class SysRole {
4
    @TableId(type = IdType.AUTO)
5
    private Long roleId;
6
    private String roleName;
7
    private String roleKey;
8

9
    @TableField(exist = false)
10
    private List<SysMenu> menus;
11
}

❸ 菜单实体#

1
@Data
2
@TableName("sys_menu")
3
public class SysMenu {
4
    @TableId(type = IdType.AUTO)
5
    private Long menuId;
6
    private String menuName;
7
    private String perms;
8
}

5. MyBatis-Plus Mapper配置#

完成实体类的创建，我们开始配置Mapper实现数据库的业务查询处理。为了快速演示，博主就不构建mapper.xml了，直接在Mapper上编写查询SQL。

UserMapper接口：主要是通过用户角色中间表获取角色信息：

1
@Mapper
2
public interface UserMapper extends BaseMapper<SysUser> {
3

4
    @Select("SELECT r.* FROM sys_role r " +
5
            "JOIN sys_user_role ur ON r.role_id = ur.role_id " +
6
            "WHERE ur.user_id = #{userId}")
7
    @Results({
8
            @Result(property = "roleId", column = "role_id"),
9
            @Result(property = "menus", column = "role_id",
10
                    many = @Many(select = "com.toher.springsecurity.demo.db.mapper.MenuMapper.selectByUserId"))
11
    })
12
    List<SysRole> selectRolesByUserId(Long userId);
13
}

RoleMapper接口：主要是通过角色菜单中间表获取菜单信息：

1
@Mapper
2
public interface RoleMapper extends BaseMapper<SysRole> {
3

4
    @Select("SELECT m.* FROM sys_menu m " +
5
            "JOIN sys_role_menu rm ON m.menu_id = rm.menu_id " +
6
            "WHERE rm.role_id = #{roleId}")
7
    List<SysMenu> selectMenusByRoleId(Long roleId);
8
}

MenuMapper接口：主要是通过用户ID直接获取菜单信息（用于用户权限汇总）：

1
@Mapper
2
public interface MenuMapper extends BaseMapper<SysMenu> {
3

4
    @Select("SELECT DISTINCT m.* FROM sys_menu m " +
5
            "JOIN sys_role_menu rm ON m.menu_id = rm.menu_id " +
6
            "JOIN sys_user_role ur ON rm.role_id = ur.role_id " +
7
            "WHERE ur.user_id = #{userId}")
8
    List<SysMenu> selectByUserId(Long userId);
9
}

6. 自定义UserDetailsService实现#

自定义UserDetailsService继承UserDetailsService，重写loadUserByUsername方法，注入UserMapper以及RoleMapper通过用户名查询数据库数据，同时将用户的角色、菜单资源集合一并赋值：

1
@Service
2
@RequiredArgsConstructor
3
public class UserDetailsServiceImpl implements UserDetailsService {
4

5
    private final UserMapper userMapper;
6
    private final RoleMapper roleMapper;
7

8
    @Override
9
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
10

11
        // 1. 查询基础用户信息
12
        LambdaQueryWrapper<SysUser> wrapper = new LambdaQueryWrapper<>();
13
        wrapper.eq(SysUser::getUsername, username);
14
        SysUser user = userMapper.selectOne(wrapper);
15

16
        if (user == null) {
17
            throw new UsernameNotFoundException("用户不存在");
18
        }
19

20
        // 2. 加载角色和权限
21
        List<SysRole> roles = userMapper.selectRolesByUserId(user.getUserId());
22
        roles.forEach(role ->
23
                role.setMenus(roleMapper.selectMenusByRoleId(role.getRoleId()))
24
        );
25
        user.setRoles(roles);
26

27
        // 3. 检查账户状态
28
        if (!user.isEnabled()) {
29
            throw new DisabledException("用户已被禁用");
30
        }
31
        return user;
32
    }
33
}

7. Spring Security配置文件与测试#

1
@Configuration
2
// 开启方法级的安全控制
3
@EnableMethodSecurity
4
@RequiredArgsConstructor
5
public class DbSecurityConfig {
6

7
    private final UserDetailsServiceImpl userDetailsService;
8

9
    @Bean
10
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
11
        http
12
            .authorizeHttpRequests(authorize -> authorize
13
                // 配置形式：ADMIN角色可以访问/admin/view
14
                .requestMatchers("/admin/view").hasAnyAuthority("ADMIN")
15
                .anyRequest().authenticated()
16
            )
17
            .userDetailsService(userDetailsService)
18
            .formLogin(withDefaults())
19
            .logout(withDefaults());
20
        return http.build();
21
    }
22

23
    @Bean
24
    public PasswordEncoder passwordEncoder() {
25
        return new BCryptPasswordEncoder();
26
    }
27
}

最后编写测试Controller，当用户登录认证成功，则默认返回当前用户数据信息：

1
@RestController
2
@RequiredArgsConstructor
3
public class DemoAbacController {
4

5
    private final UserMapper userMapper;
6
    private final PasswordEncoder passwordEncoder;
7

8
    @GetMapping("/")
9
    public ResponseEntity<SysUser> index(Authentication authentication) {
10
        System.out.println(authentication);
11
        SysUser principal = (SysUser) authentication.getPrincipal();
12
        return ResponseEntity.ok(principal);
13
    }
14

15
    /**
16
     * 基于SecurityConfig配置角色访问
17
     */
18
    @GetMapping("/admin/view")
19
    public ResponseEntity<String> admin() {
20
        return ResponseEntity.ok("基于SecurityConfig配置ROLE_ADMIN角色访问ok");
21
    }
22

23
    /**
24
     * 根据角色权限访问
25
     */
26
    @PreAuthorize("hasRole('ADMIN')")
27
    @GetMapping("/system/view")
28
    public ResponseEntity<String> system() {
29
        return ResponseEntity.ok("方法的授权hasRole ADMIN 角色访问ok");
30
    }
31

32
    /**
33
     * 根据菜单权限访问
34
     */
35
    @PreAuthorize("hasAuthority('admin:menu:add')")
36
    @GetMapping("/system/add")
37
    public ResponseEntity<String> add() {
38
        return ResponseEntity.ok("方法的授权admin:menu:add,访问ok");
39
    }
40

41
    /**
42
     * 管理员角色且用户名是admin方可访问
43
     */
44
    @PreAuthorize("hasRole('ADMIN') and authentication.name == 'admin'")
45
    @GetMapping("/system/del")
46
    public ResponseEntity<String> del() {
47
        return ResponseEntity.ok("方法的授权admin:menu:delete,访问ok");
48
    }
49
}

最终完整代码结构如下，小伙伴们可以根据自己需求构建项目测试：

启动项目，在Spring Security提供的默认登录页中输入数据库中账号密码进行登录！默认返回当前登录用户信息以及授权信息，授权信息在SysUser实现UserDetails重写getAuthorities方法中体现：

前端返回用户数据信息展示，小伙伴可以结合自己前后端项目，返回登录用户相关数据进行系统菜单、功能权限的配置：

并切换不同的用户进行登录测试访问/admin/view、/system/view、/system/add、/system/del，以确认各权限访问是否允许！

总结#

本章节演示了使用MyBatis-Plus进行数据库操作，动态加载用户、角色权限，并将其转换为Spring Security的GrantedAuthority列表，从而实现基于数据库的动态用户认证。并提供了一个简单的Controller用于测试和查看当前登录用户的信息。

至此，关于Spring Security身份认证的基于内存以及基于数据库的两种方式均讲解完了。下一个章节我们将进入授权Authorization的相关讲解，小伙伴们耐心等待…

音乐

音乐