mybatis拦截器实现数据权限-六虎

前端的菜单和按钮权限都能够经过配置来完成，但很多时分，后台查询数据库数据的权限需求经过手动添加SQL来完成。
比方职工打卡记载表，有id,name,dpt_id,company_id等字段，后两个表示部分ID和分公司ID。
检查职工打卡记载SQL为：select id,name,dpt_id,company_id from t_record

当一个总部账号能够检查悉数数据此刻,sql无需改变。由于他能够看到悉数数据。
当一个部分管理员权限职工检查悉数数据时，sql需求在末属添加 where dpt_id = #{dpt_id}

假如每个功能模块都需求手动写代码去拿到当时登陆用户的所属部分，然后手动添加where条件，就显得十分的繁琐。
因而，能够经过mybatis的阻拦器拿到查询sql句子，再主动改写sql。

mybatis 阻拦器

MyBatis 答应你在映射句子履行过程中的某一点进行阻拦调用。默许情况下，MyBatis 答应运用插件来阻拦的办法调用包含：

Executor (update, query, flushStatements, commit, rollback, getTransaction, close, isClosed)
ParameterHandler (getParameterObject, setParameters)
ResultSetHandler (handleResultSets, handleOutputParameters)
StatementHandler (prepare, parameterize, batch, update, query)

这些类中办法的细节能够经过检查每个办法的签名来发现，或者直接检查 MyBatis 发行包中的源代码。假如你想做的不仅仅是监控办法的调用，那么你最好适当了解要重写的办法的行为。由于在试图修改或重写已有办法的行为时，很可能会损坏 MyBatis 的中心模块。这些都是更底层的类和办法，所以运用插件的时分要特别当心。

经过 MyBatis 提供的强壮机制，运用插件是十分简略的，只需完成 Interceptor 接口，并指定想要阻拦的办法签名即可。

分页插件pagehelper就是一个典型的经过阻拦器去改写SQL的。

能够看到它经过注解 @Intercepts 和签名 @Signature 来完成，阻拦Executor履行器，阻拦所有的query查询类办法。
咱们能够据此也完成自己的阻拦器。


    import com.skycomm.common.util.user.Cpip2UserDeptVo;
    import com.skycomm.common.util.user.Cpip2UserDeptVoUtil;
    import lombok.extern.slf4j.Slf4j;
    import org.apache.commons.lang3.StringUtils;
    import org.apache.ibatis.cache.CacheKey;
    import org.apache.ibatis.executor.Executor;
    import org.apache.ibatis.mapping.BoundSql;
    import org.apache.ibatis.mapping.MappedStatement;
    import org.apache.ibatis.mapping.SqlSource;
    import org.apache.ibatis.plugin.Interceptor;
    import org.apache.ibatis.plugin.Intercepts;
    import org.apache.ibatis.plugin.Invocation;
    import org.apache.ibatis.plugin.Signature;
    import org.apache.ibatis.session.ResultHandler;
    import org.apache.ibatis.session.RowBounds;
    import org.springframework.stereotype.Component;
    import org.springframework.web.context.request.RequestAttributes;
    import org.springframework.web.context.request.RequestContextHolder;
    import org.springframework.web.context.request.ServletRequestAttributes;
    import javax.servlet.http.HttpServletRequest;
    import java.lang.reflect.Method;
    @Component
    @Intercepts({
            @Signature(type = Executor.class, method = "query", args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class}),
            @Signature(type = Executor.class, method = "query", args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class, CacheKey.class, BoundSql.class}),
    })
    @Slf4j
    public class MySqlInterceptor implements Interceptor {
        @Override
        public Object intercept(Invocation invocation) throws Throwable {
            MappedStatement statement = (MappedStatement) invocation.getArgs()[0];
            Object parameter = invocation.getArgs()[1];
            BoundSql boundSql = statement.getBoundSql(parameter);
            String originalSql = boundSql.getSql();
            Object parameterObject = boundSql.getParameterObject();
            SqlLimit sqlLimit = isLimit(statement);
            if (sqlLimit == null) {
                return invocation.proceed();
            }
            RequestAttributes req = RequestContextHolder.getRequestAttributes();
            if (req == null) {
                return invocation.proceed();
            }
            //处理request
            HttpServletRequest request = ((ServletRequestAttributes) req).getRequest();
            Cpip2UserDeptVo userVo = Cpip2UserDeptVoUtil.getUserDeptInfo(request);
            String depId = userVo.getDeptId();
            String sql = addTenantCondition(originalSql, depId, sqlLimit.alis());
            log.info("原SQL：{}， 数据权限替换后的SQL：{}", originalSql, sql);
            BoundSql newBoundSql = new BoundSql(statement.getConfiguration(), sql, boundSql.getParameterMappings(), parameterObject);
            MappedStatement newStatement = copyFromMappedStatement(statement, new BoundSqlSqlSource(newBoundSql));
            invocation.getArgs()[0] = newStatement;
            return invocation.proceed();
        }
        /**
         * 从头拼接SQL
         */
        private String addTenantCondition(String originalSql, String depId, String alias) {
            String field = "dpt_id";
            if(StringUtils.isNoneBlank(alias)){
                field = alias + "." + field;
            }
            StringBuilder sb = new StringBuilder(originalSql);
            int index = sb.indexOf("where");
            if (index < 0) {
                sb.append(" where ") .append(field).append(" = ").append(depId);
            } else {
                sb.insert(index + 5, " " + field +" = " + depId + " and ");
            }
            return sb.toString();
        }
        private MappedStatement copyFromMappedStatement(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());
            builder.timeout(ms.getTimeout());
            builder.parameterMap(ms.getParameterMap());
            builder.resultMaps(ms.getResultMaps());
            builder.cache(ms.getCache());
            builder.useCache(ms.isUseCache());
            return builder.build();
        }
        /**
         * 经过注解判别是否需求限制数据
         * @return
         */
        private SqlLimit isLimit(MappedStatement mappedStatement) {
            SqlLimit sqlLimit = null;
            try {
                String id = mappedStatement.getId();
                String className = id.substring(0, id.lastIndexOf("."));
                String methodName = id.substring(id.lastIndexOf(".") + 1, id.length());
                final Class<?> cls = Class.forName(className);
                final Method[] method = cls.getMethods();
                for (Method me : method) {
                    if (me.getName().equals(methodName) && me.isAnnotationPresent(SqlLimit.class)) {
                        sqlLimit = me.getAnnotation(SqlLimit.class);
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
            return sqlLimit;
        }
        public static class BoundSqlSqlSource implements SqlSource {
            private final BoundSql boundSql;
            public BoundSqlSqlSource(BoundSql boundSql) {
                this.boundSql = boundSql;
            }
            @Override
            public BoundSql getBoundSql(Object parameterObject) {
                return boundSql;
            }
        }
    }

顺便加了个注解 @SqlLimit，在mapper办法上加了此注解才进行数据权限过滤。
同时注解有两个属性，

@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface SqlLimit {
    /**
     * sql表别号
     * @return
     */
    String alis() default "";
    /**
     * 经过此列名进行限制
     * @return
     */
    String columnName() default "";
}

columnName表示经过此列名进行限制，一般来说一个系统，各表傍边的此列是一致的，能够忽略。

alis用于标注sql表别号，如针对sql select * from tablea as a left join tableb as b on a.id = b.id 进行改写，假如不知道表别号，会直接在后面拼接 where dpt_id = #{dptId},
那此SQL就会过错的，经过别号 @SqlLimit(alis = "a") 就能够知道需求拼接的是 where a.dpt_id = #{dptId}

履行结果

原SQL：select * from person，数据权限替换后的SQL：select * from person where dpt_id = 234
原SQL：select * from person where id > 1，数据权限替换后的SQL：select * from person where dpt_id = 234 and id > 1

但是在运用PageHelper进行分页的时分仍是有问题。

能够看到先履行了_COUNT办法也就是PageHelper，再履行了自定义的阻拦器。

在咱们的业务办法中注入SqlSessionFactory

@Autowired
@Lazy
private List<SqlSessionFactory> sqlSessionFactoryList;

PageInterceptor为1，自定义阻拦器为0，跟order相反，PageInterceptor优先级更高，所以越先履行。

mybatis阻拦器优先级

@Order

经过@Order操控PageInterceptor和MySqlInterceptor可行吗？

将MySqlInterceptor的加载优先级调到最高，但测验证明依然不可。

定义3个类

@Component
@Order(2)
public class OrderTest1 {
    @PostConstruct
    public void init(){
        System.out.println(" 00000 init");
    }
}

@Component
@Order(1)
public class OrderTest2 {
    @PostConstruct
    public void init(){
        System.out.println(" 00001 init");
    }
}

@Component
@Order(0)
public class OrderTest3 {
    @PostConstruct
    public void init(){
        System.out.println(" 00002 init");
    }
}

OrderTest1，OrderTest2，OrderTest3的优先级从低到高。
次序预期的履行次序应该是相反的：

00002 init
00001 init
00000 init

但事实上履行的次序是

00000 init
00001 init
00002 init

@Order 不操控实例化次序，只操控履行次序。 @Order 只跟特定一些注解收效如：@Compent @Service @Aspect … 不收效的如： @WebFilter

所以这里达不到预期作用。

@Priority 相似，同样不可。

@DependsOn

运用此注解将当时类将在依赖类实例化之后再履行实例化。

在MySqlInterceptor上符号@DependsOn(“queryInterceptor”)

启动报错，
这个时分queryInterceptor还没有实例化对象。

@PostConstruct

@PostConstruct修饰的办法会在服务器加载Servlet的时分运转，而且只会被服务器履行一次。
在同一个类里，履行次序为次序如下:Constructor > @Autowired > @PostConstruct。

但它也不能确保不同类的履行次序。

PageHelper的springboot start也是经过这个来初始化阻拦器的。

ApplicationRunner

在当时springboot容器加载完成后履行，那么这个时分pagehelper的阻拦器已经加入，在这个时分加入自定义阻拦器，就能到达咱们想要的作用。

仿照PageHelper来写

@Component
public class InterceptRunner implements ApplicationRunner {
    @Autowired
    private List<SqlSessionFactory> sqlSessionFactoryList;
    @Override
    public void run(ApplicationArguments args) throws Exception {
        MySqlInterceptor mybatisInterceptor = new MySqlInterceptor();
        for (SqlSessionFactory sqlSessionFactory : sqlSessionFactoryList) {
            org.apache.ibatis.session.Configuration configuration = sqlSessionFactory.getConfiguration();
            configuration.addInterceptor(mybatisInterceptor);
        }
    }
}

再履行，能够看到自定义阻拦器在阻拦器链傍边下标变为了1（优先级与order刚好相反）

后台打印结果，到达了预期作用。

mybatis拦截器实现数据权限

mybatis 阻拦器

mybatis阻拦器优先级

@Order

@DependsOn

@PostConstruct

ApplicationRunner

相关文章

业绩一般般，如何写出漂亮的年终总结

Docker的镜像管理

[译]轻松学习Kotlin的Flow、ChannelFlow和CallbackFlow

唯一一家！国际测评：文心大模型3.5总分第一，算法模型第一，行业覆盖第一

作者信息