SpringCloud微服务实战——搭建企业级开发框架(二十八):扩展MybatisPlus插件DataPermissionInterceptor实现数据权限控
SpringCloud微服务实战——搭建企业级开发框架(二十八):扩展MybatisPlus插件DataPermissionInterceptor实现数据权限控
一套完整的系统权限需要支持功能权限和数据权限,前面介绍了系统通过RBAC的权限模型来实现功能的权限控制,这里我们来介绍,通过扩展Mybatis-Plus的插件DataPermissionInterceptor实现数据权限控制。
简单介绍一下,所谓功能权限,顾名思义是指用户在系统中拥有对哪些功能操作的权限控制,而数据权限是指用户在系统中能够访问哪些数据的权限控制,数据权限又分为行级数据权限和列级数据权限。
数据权限基本概念:
- 行级数据权限:以表结构为描述对象,一个用户拥有对哪些数据的权限,表示为对数据库某个表整行的数据拥有权限,例如按部门区分,某一行数据属于某个部门,某个用户只对此部门的数据拥有权限,那么该用户拥有此行的数据权限。
- 列级数据权限:以表结构为描述对象,一个用户可能只对某个表中的部分字段拥有权限,例如表中银行卡、手机号等重要信息只有高级用户能够查询,而一些基本信息,普通用户就可以查询,不同的用户角色拥有的数据权限不一样。
实现方式:
- 行级数据权限: 对行级数据权限进行细分,以角色为标识的数据权限,分为:
1、只能查看本人数据;
2、只能查看本部门数据;
3、只能查看本部门及子部门数据;
4、可以查看所有部门数据;
以用户为标识的数据权限,分为:
5、同一功能角色权限拥有不同部门的数据权限;
6、不同角色权限拥有不同部门的数据权限。
第1/2/3/4类的实现方式需要在角色列表对角色进行数据权限配置,针对某一接口该角色拥有哪种数据权限。 第5类的实现方式,需要在用户列表进行配置,给用户分配多个不同部门。 第6类的实现方式比较复杂,目前有市面上的大多数解决方案是:
1、在登录时,判断用户是否拥有多个部门,如果存在,那么首先让用户选择其所在的部门,登录后只对选择的部门权限进行操作;
2、针对不同部门创建不同的用户及角色,登录时,选择对应的账号进行登录。 个人因秉承复杂的系统简单化,尽量用低耦合的方式实现复杂功能的理念,更倾向于第二种方式,原因是:
1、系统实现方面减少复杂度,越复杂的判断,越容易出问题,不仅仅在开发过程中,还在于后续系统的扩展和更新过程中。
2、对于工作量方面的取舍,一个人拥有多个部门不同权限的方式属于常用功能,但是并不普遍,也就是说在一家企业中,同一个用户即是业务部门经理,又是财务部门经理的情况并不普遍,更多的是专人专职。这里要和第5类做好区分,比如你是业务部门经理可能会管理多个部门,这种属于权限一致,只是拥有多个部门权限,这属于第5类。再比如一个总经理,可能会看到所有的业务、财务数据这属于第4类。
所以这里不会采取用户登录后选择部门的方式来判断数据权限。
- 列级数据权限: 列级数据权限的实现主要是针对某个角色能够看到哪些字段,不存在针对某个用户给他特定字段的情况,这种情况单独建立一个角色即可,尽量采用类RBAC的方式来实现,不要使用户直接和数据权限关联。列级数据权限除了要考虑后台取数据的问题,还要考虑到在界面上展示时,如果是一个表格,那么没有权限的列需要根据数据权限来判断是否展示。这里在配置界面就要考虑,在角色配置时,需要分为行级数据权限和列级数据权限进行不同的配置:行级数据权限应该配置需要数据权限控制的接口,数据权限的类型(上面提到的1234);列级数据权限除了需要配置上面提到的之外,还需要配置可以访问的字段或者排除访问的字段。
在资源管理配置资源关联接口的数据权限规则(t_sys_data_permission_role),通过RBAC的方式用角色和用户关联,在用户管理配置用户同角色的多个部门数据权限,用户直接和部门关联(t_sys_data_permission_user)。系统数据权限管理功能设计如下所示:
数据权限表设计:
CREATE TABLE `t_sys_data_permission_user` (
`id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键',
`tenant_id` bigint(20) NOT NULL DEFAULT 0 COMMENT '租户id',
`user_id` bigint(20) NOT NULL COMMENT '用户id',
`organization_id` bigint(20) NOT NULL COMMENT '机构id',
`status` tinyint(2) NULL DEFAULT 1 COMMENT '状态 0禁用,1 启用,',
`create_time` datetime(0) NULL DEFAULT NULL COMMENT '创建时间',
`creator` bigint(20) NULL DEFAULT NULL COMMENT '创建者',
`update_time` datetime(0) NULL DEFAULT NULL COMMENT '更新时间',
`operator` bigint(20) NULL DEFAULT NULL COMMENT '更新者',
`del_flag` tinyint(2) NULL DEFAULT 0 COMMENT '1:删除 0:不删除',
PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 1 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
复制代码
CREATE TABLE `t_sys_data_permission_role` (
`id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键',
`tenant_id` bigint(20) NOT NULL DEFAULT 0 COMMENT '租户id',
`resource_id` bigint(20) NOT NULL DEFAULT 0 COMMENT '功能权限id',
`data_name` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL COMMENT '数据权限名称',
`data_mapper_function` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL COMMENT '数据权限对应的mapper方法全路径',
`data_table_name` varchar(32) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL COMMENT '需要做数据权限主表',
`data_table_alias` varchar(32) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL COMMENT '需要做数据权限表的别名',
`data_column_exclude` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL COMMENT '数据权限需要排除的字段',
`data_column_include` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL COMMENT '数据权限需要保留的字段',
`inner_table_name` varchar(32) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL COMMENT '数据权限表,默认t_sys_organization',
`inner_table_alias` varchar(32) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL COMMENT '数据权限表的别名,默认organization',
`data_permission_type` varchar(2) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NOT NULL DEFAULT '1' COMMENT '数据权限类型:1只能查看本人 2只能查看本部门 3只能查看本部门及子部门 4可以查看所有数据',
`custom_expression` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL COMMENT '自定义数据权限(增加 where条件)',
`status` tinyint(2) NOT NULL DEFAULT 1 COMMENT '状态 0禁用,1 启用,',
`comments` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '备注',
`create_time` datetime(0) NULL DEFAULT NULL COMMENT '创建时间',
`creator` bigint(20) NULL DEFAULT NULL COMMENT '创建者',
`update_time` datetime(0) NULL DEFAULT NULL COMMENT '更新时间',
`operator` bigint(20) NULL DEFAULT NULL COMMENT '更新者',
`del_flag` tinyint(2) NULL DEFAULT 0 COMMENT '1:删除 0:不删除',
PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 1 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_general_ci COMMENT = '数据权限配置表' ROW_FORMAT = DYNAMIC;
数据权限缓存(Redis)设计:
- Redis Key: 多租户模式:auth:tenant:data:permission:0(租户):mapper_Mapper全路径_type_数据权限类型 普通模式:auth:data:permission:mapper_Mapper全路径_type_数据权限类型
- Redis Value:存放角色分配的DataPermissionEntity配置 数据权限插件在组装SQL时,首先通过前缀匹配查询mapper的statementId是否在缓存中,如果存在,那么取出当前用户的数据权限类型,组装好带有数据权限类型的DataPermission缓存Key,从缓存中取出数据权限配置。 在设计角色时,除了需要给角色设置功能权限之外,还要设置数据权限类型,角色的数据权限类型只能单选(1只能查看本人 2只能查看本部门 3只能查看本部门及子部门 4可以查看所有数据5自定义)
代码实现:
- 因DataPermissionInterceptor默认不支持修改selectItems,导致无法做到列级别的数据权限,所以这里自定义扩展DataPermissionInterceptor,使其支持列级权限扩展
@Data
@NoArgsConstructor
@AllArgsConstructor
@ToString(callSuper = true)
@EqualsAndHashCode(callSuper = true)
public class GitEggDataPermissionInterceptor extends DataPermissionInterceptor {
private GitEggDataPermissionHandler dataPermissionHandler;
public void beforeQuery(Executor executor, MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {
if (!InterceptorIgnoreHelper.willIgnoreDataPermission(ms.getId())) {
PluginUtils.MPBoundSql mpBs = PluginUtils.mpBoundSql(boundSql);
mpBs.sql(this.parserSingle(mpBs.sql(), ms.getId()));
}
}
protected void processSelect(Select select, int index, String sql, Object obj) {
SelectBody selectBody = select.getSelectBody();
if (selectBody instanceof PlainSelect) {
PlainSelect plainSelect = (PlainSelect)selectBody;
this.processDataPermission(plainSelect, (String)obj);
} else if (selectBody instanceof SetOperationList) {
SetOperationList setOperationList = (SetOperationList)selectBody;
List<SelectBody> selectBodyList = setOperationList.getSelects();
selectBodyList.forEach((s) -> {
PlainSelect plainSelect = (PlainSelect)s;
this.processDataPermission(plainSelect, (String)obj);
});
}
}
protected void processDataPermission(PlainSelect plainSelect, String whereSegment) {
this.dataPermissionHandler.processDataPermission(plainSelect, whereSegment);
}
}
- 自定义实现DataPermissionHandler数据权限控制
@Component
@RequiredArgsConstructor(onConstructor_ = @Autowired)
public class GitEggDataPermissionHandler implements DataPermissionHandler {
@Value(("${tenant.enable}"))
private Boolean enable;
/**
* 注解方式默认关闭,这里只是说明一种实现方式,实际使用时,使用配置的方式即可
*/
@Value(("${data-permission.annotation-enable}"))
private Boolean annotationEnable = false;
private final RedisTemplate redisTemplate;
public void processDataPermission(PlainSelect plainSelect, String mappedStatementId) {
try {
GitEggUser loginUser = GitEggAuthUtils.getCurrentUser();
// 1 当有数据权限配置时才去判断用户是否有数据权限控制
if (ObjectUtils.isNotEmpty(loginUser) && CollectionUtils.isNotEmpty(loginUser.getDataPermissionTypeList())) {
// 1 根据系统配置的数据权限拼装sql
StringBuffer statementSb = new StringBuffer();
if (enable)
{
statementSb.append(DataPermissionConstant.TENANT_DATA_PERMISSION_KEY).append(loginUser.getTenantId());
}
else
{
statementSb.append(DataPermissionConstant.DATA_PERMISSION_KEY);
}
String dataPermissionKey = statementSb.toString();
StringBuffer statementSbt = new StringBuffer(DataPermissionConstant.DATA_PERMISSION_KEY_MAPPER);
statementSbt.append(mappedStatementId).append(DataPermissionConstant.DATA_PERMISSION_KEY_TYPE);
String mappedStatementIdKey = statementSbt.toString();
DataPermissionEntity dataPermissionEntity = null;
for (String dataPermissionType: loginUser.getDataPermissionTypeList())
{
String dataPermissionUserKey = mappedStatementIdKey + dataPermissionType;
dataPermissionEntity = (DataPermissionEntity) redisTemplate.boundHashOps(dataPermissionKey).get(dataPermissionUserKey);
if (ObjectUtils.isNotEmpty(dataPermissionEntity)) {
break;
}
}
// mappedStatementId是否有配置数据权限
if (ObjectUtils.isNotEmpty(dataPermissionEntity))
{
dataPermissionFilter(loginUser, dataPermissionEntity, plainSelect);
}
//默认不开启注解,因每次查询都遍历注解,影响性能,直接选择使用配置的方式实现数据权限即可
else if(annotationEnable)
{
// 2 根据注解的数据权限拼装sql
Class<?> clazz = Class.forName(mappedStatementId.substring(GitEggConstant.Number.ZERO, mappedStatementId.lastIndexOf(StringPool.DOT)));
String methodName = mappedStatementId.substring(mappedStatementId.lastIndexOf(StringPool.DOT) + GitEggConstant.Number.ONE);
Method[] methods = clazz.getDeclaredMethods();
for (Method method : methods) {
//当有多个时,这个方法可以获取到
DataPermission[] annotations = method.getAnnotationsByType(DataPermission.class);
if (ObjectUtils.isNotEmpty(annotations) && method.getName().equals(methodName)) {
for (DataPermission dataPermission : annotations) {
String dataPermissionType = dataPermission.dataPermissionType();
for (String dataPermissionUser : loginUser.getDataPermissionTypeList()) {
if (ObjectUtils.isNotEmpty(dataPermission) && StringUtils.isNotEmpty(dataPermissionType)
&& dataPermissionUser.equals(dataPermissionType)) {
DataPermissionEntity dataPermissionEntityAnnotation = annotationToEntity(dataPermission);
dataPermissionFilter(loginUser, dataPermissionEntityAnnotation, plainSelect);
break;
}
}
}
}
}
}
}
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
/**
* 构建过滤条件
*
* @param user 当前登录用户
* @param plainSelect plainSelect
* @return 构建后查询条件
*/
public static void dataPermissionFilter(GitEggUser user, DataPermissionEntity dataPermissionEntity, PlainSelect plainSelect) {
Expression expression = plainSelect.getWhere();
String dataPermissionType = dataPermissionEntity.getDataPermissionType();
String dataTableName = dataPermissionEntity.getDataTableName();
String dataTableAlias = dataPermissionEntity.getDataTableAlias();
String innerTableName = StringUtils.isNotEmpty(dataPermissionEntity.getInnerTableName()) ? dataPermissionEntity.getInnerTableName(): DataPermissionConstant.DATA_PERMISSION_TABLE_NAME;
String innerTableAlias = StringUtils.isNotEmpty(dataPermissionEntity.getInnerTableAlias()) ? dataPermissionEntity.getInnerTableAlias() : DataPermissionConstant.DATA_PERMISSION_TABLE_ALIAS_NAME;
List<String> organizationIdList = user.getOrganizationIdList();
// 列级数据权限
String dataColumnExclude = dataPermissionEntity.getDataColumnExclude();
String dataColumnInclude = dataPermissionEntity.getDataColumnInclude();
List<String> includeColumns = new ArrayList<>();
List<String> excludeColumns = new ArrayList<>();
// 只包含这几个字段,也就是不是这几个字段的,直接删除
if (StringUtils.isNotEmpty(dataColumnInclude))
{
includeColumns = Arrays.asList(dataColumnInclude.split(StringPool.COMMA));
}
// 需要排除这几个字段
if (StringUtils.isNotEmpty(dataColumnExclude))
{
excludeColumns = Arrays.asList(dataColumnExclude.split(StringPool.COMMA));
}
List<SelectItem> selectItems = plainSelect.getSelectItems();
List<SelectItem> removeItems = new ArrayList<>();
if (CollectionUtils.isNotEmpty(selectItems)
&& (CollectionUtils.isNotEmpty(includeColumns) || CollectionUtils.isNotEmpty(excludeColumns))) {
for (SelectItem selectItem : selectItems) {
// 暂不处理其他类型的selectItem
if (selectItem instanceof SelectExpressionItem) {
SelectExpressionItem selectExpressionItem = (SelectExpressionItem) selectItem;
Alias alias = selectExpressionItem.getAlias();
if ((CollectionUtils.isNotEmpty(includeColumns) && !includeColumns.contains(alias.getName()))
|| (!CollectionUtils.isEmpty(excludeColumns) && excludeColumns.contains(alias.getName())))
{
removeItems.add(selectItem);
}
} else if (selectItem instanceof AllTableColumns) {
removeItems.add(selectItem);
}
}
if (CollectionUtils.isNotEmpty(removeItems))
{
selectItems.removeAll(removeItems);
plainSelect.setSelectItems(selectItems);
}
}
// 行级数据权限
// 查询用户机构和子机构的数据,这里是使用where条件添加子查询的方式来实现的,这样的实现方式好处是不需要判断Update,Insert还是Select,都是通用的,缺点是性能问题。
if (DataPermissionTypeEnum.DATA_PERMISSION_ORG_AND_CHILD.getLevel().equals(dataPermissionType)) {
// 如果是table的话,那么直接加inner,如果不是,那么直接在where条件里加子查询
if (plainSelect.getFromItem() instanceof Table)
{
Table fromTable = (Table)plainSelect.getFromItem();
//数据主表
Table dataTable = null;
//inner数据权限表
Table innerTable = null;
if (fromTable.getName().equalsIgnoreCase(dataTableName))
{
dataTable = (Table)plainSelect.getFromItem();
}
// 如果是查询,这里使用inner join关联过滤,不使用子查询,因为join不需要建立临时表,因此速度比子查询快。
List<Join> joins = plainSelect.getJoins();
boolean hasPermissionTable = false;
if (CollectionUtils.isNotEmpty(joins)) {
Iterator joinsIterator = joins.iterator();
while(joinsIterator.hasNext()) {
Join join = (Join)joinsIterator.next();
// 判断join里面是否存在t_sys_organization表,如果存在,那么直接使用,如果不存在则新增
FromItem rightItem = join.getRightItem();
if (rightItem instanceof Table) {
Table table = (Table)rightItem;
// 判断需要inner的主表是否存在
if (null == dataTable && table.getName().equalsIgnoreCase(dataTableName))
{
dataTable = table;
}
// 判断需要inner的表是否存在
if (table.getName().equalsIgnoreCase(innerTableName))
{
hasPermissionTable = true;
innerTable = table;
}
}
}
}
//如果没有找到数据主表,那么直接抛出异常
if (null == dataTable)
{
throw new BusinessException("在SQL语句中没有找到数据权限配置的主表,数据权限过滤失败。");
}
//如果不存在这个table,那么新增一个innerjoin
if (!hasPermissionTable)
{
innerTable = new Table(innerTableName).withAlias(new Alias(innerTableAlias, false));
Join join = new Join();
join.withRightItem(innerTable);
EqualsTo equalsTo = new EqualsTo();
equalsTo.setLeftExpression(new Column(dataTable, DataPermissionConstant.DATA_PERMISSION_ORGANIZATION_ID));
equalsTo.setRightExpression(new Column(innerTable, DataPermissionConstant.DATA_PERMISSION_ID));
join.withOnExpression(equalsTo);
plainSelect.addJoins(join);
}
EqualsTo equalsToWhere = new EqualsTo();
equalsToWhere.setLeftExpression(new Column(innerTable, DataPermissionConstant.DATA_PERMISSION_ID));
equalsToWhere.setRightExpression(new LongValue(user.getOrganizationId()));
Function function = new Function();
function.setName(DataPermissionConstant.DATA_PERMISSION_FIND_IN_SET);
function.setParameters(new ExpressionList(new LongValue(user.getOrganizationId()) , new Column(innerTable, DataPermissionConstant.DATA_PERMISSION_ANCESTORS)));
OrExpression orExpression = new OrExpression(equalsToWhere, function);
//判断是否有数据权限,如果有数据权限配置,那么添加数据权限的机构列表
if(CollectionUtils.isNotEmpty(organizationIdList))
{
for (String organizationId : organizationIdList)
{
EqualsTo equalsToPermission = new EqualsTo();
equalsToPermission.setLeftExpression(new Column(innerTable, DataPermissionConstant.DATA_PERMISSION_ID));
equalsToPermission.setRightExpression(new LongValue(organizationId));
orExpression = new OrExpression(orExpression, equalsToPermission);
Function functionPermission = new Function();
functionPermission.setName(DataPermissionConstant.DATA_PERMISSION_FIND_IN_SET);
functionPermission.setParameters(new ExpressionList(new LongValue(organizationId) , new Column(innerTable,DataPermissionConstant.DATA_PERMISSION_ANCESTORS)));
orExpression = new OrExpression(orExpression, functionPermission);
}
}
expression = ObjectUtils.isNotEmpty(expression) ? new AndExpression(expression, new Parenthesis(orExpression)) : orExpression;
plainSelect.setWhere(expression);
}
else
{
InExpression inExpression = new InExpression();
inExpression.setLeftExpression(buildColumn(dataTableAlias, DataPermissionConstant.DATA_PERMISSION_ORGANIZATION_ID));
SubSelect subSelect = new SubSelect();
PlainSelect select = new PlainSelect();
select.setSelectItems(Collections.singletonList(new SelectExpressionItem(new Column(DataPermissionConstant.DATA_PERMISSION_ID))));
select.setFromItem(new Table(DataPermissionConstant.DATA_PERMISSION_TABLE_NAME));
EqualsTo equalsTo = new EqualsTo();
equalsTo.setLeftExpression(new Column(DataPermissionConstant.DATA_PERMISSION_ID));
equalsTo.setRightExpression(new LongValue(user.getOrganizationId()));
Function function = new Function();
function.setName(DataPermissionConstant.DATA_PERMISSION_FIND_IN_SET);
function.setParameters(new ExpressionList(new LongValue(user.getOrganizationId()) , new Column(DataPermissionConstant.DATA_PERMISSION_ANCESTORS)));
OrExpression orExpression = new OrExpression(equalsTo, function);
//判断是否有数据权限,如果有数据权限配置,那么添加数据权限的机构列表
if(CollectionUtils.isNotEmpty(organizationIdList))
{
for (String organizationId : organizationIdList)
{
EqualsTo equalsToPermission = new EqualsTo();
equalsToPermission.setLeftExpression(new Column(DataPermissionConstant.DATA_PERMISSION_ID));
equalsToPermission.setRightExpression(new LongValue(organizationId));
orExpression = new OrExpression(orExpression, equalsToPermission);
Function functionPermission = new Function();
functionPermission.setName(DataPermissionConstant.DATA_PERMISSION_FIND_IN_SET);
functionPermission.setParameters(new ExpressionList(new LongValue(organizationId) , new Column(DataPermissionConstant.DATA_PERMISSION_ANCESTORS)));
orExpression = new OrExpression(orExpression, functionPermission);
}
}
select.setWhere(orExpression);
subSelect.setSelectBody(select);
inExpression.setRightExpression(subSelect);
expression = ObjectUtils.isNotEmpty(expression) ? new AndExpression(expression, new Parenthesis(inExpression)) : inExpression;
plainSelect.setWhere(expression);
}
}
// 只查询用户拥有机构的数据,不包含子机构
else if (DataPermissionTypeEnum.DATA_PERMISSION_ORG.getLevel().equals(dataPermissionType)) {
InExpression inExpression = new InExpression();
inExpression.setLeftExpression(buildColumn(dataTableAlias, DataPermissionConstant.DATA_PERMISSION_ORGANIZATION_ID));
ExpressionList expressionList = new ExpressionList();
List<Expression> expressions = new ArrayList<>();
expressions.add(new LongValue(user.getOrganizationId()));
if(CollectionUtils.isNotEmpty(organizationIdList))
{
for (String organizationId : organizationIdList)
{
expressions.add(new LongValue(organizationId));
}
}
expressionList.setExpressions(expressions);
inExpression.setRightItemsList(expressionList);
expression = ObjectUtils.isNotEmpty(expression) ? new AndExpression(expression, new Parenthesis(inExpression)) : inExpression;
plainSelect.setWhere(expression);
}
// 只能查询个人数据
else if (DataPermissionTypeEnum.DATA_PERMISSION_SELF.getLevel().equals(dataPermissionType)) {
EqualsTo equalsTo = new EqualsTo();
equalsTo.setLeftExpression(buildColumn(dataTableAlias, DataPermissionConstant.DATA_PERMISSION_SELF));
equalsTo.setRightExpression(new StringValue(String.valueOf(user.getId())));
expression = ObjectUtils.isNotEmpty(expression) ? new AndExpression(expression, new Parenthesis(equalsTo)) : equalsTo;
plainSelect.setWhere(expression);
}
//当类型为查看所有数据时,不处理
// if (DataPermissionTypeEnum.DATA_PERMISSION_ALL.getType().equals(dataPermissionType)) {
//
// }
// 自定义过滤语句
else if (DataPermissionTypeEnum.DATA_PERMISSION_CUSTOM.getLevel().equals(dataPermissionType)) {
String customExpression = dataPermissionEntity.getCustomExpression();
if (StringUtils.isEmpty(customExpression))
{
throw new BusinessException("没有配置自定义表达式");
}
try {
Expression expressionCustom = CCJSqlParserUtil.parseCondExpression(customExpression);
expression = ObjectUtils.isNotEmpty(expression) ? new AndExpression(expression, new Parenthesis(expressionCustom)) : expressionCustom;
plainSelect.setWhere(expression);
} catch (JSQLParserException e) {
throw new BusinessException("自定义表达式配置错误");
}
}
}
/**
* 构建Column
*
* @param dataTableAlias 表别名
* @param columnName 字段名称
* @return 带表别名字段
*/
public static Column buildColumn(String dataTableAlias, String columnName) {
if (StringUtils.isNotEmpty(dataTableAlias)) {
columnName = dataTableAlias + StringPool.DOT + columnName;
}
return new Column(columnName);
}
/**
* 注解转为实体类
* @param annotation 注解
* @return 实体类
*/
public static DataPermissionEntity annotationToEntity(DataPermission annotation) {
DataPermissionEntity dataPermissionEntity = new DataPermissionEntity();
dataPermissionEntity.setDataPermissionType(annotation.dataPermissionType());
dataPermissionEntity.setDataColumnExclude(annotation.dataColumnExclude());
dataPermissionEntity.setDataColumnInclude(annotation.dataColumnInclude());
dataPermissionEntity.setDataTableName(annotation.dataTableName());
dataPermissionEntity.setDataTableAlias(annotation.dataTableAlias());
dataPermissionEntity.setInnerTableName(annotation.innerTableName());
dataPermissionEntity.setInnerTableAlias(annotation.innerTableAlias());
dataPermissionEntity.setCustomExpression(annotation.customExpression());
return dataPermissionEntity;
}
@Override
public Expression getSqlSegment(Expression where, String mappedStatementId) {
return null;
}
- 系统启动时初始化数据权限配置到Redis
@Override
public void initDataRolePermissions() {
List<DataPermissionRoleDTO> dataPermissionRoleList = dataPermissionRoleMapper.queryDataPermissionRoleListAll();
// 判断是否开启了租户模式,如果开启了,那么角色权限需要按租户进行分类存储
if (enable) {
Map<Long, List<DataPermissionRoleDTO>> dataPermissionRoleListMap =
dataPermissionRoleList.stream().collect(Collectors.groupingBy(DataPermissionRoleDTO::getTenantId));
dataPermissionRoleListMap.forEach((key, value) -> {
// auth:tenant:data:permission:0
String redisKey = DataPermissionConstant.TENANT_DATA_PERMISSION_KEY + key;
redisTemplate.delete(redisKey);
addDataRolePermissions(redisKey, value);
});
} else {
redisTemplate.delete(DataPermissionConstant.DATA_PERMISSION_KEY);
// auth:data:permission
addDataRolePermissions(DataPermissionConstant.DATA_PERMISSION_KEY, dataPermissionRoleList);
}
}
private void addDataRolePermissions(String key, List<DataPermissionRoleDTO> dataPermissionRoleList) {
Map<String, DataPermissionEntity> dataPermissionMap = new TreeMap<>();
Optional.ofNullable(dataPermissionRoleList).orElse(new ArrayList<>()).forEach(dataPermissionRole -> {
String dataRolePermissionCache = new StringBuffer(DataPermissionConstant.DATA_PERMISSION_KEY_MAPPER)
.append(dataPermissionRole.getDataMapperFunction()).append(DataPermissionConstant.DATA_PERMISSION_KEY_TYPE)
.append(dataPermissionRole.getDataPermissionType()).toString();
DataPermissionEntity dataPermissionEntity = BeanCopierUtils.copyByClass(dataPermissionRole, DataPermissionEntity.class);
dataPermissionMap.put(dataRolePermissionCache, dataPermissionEntity);
});
redisTemplate.boundHashOps(key).putAll(dataPermissionMap);
}
数据权限配置指南:
- 数据权限名称:自定义一个名称,方便查找和区分
- Mapper全路径: Mapper路径配置到具体方法名称,例:com.gitegg.service.system.mapper.UserMapper.selectUserList
- 数据权限类型: 只能查看本人(实现原理是在查询条件添加数据表的creator条件) 只能查看本部门 (实现原理是在查询条件添加数据表的部门条件) 只能查看本部门及子部门 (实现原理是在查询条件添加数据表的部门条件) 可以查看所有数据(不处理) 自定义(添加where子条件)
注解配置数据权限配置指南:
/**
* 查询用户列表
* @param page
* @param user
* @return
*/
@DataPermission(dataTableName = "t_sys_organization_user", dataTableAlias = "organizationUser", dataPermissionType = "3", innerTableName = "t_sys_organization", innerTableAlias = "orgDataPermission")
@DataPermission(dataTableName = "t_sys_organization_user", dataTableAlias = "organizationUser", dataPermissionType = "2", innerTableName = "t_sys_organization", innerTableAlias = "orgDataPermission")
@DataPermission(dataTableName = "t_sys_organization_user", dataTableAlias = "organizationUser", dataPermissionType = "1", innerTableName = "t_sys_organization", innerTableAlias = "orgDataPermission")
Page<UserInfo> selectUserList(Page<UserInfo> page, @Param("user") QueryUserDTO user);
行级数据权限配置:
数据主表:主数据表,用于数据操作时的主表,例如SQL语句时的主表 数据主表别名:主数据表的别名,用于和数据权限表进行inner join操作 数据权限表:用于inner join的数据权限表,主要用于使用ancestors字段查询所有子组织机构 数据权限表别名:用于和主数据表进行inner join ######列级数据权限配置: 排除的字段:配置没有权限查看的字段,需要排除这些字段 保留的字段:配置有权限查看的字段,只保留这些字段
备注:
- 此数据权限设计较灵活,也较复杂,有些简单应用场景的系统可能根本用不到,只需配置行级数据权限即可。
- Mybatis-Plus的插件DataPermissionInterceptor使用说明 gitee.com/baomidou/my…
- update,insert逻辑说明:inner时只支持正常查询,及inner查询,不支持子查询,update,insert,子查询等直接使用添加子查询的方式实现数据权限
- 还有在这里说明一下,在我们实际业务开发过程中,只能查看本人数据的数据权限,一般不会通过系统来配置,而是在业务代码编写过程中就 会实现,比如查询个人订单接口,那么个人用户id肯定是接口的入参,在接口被请求的时候,只需要通过我们自定义的方法获取到当前登录用户,然后作为参数传入即可。这种对于个人数据的数据权限,通过业务代码来实现会更加方便和安全,且没有太多的工作量,方便理解也容易扩展。