左羽

2020-06-02 15:41 郑州升达经贸管理学院 Java

关注

Spring-Security安全框架的RBAC权限管理

rbac-security

GitHub地址

这是一个基于简单的RBAC模型，结合Spring Security开发的权限管理模块。

一、RBAC模型介绍

RBAC是Role-Based Access Control的缩写，意思就是基于角色的权限访问控制。

基本思想： 对系统的各种权限不是直接授予具体的用户，而是在用户集合与权限集合之间建立一个角色集合。每一种角色对应一组相应的权限。一旦用户被分配了适当的角色后，该用户就拥有此角色的所有操作权限。同样用户被分配了多个适当的角色，那么该用户就拥有了被分配多个角色的所有权限。

优点： 不必在每次创建用户时都进行分配权限的操作，只要分配用户相应的角色即可，而且角色的权限变更比用户的权限变更要少得多，这样将简化用户的权限管理，减少系统的开销。

该系统的RBAC模型——

二、项目思想

本项目将对用户、角色、权限三者之间的关联状态概念交给系统管理员与数据库，对外依然具有RBAC的概念。但是在项目的权限管理中，项目只维护用户与权限的关系。

当用户登录成功后立即在数据库查询该用户所具有的角色，再根据所拥有的角色查询对应的权限——然后将这些权限赋予用户。
该项目的所有接口都是基于权限级别的身份校验，而非角色级别的身份校验。
优点： 节省了对用户与角色、角色与权限之间关系的维护，对身份与接口之间的校验细化程度高，粒度级小。

三、项目技术架构

开发工具： Maven（项目构建管理）
开发环境： JDK8、MySql5.5.25
技术选型 ——
核心框架：SpringBoot 2.2.1.RELEASE
视图框架：SpringMVC 2.2.1.RELEASE
安全框架：SpringSecurity 2.2.1.RELEASE
持久层框架：Mybatis 3.5.2
数据库连接池：Druid 1.1.10
快速开发插件：Mybatis-Plus 3.2.0
API构建工具：Swagger 2 2.9.2

四、需求说明

一个用户可以拥有多个角色，该用户需拥有这些角色所具有权限的并集。
权限的控制在于两方面——前端目录菜单的展示、后端接口的访问拦截。
用户登录成功后立即返回该用户可访问的菜单结构。

五、项目结构

management-security
│ 
├─config  配置    
│    ├─SwaggerConfig.java  关于Swagger2的配置类 
│    └─WebConfig.java  关于Web的配置类
│    
├─controller  视图 
│  
├─exception  异常
│    
├─generator  代码生成 
│    
├─mapper  Mybatis接口
│
├─model  模型
│  └─vo  业务模型
│    
├─security 权限模块
│    ├─constants 常量
│    │    └─SecurityConstants.java 关于权限的常量设置
│    │    
│    ├─handler 拦截器
│    │    ├─AuthenticationFailureHandlerImpl.java   认证失败的行为
│    │    └─AuthenticationSuccessHandlerImpl.java   认证成功的行为 
│    │    
│    ├─impl security的接口实现
│    │  └─UserDetailsServiceImpl.java  用户认证实现
│    │
│    └─SecurityConfig.java  权限配置类
│
├─service  业务接口
│  └─impl  业务接口实现
│   
├─utils  工具包
│  └─Result.java  结果JSON封装
│ 
│        
│       
│ 
├──resources 
│     ├─mapper   MyBatis文件
│     │
│     ├─db  MySql文件
│     │ └─data MySql数据文件  
│     │
│     └─application.yml   全局配置文件
│

六、重点代码解析

（注意：这里我只展示重点代码，具体代码参考文初的GitHub地址）

1、权限数据模型

/**
 * 权限表
 *
 * @author zuoyu
 * @since 2019-11-22
 */
@Data
@NoArgsConstructor
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@TableName("security_authority")
@ApiModel(value = "Authority对象", description = "权限表")
public class Authority extends Model<authority> {

    private static final long serialVersionUID = 1L;

    @ApiModelProperty(value = "主键")
    @TableId(value = "AUTHORITY_ID", type = IdType.AUTO)
    private Integer authorityId;

    @ApiModelProperty(value = "权限名称")
    @TableField("AUTHORITY_NAME")
    private String authorityName;

    @ApiModelProperty(value = "权限目录名称")
    @TableField("AUTHORITY_CONTENT")
    private String authorityContent;

    @ApiModelProperty(value = "权限菜单名称")
    @TableField("AUTHORITY_MENU")
    private String authorityMenu;

    @ApiModelProperty(value = "权限目录URL")
    @TableField("AUTHORITY_MENU_URL")
    private String authorityMenuUrl;

    @ApiModelProperty(value = "创建时间")
    @TableField("AUTHORITY_CREAT_TIME_STAMP")
    private Date authorityCreatTimeStamp;

    @ApiModelProperty(value = "更新时间")
    @TableField("AUTHORITY_UPDATE_TIME_STAMP")
    private Date authorityUpdateTimeStamp;

    @ApiModelProperty(value = "是否被删除")
    @TableField("AUTHORITY_IS_DELETE")
    private Boolean authorityIsDelete;


    @Override
    protected Serializable pkVal() {
        return this.authorityId;
    }


    public Authority(String authorityName, String authorityContent, String authorityMenu, String authorityMenuUrl) {
        this.authorityName = authorityName;
        this.authorityContent = authorityContent;
        this.authorityMenu = authorityMenu;
        this.authorityMenuUrl = authorityMenuUrl;
    }
}

这里的字段权限名称、权限目录名称、权限菜单名称、权限目录URL，其中权限名称是为了Spring-Security控制接口的拦截；权限目录名称、权限菜单名称、权限目录URL是为了给前端该用户可访问的菜单。

2、用户数据模型

/**
 * 安全用户表
 *
 * @author zuoyu
 * @since 2019-11-22
 */
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@TableName("security_user")
@ApiModel(value = "User对象", description = "安全用户表")
public class User extends Model<user> implements UserDetails {

    private static final long serialVersionUID = 1L;

    @ApiModelProperty(value = "安全用户ID")
    @TableId(value = "USER_ID", type = IdType.AUTO)
    private Integer userId;

    @ApiModelProperty(value = "安全账号")
    @TableField("USER_SECURITY_NAME")
    private String userSecurityName;

    @ApiModelProperty(value = "用户密码")
    @TableField("USER_PASS_WORD")
    private String userPassWord;

    @ApiModelProperty(value = "账号是否启用")
    @TableField("USER_IS_ENABLED")
    private Boolean userIsEnabled;

    @ApiModelProperty(value = "账号是否未过期")
    @TableField("USER_IS_ACCOUNT_NON_EXPIRED")
    private Boolean userIsAccountNonExpired;

    @ApiModelProperty(value = "凭证是否未过期")
    @TableField("USER_IS_CREDENTIALS_NON_EXPIRED")
    private Boolean userIsCredentialsNonExpired;

    @ApiModelProperty(value = "帐号是否未锁定")
    @TableField("USER_IS_ACCOUNT_NON_LOCKED")
    private Boolean userIsAccountNonLocked;

    @ApiModelProperty(value = "创建时间")
    @TableField("USER_CREAT_TIME_STAMP")
    private Date userCreatTimeStamp;

    @ApiModelProperty(value = "修改时间")
    @TableField("USER_UPDATE_TIME_STAMP")
    private Date userUpdateTimeStamp;

    @ApiModelProperty(value = "该账号是否已被删除")
    @TableField("USER_IS_DELETE")
    private Boolean userIsDelete;

    @ApiModelProperty(value = "用户名")
    @TableField("USER_NAME")
    private String userName;

    @ApiModelProperty(value = "用户编号")
    @TableField("USER_NUMBER")
    private String userNumber;

    @ApiModelProperty(value = "用户手机号")
    @TableField("USER_PHONE")
    private String userPhone;

    @ApiModelProperty(value = "用户邮箱")
    @TableField("USER_EMAIL")
    private String userEmail;

    @TableField(exist = false)
    private List<authority> authorityBeans;


    public User(String userSecurityName, String userPassWord, String userName, String userNumber, String userPhone, String userEmail) {
        this.userSecurityName = userSecurityName;
        this.userPassWord = userPassWord;
        this.userName = userName;
        this.userNumber = userNumber;
        this.userPhone = userPhone;
        this.userEmail = userEmail;
    }

    @Override
    protected Serializable pkVal() {
        return this.userId;
    }

    @Override
    public Collection<!--? extends GrantedAuthority--> getAuthorities() {
        if (this.authorityBeans == null || this.authorityBeans.isEmpty()) {
            return new HashSet&lt;&gt;(0);
        }
        return authorityBeans.stream().map(authority -&gt;
                new SimpleGrantedAuthority(authority.getAuthorityName()))
                .collect(Collectors.toCollection(HashSet::new));
    }

    @Override
    public String getPassword() {
        return this.userPassWord;
    }

    @Override
    public String getUsername() {
        return this.userSecurityName;
    }

    @Override
    public boolean isAccountNonExpired() {
        return this.userIsAccountNonExpired;
    }

    @Override
    public boolean isAccountNonLocked() {
        return this.userIsAccountNonLocked;
    }

    @Override
    public boolean isCredentialsNonExpired() {
        return this.userIsCredentialsNonExpired;
    }

    @Override
    public boolean isEnabled() {
        return this.userIsEnabled;
    }
}

在这段代码中——

实现org.springframework.security.core.userdetails.UserDetails接口，将其帐号状态的一系列方法实现并对应数据库字段。
重点在添加字段authorityBeans，是权限Authority的集合，在重写的Collection getAuthorities()方法中，提取Authority的字段authorityName并将其包装为SimpleGrantedAuthority权限对象，交给Spring-Security维护用户权限。

3、菜单结构模型

/**
 * @author : zuoyu
 * @description : 菜单
 * @date : 2019-11-26 14:11
 **/
@Data
@AllArgsConstructor
@NoArgsConstructor
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@ApiModel(value = "Menu对象", description = "菜单")
public class MenuVO {

    @ApiModelProperty(value = "菜单名称")
    private String name;

    @ApiModelProperty(value = "URL路径")
    private String url;

}

/**
 * @author : zuoyu
 * @description : 目录
 * @date : 2019-11-26 14:15
 **/
@Data
@AllArgsConstructor
@NoArgsConstructor
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@ApiModel(value="Content对象", description="目录")
public class ContentVO {

    @ApiModelProperty(value = "目录名称")
    private String name;

    @ApiModelProperty(value = "菜单列表")
    private List<menuvo> menuList;

    public ContentVO(String name) {
        this.name = name;
    }
}

这两个VO类是为了构建返回给前端标准的目录-菜单结构，目标结构效果：

[
      {
          "name": "孵化器管理",
          "menuList": [
              {
                  "name": "孵化器内容管理",
                  "url": "incubator/content"
              },
              {
                  "name": "入住企业管理",
                  "url": "incubator/company"
              },
              {
                  "name": "创业端轮播图管理",
                  "url": "incubator/rotations/entrepreneurial"
              },
              {
                  "name": "投资端轮播图管理",
                  "url": "incubator/rotations/investment"
              },
              {
                  "name": "会议室管理",
                  "url": "incubator/conference"
              },
              {
                  "name": "路演管理",
                  "url": "incubator/roadshow"
              },
              {
                  "name": "课程管理",
                  "url": "incubator/course"
              }
          ]
      },
      {
          "name": "订单管理",
          "menuList": [
              {
                  "name": "会员订单管理",
                  "url": "order/members"
              },
              {
                  "name": "保荐人订单管理",
                  "url": "order/sponsor"
              },
              {
                  "name": "推荐人订单管理",
                  "url": "order/referees"
              },
              {
                  "name": "会议室预约订单管理",
                  "url": "order/conference"
              },
              {
                  "name": "路演活动订单管理",
                  "url": "order/roadshow"
              },
              {
                  "name": "企业培训订单管理",
                  "url": "order/training"
              }
          ]
      }
  ]

4、用户源与权限的注入

/**
 * @author : zuoyu
 * @description : 认证实现
 * @date : 2019-11-26 09:53
 **/
@Service
public class UserDetailsServiceImpl implements UserDetailsService {

    private final IUserService iUserService;

    public UserDetailsServiceImpl(IUserService iUserService) {
        this.iUserService = iUserService;
    }

    @Override
    public UserDetails loadUserByUsername(String userName) throws UsernameNotFoundException {
        User user = iUserService.loadUserByUsername(userName);
        if (user == null){
            throw new UsernameNotFoundException("用户名或密码错误");
        }
        List<authority> authorities = iUserService.selectAuthoritiesById(user.getUserId());
        return user.setAuthorityBeans(authorities);
    }
}

在这段代码中——

实现org.springframework.security.core.userdetails.UserDetailsService接口，自定义用户源。

重点是认证成功后，从数据库获取该用户的所有权限，自然是用户->角色->权限，SQL语句：

SELECT sa.AUTHORITY_ID                AS AUTHORITY_ID,
             sa.AUTHORITY_NAME              AS AUTHORITY_NAME,
             sa.AUTHORITY_CONTENT           AS AUTHORITY_CONTENT,
             sa.AUTHORITY_MENU              AS AUTHORITY_MENU,
             sa.AUTHORITY_MENU_URL          AS AUTHORITY_MENU_URL,
             sa.AUTHORITY_CREAT_TIME_STAMP  AS AUTHORITY_CREAT_TIME_STAMP,
             sa.AUTHORITY_UPDATE_TIME_STAMP AS AUTHORITY_UPDATE_TIME_STAMP,
             sa.AUTHORITY_IS_DELETE         AS AUTHORITY_IS_DELETE
      FROM security.security_user su,
           security.security_user_role sur,
           security.security_role sr,
           security.security_role_authority sra,
           security.security_authority sa
      WHERE sa.AUTHORITY_ID = sra.AUTHORITY_ID
        AND sa.AUTHORITY_IS_DELETE = 0
        AND sra.ROLE_ID = sr.ROLE_ID
        AND sra.ROLE_AUTHORITY_IS_DELETE = 0
        AND sr.ROLE_ID = sur.ROLE_ID
        AND sr.ROLE_IS_DELETE = 0
        AND sur.USER_ID = su.USER_ID
        AND sur.USER_ROLE_IS_DELETE = 0
        AND su.USER_IS_DELETE = 0
        AND su.USER_ID = #{userId}

5、对应权限菜单的返回

private List<contentvo> contentBuilder(Map<string, list<contentstructure>&gt; contentGroup) {
        //        根据分组组装对象
        return contentGroup.keySet().parallelStream().map(key -&gt; {
            ContentVO contentVO = new ContentVO(key);
            List<menuvo> menuList = new ArrayList&lt;&gt;(contentGroup.get(key).size());
            menuList.addAll(contentGroup.get(key).stream().map(contentStructure -&gt;
                    new MenuVO(contentStructure.getMenuName(), contentStructure.getUrl()))
                    .collect(Collectors.toList()));
            return contentVO.setMenuList(menuList);
        }).collect(Collectors.toList());
    }

   /**
     * 根据用户查询对应的目录结构
     * @param user -
     * @return List<content>
     */
public List<contentvo> getContentsByUser(User user) {
        List<authority> authorities = user.getAuthorityBeans();
        Map<string, list<contentstructure>&gt; contentGroup = authorities.stream().map(authority -&gt;
                new ContentStructure(authority.getAuthorityContent(), authority.getAuthorityMenu(),
                        authority.getAuthorityMenuUrl())).collect(Collectors.groupingBy(ContentStructure::getContentName));
        return contentBuilder(contentGroup);
    }

@Data
@NoArgsConstructor
@AllArgsConstructor
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
class ContentStructure {

    private String contentName;

    private String menuName;

    private String url;
}

在这段代码中——

利用ContentStructure类和stream流的Collectors.groupingBy(Object object)方法，根据Authority类的contentName字段，以目录名称进行分组，组建目录-菜单结构的List<contentvo>。

/**
* @author : zuoyu
* @description : 登陆成功行为
* @date : 2019-11-21 11:19
**/
@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
@Component
public class AuthenticationSuccessHandlerImpl implements AuthenticationSuccessHandler {

  private final IUserService iUserService;

  public AuthenticationSuccessHandlerImpl(IUserService iUserService) {
      this.iUserService = iUserService;
  }

  @Override
  public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response,
                                      Authentication authentication) throws IOException {
      User user = (User) authentication.getPrincipal();
      List<contentvo> contentList = iUserService.getContentsByUser(user);
      response.setContentType("application/json;charset=utf-8");
      response.setStatus(HttpServletResponse.SC_OK);
      ServletOutputStream servletOutputStream = response.getOutputStream();
      Result result = Result.detail("登陆成功", contentList);
      byte[] bytes = new ObjectMapper().writeValueAsBytes(result);
      servletOutputStream.write(bytes);
      servletOutputStream.flush();
      servletOutputStream.close();
  }
}

在这段代码中——

实现org.springframework.security.web.authentication.AuthenticationSuccessHandler定义登录成功后的行为；
从已登录的身份Authentication中获取User，根据User的authorityBeans构建菜单结构并返回。

七、关于用户—角色、角色—权限关系的修改及查询效率问题

该权限系统一共五张表，其中两张为中间表。当一个用户登录成功后，获取权限的步骤为——

根据用户ID去用户角色中间表获取对应的角色ID集（不走主键）；
根据角色ID集去角色权限中间表获取这些角色ID集所对应的权限ID集（不走主键）；

根据这些权限ID集获取权限信息。

这里有两处不走主键，所以当数据量大的时候会影响查询速度，（这里不考虑数据库索引优化），且在实际业务中一条数据是不会被真正删除的，所以当一个用户的角色修改或者一个角色的权限修改时，我们肯定不能简单粗暴的全部删除再添加。这里我利用差集的方案避免了对修改时重复数据的删除与添加。

以角色的权限修改为例——

 @Transactional(propagation = Propagation.REQUIRED, rollbackFor = {Exception.class,
         CustomException.class})
 public boolean updateRole(Integer userId, List<Integer> roleIds) {
//        在这里，取原角色的集合与新角色的差集进行删除
     List<Integer> oldRoleIds = userRoleMapper.selectRoleByUserId(userId);
     List<UserRole> oldUserRoles = oldRoleIds.stream().filter(roleId -> !roleIds.contains(roleId))
             .map(id -> new UserRole(userId, id)).collect(Collectors.toList());
     if (oldUserRoles.size() > 0) {
         if (!userRoleMapper.deleteUserRoles(oldUserRoles)) {
             throw new CustomException("更新角色错误：删除");
         }
     }
//        在这里，取新角色的集合与原角色的差集进行添加
     List<UserRole> newUserRoles = roleIds.stream().filter(roleId -> !oldRoleIds.contains(roleId))
             .map(id -> new UserRole(userId, id)).collect(Collectors.toList());
     if (newUserRoles.size() > 0) {
         if (!saveBatch(newUserRoles)) {
             throw new CustomException("更新角色错误：添加");
         }
     }
     return true;
 }

当然对角色的删除与添加都是批处理，减少与数据库的交互。
八、本地测试
通过git clone源码
修改application.yml文件，更新MySQL账号和密码
第一次启动： 创建数据库security，数据库编码为UTF-8，并将application.yml文件中的initialization-mode:设置为always，会自动建表和插入数据
已有数据库和表： 启动项目之前确保application.yml文件中的initialization-mode:设置为never
在management-security目录下，执行mvn spring-boot:run
本项目地址接口地址为：http://localhost:8080/management
测试接口浏览器打开http://localhost:8080/management/swagger-ui.html
注： idea、eclipse需安装lombok插件，不然会提示找不到Model的get 、set方法

已有账户与角色：

①——账号：admin  密码：iPadAir 角色：Admin
②——账号：user  密码：123456   角色：User
③——账号：opera 密码：123456   角色：Incubator、Opera

全部评论

推荐最新楼层

昨天 11:40

北京城市学院项目经理

在拼多多工作的体验

首先，厕所简直是稀缺资源，建议直接去商场的厕所，省得在公司里排队。 工时也是个硬指标，基本上是11点到晚上8点，周日加班的话，薪水是单倍的，但请假多了，领导可就会找你谈话。工作强度大是常态，但这也算是变相实现8小时工作制吧。至于裁员，快满三年合同的员工，可能会被优先不续签，赔偿也就那样。 竞业协议也是个麻烦事，股票的竞业计算方式很麻烦，未行权的股票就只能放弃

拼多多集团-PDD工作强度 277人发布

点赞评论收藏

11-19 14:46

宁德时代_数据产品经理(准入职员工)

宁德时代内推宁德时代面经

宁德时代校招面经‌宁德时代热管理工程师面经面试时长：25分钟面试流程：无笔试，只有一面，英语测评，智力测评（两个测评应该不刷人，我都乱写的）面试官配置：只有一位，应该是经理面试内容：面试体验非常好，面试官教了我专业之外的很多东西。1.如果领导给你个任务，你有7天的时间，你怎么分配？2.电池液冷板的流量是怎么考虑的？3.实习过程中你学到了什么？4.你觉得实习和学校最大的区别是什么？反问：1.用的什么软件，以及怎么应对在学校用的仿真软件和工作的软件不一样这个转变？面试官说用的floefd，然后又说：其实软件的学习都是次要的，你们校招生进来会培训软件的使用，同时工作中也会天天用软件，你更应该关注的是...

点赞评论收藏

10-31 19:24

门头沟学院硬件开发

大疆寄

太丑陋了。

我也曾抱有希望：说的好直白

点赞评论收藏

11-20 16:02

哈尔滨工业大学（深圳）算法工程师

秋招都快要结束了啊！

怎么感觉周围都没什么动静，是不是只有那些大佬们收获了offer？ 我真的不想相信这一切就这样结束了！希望能有点好消息，不然我真是要崩溃了！

过关斩将结果败给排序：你不是开奖了吗？

牛客创作赏金赛

点赞评论收藏

点赞收藏评论

全站热榜

正在热议

# 选完offer后，你后悔学本专业吗 #

# 听到哪句话就代表面试稳了or挂了？ #

93553次浏览 783人参与

# 机械人，你在招聘流程中的企业有哪些？ #

17704次浏览 183人参与

# 网申一定要掌握的小技巧 #

5206次浏览 52人参与

# 如果实习可以转正，你会不会放弃秋招 #

206493次浏览 2810人参与

# 一觉醒来，我觉醒了超级打工人系统 #

3740次浏览 38人参与

Spring-Security安全框架的RBAC权限管理

rbac-security

这是一个基于简单的RBAC模型，结合Spring Security开发的权限管理模块。

一、RBAC模型介绍

二、项目思想

三、项目技术架构

四、需求说明

五、项目结构

六、重点代码解析

（注意： 这里我只展示重点代码，具体代码参考文初的GitHub地址）

1、权限数据模型

2、用户数据模型

3、菜单结构模型

4、用户源与权限的注入

5、对应权限菜单的返回

七、关于 用户—角色 、 角色—权限 关系的修改及查询效率问题

以角色的权限修改为例——

八、本地测试

全站热榜

（注意：这里我只展示重点代码，具体代码参考文初的GitHub地址）

七、关于用户—角色、角色—权限关系的修改及查询效率问题