前言
权限管理是在项目中经常要使用到的模块，有着极其重要的功能。 在 Java 帝国中有两个比较出名的权限框架，分别为 Shiro 和 Spring Security，两者各有优缺，但这不是本篇要讨论的重点，这次我们不用任何权限框架来实现 RBAC 权限管理。
本文所有代码下载地址：https://github.com/zhaojun1998/Premission-Study
RBAC 简介
RBAC (Role-Based Access Control) 基于角色的权限访问控制。
即用户拥有角色,角色拥有权限。具体关于 RBAC 的好处我就不再赘言，如感兴趣请自行查询。
数据库设计
共有五张表，分别为用户表、角色表、权限表、用户-角色关系表、角色-权限关系表。其中用户表于角色表是多对多的关系，角色表于权限表也是多对多关系。具体每个字段的含义请查看相应的注释。
SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;
-- ----------------------------
-- Table structure for permission
-- ----------------------------
DROP TABLE IF EXISTS `permission`;
CREATE TABLE `permission` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`name` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '权限名称',
`description` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '权限描述表',
PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci COMMENT = '权限表' ROW_FORMAT = Dynamic;
-- ----------------------------
-- Table structure for role
-- ----------------------------
DROP TABLE IF EXISTS `role`;
CREATE TABLE `role` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`name` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '权限名称',
`description` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '权限描述',
PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci COMMENT = '角色表' ROW_FORMAT = Dynamic;
-- ----------------------------
-- Table structure for role_premission
-- ----------------------------
DROP TABLE IF EXISTS `role_premission`;
CREATE TABLE `role_premission` (
`role_id` int(11) NULL DEFAULT NULL,
`permission_id` int(11) NULL DEFAULT NULL,
INDEX `role_premission_uid_fk`(`role_id`) USING BTREE,
INDEX `role_premission_pid_fk`(`permission_id`) USING BTREE,
CONSTRAINT `role_premission_pid_fk` FOREIGN KEY (`permission_id`) REFERENCES `permission` (`id`) ON DELETE RESTRICT ON UPDATE RESTRICT,
CONSTRAINT `role_premission_uid_fk` FOREIGN KEY (`role_id`) REFERENCES `role` (`id`) ON DELETE RESTRICT ON UPDATE RESTRICT
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
-- ----------------------------
-- Table structure for user
-- ----------------------------
DROP TABLE IF EXISTS `user`;
CREATE TABLE `user` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`username` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '用户名',
`password` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '密码',
PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci COMMENT = '用户表' ROW_FORMAT = Dynamic;
-- ----------------------------
-- Table structure for user_role
-- ----------------------------
DROP TABLE IF EXISTS `user_role`;
CREATE TABLE `user_role` (
`user_id` int(11) NULL DEFAULT NULL,
`role_id` int(11) NULL DEFAULT NULL,
INDEX `user_role_uid_fk`(`user_id`) USING BTREE,
INDEX `user_role_rid_fk`(`role_id`) USING BTREE,
CONSTRAINT `user_role_rid_fk` FOREIGN KEY (`role_id`) REFERENCES `role` (`id`) ON DELETE RESTRICT ON UPDATE RESTRICT,
CONSTRAINT `user_role_uid_fk` FOREIGN KEY (`user_id`) REFERENCES `user` (`id`) ON DELETE RESTRICT ON UPDATE RESTRICT
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci COMMENT = '用户角色表' ROW_FORMAT = Dynamic;
SET FOREIGN_KEY_CHECKS = 1;
环境配置
本次基于的环境是 Spring + SpringMVC + MyBatis，不过即使你不会这几个框架也无所谓，因为权限管理没有涉及到太多这些框架的特性，用普通的 Servlet + JDBC 同样也可以实现。
因篇幅原因，框架的配置文件我这里就不再贴出，但我会将源码发到 Github，你可以去下载本实例完整代码。
实体类
首先需要创建三个与数据库对应的实体类
public class User {
private Integer id;
private String username;
private String password;
// getter setter 略
}
public class Role {
private Integer id;
private String name;
private String description;
// getter setter 略
}
public class Permission {
private Integer id;
private String name;
private String description;
// getter setter 略
}
DAO 数据操作层
UserMapper
public interface UserMapper {
int insert(User record);
User selectByPrimaryKey(Integer id);
int updateByPrimaryKey(User record);
List selectALL();
/**
* 查询用户拥有的角色列表
* @param id 用户 id
* @return 角色列表
*/
List selectRolesByPrimaryKey(Integer id);
/**
* 删除用户所有角色
* @param id 用户id
* @return 删除成功的条数
*/
int deleteRoles(Integer id);
/**
* 为用户赋予角色
* @param userId 用户 id
* @param roleId 授予的角色 id
* @return 插入成功的条数
*/
int insertUserRole(@Param("user_id") Integer userId, @Param("role_id") Integer roleId);
/**
* 根据用户名密码查询账号是否存在
* @param username 用户名
* @param password 密码
* @return 查询到的账号
*/
User selectUserByUsernameAndPassword(@Param("username")String username,@Param("password")String password);
}
RoleMapper
public interface RoleMapper {
int insert(Role record);
Role selectByPrimaryKey(Integer id);
int updateByPrimaryKey(Role record);
List selectAll();
/**
* 查询角色拥有的权限列表
* @param id 角色 id
* @return 权限列表
*/
List selectPermissionsByPrimaryKey(Integer id);
/**
* 删除角色所有的权限
* @param id 角色 id
* @return 删除成功的条数
*/
int deletePermissions(Integer id);
/**
* 为角色添加一个权限
* @param roleId 角色 id
* @param permissionId 权限 id
* @return 插入成功的条数
*/
int insertRolePermission(@Param("role_id")Integer roleId, @Param("permission_id") Integer permissionId);
}
PermissionMapper
public interface PermissionMapper {
int insert(Permission record);
Permission selectByPrimaryKey(Integer id);
int updateByPrimaryKey(Permission record);
List selectAll();
}
只需要一些简单的 SQL 操作，如需要对应的 mapper.xml 可去 Github 查看。
用户管理
用户添加
HTML 页面:
Controller:
public String addUserSubmit(User user) {
return userService.add(user) > 0 ? "success" : "error";
}
service 和 dao 略.
用户登陆
HTML 页面:
Controller:
public String login(String username, String password, HttpSession httpSession) {
User user = userService.selectUserByUsernameAndPassword(username, password);
if (user != null) {
httpSession.setAttribute("user", user);
return "登陆成功";
}
return "登陆失败";
}
service 和 dao 略.
查看用户列表
HTML 页面:
用户名
密码
操作
${user.username}
${user.password}
赋予角色
Controller:
public ModelAndView listUser() {
return new ModelAndView("user.jsp").addObject("users", userService.getAllUser());
}
image
service 和 dao 略.
为用户赋予角色
为用户赋予角色需要先添加角色，请先看下面的添加角色后再来操作。
HTML 页面:
image
Controller:
public String grantRole(int id, int[] roleId) {
userService.updateRoles(id, roleId);
return "success";
}
Service:
public void updateRoles(Integer id, int[] roleIds) {
userMapper.deleteRoles(id);
if (roleIds != null) {
for (int roleId : roleIds) {
userMapper.insertUserRole(id, roleId);
}
}
}
其实这里的修改授权角色只是将原来它拥有的所有角色删除，再分配给它提交的所有角色。
角色管理
添加角色
HTML 页面:
Controller:
public String addRole(Role role) {
return roleService.add(role) > 0 ? "success" : "error";
}
service 和 dao 略.
角色列表
HTML 页面:
角色名称
角色描述
操作
${role.name}
${role.description}
赋予权限
Controller:
public ModelAndView listRole() {
return new ModelAndView("role.jsp").addObject("roles", roleService.getAll());
}
image
service 和 dao 略.
为角色赋予权限
HTML 页面:
Controller:
public String grantPermission(int id, int[] premissionId) {
roleService.updatePermission(id, premissionId);
return "success";
}
Service:
public void updatePermission(Integer roleId, int[] permissionsIds) {
roleMapper.deletePermissions(roleId);
if (permissionsIds != null) {
for (int permissionId : permissionsIds) {
roleMapper.insertRolePermission(roleId, permissionId);
}
}
}
image
这里的为角色赋予权限同样也是先删除角色所拥有的权限，再添加表单提交的所有权限。
权限管理
添加权限
HTML 页面:
Controller:
public String add(Permission permission) {
return permissionService.add(permission) > 0 ? "success" : "error";
}
service 和 dao 略.
权限列表
HTML 页面:
Controller:
public String add(Permission permission) {
return permissionService.add(permission) > 0 ? "success" : "error";
}
image
service 和 dao 略.
权限拦截
既然已经分配好用户，角色以及权限之间的关系了，那么我们就可以设置一些需要权限才能访问的资源了。
我设置了 5 个 url, 并标注了需要何权限或何角色才可访问:
/api/add # add 权限
/api/delete # delete 权限
/api/get # get 权限
/api/employee # employee 角色
/api/boss # boos 角色
我们可以用拦截器来拦截 /api/* 下的所有请求，那么如何区分不同请求分别需要什么权限呢？
这里我参考了 Shiro 的设计，即采用注解的方式，在相应的方法上用 @RequiredRole 和 @RequiredPremission 来标注相应的请求需要某个角色或某个权限才可访问。
@RestController
@RequestMapping("/api")
public class APIController {
@RequiredPermission("add")
@RequestMapping("/add")
public String add() {
return "添加数据成功";
}
@RequiredPermission("delete")
@RequestMapping("/delete")
public String delete() {
return "删除数据成功";
}
@RequiredPermission("get")
@RequestMapping("/get")
public String select() {
return "查询数据成功";
}
@RequiredRole("boss")
@RequestMapping("/boss")
public String boss() {
return "此数据为 Boss 专用数据, 你是 boss, 你可以查看";
}
@RequiredRole("employee")
@RequestMapping("/employee")
public String employee() {
return "此数据为员工专用数据, 你是员工, 可以查看";
}
}
拦截器获取拦截的方法上的注解即可得知需要什么权限，以便来进行相应的判断，Spring 拦截器：
public class PermissionHandlerInterceptor implements HandlerInterceptor {
@Resource
private UserService userService;
@Resource
private RoleService roleService;
@Override
public boolean preHandle(HttpServletRequest request,
HttpServletResponse response,
Object handler) throws Exception {
response.setHeader("Content-type", "text/html;charset=UTF-8");
Method method = ((HandlerMethod)handler).getMethod();
RequiredRole requiredRole = method.getAnnotation(RequiredRole.class);
RequiredPermission requiredPermission = method.getAnnotation(RequiredPermission.class);
User user = (User) request.getSession().getAttribute("user");
if (user == null) {
response.getWriter().write("未登录");
return false;
}
List userRoles = userService.getUserRoles(user.getId());
if (requiredRole != null) {
for (Role role : userRoles) {
if (role.getName().equals(requiredRole.value())) {
return true;
}
}
}
if (requiredPermission != null) {
for (Role role : userRoles) {
List permissions = roleService.getPermissions(role.getId());
for (Permission persission : permissions) {
if (requiredPermission.value().equals(persission.getName())) {
return true;
}
}
}
}
response.getWriter().println("权限不足");
return false;
}
}
总结
基本实现就这些，其实没有很复杂的东西，只是将 RBAC 这个思想运用了起来。
那么反观我们这个权限管理有什么缺陷呢？
我来列举几点：
对密码没有进行加密处理, 应对密码进行加盐并散列。
每次请求都会去获取所对应的权限数据和角色数据，太耗费资源，应该进行缓存。
不支持多凭证登陆，如可用邮箱也可用手机号登陆。
这些问题我会在后续的 shiro 的笔记中一一讲到。
本文所有代码下载地址：https://github.com/zhaojun1998/Premission-Study