• 数据权限就该这么实现（实践篇），yyds！

    我的知识星球正式上线了(戳链接)，期待你的加入，我们一起冲冲冲！

    大家好，在上一篇文章中我们详细介绍了在RBAC模型中如何集成数据权限，本篇文章我们将通过实际案例，从代码实战的角度来实现这样的一个数据权限。

    在开始阅读本文之前，建议先把上篇文章 读一遍，读一遍，读一遍！

    数据权限就该这么设计，yyds！

    数据权限模型

    上篇文章的数据模型是基于传统的RBAC模型来设计的，由于我们这里的应用场景不一样，所以这里的数据权限模型并没有严格按照上篇文章的方案来设计，但是万变不离其宗，核心原理还是相同的。

    首先我来介绍一下我们最终实现的效果

    实现效果

    6d22aca89ed55cbfa9eb5ffe60eb88d2.png

    一个组件（可以理解成菜单）可以绑定多个授权维度，当给角色授权组件时可以给这个授权组件赋予不同维度的权限。

    关于数据权限的授权维度有以下几个关键点需要仔细体会：

    1. 给一个角色勾选授权维度实际上是在限制这个角色所能看到的数据范围

    2. 任何一个授权维度勾选了"全部"，相当于不限制此维度的权限。

      如果一个角色勾选了客户群的全部 + A产品线，那么最终生成的sql 会是 where 产品线 in ('A产品线')

    3. 如果一个角色勾选了多个维度，维度之间用 AND 拼接

      如果一个角色勾选了A客户群 + B产品线，那么最终生成的sql 会是 where 客户群 in（'A客户群'）AND 产品线 in ('B产品线')

    4. 一个用户可能有多个角色，角色之间用 OR 拼接

      一个用户有两个角色：客户群总监，产品线经理。其中客户群总监角色拥有A客户群和B客户群的权限，产品线经理角色拥有A产品线权限，那么最终生成的sql会是 where 客户群 in ('A客户群','B客户群') OR 产品线 in ('A产品线')

    由于我们业务场景中数据规则比较单一，全部使用 in作为sql条件连接符，你们可以根据实际业务场景进行补充。

    数据模型

    最终的数据模型如下所示：

    97f005d0999dfb20a508d20004171649.png

    这里的组件大家完全可以理解成RBAC模型中的资源、菜单，只不过叫法不同而已。

    数据权限表结构

    下面是具体的表结构设计

    授权维度表

    1. CREATE TABLE `wb_dimension` (
    2.   `ID` varchar(32) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NOT NULL COMMENT '主键',
    3.   `DIMENSION_CODE` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '维度编码',
    4.   `DIMENSION_NAME` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '维度名称',
    5.   PRIMARY KEY (`ID`) USING BTREE
    6. ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci ROW_FORMAT=DYNAMIC COMMENT='授权维度'

    具体授权维度表（产品线）

    1. CREATE TABLE `wb_dimension_proc_line` (
    2.   `ID` varchar(32) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NOT NULL COMMENT '主键',
    3.   `DIMENSION_CODE` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '维度编码',
    4.   `PROC_LINE_CODE` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '产品线编码',
    5.   `PROC_LINE_NAME` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '产品线名称',
    6.   PRIMARY KEY (`ID`) USING BTREE
    7. ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci ROW_FORMAT=DYNAMIC COMMENT='授权维度-产品线'

    跟授权维度表实际是一个表继承的关系，由于每个授权维度的属性不一样，展现形式也不一样，所以分表存储。

    组件路由表

    1. CREATE TABLE `wb_route` (
    2.   `ID` varchar(32) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NOT NULL COMMENT '主键ID',
    3.   `COMPONENT_ID` varchar(32) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '组件ID',
    4.   `ROUTE_URL` varchar(1000) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '路由地址',
    5.   `AUTHORIZATION_TYPE` varchar(32) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '授权方式:1 自定义，2 上下级授权， 3 范围授权',
    6.   `AUTHORIZATION_DIMENSION` json DEFAULT NULL COMMENT '授权维度',
    7.   PRIMARY KEY (`ID`) USING BTREE
    8. ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci ROW_FORMAT=DYNAMIC COMMENT='组件路由'

    当组件属性授权方式为范围授权时在应用侧会强制要求选择具体的授权维度，如 产品线、客户群。

    角色表

    1. CREATE TABLE `wb_role` (
    2.   `ID` varchar(32) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NOT NULL COMMENT '主键ID',
    3.   `ROLE_CODE` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '角色CODE',
    4.   `ROLE_NAME` varchar(500) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '角色名称',
    5.   `IDENTITY_ID` varchar(32) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '身份ID'
    6.   PRIMARY KEY (`ID`) USING BTREE
    7. ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci ROW_FORMAT=DYNAMIC COMMENT='角色表'

    角色上有一个身份属性，多个角色可以归属同一个身份，方便对角色进行分类管理。

    角色组件绑定表

    1. CREATE TABLE `role_component_relation` (
    2.   `ID` varchar(32) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NOT NULL COMMENT '主键ID',
    3.   `ROLE_ID` varchar(32) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NOT NULL COMMENT '角色ID',
    4.   `COMPONENT_ID` varchar(32) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NOT NULL COMMENT '组件ID',
    5.   PRIMARY KEY (`ID`) USING BTREE
    6. ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci ROW_FORMAT=DYNAMIC COMMENT='角色授权组件'

    角色组件授权规则表（核心）

    1. CREATE TABLE `wb_role_component_rule` (
    2.   `ID` varchar(32) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NOT NULL COMMENT '主键',
    3.   `ROLE_ID` varchar(32) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '角色ID',
    4.   `COMPONENT_ID` varchar(32) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '组件ID',
    5.   `RULE_CODE` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '规则编码',
    6.   `RULE_NAME` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '规则名称',
    7.   `RULE_CONDITION` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '规则条件',
    8.   `RULE_VALUE` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '规则值',
    9.   PRIMARY KEY (`ID`) USING BTREE
    10. ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci ROW_FORMAT=DYNAMIC COMMENT='角色组件维度规则表'

    数据权限的核心表，规则条件的取值为IN，规则值存储具体的维度编码，当在数据维度中选择 全部 时我们将规则值存储为ALL这个特殊值，方便后续生成SQL语句。

    2f9e7e6cba44b79729d2f0dfaf28a232.png

    实现过程

    上篇文章中提到过数据权限的实现过程，这里再回顾一下

    1. 自定义一个数据权限的注解，比如叫DataPermission

    2. 在对应的资源请求方法，比如商机列表上添加自定义注解@DataPermission

    3. 利用AOP抓取到用户对应角色的所有数据规则并进行SQL拼接，最终在SQL层面实现数据过滤。

    代码实现

    自定义数据权限注解

    1. @Retention(RetentionPolicy.RUNTIME)
    2. @Target({ElementType.TYPE,ElementType.METHOD})
    3. @Documented
    4. public @interface DataPermission {
    5.  /**
    6.   * 数据权限类型
    7.   * 1 上下级授权  2 数据范围授权
    8.   */
    9.  String permissionType() default "2";
    10.  
    11.  /**
    12.   * 配置菜单的组件路径,用于数据权限
    13.   */
    14.  String componentRoute() default "";
    15. }

    定义数据权限处理切面

    1. @Aspect
    2. @Slf4j
    3. public class DataPermissionAspect {
    4.  
    5.  @Autowired
    6.  private RoleComponentRuleService roleComponentRuleService;
    7.  
    8.  @Pointcut("@annotation(com.ifly.workbench.security.annotation.DataPermission)")
    9.  public void pointCut() {
    10.   
    11.  }
    12.  
    13.  @Around("pointCut()")
    14.  public Object around(ProceedingJoinPoint point) throws  Throwable{
    15.  
    16.   HttpServletRequest request = SpringContextUtils.getHttpServletRequest();
    17.  
    18.   //获取请求token
    19.   String token = request.getHeader(CommonConstant.X_ACCESS_TOKEN);
    20.   String userName = JwtUtil.getUsername(token);
    21.     
    22.   MethodSignature signature = (MethodSignature) point.getSignature();
    23.   Method method = signature.getMethod();
    24.   DataPermission permissionData = method.getAnnotation(DataPermission.class);
    25.  
    26.     //获取授权方式
    27.   String permissionType = permissionData.permissionType();
    28.   //获取组件路由
    29.   String componentRoute = permissionData.componentRoute();
    30.     
    31.     if (StringUtils.isNotEmpty(componentRoute)){
    32.    // 查找当前用户此组件下的所有规则
    33.    List componentRules = roleComponentRuleService.getRoleComponentRule(userName, componentRoute);
    34.       
    35.    if(CollectionUtils.isNotEmpty(componentRules)){
    36.      DataPermissionUtils.installDataSearchConditon(request, componentRules);
    37.      SysUserCacheInfo userInfo = buildCacheUser(userName);
    38.      DataPermissionUtils.installUserInfo(request, userInfo);
    39.     }
    40.   }
    41.     
    42.     return  point.proceed();
    43.  }
    44.  
    45.  private SysUserCacheInfo buildCacheUser(String userName) {
    46.   SysUserCacheInfo info = new SysUserCacheInfo();
    47.   info.setSysUserName(userName);
    48.   info.setOneDepart(true);
    49.   return info;
    50.  }
    51. }

    在AOP中获取当前用户、需要访问的组件中所有的数据规则，参考wb_role_component_rule表设计，并将其放到Request作用域中。

    数据权限工具类

    1. public class DataPermissionUtils {
    2.  
    3.  public static final String COMPONENT_DATA_RULES = "COMPONENT_DATA_RULES";
    4.  
    5.  public static final String SYS_USER_INFO = "SYS_USER_INFO";
    6.  
    7.  
    8.    /**
    9.   * 往链接请求里面，传入数据查询条件
    10.   * @param request
    11.   * @param componentRules
    12.   */
    13.  public static void installDataSearchConditon(HttpServletRequest request, List componentRules) {
    14.   // 1.先从request获取MENU_DATA_AUTHOR_RULES，如果存则获取到LIST
    15.   List list = loadDataSearchCondition();
    16.  
    17.   if (list==null) {
    18.    // 2.如果不存在，则new一个list
    19.    list = Lists.newArrayList();
    20.   }
    21.   list.addAll(componentRules);
    22.   // 3.往list里面增量存指
    23.   request.setAttribute(COMPONENT_DATA_RULES, list);
    24.  }
    25.  
    26.  /**
    27.   * 获取请求对应的数据权限规则
    28.   *
    29.   */
    30.  @SuppressWarnings("unchecked")
    31.  public synchronized List loadDataSearchCondition() {
    32.   return (List) SpringContextUtils.getHttpServletRequest().getAttribute(COMPONENT_DATA_RULES);
    33.     
    34.  }
    35.  
    36.  public synchronized void installUserInfo(HttpServletRequest request, SysUserCacheInfo userinfo) {
    37.   request.setAttribute(SYS_USER_INFO, userinfo);
    38.  }
    39. }

    在Request中存储数据规则。

    查询组件规则

    1. public interface RoleComponentRuleService extends IService {
    2.  
    3.     /**
    4.      * 根据 用户域账户和组件编码 获取组件对应的关系
    5.      *
    6.      * @param userName      域账号
    7.      * @param componentCode 组件编码
    8.      * @return 用户的所有规则
    9.      */
    10.     List getRoleComponentRule(String userName, String componentCode);
    11. }
    1. @Service
    2. public class RoleComponentRuleServiceImpl extends ServiceImpl implements RoleComponentRuleService {
    3.  
    4.     @Resource
    5.     private RoleComponentRuleMapper roleComponentRuleMapper;
    6.  
    7.     /**
    8.      * 根据 用户域账户和组件编码 获取组件对应的关系
    9.      * @param userName      域账号
    10.      * @param componentCode 组件编码
    11.      * @return 用户的所有规则
    12.      */
    13.     @Override
    14.     public List getRoleComponentRule(String userName, String componentCode) {
    15.         return roleComponentRuleMapper.getRoleComponentRule(userName,componentCode);
    16.     }
    17.  
    18. }
    1. <select id="getRoleComponentRule" resultType="com.ifly.vo.RoleComponentRuleDTO">
    2.  SELECT
    3.     tab1.id,
    4.     tab1.role_id,
    5.     tab4.role_code,
    6.     tab1.component_id,
    7.     tab1.rule_code,
    8.     tab1.rule_name,
    9.     tab1.rule_condition,
    10.     tab1.rule_value,
    11.     tab4.identity_id
    12.   FROM
    13.    wb_role_component_rule tab1
    14.    LEFT JOIN user_role_relation tab2 ON tab2.role_id = tab1.role_id
    15.    LEFT JOIN wb_component tab3 ON tab3.id = tab1.component_id
    16.    LEFT JOIN wb_role tab4 ON tab4.id = tab1.role_id
    17.    JOIN role_component_relation tab5 ON tab5.role_id = tab1.role_id
    18.    AND tab5.component_id = tab1.component_id
    19.   where
    20.    tab2.user_account = #{userName}
    21.    and tab3.component_code = #{componentCode}
    22. select>

    Controller调用

    1. @ApiOperation(value = "服务BU-领导-总览")
    2. @GetMapping("opp/getLeaderOverviewSve")
    3. @DataPermission(componentRoute = "020202")
    4. public Result getLeaderOverviewSve(@RequestParam(name = "identityId") String identityId) {
    5.  String permissionSql = RuleQueryGenerator.getPermissionSql(identityId);
    6.   log.info("查服务BU-领导-总览-permissionSQL==" + permissionSql);
    7.  
    8.  return Result.OK(overviewSveService.getLeaderOverviewSve(permissionSql));
    9. }

    在controller的请求方法上加上自定义注解@DataPermission并指定组件编码，然后通过工具类生成SQL条件，最后将SQL条件传入service层进行处理。

    构建数据权限SQL

    1. @Slf4j
    2. @UtilityClass
    3. public class RuleQueryGenerator {
    4.  
    5.     private static final String SQL_AND = " and ";
    6.  
    7.     private static final String SQL_OR = " or ";
    8.  
    9.     private static final String SQL_JOINT = " (%s) ";
    10.  
    11.     /**
    12.      * 获取带有数据权限的SQL
    13.      * @param identityId 身份ID
    14.      */
    15.     public String getPermissionSql(String identityId) {
    16.         //------------------------获取当前身份的数据规则------------------------------------
    17.         List conditionList = getCurrentIdentyPermission(identityId);
    18.         if (CollectionUtils.isEmpty(conditionList)) {
    19.             //没有权限
    20.             return "1 = 0";
    21.         }
    22.         //存在权限
    23.         //对当前身份根据规则编码分组-去除不同角色中相同编码且规则值为ALL的规则 并根据角色id分组
    24.         Map> ruleMap = getRuleMapByRoleId(conditionList);
    25.  
    26.         StringBuilder sb = new StringBuilder();
    27.         String roleSql;
    28.         if (MapUtils.isNotEmpty(ruleMap)) {
    29.             //按角色拼接SQL
    30.             for (Map.Entry> entry : ruleMap.entrySet()) {
    31.  
    32.                 List lists = entry.getValue();
    33.  
    34.                 // 同角色之间使用 AND
    35.                 roleSql = buildRoleSql(lists);
    36.  
    37.                 //角色之间使用 OR
    38.                 if (StringUtils.isNotEmpty(roleSql)) {
    39.                     jointSqlByRoles(sb, roleSql);
    40.                 }
    41.             }
    42.  
    43.         }
    44.         return sb.toString();
    45.     }
    46.  
    47.     private static List getCurrentIdentyPermission(String identityId) {
    48.         //----------------------------获取所有数据规则-----------------------------
    49.         List roleRuleList = DataPermissionUtils.loadDataSearchCondition();
    50.         if(CollectionUtils.isEmpty(roleRuleList)){
    51.             return null;
    52.         }
    53.         //-----------------------------过滤掉不属于当前身份的规则-----------------------------------
    54.         return roleRuleList.stream()
    55.                 .filter(item -> item.getIdentityId().equals(identityId))
    56.                 .collect(Collectors.toList());
    57.     }
    58.  
    59.     /**
    60.      * 构建单角色SQL
    61.      */
    62.     private static String buildRoleSql(List lists) {
    63.         StringBuilder roleSql = new StringBuilder();
    64.         for (RoleComponentRuleDTO item : lists) {
    65.             //如果出现全选 则 代表全部，不需要限定范围
    66.             if ("ALL".equals(item.getRuleValue())) {
    67.                 continue;
    68.             }
    69.             //将规则转换成SQL
    70.             String filedSql = convertRuleToSql(item);
    71.  
    72.             roleSql.append(SQL_AND).append(filedSql);
    73.         }
    74.         return roleSql.toString();
    75.     }
    76.  
    77.  
    78.     /**
    79.      * 将单一规则转化成SQL，默认全部使用 In
    80.      * ruleCode : area_test
    81.      * ruleValue : 区域1，区域2，区域3
    82.      * @param rule 规则值
    83.      */
    84.     private static String convertRuleToSql(RoleComponentRuleDTO rule) {
    85.         String whereCondition = " in ";
    86.         String ruleValueConvert = getInConditionValue(rule.getRuleValue());
    87.         return rule.getRuleCode() + whereCondition + ruleValueConvert;
    88.     }
    89.  
    90.  
    91.     /**
    92.      * IN字符串转换
    93.      * 区域1, 区域2, 区域3  --> ("区域1","区域2","区域3")
    94.      * 江西大区  --> ("江西大区")
    95.      */
    96.     private static String getInConditionValue(String ruleValue) {
    97.         String[] temp = ruleValue.split(",");
    98.         StringBuilder res = new StringBuilder();
    99.         for (String string : temp) {
    100.             res.append(",'").append(string).append("'");
    101.         }
    102.         return "(" + res.substring(1) + ")";
    103.     }
    104.  
    105.     /**
    106.      * 拼接单角色的SQL
    107.      * @param sqlBuilder 总的SQL
    108.      * @param roleSql    单角色SQL
    109.      */
    110.     private static void jointSqlByRoles(StringBuilder sqlBuilder, String roleSql) {
    111.         roleSql = roleSql.replaceFirst(SQL_AND, "");
    112.         if (StringUtils.isEmpty(sqlBuilder.toString())) {
    113.             sqlBuilder.append(String.format(SQL_JOINT, roleSql));
    114.         } else {
    115.             sqlBuilder.append(SQL_OR).append(String.format(SQL_JOINT, roleSql));
    116.         }
    117.     }
    118.  
    119.     /**
    120.      *
    121.      * 1. 对当前身份根据规则编码分组-去除不同角色中相同编码且规则值为ALL的规则
    122.      * 2. 对角色进行分组
    123.      * @param conditionList 数据规则
    124.      * @return 分组后的规则list
    125.      */
    126.     private static Map> getRuleMapByRoleId(List conditionList) {
    127.     //--------过滤掉不属于当前身份的规则,并对条件编码进行分组-----------------------------------
    128.     Map> conditionMap = conditionList.stream().collect(Collectors.groupingBy(RoleComponentRuleDTO::getRuleCode));
    129.  
    130.   //--------相同编码分组中存在ALL的排除掉-----------------------------------------------
    131.     List newRoleRuleList = new ArrayList<>();
    132.     if (MapUtils.isNotEmpty(conditionMap)) {
    133.      for (Map.Entry> entry : conditionMap.entrySet()) {
    134.        boolean flag = true;
    135.         List lists = entry.getValue();
    136.         for (RoleComponentRuleDTO item : lists) {
    137.          if ("ALL".equals(item.getRuleValue())) {
    138.            flag = false;
    139.             break;
    140.           }
    141.         }
    142.         
    143.         if (flag) {
    144.            newRoleRuleList.addAll(lists);
    145.         }
    146.       }
    147.      }
    148.      if (CollectionUtils.isNotEmpty(newRoleRuleList)) {
    149.         return newRoleRuleList.stream().collect(Collectors.groupingBy(RoleComponentRuleDTO::getRoleId));
    150.       }
    151.      return Maps.newHashMap();
    152.     }
    153. }

    核心类，用于生成数据权限查询的SQL脚本。

    Dao层实现

    1. <select id="getLeaderOverviewSve" resultType="com.ifly.center.entity.SalesProjOverviewSve">
    2.  SELECT "column_list"/>  FROM U_STD_ADS.LTC_SALES_PROJ_OVERVIEW_SVE
    3.   
    4.    <if test="permissionSql != null and permissionSql != ''">
    5.     ${permissionSql}
    6.     if>
    7.   
    8. select>

    Dao层接受service层传入已经生成好的sql语句，作为查询条件直接拼接在业务语句之后。

    小结

    以上，就是数据权限的实现过程，其实代码实现并不复杂，主要还是得理解其中的实现原理。如果你也有数据权限的需求，不妨参考一下。当然如果你有更好的实现方案，也可以留言告诉我。

    2a1c7d18baf2b258ef476dd12173be38.png

  • 相关阅读:
    Py之interpret：interpret的简介、安装、案例应用之详细攻略
    目的和目标的差异|丰田自动工程完结的目的、目标、应用化的意义和明确、二
    PySpark 小白教程 (二) PySpark SQL 简介
    Element & 8080端口被占用
    Linux 阻塞机制及等待队列
    前端在请求数据时使用节流来防止多个重复请求
    高等数学（第七版）同济大学 习题10-5 个人解答
    获取多个接口的数据并进行处理，使用Promise.all来等待所有接口请求完成
    基于Java毕业设计薪酬福利管理信息系统源码+系统+mysql+lw文档+部署软件
    每日一题——使用tkinter开发GUI程序习题
  • 原文地址：https://blog.csdn.net/jianzhang11/article/details/126169113