• MyBatis-Plus 使用拦截器实现数据权限控制

    平时开发中遇到根据当前用户的角色，只能查看数据权限范围的数据需求。列表实现方案有两种，一是在开发初期就做好判断赛选，但如果这个需求是中途加的，或不希望每个接口都加一遍，就可以方案二加拦截器的方式。在mybatis执行sql前修改语句，限定where范围。

    当然拦截器生效后是全局性的，如何保证只对需要的接口进行拦截和转化，就可以应用注解进行识别

    因此具体需要哪些步骤就明确了

    • 创建注解类

    • 创建拦截器实现InnerInterceptor接口，重写查询方法

    • 创建处理类，获取数据权限 SQL 片段，设置where

    • 将拦截器加到MyBatis-Plus插件中

    上代码（基础版）

    自定义注解

    1. import java.lang.annotation.ElementType;
    2. import java.lang.annotation.Retention;
    3. import java.lang.annotation.RetentionPolicy;
    4. import java.lang.annotation.Target;
    5.  
    6. @Target({ElementType.METHOD, ElementType.TYPE})
    7. @Retention(RetentionPolicy.RUNTIME)
    8. public @interface UserDataPermission {
    9. }

    拦截器

    1. import com.baomidou.mybatisplus.core.plugins.InterceptorIgnoreHelper;
    2. import com.baomidou.mybatisplus.core.toolkit.PluginUtils;
    3. import com.baomidou.mybatisplus.extension.parser.JsqlParserSupport;
    4. import com.baomidou.mybatisplus.extension.plugins.inner.InnerInterceptor;
    5. import lombok.*;
    6. import net.sf.jsqlparser.expression.Expression;
    7. import net.sf.jsqlparser.statement.select.PlainSelect;
    8. import net.sf.jsqlparser.statement.select.Select;
    9. import net.sf.jsqlparser.statement.select.SelectBody;
    10. import net.sf.jsqlparser.statement.select.SetOperationList;
    11. import org.apache.ibatis.executor.Executor;
    12. import org.apache.ibatis.mapping.BoundSql;
    13. import org.apache.ibatis.mapping.MappedStatement;
    14. import org.apache.ibatis.session.ResultHandler;
    15. import org.apache.ibatis.session.RowBounds;
    16.  
    17. import java.sql.SQLException;
    18. import java.util.List;
    19.  
    20. @Data
    21. @NoArgsConstructor
    22. @AllArgsConstructor
    23. @ToString(callSuper = true)
    24. @EqualsAndHashCode(callSuper = true)
    25. public class MyDataPermissionInterceptor extends JsqlParserSupport implements InnerInterceptor {
    26.  
    27.     /**
    28.      * 数据权限处理器
    29.      */
    30.     private MyDataPermissionHandler dataPermissionHandler;
    31.  
    32.     @Override
    33.     public void beforeQuery(Executor executor, MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {
    34.         if (InterceptorIgnoreHelper.willIgnoreDataPermission(ms.getId())) {
    35.             return;
    36.         }
    37.         PluginUtils.MPBoundSql mpBs = PluginUtils.mpBoundSql(boundSql);
    38.         mpBs.sql(this.parserSingle(mpBs.sql(), ms.getId()));
    39.     }
    40.  
    41.     @Override
    42.     protected void processSelect(Select select, int index, String sql, Object obj) {
    43.         SelectBody selectBody = select.getSelectBody();
    44.         if (selectBody instanceof PlainSelect) {
    45.             this.setWhere((PlainSelect) selectBody, (String) obj);
    46.         } else if (selectBody instanceof SetOperationList) {
    47.             SetOperationList setOperationList = (SetOperationList) selectBody;
    48.             List<SelectBody> selectBodyList = setOperationList.getSelects();
    49.             selectBodyList.forEach(s -> this.setWhere((PlainSelect) s, (String) obj));
    50.         }
    51.     }
    52.  
    53.     /**
    54.      * 设置 where 条件
    55.      *
    56.      * @param plainSelect  查询对象
    57.      * @param whereSegment 查询条件片段
    58.      */
    59.     private void setWhere(PlainSelect plainSelect, String whereSegment) {
    60.  
    61.         Expression sqlSegment = this.dataPermissionHandler.getSqlSegment(plainSelect, whereSegment);
    62.         if (null != sqlSegment) {
    63.             plainSelect.setWhere(sqlSegment);
    64.         }
    65.     }
    66. }

    拦截器处理器

    基础只涉及 = 表达式，要查询集合范围 in 看进阶版用例

    1. import cn.hutool.core.collection.CollectionUtil;
    2. import lombok.SneakyThrows;
    3. import lombok.extern.slf4j.Slf4j;
    4. import net.sf.jsqlparser.expression.Alias;
    5. import net.sf.jsqlparser.expression.Expression;
    6. import net.sf.jsqlparser.expression.HexValue;
    7. import net.sf.jsqlparser.expression.StringValue;
    8. import net.sf.jsqlparser.expression.operators.conditional.AndExpression;
    9. import net.sf.jsqlparser.expression.operators.relational.EqualsTo;
    10. import net.sf.jsqlparser.expression.operators.relational.ExpressionList;
    11. import net.sf.jsqlparser.expression.operators.relational.InExpression;
    12. import net.sf.jsqlparser.expression.operators.relational.ItemsList;
    13. import net.sf.jsqlparser.schema.Column;
    14. import net.sf.jsqlparser.schema.Table;
    15. import net.sf.jsqlparser.statement.select.PlainSelect;
    16.  
    17. import java.lang.reflect.Method;
    18. import java.util.List;
    19. import java.util.Objects;
    20. import java.util.Set;
    21. import java.util.stream.Collectors;
    22.  
    23. @Slf4j
    24. public class MyDataPermissionHandler {
    25.  
    26.     /**
    27.      * 获取数据权限 SQL 片段
    28.      *
    29.      * @param plainSelect  查询对象
    30.      * @param whereSegment 查询条件片段
    31.      * @return JSqlParser 条件表达式
    32.      */
    33.     @SneakyThrows(Exception.class)
    34.     public Expression getSqlSegment(PlainSelect plainSelect, String whereSegment) {
    35.         // 待执行 SQL Where 条件表达式
    36.         Expression where = plainSelect.getWhere();
    37.         if (where == null) {
    38.             where = new HexValue(" 1 = 1 ");
    39.         }
    40.         log.info("开始进行权限过滤,where: {},mappedStatementId: {}", where, whereSegment);
    41.         //获取mapper名称
    42.         String className = whereSegment.substring(0, whereSegment.lastIndexOf("."));
    43.         //获取方法名
    44.         String methodName = whereSegment.substring(whereSegment.lastIndexOf(".") + 1);
    45.         Table fromItem = (Table) plainSelect.getFromItem();
    46.         // 有别名用别名，无别名用表名，防止字段冲突报错
    47.         Alias fromItemAlias = fromItem.getAlias();
    48.         String mainTableName = fromItemAlias == null ? fromItem.getName() : fromItemAlias.getName();
    49.         //获取当前mapper 的方法
    50.         Method[] methods = Class.forName(className).getMethods();
    51.         //遍历判断mapper 的所以方法，判断方法上是否有 UserDataPermission
    52.         for (Method m : methods) {
    53.             if (Objects.equals(m.getName(), methodName)) {
    54.                 UserDataPermission annotation = m.getAnnotation(UserDataPermission.class);
    55.                 if (annotation == null) {
    56.                     return where;
    57.                 }
    58.                 // 1、当前用户Code
    59.              User user = SecurityUtils.getUser();
    60.                 // 查看自己的数据
    61.                  //  = 表达式
    62.                  EqualsTo usesEqualsTo = new EqualsTo();
    63.                  usesEqualsTo.setLeftExpression(new Column(mainTableName + ".creator_code"));
    64.                  usesEqualsTo.setRightExpression(new StringValue(user.getUserCode()));
    65.                  return new AndExpression(where, usesEqualsTo);
    66.             }
    67.         }
    68.         //说明无权查看，
    69.         where = new HexValue(" 1 = 2 ");
    70.         return where;
    71.     }
    72.  
    73. }

    将拦截器加到MyBatis-Plus插件中

    如果你之前项目配插件 ，直接用下面方式就行

    1. @Bean
    2. public MybatisPlusInterceptor mybatisPlusInterceptor() {
    3.     MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
    4.     // 添加数据权限插件
    5.     MyDataPermissionInterceptor dataPermissionInterceptor = new MyDataPermissionInterceptor();
    6.     // 添加自定义的数据权限处理器
    7.     dataPermissionInterceptor.setDataPermissionHandler(new MyDataPermissionHandler());
    8.     interceptor.addInnerInterceptor(dataPermissionInterceptor);
    9.     interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
    10.     return interceptor;
    11. }

    但如果你项目之前是依赖包依赖，或有公司内部统一拦截设置好，也可以往MybatisPlusInterceptor进行插入，避免影响原有项目配置

    1. @Bean
    2. public MyDataPermissionInterceptor myInterceptor(MybatisPlusInterceptor mybatisPlusInterceptor) {
    3.     MyDataPermissionInterceptor sql = new MyDataPermissionInterceptor();
    4.     sql.setDataPermissionHandler(new MyDataPermissionHandler());
    5.     List<InnerInterceptor> list = new ArrayList<>();
    6.     // 添加数据权限插件
    7.     list.add(sql);
    8.     // 分页插件
    9.     mybatisPlusInterceptor.setInterceptors(list);
    10.     list.add(new PaginationInnerInterceptor(DbType.MYSQL));
    11.     return sql;
    12. }

    以上就是简单版的是拦截器修改语句使用

    使用方式

    在mapper层添加注解即可

    1. @UserDataPermission
    2. List selectAllCustomerPage(IPage page, @Param("customerName")String customerName);

    进阶版

    基础班只是能用，业务功能没有特别约束，先保证能跑起来

    进阶版 解决两个问题：

    • 加了角色，用角色决定范围

    • 解决不是mapper层自定义sql查询问题。

    两个是完全独立的问题 ，可根据情况分开解决

    解决不是mapper层自定义sql查询问题。

    例如我们名称简单的sql语句 直接在Service层用mybatisPluse自带的方法

    1. xxxxService.list(Wrapper<T> queryWrapper)
    2. xxxxService.page(new Page<>(),Wrapper<T> queryWrapper)

    以上这种我应该把注解加哪里呢

    因为service层，本质上还是调mapper层， 所以还是在mapper层做文章，原来的mapper实现了extends BaseMapper 接口，所以能够查询，我们要做的就是在 mapper层中间套一个中间接口，来方便我们加注解

    xxxxxMapper ——》DataPermissionMapper（中间） ——》BaseMapper

    根据自身需要，在重写的接口方法上加注解即可，这样就影响原先的代码

    图片

    1. import com.baomidou.mybatisplus.core.conditions.Wrapper;
    2. import com.baomidou.mybatisplus.core.mapper.BaseMapper;
    3. import com.baomidou.mybatisplus.core.metadata.IPage;
    4. import com.baomidou.mybatisplus.core.toolkit.Constants;
    5. import org.apache.ibatis.annotations.Param;
    6.  
    7. import java.io.Serializable;
    8. import java.util.Collection;
    9. import java.util.List;
    10. import java.util.Map;
    11.  
    12. public interface DataPermissionMapper<T> extends BaseMapper<T> {
    13.  
    14.     /**
    15.      * 根据 ID 查询
    16.      *
    17.      * @param id 主键ID
    18.      */
    19.     @Override
    20.     @UserDataPermission
    21.     T selectById(Serializable id);
    22.  
    23.     /**
    24.      * 查询（根据ID 批量查询）
    25.      *
    26.      * @param idList 主键ID列表(不能为 null 以及 empty)
    27.      */
    28.     @Override
    29.     @UserDataPermission
    30.     List<T> selectBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);
    31.  
    32.     /**
    33.      * 查询（根据 columnMap 条件）
    34.      *
    35.      * @param columnMap 表字段 map 对象
    36.      */
    37.     @Override
    38.     @UserDataPermission
    39.     List<T> selectByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);
    40.  
    41.     /**
    42.      * 根据 entity 条件，查询一条记录
    43.      *
    44.      * @param queryWrapper 实体对象封装操作类（可以为 null）
    45.      */
    46.     @Override
    47.     @UserDataPermission
    48.     T selectOne(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
    49.  
    50.     /**
    51.      * 根据 Wrapper 条件，查询总记录数
    52.      *
    53.      * @param queryWrapper 实体对象封装操作类（可以为 null）
    54.      */
    55.     @Override
    56.     @UserDataPermission
    57.     Integer selectCount(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
    58.  
    59.     /**
    60.      * 根据 entity 条件，查询全部记录
    61.      *
    62.      * @param queryWrapper 实体对象封装操作类（可以为 null）
    63.      */
    64.     @Override
    65.     @UserDataPermission
    66.     List<T> selectList(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
    67.  
    68.     /**
    69.      * 根据 Wrapper 条件，查询全部记录
    70.      *
    71.      * @param queryWrapper 实体对象封装操作类（可以为 null）
    72.      */
    73.     @Override
    74.     @UserDataPermission
    75.     List<Map<String, Object>> selectMaps(@Param(Constants.WRAPPER) Wrapper queryWrapper);
    77.     /**
    78.      * 根据 Wrapper 条件，查询全部记录
    79.      * <p>注意： 只返回第一个字段的值</p>
    80.      *
    81.      * @param queryWrapper 实体对象封装操作类（可以为 null）
    82.      */
    83.     @Override
    84.     @UserDataPermission
    85.     List<Object> selectObjs(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
    86.  
    87.     /**
    88.      * 根据 entity 条件，查询全部记录（并翻页）
    89.      *
    90.      * @param page         分页查询条件（可以为 RowBounds.DEFAULT）
    91.      * @param queryWrapper 实体对象封装操作类（可以为 null）
    92.      */
    93.     @Override
    94.     @UserDataPermission
    95.     <E extends IPage<T>> E selectPage(E page, @Param(Constants.WRAPPER) Wrapper queryWrapper);
    97.     /**
    98.      * 根据 Wrapper 条件，查询全部记录（并翻页）
    99.      *
    100.      * @param page         分页查询条件
    101.      * @param queryWrapper 实体对象封装操作类
    102.      */
    103.     @Override
    104.     @UserDataPermission
    105.     <E extends IPage<Map<String, Object>>> E selectMapsPage(E page, @Param(Constants.WRAPPER) Wrapper queryWrapper);
    106. }

    解决角色控制查询范围

    引入角色，我们先假设有三种角色，按照常规的业务需求，一种是管理员查看全部、一种是部门管理查看本部门、一种是仅查看自己。

    有了以上假设，就可以设置枚举类编写业务逻辑， 对是业务逻辑，所以我们只需要更改”拦截器处理器类“

    • 建立范围枚举

    • 建立角色枚举以及范围关联关系

    • 重写拦截器处理方法

    范围枚举

    1. @AllArgsConstructor
    2. @Getter
    3. public enum DataScope {
    4.     // Scope 数据权限范围 ： ALL（全部）、DEPT（部门）、MYSELF（自己）
    5.     ALL("ALL"),
    6.     DEPT("DEPT"),
    7.     MYSELF("MYSELF");
    8.     private String name;
    9. }

    角色枚举

    1. @AllArgsConstructor
    2. @Getter
    3. public enum DataPermission {
    4.  
    5.     // 枚举类型根据范围从前往后排列，避免影响getScope
    6.     // Scope 数据权限范围 ： ALL（全部）、DEPT（部门）、MYSELF（自己）
    7.     DATA_MANAGER("数据管理员", "DATA_MANAGER",DataScope.ALL),
    8.     DATA_AUDITOR("数据审核员", "DATA_AUDITOR",DataScope.DEPT),
    9.     DATA_OPERATOR("数据业务员", "DATA_OPERATOR",DataScope.MYSELF);
    10.  
    11.     private String name;
    12.     private String code;
    13.     private DataScope scope;
    14.  
    15.  
    16.     public static String getName(String code) {
    17.         for (DataPermission type : DataPermission.values()) {
    18.             if (type.getCode().equals(code)) {
    19.                 return type.getName();
    20.             }
    21.         }
    22.         return null;
    23.     }
    24.  
    25.     public static String getCode(String name) {
    26.         for (DataPermission type : DataPermission.values()) {
    27.             if (type.getName().equals(name)) {
    28.                 return type.getCode();
    29.             }
    30.         }
    31.         return null;
    32.     }
    33.  
    34.     public static DataScope getScope(Collection<String> code) {
    35.         for (DataPermission type : DataPermission.values()) {
    36.             for (String v : code) {
    37.                 if (type.getCode().equals(v)) {
    38.                     return type.getScope();
    39.                 }
    40.             }
    41.         }
    42.         return DataScope.MYSELF;
    43.     }
    44. }

    重写拦截器处理类 MyDataPermissionHandler

    1. import lombok.SneakyThrows;
    2. import lombok.extern.slf4j.Slf4j;
    3. import net.sf.jsqlparser.expression.Alias;
    4. import net.sf.jsqlparser.expression.Expression;
    5. import net.sf.jsqlparser.expression.HexValue;
    6. import net.sf.jsqlparser.expression.StringValue;
    7. import net.sf.jsqlparser.expression.operators.conditional.AndExpression;
    8. import net.sf.jsqlparser.expression.operators.relational.EqualsTo;
    9. import net.sf.jsqlparser.expression.operators.relational.ExpressionList;
    10. import net.sf.jsqlparser.expression.operators.relational.InExpression;
    11. import net.sf.jsqlparser.expression.operators.relational.ItemsList;
    12. import net.sf.jsqlparser.schema.Column;
    13. import net.sf.jsqlparser.schema.Table;
    14. import net.sf.jsqlparser.statement.select.PlainSelect;
    15.  
    16. import java.lang.reflect.Method;
    17. import java.util.List;
    18. import java.util.Objects;
    19. import java.util.Set;
    20. import java.util.stream.Collectors;
    21.  
    22. @Slf4j
    23. public class MyDataPermissionHandler {
    24.  
    25.     private RemoteRoleService remoteRoleService;
    26.     private RemoteUserService remoteUserService;
    27.  
    28.  
    29.     /**
    30.      * 获取数据权限 SQL 片段
    31.      *
    32.      * @param plainSelect  查询对象
    33.      * @param whereSegment 查询条件片段
    34.      * @return JSqlParser 条件表达式
    35.      */
    36.     @SneakyThrows(Exception.class)
    37.     public Expression getSqlSegment(PlainSelect plainSelect, String whereSegment) {
    38.         remoteRoleService = SpringUtil.getBean(RemoteRoleService.class);
    39.         remoteUserService = SpringUtil.getBean(RemoteUserService.class);
    40.  
    41.         // 待执行 SQL Where 条件表达式
    42.         Expression where = plainSelect.getWhere();
    43.         if (where == null) {
    44.             where = new HexValue(" 1 = 1 ");
    45.         }
    46.         log.info("开始进行权限过滤,where: {},mappedStatementId: {}", where, whereSegment);
    47.         //获取mapper名称
    48.         String className = whereSegment.substring(0, whereSegment.lastIndexOf("."));
    49.         //获取方法名
    50.         String methodName = whereSegment.substring(whereSegment.lastIndexOf(".") + 1);
    51.         Table fromItem = (Table) plainSelect.getFromItem();
    52.         // 有别名用别名，无别名用表名，防止字段冲突报错
    53.         Alias fromItemAlias = fromItem.getAlias();
    54.         String mainTableName = fromItemAlias == null ? fromItem.getName() : fromItemAlias.getName();
    55.         //获取当前mapper 的方法
    56.         Method[] methods = Class.forName(className).getMethods();
    57.         //遍历判断mapper 的所以方法，判断方法上是否有 UserDataPermission
    58.         for (Method m : methods) {
    59.             if (Objects.equals(m.getName(), methodName)) {
    60.                 UserDataPermission annotation = m.getAnnotation(UserDataPermission.class);
    61.                 if (annotation == null) {
    62.                     return where;
    63.                 }
    64.                 // 1、当前用户Code
    65.                 User user = SecurityUtils.getUser();
    66.                 // 2、当前角色即角色或角色类型（可能多种角色）
    67.                 Set<String> roleTypeSet = remoteRoleService.currentUserRoleType();
    68.                 
    69.                 DataScope scopeType = DataPermission.getScope(roleTypeSet);
    70.                 switch (scopeType) {
    71.                     // 查看全部
    72.                     case ALL:
    73.                         return where;
    74.                     case DEPT:
    75.                         // 查看本部门用户数据
    76.                         // 创建IN 表达式
    77.                         // 创建IN范围的元素集合
    78.                         List<String> deptUserList = remoteUserService.listUserCodesByDeptCodes(user.getDeptCode());
    79.                         // 把集合转变为JSQLParser需要的元素列表
    80.                         ItemsList deptList = new ExpressionList(deptUserList.stream().map(StringValue::new).collect(Collectors.toList()));
    81.                         InExpression inExpressiondept = new InExpression(new Column(mainTableName + ".creator_code"), deptList);
    82.                         return new AndExpression(where, inExpressiondept);
    83.                     case MYSELF:
    84.                         // 查看自己的数据
    85.                         //  = 表达式
    86.                         EqualsTo usesEqualsTo = new EqualsTo();
    87.                         usesEqualsTo.setLeftExpression(new Column(mainTableName + ".creator_code"));
    88.                         usesEqualsTo.setRightExpression(new StringValue(user.getUserCode()));
    89.                         return new AndExpression(where, usesEqualsTo);
    90.                     default:
    91.                         break;
    92.                 }
    93.             }
    94.  
    95.         }
    96.         //说明无权查看，
    97.         where = new HexValue(" 1 = 2 ");
    98.         return where;
    99.     }
    100. }

    以上就是全篇知识点， 需要注意的点可能有：

    • 记得把拦截器加到MyBatis-Plus的插件中，确保生效

    • 要有一个业务赛选标识字段， 这里用的创建人 creator_code, 也可以用dept_code 等等

  • 相关阅读:
    taro超过3行隐藏显示展开功能
    [NOI2011] 阿狸的打字机
    数据库sql中判断时间冲突
    X86（32位）汇编指令与机器码转换原理
    计算机毕业设计Java慧学IT精品课程网站(源码+系统+mysql数据库+lw文档)
    特征工程学习笔记
    垃圾堆—＞初赛错题集（待更）
    【物理应用】基于Matlab模拟极化雷达回波
    【初识Linux】：背景介绍以及环境搭建
    python3:len()返回对象的长度(元素数量) 2023-11-17
  • 原文地址：https://blog.csdn.net/yuechuzhixing/article/details/133016109