MybatisPlus+SpringBoot 通过sql根据表的createuserid字段拼接where过滤增删改查操作

因为项目有个需求，对指定的功能的某些操作（比如数据的修改删除等）做权限过滤控制，当前登录人必须是自己或者权限范围内的人创建的数据才可以被操作，所以在操作sql前加一层sql过滤

config配置

import com.baomidou.mybatisplus.core.parser.ISqlParser;
import com.baomidou.mybatisplus.extension.parsers.DynamicTableNameParser;
import com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor;
import com.baomidou.mybatisplus.extension.plugins.tenant.TenantHandler;
import com.baomidou.mybatisplus.extension.plugins.tenant.TenantSqlParser;
import net.sf.jsqlparser.expression.Expression;
import net.sf.jsqlparser.expression.StringValue;
import org.apache.commons.lang3.ArrayUtils;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.util.CollectionUtils;

import java.util.ArrayList;
import java.util.List;

@Configuration
public class DynamicTableConfig {

    @Value("${mybatisPlus.noUseDataTable:user_table,role_table}")
    private String[] noUseDataTable;


    @Bean
    public PaginationInterceptor paginationInterceptor() {
        PaginationInterceptor paginationInterceptor = new PaginationInterceptor();
        // 设置最大单页限制数量，默认 500 条，-1 不受限制
        paginationInterceptor.setLimit(-1);
        //自定义的拦截sql进行处理的类
        UserDataSqlParser userDataSqlParser = new UserDataSqlParser();
        userDataSqlParser.setUserDataHandler(new UserDataHandler() {

            @Override
            public Expression getUserId(boolean var1) {
                return new StringValue(user.getId());
            }

            @Override
            public boolean doTableFilter(String tableName) {
                // 这里可以判断过滤哪些表
                if (ArrayUtils.isNotEmpty(noUseDataTable)) {
                    for (String i : noUseDataTable) {
                        if (tableName.equals(i)) {
                            return true;
                        }
                    }
                }
                return false;
            }
        });
        List<ISqlParser> sqlParserList = new ArrayList<>();
        sqlParserList.add(userDataSqlParser);
        paginationInterceptor.setSqlParserList(sqlParserList);
        return paginationInterceptor;
    }
}

授权数据过滤处理器UserDataHandler

import net.sf.jsqlparser.expression.Expression;

/**
 * 授权数据过滤处理器
 */
public interface UserDataHandler {

    /**
     * 根据表名判断是否进行过滤
     *
     * @param tableName 表名
     * @return 是否进行过滤, true:表示忽略
     */
    boolean doTableFilter(String tableName);

    /**
     * 获取用户 ID 值表达式，支持多个 ID 条件查询
     * <p>
     *
     * @param where 参数 true 表示为 where 条件 false 表示为 insert 或者 select 条件
     * @return 用户 ID 值表达式
     */
    Expression getUserId(boolean where);
}

具体处理类UserDataSqlParser

import com.baomidou.mybatisplus.core.parser.AbstractJsqlParser;
import com.baomidou.mybatisplus.core.toolkit.StringPool;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;
import net.sf.jsqlparser.expression.BinaryExpression;
import net.sf.jsqlparser.expression.Expression;
import net.sf.jsqlparser.expression.Parenthesis;
import net.sf.jsqlparser.expression.operators.conditional.AndExpression;
import net.sf.jsqlparser.expression.operators.conditional.OrExpression;
import net.sf.jsqlparser.expression.operators.relational.EqualsTo;
import net.sf.jsqlparser.schema.Column;
import net.sf.jsqlparser.schema.Table;
import net.sf.jsqlparser.statement.delete.Delete;
import net.sf.jsqlparser.statement.insert.Insert;
import net.sf.jsqlparser.statement.select.SelectBody;
import net.sf.jsqlparser.statement.update.Update;

/**
 * 用于数据过滤
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
@Accessors(chain = true)
@EqualsAndHashCode(callSuper = true)
public class UserDataSqlParser  extends AbstractJsqlParser {

    private UserDataHandler userDataHandler;

    /**
     * insert 语句处理
     */
    @Override
    public void processInsert(Insert insert) {

    }

    /**
     * delete 语句处理(只能删除自己创建的数据)
     */
    @Override
    public void processDelete(Delete delete) {
        if (userDataHandler.doTableFilter(delete.getTable().getName())) {
            // 过滤退出执行
            return;
        }
        delete.setWhere(this.andExpression(delete.getTable(), delete.getWhere()));
    }

    /**
     * update 语句处理
     */
    @Override
    public void processUpdate(Update update) {
        if (userDataHandler.doTableFilter(update.getTable().getName())) {
            // 过滤退出执行
            return;
        }
        //拼接where条件
        update.setWhere(this.andExpression(update.getTable(), update.getWhere()));
    }

    /**
     * select 语句处理
     */
    @Override
    public void processSelectBody(SelectBody selectBody) {

    }

    /**
     * delete update 语句 where 处理
     */
    protected BinaryExpression andExpression(Table table, Expression where) {
        //获得where条件表达式
        EqualsTo equalsTo = new EqualsTo();
        //左右拼接出来就是tableName.createuserid=userid
        equalsTo.setLeftExpression(this.getAliasColumn(table));
        equalsTo.setRightExpression(userDataHandler.getUserId(true));
        if (null != where) {
            if (where instanceof OrExpression) {
                return new AndExpression(equalsTo, new Parenthesis(where));
            } else {
                return new AndExpression(equalsTo, where);
            }
        }
        return equalsTo;
    }

    /**
     * 用户字段别名设置
     * <p>tableName.createuserid 或 tableAlias.createuserid</p>
     *
     * @param table 表对象
     * @return 字段
     */
    protected Column getAliasColumn(Table table) {
        StringBuilder column = new StringBuilder();
        if (null == table.getAlias()) {
            column.append(table.getName());
        } else {
            column.append(table.getAlias().getName());
        }
        column.append(StringPool.DOT);
        column.append("createuserid");
        return new Column(column.toString());
    }
}