BaseMultiTableInnerInterceptor源码解读

Liu Zijian's Blog | 一个技术博客

Liu Zijian · 2025-03-07 · via Liu Zijian's Blog | 一个技术博客

一、概述

BaseMultiTableInnerInterceptor是MyBatis-Plus中的一个抽象类，位于mybatis-plus-jsqlparser-4.9模块中com.baomidou.mybatisplus.extension.plugins.inner包下，提供解析和重写SQL功能，MyBatis-Plus的数据权限(TenantLineInnerInterceptor)插件和多租户(DataPermissionInterceptor)插件均继承了BaseMultiTableInnerInterceptor类来实现对应的功能。

本文基于MyBatis-Plus的3.5.9版本的源码，并fork了代码： https://github.com/changelzj/mybatis-plus/tree/lzj-3.5.9

public abstract class BaseMultiTableInnerInterceptor 
extends JsqlParserSupport 
implements InnerInterceptor {

    protected void processSelectBody(Select selectBody, final String whereSegment) {...}

    protected Expression andExpression(Table table, Expression where, final String whereSegment) {...}

    protected void processPlainSelect(final PlainSelect plainSelect, final String whereSegment) {...}

    private List<Table> processFromItem(FromItem fromItem, final String whereSegment) {...}

    protected void processWhereSubSelect(Expression where, final String whereSegment) {...}

    protected void processSelectItem(SelectItem selectItem, final String whereSegment) {...}

    protected void processFunction(Function function, final String whereSegment) {...}

    protected void processOtherFromItem(FromItem fromItem, final String whereSegment) {...}

    private List<Table> processSubJoin(ParenthesedFromItem subJoin, final String whereSegment) {...}

    private List<Table> processJoins(List<Table> mainTables, List<Join> joins, final String whereSegment) {...}

    protected Expression builderExpression(Expression currentExpression, List<Table> tables, final String whereSegment) {...}

    public abstract Expression buildTableExpression(final Table table, final Expression where, final String whereSegment);

}

二、执行流程

BaseMultiTableInnerInterceptor实现了InnerInterceptor接口中的beforeQuery(),beforePrepare()方法，实际上是子类去间接实现的，MyBatis-Plus就是对实现这个接口的类进行回调，在查询SQL即将执行时调用beforeQuery()，在增删改SQL即将执行前调用beforePrepare()，beforeQuery()中再去调用parserSingle()，beforePrepare()再去调用parserMulti()

查询语句只能一次执行一条，增删改语句可以用分号间隔一次执行多条。故beforeQuery()调用parserSingle()，beforePrepare()调用parserMulti()


@Override
public void beforeQuery(Executor executor, MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {
    if (InterceptorIgnoreHelper.willIgnoreDataPermission(ms.getId())) {
        return;
    }
    PluginUtils.MPBoundSql mpBs = PluginUtils.mpBoundSql(boundSql);
    mpBs.sql(parserSingle(mpBs.sql(), ms.getId()));
}

@Override
public void beforePrepare(StatementHandler sh, Connection connection, Integer transactionTimeout) {
    PluginUtils.MPStatementHandler mpSh = PluginUtils.mpStatementHandler(sh);
    MappedStatement ms = mpSh.mappedStatement();
    SqlCommandType sct = ms.getSqlCommandType();
    if (sct == SqlCommandType.UPDATE || sct == SqlCommandType.DELETE) {
        if (InterceptorIgnoreHelper.willIgnoreDataPermission(ms.getId())) {
            return;
        }
        PluginUtils.MPBoundSql mpBs = mpSh.mPBoundSql();
        mpBs.sql(parserMulti(mpBs.sql(), ms.getId()));
    }
}

parserSingle()，parserMulti()是BaseMultiTableInnerInterceptor从JsqlParserSupport抽象类继承而来的，JsqlParserSupport是MyBatis-Plus基于JsqlParser（JSQLParser详见：SQL解析工具JSQLParser）封装的一个工具类，这个类的功能非常简单，作用是判断SQL是增删改查的哪一种类型，然后分别调用对应的方法开始解析。

public abstract class JsqlParserSupport {
    /**
     * 日志
     */
    protected final Log logger = LogFactory.getLog(this.getClass());

    public String parserSingle(String sql, Object obj) {
        if (logger.isDebugEnabled()) {
            logger.debug("original SQL: " + sql);
        }
        try {
            Statement statement = JsqlParserGlobal.parse(sql);
            return processParser(statement, 0, sql, obj);
        } catch (JSQLParserException e) {
            throw ExceptionUtils.mpe("Failed to process, Error SQL: %s", e.getCause(), sql);
        }
    }

    public String parserMulti(String sql, Object obj) {
        if (logger.isDebugEnabled()) {
            logger.debug("original SQL: " + sql);
        }
        try {
            // fixed github pull/295
            StringBuilder sb = new StringBuilder();
            Statements statements = JsqlParserGlobal.parseStatements(sql);
            int i = 0;
            for (Statement statement : statements) {
                if (i > 0) {
                    sb.append(StringPool.SEMICOLON);
                }
                sb.append(processParser(statement, i, sql, obj));
                i++;
            }
            return sb.toString();
        } catch (JSQLParserException e) {
            throw ExceptionUtils.mpe("Failed to process, Error SQL: %s", e.getCause(), sql);
        }
    }

    /**
     * 执行 SQL 解析
     *
     * @param statement JsqlParser Statement
     * @return sql
     */
    protected String processParser(Statement statement, int index, String sql, Object obj) {
        if (logger.isDebugEnabled()) {
            logger.debug("SQL to parse, SQL: " + sql);
        }
        if (statement instanceof Insert) {
            this.processInsert((Insert) statement, index, sql, obj);
        } else if (statement instanceof Select) {
            this.processSelect((Select) statement, index, sql, obj);
        } else if (statement instanceof Update) {
            this.processUpdate((Update) statement, index, sql, obj);
        } else if (statement instanceof Delete) {
            this.processDelete((Delete) statement, index, sql, obj);
        }
        sql = statement.toString();
        if (logger.isDebugEnabled()) {
            logger.debug("parse the finished SQL: " + sql);
        }
        return sql;
    }

    /**
     * 新增
     */
    protected void processInsert(Insert insert, int index, String sql, Object obj) {
        throw new UnsupportedOperationException();
    }

    /**
     * 删除
     */
    protected void processDelete(Delete delete, int index, String sql, Object obj) {
        throw new UnsupportedOperationException();
    }

    /**
     * 更新
     */
    protected void processUpdate(Update update, int index, String sql, Object obj) {
        throw new UnsupportedOperationException();
    }

    /**
     * 查询
     */
    protected void processSelect(Select select, int index, String sql, Object obj) {
        throw new UnsupportedOperationException();
    }
}

当调用parserSingle()或parserMulti()并传入SQL时，会在processParser()方法中先判断是哪一种Statement，然后分别强转为具体的Select、Update、Delete、Insert对象，再调用子类（例如：DataPermissionInterceptor）间接继承并重写的processSelect()、processDelete()、processUpdate()方法。

子类中的processSelect()方法会再调用父类BaseMultiTableInnerInterceptor中的processSelectBody()对查询进行解析，processUpdate()和processDelete()同理。这样设计的原因可能是由具体的子类根据功能来最终确定解析和重写逻辑，而BaseMultiTableInnerInterceptor只提供解析和重写能力不负责不同场景下的具体逻辑实现。

@Override
protected void processSelect(Select select, int index, String sql, Object obj) {
    if (dataPermissionHandler == null) {
        return;
    }
    if (dataPermissionHandler instanceof MultiDataPermissionHandler) {
        // 参照 com.baomidou.mybatisplus.extension.plugins.inner.TenantLineInnerInterceptor.processSelect 做的修改
        final String whereSegment = (String) obj;
        processSelectBody(select, whereSegment);
        List<WithItem> withItemsList = select.getWithItemsList();
        if (!CollectionUtils.isEmpty(withItemsList)) {
            withItemsList.forEach(withItem -> processSelectBody(withItem, whereSegment));
        }
    } else {
        // 兼容原来的旧版 DataPermissionHandler 场景
        if (select instanceof PlainSelect) {
            this.setWhere((PlainSelect) select, (String) obj);
        } else if (select instanceof SetOperationList) {
            SetOperationList setOperationList = (SetOperationList) select;
            List<Select> selectBodyList = setOperationList.getSelects();
            selectBodyList.forEach(s -> this.setWhere((PlainSelect) s, (String) obj));
        }
    }
}



/**
 * update 语句处理
 */
@Override
protected void processUpdate(Update update, int index, String sql, Object obj) {
    final Expression sqlSegment = getUpdateOrDeleteExpression(update.getTable(), update.getWhere(), (String) obj);
    if (null != sqlSegment) {
        update.setWhere(sqlSegment);
    }
}

/**
 * delete 语句处理
 */
@Override
protected void processDelete(Delete delete, int index, String sql, Object obj) {
    final Expression sqlSegment = getUpdateOrDeleteExpression(delete.getTable(), delete.getWhere(), (String) obj);
    if (null != sqlSegment) {
        delete.setWhere(sqlSegment);
    }
}

protected Expression getUpdateOrDeleteExpression(final Table table, final Expression where, final String whereSegment) {
    if (dataPermissionHandler == null) {
        return null;
    }
    if (dataPermissionHandler instanceof MultiDataPermissionHandler) {
        return andExpression(table, where, whereSegment);
    } else {
        // 兼容旧版的数据权限处理
        return dataPermissionHandler.getSqlSegment(where, whereSegment);
    }
}

三、源码解读

与更新和删除语句的解析相比，对查询语句进行解析和重写的逻辑是更加复杂的，步骤也更多，需要解析到SQL语句的各个部分，分为多个方法，方法间互相配合实现对复杂查询SQL语句的解析和重写

执行的大致流程如下：

如SQL结构复杂，需要先将一个复杂SQL拆分为若干简单SQL，然后依次对每个SQL需要重写条件的地方（select xx，from xx，join xx，where xx）进行表和条件解析然后追加过滤条件，如果遇到子查询需要递归解析子查询直到SQL所有部分都被解析到

3.1 processSelectBody

该方法是解析SELECT语句的入口方法，会先对复杂的SELECT语句进行简化拆分，再分别调用processPlainSelect()来解析每个部分

protected void processSelectBody(Select selectBody, final String whereSegment) {
    if (selectBody == null) {
        return;
    }
    if (selectBody instanceof PlainSelect) {
        processPlainSelect((PlainSelect) selectBody, whereSegment);
    } else if (selectBody instanceof ParenthesedSelect) {
        ParenthesedSelect parenthesedSelect = (ParenthesedSelect) selectBody;
        processSelectBody(parenthesedSelect.getSelect(), whereSegment);
    } else if (selectBody instanceof SetOperationList) {
        SetOperationList operationList = (SetOperationList) selectBody;
        List<Select> selectBodyList = operationList.getSelects();
        if (CollectionUtils.isNotEmpty(selectBodyList)) {
            selectBodyList.forEach(body -> processSelectBody(body, whereSegment));
        }
    }
}

解读：

该方法传入一个jsqlparser的Select对象，因为有的SELECT语句结构比较复杂，需要化繁为简进行拆分然后对每个部分分别进行解析，这里MyBatis-Plus考虑了三种情况：

PlainSelect：最标准的SELECT语句格式，直接调用processPlainSelect(PlainSelect plainSelect)方法开始解析即可
ParenthesedSelect：带括号的子查询，先去掉括号，将括号内SELECT语句再次调用processSelectBody(Select select)进行递归解析，直到格式满足PlainSelect
SetOperationList：多个SELECT语句通过UNION、UNION ALL等组合为一个整体的SELECT语句的情况，分别拆开取出每一段SELECT，将每一段SELECT再次调用processSelectBody(Select select)进行递归解析，直到格式满足PlainSelect

还有一种select语句中带有with的情况，要把with中的查询语句提取进行解析，不过不是在这里处理的，而是在子类的processSelect方法中，调用processSelectBody方法之后

3.2 processPlainSelect

该方法用于开启一个对常规形式的SELECT语句的解析

protected void processPlainSelect(final PlainSelect plainSelect, final String whereSegment) {
    //#3087 github
    List<SelectItem<?>> selectItems = plainSelect.getSelectItems();
    if (CollectionUtils.isNotEmpty(selectItems)) {
        selectItems.forEach(selectItem -> processSelectItem(selectItem, whereSegment));
    }

    // 处理 where 中的子查询
    Expression where = plainSelect.getWhere();
    processWhereSubSelect(where, whereSegment);

    // 处理 fromItem
    FromItem fromItem = plainSelect.getFromItem();
    List<Table> list = processFromItem(fromItem, whereSegment);
    List<Table> mainTables = new ArrayList<>(list);

    // 处理 join
    List<Join> joins = plainSelect.getJoins();
    if (CollectionUtils.isNotEmpty(joins)) {
        processJoins(mainTables, joins, whereSegment);
    }

    // 当有 mainTable 时，进行 where 条件追加
    if (CollectionUtils.isNotEmpty(mainTables)) {
        plainSelect.setWhere(builderExpression(where, mainTables, whereSegment));
    }
}

解读：

该方法分别对SELECT语句中需要追加条件的部位进行解析，包括SELECT部分的[SelectItem] ，FROM部分的[FromItem]，WHERE后面的条件(中的子查询)[Expression]，JOIN连接查询的部分[JOIN]

SELECT
    [SelectItem] 
FROM
    [FromItem]
LEFT/RIGHT/INNER JOIN [JOIN]
WHERE
    [Expression]

解析完成后会调用plainSelect.setWhere(builderExpression(where, mainTables))对需要最终查出所有数据的驱动表进行WHERE条件重写，详见：3.10 buildTableExpression，到底哪个表是驱动表，会由processJoins方法进行计算确认，具体见：3.7 processJoins

3.3 processSelectItem

该方法用于解析和重写SELECT列表中带有SELECT的语法结构

protected void processSelectItem(SelectItem selectItem, final String whereSegment) {
    Expression expression = selectItem.getExpression();
    if (expression instanceof Select) {
        processSelectBody(((Select) expression), whereSegment);
    } else if (expression instanceof Function) {
        processFunction((Function) expression, whereSegment);
    } else if (expression instanceof ExistsExpression) {
        ExistsExpression existsExpression = (ExistsExpression) expression;
        processSelectBody((Select) existsExpression.getRightExpression(), whereSegment);
    }
}

解读：

该方法会对SELECT列表项中的子查询语句，函数参数中的SELECT语句和EXIST结构中的SELECT语句进行解析

SQL举例说明：

SELECT 
    id,
    employee_id,
    fun_first_name( (select n from users u where u.id = e.uid) ) as first_name ,
    (select last_name from users u where u.id = e.uid) as last_name,
    EXISTS(SELECT 1 FROM projects WHERE manager_id = e.employee_id)  AS is_manager
FROM 
    employees e;

解析并处理后得到SQL：

SELECT 
    id, 
    employee_id, 
    fun_first_name((SELECT n FROM users u WHERE u.id = e.uid AND users.scope = 12)) AS first_name, 
    (SELECT last_name FROM users u WHERE u.id = e.uid AND users.scope = 12) AS last_name, 
    EXISTS (SELECT 1 FROM projects WHERE manager_id = e.employee_id AND projects.scope = 12) AS is_manager 
FROM
    employees e
WHERE 
    employees.scope = 12

EXISTS (...) as ..不能写成( EXISTS (...) ) as ..，否则不会被解析为Select而是会被解析为Parenthesis，而该方法没有提供Parenthesis的解析，会导致被忽略

3.4 processWhereSubSelect

该方法用于对WHERE后面的SQL语句结构进行解析和追加过滤条件，主要是在分段拆分解析where表达式，代码实现的方式非常精巧，分析起来自然稍微有一点难度，但是远比processJoins()简单的多。

protected void processWhereSubSelect(Expression where, final String whereSegment) {
    if (where == null) {
        return;
    }
    if (where instanceof FromItem) {
        processOtherFromItem((FromItem) where, whereSegment);
        return;
    }
    if (where.toString().indexOf("SELECT") > 0) {
        /* 通过if (where.toString().indexOf("SELECT") > 0)判断当前的where语句中是否含有select关键字
        如果有的话说明where条件后的表达式存在子查询，又会马上进入以下逻辑对子查询的表进行解析和追加条件*/
        if (where instanceof BinaryExpression) {
            // 比较符号 , and , or , 等等
            BinaryExpression expression = (BinaryExpression) where;
            processWhereSubSelect(expression.getLeftExpression(), whereSegment);
            processWhereSubSelect(expression.getRightExpression(), whereSegment);
        }
        else if (where instanceof InExpression) {
            // in
            InExpression expression = (InExpression) where;
            Expression inExpression = expression.getRightExpression();
            // in的是子查询才处理
            if (inExpression instanceof Select) {
                processSelectBody(((Select) inExpression), whereSegment);
            }
        } 
        else if (where instanceof ExistsExpression) {
            // exists
            ExistsExpression expression = (ExistsExpression) where;
            processWhereSubSelect(expression.getRightExpression(), whereSegment);
        } 
        else if (where instanceof NotExpression) {
            // not exists , not in ...
            // 如果是not的结构，还需要expression.getExpression()后再递归调用processWhereSubSelect()特殊处理
            NotExpression expression = (NotExpression) where;
            processWhereSubSelect(expression.getExpression(), whereSegment);
        } 
        else if (where instanceof Parenthesis) {
            Parenthesis expression = (Parenthesis) where;
            processWhereSubSelect(expression.getExpression(), whereSegment);
        }
    }
}

解读：

传进来的参数Expression where是一个JSQLParser的Expression类型，因为WHERE条件中可能解析出很多不同类型的SQL语法结构，这些结构都在processWhereSubSelect方法中一并处理，因此这里用了一个偏底层可以泛指这些结构的Expression对象作为参数，主要需要处理的就是子查询和返回布尔值的各种表达式。

解析时首先判断传进来的Expression是否为FromItem结构(通常就是子查询)，如是直接传入processOtherFromItem()处理子查询，否则进一步判断该结构的语句体中是否有where关键字，如有说明存在子查询需要进一步处理，接着就会判断该结构是否为为比较符号(and，or, =, >等)衔接的BinaryExpression结构。

如果是BinaryExpression结构则先拆分为左右两部分，拆成的左右两部分可能有一侧还是BinaryExpression结构，甚至两侧都还是BinaryExpression结构，这样的话就要递归调用processWhereSubSelect()方法将拆分后的结构再次拆分，这样整个表达式便越拆越小，直到某个拆出的结构满足where instanceof FromItem后，再把该结构传入processOtherFromItem()处理子查询。

如果拆出的结构既不是FromItem又不是BinaryExpression，则需要再判断它是否属于in, exists，如是且有子查询结构，则将子查询剔出调用processSelectBody()进行解析子查询。

如果是not的结构，还需要expression.getExpression()后再递归调用processWhereSubSelect()特殊处理，因为not的情况比较特殊，不能一口气把子查询剔干净，实测not exists(select ...)不能拆出(select ...)，只能先拆分出exists(select ...)，再调用processWhereSubSelect走到else if (where instanceof ExistsExpression)分支后再拆出(select ...)，not in同理，因此NotExpression结构不能直接拿到子查询，剔出来的是not后面的结构，要再递归调用processWhereSubSelect()，而不是直接processSelectBody()。

案例说明：

SELECT name 
FROM user u 
WHERE u.math_score < (SELECT avg(score) FROM math ) 
OR u.english_score > (SELECT avg(score) FROM english ) 
AND (SELECT order_num FROM student ) = u.order_num 
AND u.role_id IN (SELECT id FROM role ) 
AND EXISTS ( SELECT * FROM customer WHERE id = 6 )
AND NOT EXISTS ( SELECT * FROM customer WHERE id = 7 )

在这段SQL中，通过plainSelect.getWhere()得到的where的部分是：u.math_score < (SELECT avg(score) FROM math) OR u.english_score > (SELECT avg(score) FROM english) AND (SELECT order_num FROM student) = u.order_num AND u.role_id IN (SELECT id FROM role) AND EXISTS (SELECT * FROM customer WHERE id = 6) AND NOT EXISTS (SELECT * FROM customer WHERE id = 7)，该部分会作为参数传入Expression where中，这段复杂的where表达式中的子查询是采用拆分的方法解析到的，具体解析和追加的步骤如下：

第一次拆分：首先where结构被整个传入，where instanceof FromItem == false且where instanceof BinaryExpression == true，整个where表达式将被processWhereSubSelect(expression.getLeftExpression(), whereSegment)拆分为：

expression.getLeftExpression() => u.math_score < (SELECT avg(score) FROM math)
expression.getRightExpression() => u.english_score > (SELECT avg(score) FROM english) AND (SELECT order_num FROM student) = u.order_num AND u.role_id IN (SELECT id FROM role) AND EXISTS (SELECT * FROM customer WHERE id = 6) AND NOT EXISTS (SELECT * FROM customer WHERE id = 7)

第二次拆分：执行到processWhereSubSelect(expression.getLeftExpression(), whereSegment)处，将u.math_score < (SELECT avg(score) FROM math)传入processWhereSubSelect递归解析，这次执行仍然满足where instanceof FromItem == false，where instanceof BinaryExpression == true，u.math_score < (SELECT avg(score) FROM math)将被拆分为：

expression.getLeftExpression() => u.math_score
expression.getRightExpression() => (SELECT avg(score) FROM math)

接下来还会递归执行到processWhereSubSelect(expression.getLeftExpression(), whereSegment)处，将u.math_score传入processWhereSubSelect递归解析，没有满足条件的分支直接跳过，紧接着执行processWhereSubSelect(expression.getRightExpression(), whereSegment)，将(SELECT avg(score) FROM math)传入processWhereSubSelect递归解析，这次执行满足where instanceof FromItem的条件，不需要拆分，执行processOtherFromItem对(SELECT avg(score) FROM math)进行过滤条件追加，至此，第一步拆分拆出来的bexpression.getLeftExpression()部分解析处理完成，第一段递归随即跳出。

第三次拆分：第一步拆分出来的expression.getRightExpression()开始传入processWhereSubSelect进行递归解析，这部分也满足where instanceof FromItem == false，where instanceof BinaryExpression == true，将被拆分为：

expression.getLeftExpression() => u.english_score > (SELECT avg(score) FROM english) AND (SELECT order_num FROM student) = u.order_num AND u.role_id IN (SELECT id FROM role) AND EXISTS (SELECT * FROM customer WHERE id = 6)
expression.getRightExpression() => NOT EXISTS (SELECT * FROM customer WHERE id = 7)

同理，取出expression.getLeftExpression()进行第四次拆分：