mybatis-plus数据权限实现

说明

数据权限是平台系统中不可分割的一部分，在mybatis框架中，大部分都是基于mybatis拦截器进行数据权限的插入，有的将数据权限参数作为XML的标签，有的是基于注解方式，但是不管这两种方式如何，都必须在拦截器中处理自己解析SQL，稍有不慎或者说没解析到就会出现各种奇奇怪怪的问题。在引入mybatis-plus以后通过查看myabtis-mate插件的部分示例。结合了mybatis-plus的插件方式，做出了自己的注解方式的数据权限，虽然可能存在一部分的局限性，但很好的解决了我们自己去解析SQL的功能。

自定义注解部分

建立两个注解与一个枚举，枚举是实现插入数据权限SQL的前置
注解：@DataScope,@DataColumn.这个两个注解作为在Mapper方法上使用

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

    DataColumn[] value() default {};
}

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

    String alias() default "";

    String name();

    ColumnType type() default ColumnType.USER;

}

自定义枚举

自定义一个枚举：ColumnType 枚举中有个Class 是属于继承AbstractDataColumnStrategy（抽象数据列处理策略）

public enum ColumnType {
    USER(UserDataColumnStrategy.class),
    DEPT(DeptDataColumnStrategy.class);

    private Class<? extends AbstractDataColumnStrategy> clazz;

    ColumnType(Class<? extends AbstractDataColumnStrategy> userDataColumnStrategyClass) {

    }


    public Class<? extends AbstractDataColumnStrategy> getClazz() {
        return clazz;
    }
}

自定义Mybatis-Plus的插件

mybatis-plus的自定义插件需要继承JsqlParserSupport，且实现InnerInterceptor接口。其中JsqlParserSupport是Myabtis-Plus使用JsqlParser依赖改造的通过JsqlParser来解析需要执行的SQL。

public class DataPermissionInterceptor extends JsqlParserSupport implements InnerInterceptor {

    private static final String COUNT_PRE = "_COUNT";
    private MappedStatement ms;
    private DataScope dataScope;
	//重写查询之前方法
    @Override
    public void beforeQuery(Executor executor, MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {
        this.ms = ms;
        if (InterceptorIgnoreHelper.willIgnoreDataPermission(ms.getId())) {
            PluginUtils.MPBoundSql mpBs = PluginUtils.mpBoundSql(boundSql);
            mpBs.sql(this.parserSingle(mpBs.sql(), ms.getId()));
            return;
        }
        //获取权限注解 如果没有加注解 则忽略数据权限
        DataScope dataScope = this.getPermissionAnnotation(ms);
        if (dataScope == null) {
            return;
        }
        this.dataScope = dataScope;
        PluginUtils.MPBoundSql mpBs = PluginUtils.mpBoundSql(boundSql);
        mpBs.sql(this.parserSingle(mpBs.sql(), ms.getId()));
    }
		//重写处理Select方法
    @Override
    protected void processSelect(Select select, int index, String sql, Object obj) {
        SelectBody selectBody = select.getSelectBody();
        //如果是_COUNT结尾的SQL 则是PageHelper的统计SQL 包裹了原SQL 则需要获取到子句 进行条件添加
        try {
            if (obj.toString().endsWith(COUNT_PRE)) {
                PlainSelect plainSelect = (PlainSelect) selectBody;
                FromItem fromItem = plainSelect.getFromItem();
                if (fromItem instanceof SubSelect) {
                    SubSelect subSelect = (SubSelect) fromItem;
                    SelectBody selectBody1 = subSelect.getSelectBody();
                    this.setWhere((PlainSelect) selectBody1, (String) obj);
                }
            } else {
                this.setWhere((PlainSelect) selectBody, (String) obj);
            }
        } catch (IllegalAccessException | InstantiationException e) {
            e.printStackTrace();
            logger.error("处理数据权限SQL异常 error:{}", e);
            throw new RuntimeException(e.getMessage());
        }
    }
		//设置条件的方法
    private void setWhere(PlainSelect plainSelect, String whereSegment) throws IllegalAccessException, InstantiationException {
        DataColumn[] columns = this.getDataScope().value();
        //如果没有添加数据权限列 返回
        if (columns.length < 1) {
            return;
        }
        //获取所有需要处理的数据权限列，根据枚举获取SQL处理的策略
        for (DataColumn column : columns) {
            Class<? extends AbstractDataColumnStrategy> clazz = column.type().getClazz();
            AbstractDataColumnStrategy strategy = clazz.newInstance();
            strategy.setAlias(column.alias());
            strategy.setName(column.name());
            strategy.setPlainSelect(plainSelect);
            PlainSelect strategyPlainSelect = strategy.getPlainSelect();
            plainSelect = strategyPlainSelect;
        }
    }


    /**
     * 获得权限注释
     *
     * @param ms
     * @return {@link DataScope}
     */
    private DataScope getPermissionAnnotation(MappedStatement ms) {
        DataScope data = null;
        try {
            // id为执行的mapper方法的全路径名，如com.mapper.UserMapper
            String id = ms.getId();
            log.info("解析得到全类型名称 ID:{}", id);
            //统计SQL取得注解也是实际查询id上得注解，所以需要去掉_COUNT
            if (id.contains(COUNT_PRE)) {
                id = id.replace(COUNT_PRE, "");
            }
            //获取类名和方法名
            String className = id.substring(0, id.lastIndexOf("."));
            String methodName = id.substring(id.lastIndexOf(".") + 1);
            final Class<?> cls = Class.forName(className);
            final Method[] method = cls.getMethods();
            //反射 获取注解
            for (Method me : method) {
                if (me.getName().equals(methodName) && me.isAnnotationPresent(DataScope.class)) {
                    data = me.getAnnotation(DataScope.class);
                }
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return data;
     }
   }
 

本地线程

通过本地线程或者阿里的父子传递的线程将数据权限解析后的用户或部门进行传递

@Data
public class DataPermissionDto {

    private List<Long> userIds;

    private List<Long> deptIds;

    private Long myUserId;

    private Long myDeptId;

    private Long tenantId;
}

//线程池
public class DataPermissionTenantHolder {

    /**
     * 支持父子线程之间的数据传递
     */
    private static final ThreadLocal<DataPermissionDto> CONTEXT_HOLDER = new TransmittableThreadLocal<>();

    public static <T extends DataPermissionDto> void setTenant(T tenant) {
        CONTEXT_HOLDER.set(tenant);
    }

    public static <T extends DataPermissionDto> T getTenant() {
        return (T) CONTEXT_HOLDER.get();
    }

    public static void clear() {
        CONTEXT_HOLDER.remove();
    }
}

/* 抽象策略*/
@Data
public abstract class AbstractDataColumnStrategy {

    private PlainSelect plainSelect;

    private String alias;

    private String name;


    public abstract PlainSelect handleColumn();
}

/*用户Id策略*/
public class UserDataColumnStrategy extends AbstractDataColumnStrategy {


    @Override
    public PlainSelect handleColumn() {
        String alias = getAlias();
        String name = getName();
        String column = name;
        if (StringUtils.isNotBlank(alias)) {
            column = alias.trim() + "." + name.trim();
        }
        PlainSelect plainSelect = getPlainSelect();
        DataPermissionDto tenant = DataPermissionTenantHolder.getTenant();
        List<Long> userIds = tenant.getUserIds();
        //如果线程中没有 数据权限中的用户集合
        if (CollectionUtils.isEmpty(userIds)) {
            Long myUserId = tenant.getMyUserId();
            EqualsTo equalsTo = new EqualsTo();
            equalsTo.setLeftExpression(new Column(column));
            equalsTo.setRightExpression(new LongValue(myUserId));
            if (null == plainSelect.getWhere()) {
                // 不存在 where 条件
                plainSelect.setWhere(new Parenthesis(equalsTo));
            } else {
                // 存在 where 条件 and 处理
                plainSelect.setWhere(new AndExpression(plainSelect.getWhere(), equalsTo));
            }
            return plainSelect;
        }
        // 有数据权限中的用户集合
        ItemsList itemsList = new ExpressionList(userIds.stream().map(LongValue::new).collect(Collectors.toList()));
        InExpression inExpression = new InExpression(new Column(column), itemsList);
        if (null == plainSelect.getWhere()) {
            // 不存在 where 条件
            plainSelect.setWhere(new Parenthesis(inExpression));
        } else {
            // 存在 where 条件 and 处理
            plainSelect.setWhere(new AndExpression(plainSelect.getWhere(), inExpression));
        }
        return plainSelect;
			
    }
}

添加自定义插件

想Myabtis-Plus中添加我们的数据权限插件

 @Bean
    @ConditionalOnMissingBean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        //是否开启多租户（这里是多租户插件部分,下次再提）
        if (tenantProperties.isEnabled()) {
            TenantLineInnerInterceptor tenantLineInnerInterceptor = new TenantLineInnerInterceptor(new TenantLineHandlerInterceptor(tenantProperties));
            interceptor.addInnerInterceptor(tenantLineInnerInterceptor);
        }
		//数据权限的插件
        interceptor.addInnerInterceptor(new DataPermissionInterceptor());
        return interceptor;
    }

总结

Mybatis-Plus 提供了自定义插件的配置，通过自定义插件的方式实现对执行的SQL操作，比如分页插件，多租户插件等等。通过JsqlParser依赖很好的解析执行SQL并对执行的SQL进行一系列的操作。