17、基于注解的动态数据权限实现方案

数据权限简介

前言

一般的系统都离不开权限模块,它是支撑整个系统运行的基础模块。而根据项目类型和需求的不同,权限模块的设计更是大相径庭。但不管怎么变,权限模块从大的方面来说,可以分为三种大的类型:功能权限、接口权限、数据权限。

功能权限:也就是我们最熟悉的菜单、按钮权限。可以配置各个角色能看到的菜单、按钮从而从最表层分配好权限

接口权限:顾名思义,配置不通角色调用接口的权限。有些敏感接口,是只能有固定的一些角色才能调用,普通角色是不能调用的。这种情况需要有一个明确的系统来控制对应的访问权限

数据权限:是大家最为需求也是最广为谈资的一个设计理念。我们需要控制不通的角色、机构人员有查看不通数据范围的权限。如果你动手去设计数据权限,当你去各大平台、百度、谷歌查找设计思路的时候,你会发现很难找到有用的资料,很多设计思路局限性非常大。

寻找一些开源解决方案

Mybatis-Plus

Mybatis-Plus的3.4.1 +版本,提供了DataPermissionInterceptor数据权限处理器,需要自己实现DataPermissionHandler接口,其实现规则是获取SQL中的where条件,根据不同的部门或者自定义的权限规则,拼接where条件进行数据权限处理。

使用案例
*

若依

若依使用了AOP机制,提供DataScopeAspect及DataScope注解实现权限数据。实现原理为,接口添加DataScope注解,AOP前置拦截接口,获取角色信息,根据不同的权限,拼接SQL,然后设置到参数中,在Mapper中,获取参数的SQL拼接到最后的SQL中。
*

JeecgBoot

JeecgBoot也采用的AOP机制,提供了PermissionData注解及切面PermissionDataAspect。

可以看出切面的主要功能是获取当前请求的用户角色及权限信息。
*
然后将请求中的权限信息,加载到MP的QueryWrapper中,实现SQL数据权限。
*

使用时,需要代码添加数据规则。
*

分析总结

在以上开源的框架中,可以了解到,实现原理差不多都是根据用户的角色及其他信息,拼接SQL,最终实现不同用户,查询不同的角色信息。还有一些框架是使用了Mybatis插件,对查询方法进行拦截,道理大致一样。

思路:

1、 添加一个数据权限表,存储规则,关联角色;
2、 添加基于角色的权限配置、查询;
3、 添加注解、拦截规则枚举分类;
4、 添加插件,拦截执行器query方法;
5、 登录获取用户数据权限,存在redis;
6、 用户查询时,redis获取拥有数据权限,不同规则拼接不同的SQL;

开发数据权限

1. 环境搭建

首先,我们搭建一个集成Mybatis-Plus的项目,将用户部门等表导入数据库中,并生成对应的Mapper及实体类。

2. 添加数据权限注解及枚举类

问题1 注解位置

因为数据权限是和SQL绑定的,所以注解最优的地方是放在mapper接口上,但是MP基础的CRUD接口是内置的,所以内置的这些方法,使用时,需要自己移入到Mapper文件中。

问题2 注解属性值

数据权限的分类可能有很多种,比如:

  • 根据部门分类,比如最高级部门可以查看所有部门的数据,中级部门可以查看本级及下属部门的数据,最下面的部门则只能查看当前部门的数据
  • 根据用户分类,用户只能查看自己的数据
  • 自定义数据权限,比如用户只能查看一年的用户,管理员则能查看所有数据,而且是动态的,可以通过页面配置

所有数据权限注解,应该有类型分类、是否开启、自定义等属性,我们需要创建枚举定义这些类型分类。

2.1 创建权限注解和枚举

创建枚举DataScopeType,我们主要分两类,一个是根据用户所属部门,一个是动态查询的数据权限,可以根据实际业务场景添加多个。

@Getter
@AllArgsConstructor
public enum DataScopeType {
   
     

    ALL(1, "所有部门"),

    OWN_AND_CHILD_DEPT(2, "本部门及子部门"),

    OWN_ONLY_DEPT(3, "仅本部门"),

    OWN_ONLY(4, "仅创建用户自己"),

    DB_DYNAMIC(5, "数据库动态配置");

    int type;

    String desc;
}

创建数据权限注解@DataScope,配置在Mapper接口方法或者接口上,主要配置不同的数据权限类型:

@Documented
@Inherited
@Retention(RetentionPolicy.RUNTIME)
@Target({
   
     ElementType.METHOD, ElementType.TYPE})
public @interface DataScope {
   
     

    /**
     * 是否开启 默认true
     */
    boolean enabled() default true;

    /**
     * 数据权限类型。默认一般是查询自己部门及下属部门数据
     */
    DataScopeType type() default DataScopeType.OWN_AND_CHILD_DEPT;

}

3. 添加配置类

添加配置类PearlDataScopeProperties,可以在YML中配置是否开启数据权限插件,及配置部门字段:

@Data
@ConfigurationProperties(prefix = "pearl.data-scope")
public class PearlDataScopeProperties {
   
     

    Boolean enabled;

    String deptField;
}

在YML中,添加如下配置:

pearl:
  data-scope:
    enabled: true
    dept-field: dept_id

4. 添加数据权限处理器

首先添加数据权限处理器接口,针对不同类型,处理数据权限:

public interface IDataScopeHandler {
   
     

    /**
     * 构建IN (xxx,xxx) 表达式
     *
     * @param plainSelect       普通查询对象
     * @param dataScopeProperty DataScope注解属性
     */
    void buildInExpression(PlainSelect plainSelect, DataScopeMapperProperty dataScopeProperty);

    /**
     * 构建 部门 = xx 表达式
     *
     * @param plainSelect       普通查询对象
     * @param dataScopeProperty DataScope注解属性
     */
    void buildDeptEqualToExpression(PlainSelect plainSelect, DataScopeMapperProperty dataScopeProperty);

    /**
     * 构建 创建用户 = xx 表达式
     *
     * @param plainSelect 普通查询对象
     */
    void buildUserEqualToExpression(PlainSelect plainSelect);

    /**
     * 构建 动态权限(数据库或缓存查询)表达式
     *
     * @param plainSelect 普通查询对象
     * @param msId        MappedStatementID
     * @throws JSQLParserException 解析异常
     */
    void buildDynamicExpression(PlainSelect plainSelect, Object msId) throws JSQLParserException;
}

添加处理器抽象类,实现部分方法:

public abstract class AbstractDataScopeHandler implements IDataScopeHandler {
   
     

    /**
     * 默认部门字段名称
     */
    public String defaultDeptFiled;

    /**
     * 所有字段关键字
     */
    public static final String ALL_COLUMN_FILED = "*";

    /**
     * 获取 ItemsList,由子类实现
     *
     * @return ItemsList IN 表达式元素集合
     */
    abstract ItemsList renderInExpressionList();

    /**
     * 获取动态的数据权限,由子类实现
     *
     * @param msId MappedStatementID
     * @return DynamicDataPermission 动态的数据权限
     */
    abstract DynamicDataPermission renderDataPermission(Object msId);

    @Override
    public void buildInExpression(PlainSelect plainSelect, DataScopeMapperProperty dataScopeProperty) {
   
     
        // 1. 构建In 表达式
        FromItem fromItem = plainSelect.getFromItem();
        if (fromItem instanceof Table) {
   
     
            Column aliasColumn = getAliasColumn((Table) fromItem, defaultDeptFiled);
            InExpression inExpression = new InExpression(aliasColumn, renderInExpressionList());
            // 2. 添加新的Where语句
            if (null == plainSelect.getWhere()) {
   
     
                plainSelect.setWhere(new Parenthesis(inExpression));
            } else {
   
     
                plainSelect.setWhere(new AndExpression(plainSelect.getWhere(), inExpression));
            }
        }
    }

    @Override
    public void buildDynamicExpression(PlainSelect plainSelect, Object msId) throws JSQLParserException {
   
     
        // 1. 子类查询动态数据权限
        DynamicDataPermission dynamicDataPermission = renderDataPermission(msId);
        String dataPermissionSql = dynamicDataPermission.getExpression();// 数据库中的SQL表表示
        // 2.  处理查询字段
        String fields = dynamicDataPermission.getSelectItems();
        if (StrUtil.isNotEmpty(fields)) {
   
      // 配置了查询哪些字段
            List<SelectItem> selectItems = new ArrayList<>();
            if (ALL_COLUMN_FILED.equals(fields)) {
   
      // 所有字段
                selectItems.add(new AllColumns());
            } else {
   
     
                String[] fieldArray = fields.split(StrPool.COMMA);
                for (String field : fieldArray) {
   
     
                    SelectExpressionItem selectExpressionItem = new SelectExpressionItem();
                    selectExpressionItem.setExpression(new Column(field));
                    selectItems.add(selectExpressionItem);
                }
                plainSelect.setSelectItems(selectItems);
            }
        }
        // 2. 添加查询条件
        Expression expression = CCJSqlParserUtil.parseCondExpression(dataPermissionSql);
        Expression where = plainSelect.getWhere();
        if (where == null) {
   
     
            plainSelect.setWhere(expression);
        } else {
   
     
            plainSelect.setWhere(where instanceof OrExpression ? new AndExpression(new Parenthesis(where), expression) : new AndExpression(where, expression));
        }
    }

    /**
     * 获取带别名的列
     *
     * @param table      表
     * @param columnName 列名
     * @return 新的列名
     */
    public Column getAliasColumn(Table table, String columnName) {
   
     
        StringBuilder column = new StringBuilder();
        if (table.getAlias() != null) {
   
     
            column.append(table.getAlias().getName()).append(".");
        }
        column.append(columnName);
        return new Column(column.toString());
    }

    /**
     * 构建 = 表达式
     *
     * @param plainSelect 普通查询对象
     * @param column      列名
     * @param value       值
     */
    protected void buildEqualToExpression(PlainSelect plainSelect, String column, Expression value) {
   
     
        // 1. 构建等于表达式
        FromItem fromItem = plainSelect.getFromItem();
        Column aliasColumn = getAliasColumn((Table) fromItem, column);
        Expression where = plainSelect.getWhere();
        EqualsTo equalsToExpression = new EqualsTo();
        equalsToExpression.setLeftExpression(aliasColumn);
        equalsToExpression.setRightExpression(value);
        // 2. 添加表达式
        if (where == null) {
   
     
            plainSelect.setWhere(equalsToExpression);
        } else {
   
     
            plainSelect.setWhere(where instanceof OrExpression ? new AndExpression(new Parenthesis(where), equalsToExpression) : new AndExpression(where, equalsToExpression));
        }
    }

实现自己的处理器,主要是设置字段,查询动态数据权限,查询用户信息,查询登陆用户部门信息等。

@Data
public class PearlDataScopeHandler extends AbstractDataScopeHandler {
   
     

    public PearlDataScopeHandler(PearlDataScopeProperties pearlDataScopeProperties) {
   
     
        this.defaultDeptFiled = pearlDataScopeProperties.deptField;
    }

    @Override
    public void buildUserEqualToExpression(PlainSelect plainSelect) {
   
     
        buildEqualToExpression(plainSelect, "create_user_id", new LongValue(123555L)); // 值
    }

    @Override
    public void buildDeptEqualToExpression(PlainSelect plainSelect, DataScopeMapperProperty dataScopeProperty) {
   
     
        buildEqualToExpression(plainSelect, defaultDeptFiled, new LongValue(001L));
    }

    @Override
    ItemsList renderInExpressionList() {
   
     
        // 1. 查询部门集合(本部门及下属部门)
        return new ExpressionList(
                // 部门集合实际应当从用户信息中获取
                Arrays.asList(
                        new LongValue("001"),
                        new LongValue("002"),
                        new LongValue("003")
                ));
    }

    @Override
    public DynamicDataPermission renderDataPermission(Object obj) {
   
     
        // 1. 数据库或者缓存根据当前用户角色查询拥有的数据权限值
        DataPermission dataPermission = new DataPermission(); // 模拟数据=》数据库查询的应该是集合
        List<DataPermission> list = new ArrayList<>();
        dataPermission.setCode("test001")
                .setClassName("org.pearl.springbootsecurity.demo.dao.UserMapper.getUserInfoByUserName")
                .setColumn("bbb")
                .setName("只能查看2021年之后的数据")
                .setField("aaa,bbb,ccc")
                .setValue("u.create_date > \"2021-01-01 00:00:00\"");
        list.add(dataPermission);
        // 2. 根据执行的MS,查询当前有没有配置的数据权限
        DataPermission dbPermission = list.stream().filter(permission -> obj.toString().equals(permission.getClassName())).findAny().orElse(null);
        if (dataPermission == null) {
   
     
            throw new DataScopeException("当前用户未查询到数据权限");
        }
        DynamicDataPermission dynamicDataPermission = new DynamicDataPermission();
        dynamicDataPermission.setExpression(dbPermission.getValue());
        dynamicDataPermission.setMapperMethodName(dbPermission.getClassName());
        dynamicDataPermission.setSelectItems(dataPermission.getField());
        return dynamicDataPermission;
    }
}

5. 添加拦截器

添加拦截器,这里使用MP提供的InnerInterceptor拦截器,注入一个IDataScopeHandler 实现类,然后根据不同的类型,执行不同的逻辑。

public class DataScopeInterceptor extends JsqlParserSupport implements InnerInterceptor {
   
     

    /**
     * 数据权限处理器
     */
    private IDataScopeHandler dataScopeHandler;

    public DataScopeInterceptor(IDataScopeHandler dataScopeHandler) {
   
     
        if (null != dataScopeHandler) {
   
     
            this.dataScopeHandler = dataScopeHandler;
        }
    }

    /**
     * 查询之前
     */
    @Override
    public void beforeQuery(Executor executor, MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {
   
     
        // 1. 查询是否配置了忽略@InterceptorIgnore
        if (!InterceptorIgnoreHelper.willIgnoreDataPermission(ms.getId())) {
   
     
            // 2. 获取BoundSql
            PluginUtils.MPBoundSql mpBs = PluginUtils.mpBoundSql(boundSql);
            // 3. 获取新的SQL 并设置到BoundSql对象中
            mpBs.sql(this.parserSingle(mpBs.sql(), ms.getId()));
        }
    }

    /**
     * 处理查询
     *
     * @param select 查询对象Select
     * @param index  序列
     * @param sql    语句:
     * @param obj    查询Mapper方法全路径
     */
    @SneakyThrows
    @Override
    protected void processSelect(Select select, int index, String sql, Object obj) {
   
     
        this.processSelectBody(select.getSelectBody(), obj);
        List<WithItem> withItemsList = select.getWithItemsList();
        if (!CollectionUtils.isEmpty(withItemsList)) {
   
     
            withItemsList.forEach(e -> {
   
     
                try {
   
     
                    processSelectBody(e, obj);
                } catch (JSQLParserException ex) {
   
     
                    ex.printStackTrace();
                }
            });
        }
    }

    /**
     * 处理  selectBody
     *
     * @param selectBody
     */
    void processSelectBody(SelectBody selectBody, Object obj) throws JSQLParserException {
   
     
        if (selectBody != null) {
   
     
            if (selectBody instanceof PlainSelect) {
   
     
                this.processPlainSelect((PlainSelect) selectBody, obj);
            } else if (selectBody instanceof WithItem) {
   
     
                WithItem withItem = (WithItem) selectBody;
                // 处理每个With 语句的查询
                this.processSelectBody(withItem.getSelectBody(), obj);
            } else {
   
     
                SetOperationList operationList = (SetOperationList) selectBody;
                if (operationList.getSelects() != null && operationList.getSelects().size() > 0) {
   
     
                    operationList.getSelects().forEach(e -> {
   
     
                        try {
   
     
                            processSelectBody(e, obj);
                        } catch (JSQLParserException ex) {
   
     
                            ex.printStackTrace();
                        }
                    });
                }
            }
        }
    }

    /**
     * 处理查询 添加 WHERE 条件
     *
     * @param plainSelect
     * @param obj
     * @throws JSQLParserException
     */
    protected void processPlainSelect(PlainSelect plainSelect, Object obj) throws JSQLParserException {
   
     
        // 1. 缓存中获取当前执行
        DataScopeMapperProperty dataScopeProperty = InMemoryDataScopeMetaStore.getCache(obj.toString().substring(0, obj.toString().lastIndexOf(StrUtil.C_DOT)));
        if (dataScopeProperty == null) {
   
     
            dataScopeProperty = InMemoryDataScopeMetaStore.getCache(obj.toString());
        }
        if (dataScopeProperty != null) {
   
      // 没有注解或者配置的不开启,执行放行
            // 2. 处理查询
            DataScopeType type = dataScopeProperty.type; // 注解类型
            // 2.1.1 首先处理部门数据权限,添加到Where中
            if (DataScopeType.OWN_AND_CHILD_DEPT == type) {
   
     
                // 2.1.1.2 本部门及以下部门,查询当前用户部门信息及下属部门信息,拼接IN语句
                dataScopeHandler.buildInExpression(plainSelect, dataScopeProperty);// 调用处理器构建In 表达式
            } else if (DataScopeType.OWN_ONLY_DEPT == type) {
   
     
                // 2.1.1.3  仅本部门数据
                dataScopeHandler.buildDeptEqualToExpression(plainSelect, dataScopeProperty);
            } else if (DataScopeType.OWN_ONLY == type) {
   
     
                // 2.1.1.4 仅仅本人数据
                dataScopeHandler.buildUserEqualToExpression(plainSelect);
            } else if (DataScopeType.DB_DYNAMIC == type) {
   
     
                // 2.1.1.5 数据库动态权限
                dataScopeHandler.buildDynamicExpression(plainSelect, obj);
            } else {
   
     
                System.out.println("if (DataScopeType.ALL == type) {\n" +
                        "                // 2.1.1.1 全部数据 直接放行\n" +
                        "            } else ");
            }
        }
    }
}

6. 注入拦截器

在MybatisPlus配置类中,将数据权限拦截器,添加到连接器链中。

    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor(PearlDataScopeProperties pearlDataScopeProperties,PearlDataScopeHandler dataScopeHandler) {
   
     
        // 添加租户插件
        // 如果用了分页插件注意先 add TenantLineInnerInterceptor 再 add PaginationInnerInterceptor
        // 用了分页插件必须设置 MybatisConfiguration#useDeprecatedExecutor = false ,3.4已移除
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        if (pearlDataScopeProperties.getEnabled()) {
   
     
            // 开启配置,添加数据权限插件
            interceptor.addInnerInterceptor(new DataScopeInterceptor(dataScopeHandler));
        }
        // 分页插件
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));

        return interceptor;
    }

7. 测试

添加注解,配置不同的属性,发现数据权限表达式成功添加。
*

版权声明:本文不是「本站」原创文章,版权归原作者所有 | 原文地址: