mybatis拦截器+CCJSqlParser实现解耦数据权限
前言
从工作以来经手了好多个从0-1的项目，所以也写了很多很多次权限相关的代码，但每次的数据权限实现都不理想，每接入一个新的功能页面都要针对各个接口进行数据过滤，由其是一些不清楚权限设计的同学想写个功能，还要去弄明白权限的那一堆事才可以，然后过滤的逻辑就会耦合在各个业务代码中合，简直就是被代码支配的恐惧。那有什么好的办法能做好解耦呢
方案与实现
数据权限无非就是通过sql，过滤掉无权限的数据，以及拦截那些无权限数据的操作。那我们直接拦截sql，将拦截语句拼装进去不就行啦~
使用自定义注解来标识哪些Mapper方法需要被拦截
创建mybatis intercept拦截器，检测方法是否有自定义注解
使用CCJSqlParser解析并改写SQL
覆盖原SQL
数据表设计
CREATE TABLE `data_group_ref` (
`id` bigint(20) unsigned NOT NULL AUTO_INCREMENT COMMENT '主键',
`data_id` bigint(20) NOT NULL DEFAULT '0' COMMENT '数据id',
`data_type` tinyint(4) NOT NULL DEFAULT '0' COMMENT '数据类型',
`group_id` bigint(20) NOT NULL DEFAULT '0' COMMENT '用户组id',
......
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='数据与用户组的对应关系表';
在小数据量下，我们只需要一个数据与用户组的关系表即可。
data_id 对应数据表的主键id
data_type 是数据类型标识，因为系统可能会有很多数据表需要做权限，每个表都创一个关系表，就会出现表爆炸，所以全放一个关系表里用type来区分就好
group_id 是对应的用户组主键id ,每一个数据可以对应多个组,那就会有多条记录
自定义注解
@Target(value = {ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface DataAuthSelect {
//数据类型， data_group_ref表中的 data_type 字段值
int type() default 0;
}
这里我只列出type用来告知拦截器需要过滤的数据类型，大家可以根据自己的业务进行扩展
拦截器
针对拦截器的原理，网上有好多资料，我就不再反复阐述，大家可参考
https://blog.csdn.net/weixin_39494923/article/details/91534658
@Intercepts({@Signature(method = "query", type = Executor.class,
args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class})})
@Component
public class DataAuthSelectIntercept implements Interceptor {
private static final Logger logger = LoggerFactory.getLogger(DataAuthSelectIntercept.class);
@Autowired
HttpServletRequest request;
@Override
public Object intercept(Invocation invocation) throws Throwable {
MappedStatement mappedStatement = (MappedStatement) invocation.getArgs()[0];
//没自定义注解直接按通过算
DataAuthSelect dataAuth = getDataAuth(mappedStatement);
if (dataAuth == null) {
return invocation.proceed();
}
//没登录是异常
UserInfo user = (UserInfo) request.getSession().getAttribute("userInfo");
if (user == null) {
throw new Exception("获取用户登录信息失败");
}
//超级管理员不过滤
if (user.isSuperAdmin()) {
return invocation.proceed();
}
//根据自己的业务写更多的过滤判断.....
//如果获取用户组失败，或者为全部权限，则直接通过
String groupStr = getGroupStr(user);
if (StringUtils.isBlank(groupStr)) {
return invocation.proceed();
}
//拼装sql(这里是关键！！！)
BoundSql boundSql = mappedStatement.getBoundSql(invocation.getArgs()[1]);
String orgSql = boundSql.getSql(); //获取到当前需要被执行的SQL
String authSql = makeSql(orgSql, groupStr, dataAuth); //进行数据权限过滤组装
//替换
MappedStatement newStatement = newMappedStatement(mappedStatement, new BoundSqlSqlSource(boundSql));
MetaObject msObject = MetaObject.forObject(newStatement, new DefaultObjectFactory(), new DefaultObjectWrapperFactory(), new DefaultReflectorFactory());
msObject.setValue("sqlSource.boundSql.sql", authSql);
invocation.getArgs()[0] = newStatement;
logger.debug("baseSql:{} authSql:{}", orgSql, authSql);
return invocation.proceed();
}
/**
* 通过反射获取mapper方法是否加了自定义注解
*/
private DataAuthSelect getDataAuth(MappedStatement mappedStatement) throws ClassNotFoundException {
DataAuthSelect dataAuth = null;
String id = mappedStatement.getId();
String className = id.substring(0, id.lastIndexOf("."));
String methodName = id.substring(id.lastIndexOf(".") + 1);
final Class<?> cls = Class.forName(className);
final Method[] methods = cls.getMethods();
for (Method method : methods) {
if (method.getName().equals(methodName) && method.isAnnotationPresent(DataAuthSelect.class)) {
dataAuth = method.getAnnotation(DataAuthSelect.class);
break;
}
}
return dataAuth;
}
/**
* 获取当前登录的用户配置的用户组信息 （group_id）
*/
private String getGroupStr(UserInfo user) {
//分局自己的业务逻辑实现
return "1,2,3,4,5";
}
/**
* 核心代码： 将原SQL 进行解析并拼装 一个子查询 id in ( 数据权限过滤SQL )
*/
private String makeSql(String sql, String groupStr, DataAuthSelect dataAuth) throws JSQLParserException {
CCJSqlParserManager parserManager = new CCJSqlParserManager();
Select select = (Select) parserManager.parse(new StringReader(sql));
PlainSelect plain = (PlainSelect) select.getSelectBody();
Table fromItem = (Table) plain.getFromItem();
//有别名用别名，无别名用表名，防止字段冲突报错
String mainTableName = fromItem.getAlias() == null ? fromItem.getName() : fromItem.getAlias().getName();
//构建子查询
String dataAuthSql = mainTableName + ".id in ( select data_id from data_group_ref where " + mainTableName + ".id = data_id and data_type = " + dataAuth.type() + " and group_id in (" + groupStr + ")" + ")";
if (plain.getWhere() == null) {
plain.setWhere(CCJSqlParserUtil.parseCondExpression(dataAuthSql));
} else {
plain.setWhere(new AndExpression(plain.getWhere(), CCJSqlParserUtil.parseCondExpression(dataAuthSql)));
}
return select.toString();
}
private MappedStatement newMappedStatement(MappedStatement ms, SqlSource newSqlSource) {
MappedStatement.Builder builder =
new MappedStatement.Builder(ms.getConfiguration(), ms.getId(), newSqlSource, ms.getSqlCommandType());
builder.resource(ms.getResource());
builder.fetchSize(ms.getFetchSize());
builder.statementType(ms.getStatementType());
builder.keyGenerator(ms.getKeyGenerator());
if (ms.getKeyProperties() != null && ms.getKeyProperties().length != 0) {
StringBuilder keyProperties = new StringBuilder();
for (String keyProperty : ms.getKeyProperties()) {
keyProperties.append(keyProperty).append(",");
}
keyProperties.delete(keyProperties.length() - 1, keyProperties.length());
builder.keyProperty(keyProperties.toString());
}
builder.timeout(ms.getTimeout());
builder.parameterMap(ms.getParameterMap());
builder.resultMaps(ms.getResultMaps());
builder.resultSetType(ms.getResultSetType());
builder.cache(ms.getCache());
builder.flushCacheRequired(ms.isFlushCacheRequired());
builder.useCache(ms.isUseCache());
return builder.build();
}
private class BoundSqlSqlSource implements SqlSource {
private BoundSql boundSql;
public BoundSqlSqlSource(BoundSql boundSql) {
this.boundSql = boundSql;
}
@Override
public BoundSql getBoundSql(Object parameterObject) {
return boundSql;
}
}
至此我们已经完成了数据权限所有的代码编写。
一起看下原始sql与拼装后sql的区别
select id,name from test where is_deleted = 0
select id,name from test where is_deleted = 0 and id in ( select data_id from data_group_ref where test.id = data_id and data_type = 1 and group_id in ("1,2,3") )
为什么使用子查询不用join？ 因为子查询兼容更强，需要改写的sql更少，如果用join 原sql是单查询，那组装时还要对 select的字段进行加别名，能少做点事就少做点吧~
使用与规范
让我们一起来体验下解耦后的快了吧，我们只需一行代码，在对应需要做权限的mapper中加一个注解！
对应的sql就会自动被增加数据权限的过滤，不需要了解权限的设计，不需要自己反复的拼接那条一样的sql。
@Select(value = "SELECT * FROM lcp_rule WHERE id = #{id} and is_deleted = 0")
@DataAuthSelect(type = 1)
Rule selectByIdAuth(Serializable id);
虽然我们只定义了对sql的拦截，但是我们却能够实现 列表、查看、编辑、删除 等等常见数据权限限制！
列表与查看不用多说，本身就是查询。 编辑与删除，是update与delete ，我们虽然没有拦截，但通常在进行修改与删除之前，我们需要进行一个 getbyid的查询来确保数据存在。一但进行这个查询，不就又命中我们的拦截，如果返回空数据，c层直接返回无权限即可~
