多租户实现方案探索与应用

麦金缦图coder

点击关注上方蓝字，阅读更多干货~

1 前言

多租户（Multi-Tenancy）是一种软件架构模式，其中单个软件实例可以同时服务于多个租户（Tenant）。租户是指独立的组织、公司或个人，他们使用共享的软件系统，并且每个租户之间的数据和配置是相互隔离的。

在多租户架构中，每个租户都有各自的虚拟实例，包括数据库、应用程序和用户界面。这样可以实现租户之间的数据隔离，确保每个租户的数据安全和隐私。同时多租户架构可以实现资源共享，降低系统维护和运营成本。

2 什么是多租户技术

多租户技术或称多重租赁技术，简称多租户技术，是一种软件架构技术，允许多个用户或组织共享同一个软件应用程序、服务或基础设施，同时保持彼此之间的逻辑和数据隔离。

例如，在多租户技术之前软件产品销售并交付给客户，需要到客户现场交付或重复部署一套系统，这种模式简单，但是扩展性和维护成本较高；而在多租户技术架构实现下，将不同租户的数据存储在同一个数据库中，但通过数据隔离和多租户架构来确保数据之间的逻辑和物理隔离。每个租户都有自己的数据表或模式，以实现数据的隔离和安全性。这种方式在数据共享和管理方面更加灵活。

图1 软件产品多租户场景交付发展前后对比

3 多租户实现方案

3.1 独立数据库

在独立数据库的情况下，每个租户都有自己独立的数据库实例，用于存储和管理其相关的数据，具有以下优点：

独立数据库确保了不同租户之间数据的完全隔离，避免数据混淆和泄露的风险。
独立数据库允许对每个租户的资源进行独立分配和管理。这样可以根据租户的需求和负载情况进行资源调整，优化系统的性能和可扩展性。
独立数据库简化了系统的维护和备份操作。

图2 独立数据库模型的多租户实现

3.2 共享数据库，隔离数据表

隔离数据表是在共享数据库的基础上，为每个租户创建独立的数据表空间。每个租户拥有自己的数据表集合，只能访问和操作自己的数据表。这种隔离级别可进一步增强数据的安全性和隐私保护，避免租户之间的数据混淆和干扰。具有以下优点：

资源节约：共享数据库可以节约资源，避免为每个租户都创建独立的数据库实例。这样可以减少服务器的数量和维护成本，并提高资源利用率。适用于租户之间的数据访问模式相似或数据量较小的情况。
数据共享：共享数据库允许不同租户之间共享部分数据，促进协作和数据交互。对于某些业务场景，租户可能需要共享一些公共数据，例如用户信息、产品目录等。通过共享数据库，可以简化数据共享和协作的管理，提高系统的灵活性和效率。
隔离数据表：尽管共享数据库，但通过隔离数据表可以确保租户之间的数据隔离和安全性。每个租户拥有自己独立的数据表空间，只能访问和操作自己的数据表。这种隔离级别提供了更高的数据保护和安全性，防止数据泄露和干扰。

图3 共享数据库，隔离数据表模型的多租户实现

3.3 共享数据库，共享数据表

多租户共享数据库是指在一个系统或平台中，为多个独立的客户（也称为租户）提供服务和资源时，使用同一个数据库实例。具体来说，多租户系统中的数据库是在物理上共享的，但在逻辑上是隔离的，每个租户只能访问自己的数据。简单来说，使用同一个数据库，同一个表，在表中增加了租户ID 字段做逻辑隔离。具有以下优点：

节约资源：使用共享数据库和共享数据表，可以减少数据库实例和数据表空间的数量，从而节约服务器和存储资源，提高资源利用率。
简化管理：共享数据库和共享数据表可以简化管理，减少管理员的工作量，提高系统的可维护性和可扩展性。
跨租户分析：共享数据库和共享数据表使得多个租户的数据可以在同一数据存储中查询和分析，从而方便了跨租户数据分析和报告的生成，为租户提供全局的、综合的业务洞察。

图4 共享数据库，共享数据表模型的多租户实现

图5 用户表增加租户ID视图

3.4 三种解决方案优缺点

隔离方案	成本	支持租户用户数量	隔离级别	维护成本	故障情况下，数据恢复复杂度
独立数据库	高	少	好	高	容易
共享数据库，隔离数据表	中	较多	较为安全	中	较为困难
共享数据库，共享数据表	底	非常多	底	低	困难

每个技术方案有对应的优缺点，具体问题具体分析，需要根据自身的业务场景选择对应的解决方案。

独立数据库适用于金融、医疗等对数据的隔离和安全性要求非常高的领域；共享数据库，隔离数据表适用于租户之间的数据相对较为独立，但仍需要共享一些公共资源和提高数据管理效率的场景，如客户信息、销售机会等数据需要被不同用户以及各自的团队所共享和协同编辑的 CRM 系统；共享数据库，共享数据表适用于以最少的维护成本为最多的租户提供服务，并且接受牺牲隔离级别换取降低成本的业务场景。

3.5
三种解决方案技术方案

3.5.1 独立数据库技术方案

此情况分为两种，同个实例的不同数据库，此方案实现类似于「3.5.2 共享数据库，隔离数据表技术方案实现」。租户在「增删插改」操作数据时可以通过 Mybatis-plus 拦截器添加动态数据库名的方式实现，效果如下：

-- 租户id 为 1 的数据库名称为db_00000001，租户id 为 2 的数据库名称为db_00000002-- 业务代码 xml SQL，查询合同表：select * from document;-- 通过 Mybatis-plus 拦截器添加动态数据库名的方式，租户 id 为 1 情况下查询合同表select * from `db_00000001`.document;

而不同实例的数据库实现多租户较为复杂，需要在执行过程中不停动态切换数据源，还要考虑多个数据源之间的事务控制，搜索资料都是推荐第三方框架：Dynamic-datasource，一个基于SpringBoot的快速集成多数据源的启动器。

3.5.2 共享数据库，隔离数据表技术方案

所有租户数据共用一个数据库，不同租户的业务数据表使用租户id 为后缀，创建租户时，则需要创建相对应租户的数据表，可以使用阿里云的 DMS 工具或者数据库脚本创建。如果业务表信息变更，则需要将所有的租户表都需要进行相应的变更，这就导致维护较为复杂，租户在「增删插改」操作数据时可以通过 Mybatis-plus 拦截器添加动态数据表名的方式实现，效果如下：

-- 合同表，租户id 为 1 的合同表为document_00000001，租户id 为 2 的合同表为document_00000002-- 业务代码 xml SQL，查询合同表：select * from document;-- 通过 Mybatis-plus 拦截器添加动态数据库名的方式，租户 id 为 1 情况下查询合同表select * from `document_00000001`.document;

3.5.3 共享数据库，共享数据表技术方案

所有租户数据共用一个数据库，共享数据表，仅仅是在每个业务表中增加tenant_id字段用于区分不同的租户数据，用户登录系统，从Header头传递租户信息，租户在「增删插改」操作数据时，在原sql语句基础上拼接对应的tenant_id，这种可以通过 AOP切面方式或者Mybatis-plus 拦截器实现，确保数据之间的隔离，效果如下：

-- 业务代码 xml SQL，查询合同表：select * from document;-- 通过 Mybatis-plus 拦截器拼接 租户id 的方式，租户 id 为 1 情况下查询合同表select * from document where tenant_id = 1;

3.5.4 总结

不同实例的数据库实现多租户插件复杂，当遇到故障时，数据恢复也较为简单，但是这种方案需要单独的实例独立数据库，代码复杂度以及成本很高，这种场景适合银行开发类系统。

同个实例的不同数据库，以及同个数据库不同数据表的方案提供了一定的数据隔离，但是数据隔离不彻底，遇到业务表信息变更，则需要将所有的租户表都需要进行相应的变更，这就导致维护较为复杂。

同个数据库同个数据表方案成本最低，但是所有数据在一起，数据隔离性也是最低的，这就导致单个租户的数据恢复以及备份很复杂。

以最少的维护成本为最多的租户提供服务，并且接受牺牲隔离级别换取降低成本，「共享数据库，共享数据表」解决方案最为合适，接下来讲解「共享数据库，共享数据表」的具体技术实现方案。

4 共享数据库，共享数据表技术方案实现

4.1 基于 Mybatis-plus 实现多租户技术

Mybatis-plus官方提供多租户插件实现多租户技术。多租户插件实现InnerInterceptor类，而InnerInterceptor类作用实际就是拦截器，多租户插件在SQL语句构建阶段注入tenant_id字段，详情见下文「Mybatis-plus 多租户插件详解」。

4.2 基于 Mybatis 实现多租户技术

Mybatis实现多租户技术，需要手动实现拦截器，拦截SQL语句在构建阶段注入tenant_id字段，简单示例如下，实现TenantInterceptor拦截器：

public class TenantInterceptor implements Interceptor {    @Override    public Object intercept(Invocation invocation) throws Throwable {        MappedStatement mappedStatement = (MappedStatement) invocation.getArgs()[0];        Object parameter = invocation.getArgs()[1];        BoundSql boundSql = mappedStatement.getBoundSql(parameter);
        // 获取当前租户标识，可以从 ThreadLocal、Spring Security 等获取        String tenantId = getCurrentTenantId();
        String sql = boundSql.getSql();        String newSql = sql + " WHERE tenant_id = '" + tenantId + "'";
        BoundSql newBoundSql = new BoundSql(mappedStatement.getConfiguration(), newSql,            boundSql.getParameterMappings(), parameter);        MappedStatement newMappedStatement = copyFromMappedStatement(mappedStatement, new BoundSqlSqlSource(newBoundSql));
        invocation.getArgs()[0] = newMappedStatement;
        return invocation.proceed();    }
    // 实现其他必要的方法...}

在MyBatis配置文件中注册自定义Interceptor。在<plugins>部分添加如下内容：

<plugins>    <plugin interceptor="com.example.TenantInterceptor"/></plugins>

在业务代码中，当执行查询或更新操作时，MyBatis将会自动调用拦截器中的逻辑，确保SQL语句会被添加上租户标识条件。

4.3 基于 JdbcTemplate 实现多租户技术

JdbcTemplate实现多租户功能也可以通过拦截器和动态SQL来实现，和Mybatis类似，简单示例如下：

实现Interceptor，实现StatementInterceptor接口的beforeExecution拦截SQL执行。

public class TenantStatementInterceptor implements StatementInterceptor {    @Override    public void beforeExecution(PreparedStatement ps) {        String tenantId = getCurrentTenantId();
        try {            // 获取原始 SQL 语句            String originalSql = ps.toString();
            // 修改 SQL 语句，添加租户标识条件            String newSql = originalSql + " WHERE tenant_id = '" + tenantId + "'";
            // 替换 PreparedStatement 中的 SQL            Field field = ps.getClass().getDeclaredField("sql");            field.setAccessible(true);            field.set(ps, newSql);        } catch (Exception e) {            // 处理异常        }    }}

<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">    <property name="dataSource" ref="dataSource" />    <property name="statementInterceptors">        <list>            <ref bean="tenantStatementInterceptor" />        </list>    </property></bean>
<bean id="tenantStatementInterceptor" class="com.example.TenantStatementInterceptor" />

在业务代码中，当执行查询或更新操作时，JdbcTemplate将会自动调用拦截器中的逻辑，确保SQL语句会被添加上租户标识条件。

4.4 总结

基于Mybatis-plus MybatisJdbcTemplate技术实现多租户方案，发现实现方案大同小异，都是基于SQL语句的拦截，实现在语句上拼接上租户标识，而Mybatis-plus官方提供了TenantLineInnerInterceptor插件，支持特殊的SQL语句。基于共享数据库，共享数据表的实现方式，具有数据隔离性、易于维护、扩展性、安全性、灵活配置的优点。

5 Mybatis-plus 多租户插件详解

Mybatis插件，实际上就是一个拦截器，应用代理模式，在方法级别上进行拦截。可以实现分页、SQL打印监控、公共字段赋值等功能，基本上可以控制SQL执行的各个阶段，如执行阶段，参数处理阶段，语法构建阶段，结果集处理阶段，具体可以根据项目业务来实现对应业务逻辑。Mybatis-plus提供 InnerInterceptor来实现插件功能。

5.1 TenantLineInnerInterceptor 类源码分析

TenantLineInnerInterceptor类，实现InnerInterceptor接口，其作用是 sql 拦截器，继承JsqlParserSupport类，其作用是 sql 解析。

5.1.1 TenantLineInnerInterceptor 拦截器实现原理

InnerInterceptor接口方法功能：

public interface InnerInterceptor {
    /**     * 判断是否执行 {@link Executor#query(MappedStatement, Object, RowBounds, ResultHandler, CacheKey, BoundSql)}     * <p>     * 如果不执行query操作,则返回 {@link Collections#emptyList()}     *     * @param executor      Executor(可能是代理对象)     * @param ms            MappedStatement     * @param parameter     parameter     * @param rowBounds     rowBounds     * @param resultHandler resultHandler     * @param boundSql      boundSql     * @return 新的 boundSql     */    default boolean willDoQuery(Executor executor, MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {        return true;    }
    /**     * {@link Executor#query(MappedStatement, Object, RowBounds, ResultHandler, CacheKey, BoundSql)} 操作前置处理     * <p>     * 改改sql啥的     *     * @param executor      Executor(可能是代理对象)     * @param ms            MappedStatement     * @param parameter     parameter     * @param rowBounds     rowBounds     * @param resultHandler resultHandler     * @param boundSql      boundSql     */    default void beforeQuery(Executor executor, MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {        // do nothing    }
    /**     * 判断是否执行 {@link Executor#update(MappedStatement, Object)}     * <p>     * 如果不执行update操作,则影响行数的值为 -1     *     * @param executor  Executor(可能是代理对象)     * @param ms        MappedStatement     * @param parameter parameter     */    default boolean willDoUpdate(Executor executor, MappedStatement ms, Object parameter) throws SQLException {        return true;    }
    /**     * {@link Executor#update(MappedStatement, Object)} 操作前置处理     * <p>     * 改改sql啥的     *     * @param executor  Executor(可能是代理对象)     * @param ms        MappedStatement     * @param parameter parameter     */    default void beforeUpdate(Executor executor, MappedStatement ms, Object parameter) throws SQLException {        // do nothing    }
    /**     * {@link StatementHandler#prepare(Connection, Integer)} 操作前置处理     * <p>     * 改改sql啥的     *     * @param sh                 StatementHandler(可能是代理对象)     * @param connection         Connection     * @param transactionTimeout transactionTimeout     */    default void beforePrepare(StatementHandler sh, Connection connection, Integer transactionTimeout) {        // do nothing    }
    /**     * {@link StatementHandler#getBoundSql()} 操作前置处理     * <p>     * 只有 {@link BatchExecutor} 和 {@link ReuseExecutor} 才会调用到这个方法     *     * @param sh StatementHandler(可能是代理对象)     */    default void beforeGetBoundSql(StatementHandler sh) {        // do nothing    }
    default void setProperties(Properties properties) {        // do nothing    }}

TenantLineInnerInterceptor多租户插件实现InnerInterceptor接口：

@Override/**   * sql 前置操作操作，改改 sql 啥的   * Executor executor 可能是代理对象   */public void beforeQuery(Executor executor, MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {    // 第一步    // @InterceptorIgnore(tenantLine = "true") 注解的作用    // 如果开启了这个忽略租户插件注解直接返回    if (InterceptorIgnoreHelper.willIgnoreTenantLine(ms.getId())) return;    // ms 执行 sql 的 map 相关信息，id 就是 xml 方法里面，比如：id com.baomidou.mybatisplus.samples.tenant.mapper.UserMapper.myCount    // bound 就是 sql 的信息，参数等    PluginUtils.MPBoundSql mpBs = PluginUtils.mpBoundSql(boundSql);    // 获取 sql 语句    mpBs.sql(parserSingle(mpBs.sql(), null));}
@Overridepublic 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.INSERT || sct == SqlCommandType.UPDATE || sct == SqlCommandType.DELETE) {        if (InterceptorIgnoreHelper.willIgnoreTenantLine(ms.getId())) {            return;        }        PluginUtils.MPBoundSql mpBs = mpSh.mPBoundSql();        mpBs.sql(parserMulti(mpBs.sql(), null));    }}

Mybatis-plus插件配置，注册多租户插件：

@Beanpublic MybatisPlusInterceptor mybatisPlusInterceptor() {    MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();    interceptor.addInnerInterceptor(new TenantLineInnerInterceptor(new TenantLineHandler() {        @Override        public Expression getTenantId() {            // 租户的信息            return new LongValue(1);        }
        // 这是 default 方法,默认返回 false 表示所有表都需要拼多租户条件        @Override        public boolean ignoreTable(String tableName) {            return false;        }    }));    return interceptor;}

MybatisPlusInterceptor调用实现了Interceptor接口并注册的拦截器：

public class MybatisPlusInterceptor implements Interceptor {
    @Setter    private List<InnerInterceptor> interceptors = new ArrayList<>();
    @Override    public Object intercept(Invocation invocation) throws Throwable {        Object target = invocation.getTarget();        Object[] args = invocation.getArgs();        if (target instanceof Executor) {            final Executor executor = (Executor) target;            Object parameter = args[1];            boolean isUpdate = args.length == 2;            MappedStatement ms = (MappedStatement) args[0];            if (!isUpdate && ms.getSqlCommandType() == SqlCommandType.SELECT) {                RowBounds rowBounds = (RowBounds) args[2];                ResultHandler resultHandler = (ResultHandler) args[3];                BoundSql boundSql;                if (args.length == 4) {                    boundSql = ms.getBoundSql(parameter);                } else {                    // 几乎不可能走进这里面,除非使用Executor的代理对象调用query[args[6]]                    boundSql = (BoundSql) args[5];                }                for (InnerInterceptor query : interceptors) {                    if (!query.willDoQuery(executor, ms, parameter, rowBounds, resultHandler, boundSql)) {                        return Collections.emptyList();                    }                    query.beforeQuery(executor, ms, parameter, rowBounds, resultHandler, boundSql);                }                CacheKey cacheKey = executor.createCacheKey(ms, parameter, rowBounds, boundSql);                return executor.query(ms, parameter, rowBounds, resultHandler, cacheKey, boundSql);            } else if (isUpdate) {                for (InnerInterceptor update : interceptors) {                    if (!update.willDoUpdate(executor, ms, parameter)) {                        return -1;                    }                    update.beforeUpdate(executor, ms, parameter);                }            }        } else {            // StatementHandler            final StatementHandler sh = (StatementHandler) target;            // 目前只有StatementHandler.getBoundSql方法args才为null            if (null == args) {                for (InnerInterceptor innerInterceptor : interceptors) {                    innerInterceptor.beforeGetBoundSql(sh);                }            } else {                Connection connections = (Connection) args[0];                Integer transactionTimeout = (Integer) args[1];                for (InnerInterceptor innerInterceptor : interceptors) {                    innerInterceptor.beforePrepare(sh, connections, transactionTimeout);                }            }        }        return invocation.proceed();    }}

5.1.2 多租户插件配置实现原理

通过@AllArgsConstructor注解，用于实例化TenantLineInnerInterceptor，需传递租户处理器TenantLineHandler接口参数，用于后续多租户插件应用配置。

图6 TenantLineInnerInterceptor 类的多租户配置自动注入

public interface TenantLineHandler {
    /**     * 获取租户 ID 值表达式，只支持单个 ID 值     * <p>     *     * @return 租户 ID 值表达式     */    Expression getTenantId();
    /**     * 获取租户字段名     * <p>     * 默认字段名叫: tenant_id     *     * @return 租户字段名     */    default String getTenantIdColumn() {        return "tenant_id";    }
    /**     * 根据表名判断是否忽略拼接多租户条件     * <p>     * 默认都要进行解析并拼接多租户条件     *     * @param tableName 表名     * @return 是否忽略, true:表示忽略，false:需要解析并拼接多租户条件     */    default boolean ignoreTable(String tableName) {        return false;    }
    /**     * 忽略插入租户字段逻辑     *     * @param columns        插入字段     * @param tenantIdColumn 租户 ID 字段     * @return     */    default boolean ignoreInsert(List<Column> columns, String tenantIdColumn) {        return columns.stream().map(Column::getColumnName).anyMatch(i -> i.equalsIgnoreCase(tenantIdColumn));    }}

5.2 JsqlParserSupport 主要类解析

Mybatis-plus官方是使用JsqlParserSupport解析SQL成语法树，特此对一些主要类分析。

5.2.1 PlainSelect 类解析

实现了SelectBody接口，而SelectBody可以理解为Select语句对象，以select sql语句为例。

查询用户信息，并且内联user_addrs表：

-- plainSelect 就是整条 sql 语句select users.id, users.name, users.tenant_idfrom usersjoin user_addrs on users.id = user_addrs.idwhere id in (1, 2, 3);

图7 PlainSelect 类属性

user.id, users.name, users.tenant_id 是SelectItem类信息
users是FromItem类信息
users_addrs on users.id = user_addrs.id 是Join类信息
id in (1,2,3)是Expression类信息

图8 select sql 语句解析成对象

5.2.2 SubSelect 类解析

针对使用子查询sql语句，将子查询的语句转换SubSelect类：

select *from userswhere id in (select user_id from user_addrs)

select user_id from user_addrs是SubSelect类信息

图9 子查询 sql 语句运行断点

5.2.3 WithItem 类解析

with其实就是一个子查询抽取出来，换了一个别名，和视图的区别：with as等同于一次性视图，只会持续到下一个查询，在之后就不能再被引用。with语法，不适用于mysql 8.0版本之前。简单的with as sql语句：

-- 经过 JSqlParser 解析之后，WithItem 是 select * from userswith a as (select * from users) select * from a;

select * from users是WithItem类信息

图10 WithItem 类属性

5.2.4 SetOperationList 类解析

当我们使用INTERSECT、EXCEPT、MINUS、UNION这些交并集查询时，就会转换为SetOperationList对象。

图11 union sql 语句运行断点

select id from users union select user_id from user_addrs 是SetOperationList类信息
select id from users和select user_id from user_addrs 是SelectBodyList类信息

5.2.5 Insert 类解析

针对Insertsql语句的转换Insert类：

图12 insert sql 语句解析成对象截图

user_addrs是Table类信息
id, user_id, name, tenant_id, create_time, update_time 是Column类信息
(3, 3, 'Tom Home', 2, '2023-03-08 18:01:47', '2023-03-08 18:01:47')和(4, 4, 'Sandy Home', 3, '2023-03-08 18:01:47', '2023-03-08 18:01:47')是ItemsList类信息

5.3 多租户插件 SQL 语句各场景源码解析

实现多租户插件针对 SQL 语句各种场景下拼接租户ID。

图13 多租户插件处理各 sql 语句业务逻辑流转

5.3.1 多租户插件Select语句执行源码解析

图14 多租户插件Select语句执行源码流程图

Mybatis-Plus多租户插件在执行select语句时，会调用MybatisPlusInterceptor类的intercept方法，作用是对sql语句进行解析和修改。再调用多租户插件的beforeQuery方法，至此已进入多租户插件流程，多租户插件首先对sql进行解析并组装各种有含义的类，依次执行：

processSelectBody方法：处理select语句，处理并拆分with as语句，处理并拆分intersect,except,minus,union语句

protected void processSelectBody(SelectBody selectBody) {    if (selectBody == null) {        return;    }    if (selectBody instanceof PlainSelect) {        // 处理 select 语句        processPlainSelect((PlainSelect) selectBody);    } else if (selectBody instanceof WithItem) {        // 处理 with as 语句        WithItem withItem = (WithItem) selectBody;        processSelectBody(withItem.getSubSelect().getSelectBody());    } else {        // 处理 INTERSECT、EXCEPT、MINUS、UNION 语句        SetOperationList operationList = (SetOperationList) selectBody;        List<SelectBody> selectBodyList = operationList.getSelects();        if (CollectionUtils.isNotEmpty(selectBodyList)) {            selectBodyList.forEach(this::processSelectBody);        }    }}

processSelectItem方法：处理select字段，包含处理子查询，方法函数场景
processWhereSubSelect方法：处理where条件的子查询，包含处理子查询以及!=, or, and, exist, in等场景
processFromItem方法：处理from表，包含处理临时表场景
processJoins方法：处理join表，包含处理子查询，内连接，右链接，左链接场景

/**     * 处理 PlainSelect     */protected void processPlainSelect(PlainSelect plainSelect) {    // 处理 select 的子查询    List<SelectItem> selectItems = plainSelect.getSelectItems();    if (CollectionUtils.isNotEmpty(selectItems)) {        selectItems.forEach(this::processSelectItem);    }
    // 处理 where 中的子查询    Expression where = plainSelect.getWhere();    processWhereSubSelect(where);
    // 获取 主表    FromItem fromItem = plainSelect.getFromItem();    // 获取 table，处理 From 表子查询    List<Table> list = processFromItem(fromItem);    List<Table> mainTables = new ArrayList<>(list);
    // 处理 join    List<Join> joins = plainSelect.getJoins();    if (CollectionUtils.isNotEmpty(joins)) {        mainTables = processJoins(mainTables, joins);    }
    // 当有 mainTable 时，进行 where 租户ID 条件追加    if (CollectionUtils.isNotEmpty(mainTables)) {        plainSelect.setWhere(builderExpression(where, mainTables));    }}

builderExpression方法：多租户插件会根据获取到的租户信息，将其添加到原始SQL语句中

/** * 处理条件 */protected Expression builderExpression(Expression currentExpression, List<Table> tables) {    // 没有表需要处理直接返回    if (CollectionUtils.isEmpty(tables)) {        return currentExpression;    }    // 过滤配置的忽略表信息    List<Table> tempTables = tables.stream()            .filter(x -> !tenantLineHandler.ignoreTable(x.getName()))            .collect(Collectors.toList());
    // 没有表需要处理直接返回    if (CollectionUtils.isEmpty(tempTables)) {        return currentExpression;    }
    // 获取租户ID    Expression tenantId = tenantLineHandler.getTenantId();    List<EqualsTo> equalsTos = tempTables.stream()            // 增加别名，如果没有别名就用表名            .map(item -> new EqualsTo(getAliasColumn(item), tenantId))            .collect(Collectors.toList());
    // 注入的表达式    Expression injectExpression = equalsTos.get(0);    // 如果有多表，则用 and 连接    if (equalsTos.size() > 1) {        for (int i = 1; i < equalsTos.size(); i++) {            injectExpression = new AndExpression(injectExpression, equalsTos.get(i));        }    }
    if (currentExpression == null) {        return injectExpression;    }    // 存在 or 条件的话，则用 () 括起来如 a.tenant_id = 1 and (id = 2 or id = 1)    if (currentExpression instanceof OrExpression) {        return new AndExpression(new Parenthesis(currentExpression), injectExpression);    } else {        return new AndExpression(currentExpression, injectExpression);    }}

5.3.2 多租户插件 Insert Update Delete 语句执行源码解析

和Select语句执行源码类似，Mybatis-Plus多租户插件在执行Insert Update Delete语句时，最后也是调用多租户插件的beforeQuery方法，通过JsqlParserSupport类对sql语句进行解析并组装各种有含义的类后，根据不同类型的Insert Update Delete sql语句执行不同的多租户插件业务流程。

Insert sql语句调用多租户插件的processInsert方法

protected void processInsert(Insert insert, int index, String sql, Object obj) {    if (tenantLineHandler.ignoreTable(insert.getTable().getName())) {        // 过滤退出执行        return;    }    List<Column> columns = insert.getColumns();    if (CollectionUtils.isEmpty(columns)) {        // 针对不给列名的 insert 不处理        return;    }    String tenantIdColumn = tenantLineHandler.getTenantIdColumn();    if (tenantLineHandler.ignoreInsert(columns, tenantIdColumn)) {        // 针对已给出租户列的 insert 不处理        return;    }    columns.add(new Column(tenantIdColumn));
    // fixed gitee pulls/141 duplicate update【测试了下效果无用】    List<Expression> duplicateUpdateColumns = insert.getDuplicateUpdateExpressionList();    if (CollectionUtils.isNotEmpty(duplicateUpdateColumns)) {        EqualsTo equalsTo = new EqualsTo();        equalsTo.setLeftExpression(new StringValue(tenantIdColumn));        equalsTo.setRightExpression(tenantLineHandler.getTenantId());        duplicateUpdateColumns.add(equalsTo);    }
    Select select = insert.getSelect();    if (select != null) {        this.processInsertSelect(select.getSelectBody());    } else if (insert.getItemsList() != null) {        // fixed github pull/295        ItemsList itemsList = insert.getItemsList();        if (itemsList instanceof MultiExpressionList) {            // 多批量 insert into values            ((MultiExpressionList) itemsList).getExpressionLists().forEach(el -> el.getExpressions().add(tenantLineHandler.getTenantId()));        } else {            ((ExpressionList) itemsList).getExpressions().add(tenantLineHandler.getTenantId());        }    } else {        throw ExceptionUtils.mpe("Failed to process multiple-table update, please exclude the tableName or statementId");    }}

Delete sql语句调用多租户插件的processDelete方法

protected void processDelete(Delete delete, int index, String sql, Object obj) {    if (tenantLineHandler.ignoreTable(delete.getTable().getName())) {        // 过滤退出执行        return;    }    delete.setWhere(this.andExpression(delete.getTable(), delete.getWhere()));}

Update sql语句调用多租户插件的processUpdate方法

protected void processUpdate(Update update, int index, String sql, Object obj) {    final Table table = update.getTable();    if (tenantLineHandler.ignoreTable(table.getName())) {        // 过滤退出执行        return;    }    // 拼接 where 条件    update.setWhere(this.andExpression(table, update.getWhere()));}

6 实战

6.1 接入多租户插件

在Mybatis-Plus中，采用的是“共享数据库，共享数据表”的方式，此方式需要我们在每个数据表中增加tenant_id字段信息，插件会在操作语句时，自动添加tenant_id字段信息，用于逻辑区分租户。

ALTER TABLE `gift_card_refunds` ADD `tenant_id` BIGINT(20)UNSIGNED NULL DEFAULT NULL COMMENT '租户id' AFTER `updated_time`

通过配置文件中读取多租户插件的“忽略应用多租户插件表列表”和“多租户插件开关”来配置多租户插件。

@Data@Component@ConfigurationProperties(prefix = "tenantplugin")public class TenantPluginProperties implements Serializable {    /**     * 忽略应用多租户插件表列表     */    private List<String> ignoreTables;
    /**     * 多租户插件开关     */    private Boolean enable;}

注册并实现TenantLineInnerInterceptor内容，根据具体的数据库类型和租户信息，实现相应的多租户SQL解析器。

@Bean@ConditionalOnMissingBeanpublic TenantPluginProperties tenantPluginProps() {    return new TenantPluginProperties();}
@Beanpublic MybatisPlusInterceptor mybatisPlusInterceptor(TenantPluginProperties tenantPluginProperties) {    MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();    interceptor.addInnerInterceptor(this.tenantPluginInterceptor(tenantPluginProperties));    interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));    return interceptor;}
/** * 多租户插件 拦截器 * @param tenantPluginProperties * @return */private TenantLineInnerInterceptor tenantPluginInterceptor(TenantPluginProperties tenantPluginProperties) {    return new TenantLineInnerInterceptor(new TenantLineHandler() {        @Override        public Expression getTenantId() {            Long tenantId = ReqUtil.getTenantId();            return new LongValue(tenantId);        }
        @Override        public boolean ignoreTable(String tableName) {            // 如果没配置 nacos 配置，或者 nacos 配置禁用多租户插件            if (ObjectUtils.isEmpty(tenantPluginProperties.getEnable()) ||                    Boolean.FALSE.equals(tenantPluginProperties.getEnable())) {                return true;            }            // 过滤配置指定表忽略使用多租户插件            if (CollectionUtils.isNotEmpty(tenantPluginProperties.getIgnoreTables()) &&                    tenantPluginProperties.getIgnoreTables().contains(tableName)) {                return true;            }            return false;        }    });}

nacos提供“忽略应用多租户插件表列表”和“多租户插件开关”配置，方便开发者针对不同服务、不同业务表灵活配置需要自动添加tenant_id字段信息。

tenantplugin:  # 忽略的表应用多租户插件  ignoreTables:    - tenant_infos  # 启动多租户插件  enable: true

6.2 效果展示

引用Mybatis-Plus多租户插件后，在查询用户信息时，自动在where条件拼接users.tenant_id = 1条件，从而实现多租户。

图15 多租户插件效果展示

6.3 多租户插件源码分析的思考

6.3.1 insert 语句 tenant_id 和 `tenant_id` 效果不同

当手动Insert `tenant_id`字段，源码在sql后面拼接tenant_id字段，导致异常Column `tenant_id` sepcifed twice。

图16 多租户插件下 insert sql 语句 tenant_id 与 `tenant_id` 效果展示

6.3.2 Join 与 Inner Join 效果不同

使用Inner Join查询语句，在语句后面拼接了users.tenant_id = 1 and user_addrs.tenant_id = 1条件，而使用Join的查询语句，仅仅是在语句后面拼接了users.tenant_id = 1条件。

图17 多租户插件下 join 与 inner join 效果展示

官方文档说明如下：

原因是：processJoins代码块仅判断 join.isRight() join.isLeft() join.isInner()，而未判断使用Join的sql语句。

图18 多租户插件处理 join 语句源码

6.3.3 INSERT ON DUPLICATE KEY UPDATE SQL 语句不起效果

使用insert into on duplicate key update语句，引用Mybatis-Plus多租户插件后，未在sql语句后面拼接租户id。

图19 多租户插件下 insert into on duplicate key update 语句效果展示

原因是：processInsert方法中duplicateUpdateColumn处理后的变量最后未使用。

图20 多租户插件处理 insert into on duplicate key update 语句源码

6.3.4 忽略多租户插件

在mapper接口上加上@InterceptorIgnore(tenantLine = "true")注解，即可使得多租户屏蔽某个特定mapper的方法。

图21 应用忽略多租户插件

原因是：源码检测mapper接口是否加上忽略多租户插件注解，如果加入则直接跳过。

图22 多租户插件处理忽略拼接租户id 源码

7 总结

Mabtis-plus 多租户插件是一个基于 MyBatis-plus 框架的多租户解决方案，具有以下优点：

数据隔离性：可以轻松地实现租户数据的隔离，确保不同租户之间的数据不会相互干扰
易于维护：可以帮助开发人员快速构建多租户应用程序，减少了维护和升级成本
扩展性：可以与其他框架和技术集成，为多租户应用程序的扩展提供了更多的可能性
安全性：可以实现租户数据的安全性，确保数据不会被非法访问和篡改
灵活配置：自定义租户字段，支持配置表，mapper方法添加注解方式忽略使用多租户插件

Mabtis-plus 多租户插件是一种可靠、灵活和易于维护的解决方案，可以帮助开发人员轻松构建多租户应用程序，提高开发效率和应用程序的可靠性。但是如果系统定位是超级管理员查看所有租户数据的平台，则不适用 Mabtis-plus 多租户插件。

本文作者

麦金，来自缦图互联网中心后端团队。

--------END--------

也许你还想看

| 走进分布式系统共识算法

| 分布式定时任务选型及源码解析

| 聊聊我们身边的spring扩展点

继续滑动看下一个