Mybatis Plus 多租户架构实现（完美教程）

一、背景介绍

　　多租户技术或称多重租赁技术，简称SaaS，是一种软件架构技术，是实现如何在多用户环境下（此处的多用户一般是面向企业用户）共用相同的系统或程序组件，并且可确保各用户间数据的隔离性。
　　简单讲：在一台服务器上运行单个应用实例，它为多个租户（客户）提供服务。从定义中我们可以理解：多租户是一种架构，目的是为了让多用户环境下使用同一套程序，且保证用户间数据隔离。那么重点就很浅显易懂了，多租户的重点就是同一套程序下实现多用户数据的隔离。

二、基础介绍

　　近日有些朋友向我讨教关于多租户设计方案，正好公司做的也是多租户系统，功能实现不是我开发的，之前也没有细致的了解实现过程。借此机会，结合公司现有的多租户方案及其网上浏览的租户方案设计，自己实现了一套技术方案，可以解决共享数据库或共享数据表。

三、数据隔离技术方案

1.独立数据库

　　即一个租户一个数据库，这种方案的用户数据隔离级别最高，安全性最好，但成本较高。
　　优点：为不同的租户提供独立的数据库，有助于简化数据模型的扩展设计，满足不同租户的独特需求；如果出现故障，恢复数据比较简单。
　　缺点：增多了数据库的安装数量，随之带来维护成本和购置成本的增加。

2.共享数据库，独立 Schema

　　多个或所有租户共享Database，但是每个租户一个Schema（也可叫做一个user）。底层库比如是：DB2、ORACLE等，一个数据库下可以有多个SCHEMA。
　　优点：为安全性要求较高的租户提供了一定程度的逻辑数据隔离，并不是完全隔离；每个数据库可支持更多的租户数量。
　　缺点：如果出现故障，数据恢复比较困难，因为恢复数据库将牵涉到其他租户的数据；

3.共享数据库，共享 Schema，共享数据表　　

　　即租户共享同一个Database、同一个Schema，但在表中增加TenantID多租户的数据字段。这是共享程度最高、隔离级别最低的模式。
　　简单来讲，即每插入一条数据时都需要有一个客户的标识。这样才能在同一张表中区分出不同客户的数据，这也是我们系统目前用到的(tenant_id)
　　优点：三种方案比较，第三种方案的维护和购置成本最低，允许每个数据库支持的租户数量最多。
　　缺点：隔离级别最低，安全性最低，需要在设计开发时加大对安全的开发量； 数据备份和恢复最困难，需要逐表逐条备份和还原。

四、优点介绍

　　 本次租户业务实现看似是一个方案，其实是结合了独立数据库、共享数据库，共享 Schema，共享数据表类实现的两个方案，具体根据您的需求来设计。

　　由于多租户中我们不止是每个租户都存在一个客户标识，可能每个表中都存在创建人、更新人、删除标识，这次我也是集成了方案解决。

　    根据自己的需求，灵活变更业务逻辑，业务代码高可用、注释完善、易上手。

　    网上的教程大部分都是基于mybatis-plus的TenantLineInnerInterceptor 实现所有的租户通过tenant_id来处理多租户之间打数据隔离，这个局限性太低了，而我实现的可灵活自定义实现。

五、业务实现

　　注意：以下实现主要列出核心编码实现，完整代码放在文章最下方。如有不足之处，希望各位IT界大佬多多指教，谢谢！

1.导入maven jar包

<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
        </dependency>
        <!--阿里数据库连接池 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.21</version>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.4.1</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-extension</artifactId>
            <version>3.4.1</version>
        </dependency>
    </dependencies>

2.数据库表，可以建两个库进行模拟

CREATE TABLE `tenant` (
  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主键id',
  `name` varchar(255) DEFAULT NULL COMMENT '租户名称',
  `tenant_id` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci DEFAULT NULL COMMENT '租户id',
  `create_time` datetime DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
  `create_by` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci DEFAULT NULL COMMENT '创建人',
  `update_time` datetime DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '修改时间',
  `update_by` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci DEFAULT NULL COMMENT '修改人',
  `is_delete` tinyint(1) DEFAULT '0' COMMENT '1删除 0未删除 默认0',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=12 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci COMMENT='企业表';

 3.我们实现Mybtis中Interceptor，来拦截我们的接口，处理sql。

　　注意：handleReplace 方法中的 tenantProperties.getTenantTable()就是获取库的名称，这个需要根据你业务，用户登录后存储租户标识，此处根据不同的用户获取不同的标识，切换数据库，我在本案例中只是指定了某个库区执行sql。

/**
 * @author: fuzongle
 * @description:  拦截器
 **/

@Slf4j
@Intercepts({
        @Signature(type = Executor.class, method = "query", args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class}),
        @Signature(type = Executor.class, method = "update", args = {MappedStatement.class, Object.class})
})
public class SqlLogInterceptor implements Interceptor {

    @Autowired
    private TenantProperties tenantProperties;

    public static class CustomSqlSource implements SqlSource {

        private BoundSql boundSql;

        protected CustomSqlSource(BoundSql boundSql){
            this.boundSql = boundSql;
        }

        @Override
        public BoundSql getBoundSql(Object o) {
            return boundSql;
        }
    }

    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        MappedStatement ms = (MappedStatement)invocation.getArgs()[0];
        Object parameterObject = null;
        InterceptorIgnore annotation = null;
        Class<?> clazz = Class.forName(ms.getId().substring(0, ms.getId().lastIndexOf(".")));
        Method[] methods = clazz.getDeclaredMethods();
        for (Method method : methods) {
           annotation = method.getAnnotation(InterceptorIgnore.class);
        }
        if(invocation.getArgs().length > 1){
            parameterObject = invocation.getArgs()[1];
        }

        BoundSql boundSql = ms.getBoundSql(parameterObject);
        String sql = boundSql.getSql();

        if (tenantProperties.getEnable() || annotation == null) {
            sql = handleReplace(boundSql.getSql());
        }
        BoundSql newBoundSql = new BoundSql(
                ms.getConfiguration(),
                sql, //sql替换  唯一发生改变的地方
                boundSql.getParameterMappings(),
                boundSql.getParameterObject()
        );

        MappedStatement.Builder build = new MappedStatement.Builder(
                ms.getConfiguration(),
                ms.getId(),
                new CustomSqlSource(newBoundSql),
                ms.getSqlCommandType()
        );
        build.resource(ms.getResource());
        build.fetchSize(ms.getFetchSize());
        build.statementType(ms.getStatementType());
        build.keyGenerator(ms.getKeyGenerator());
        build.timeout(ms.getTimeout());
        build.parameterMap(ms.getParameterMap());
        build.resultMaps(ms.getResultMaps());
        build.cache(ms.getCache());

        MappedStatement newStmt = build.build();
        //替换原来的MappedStatement
        invocation.getArgs()[0] = newStmt;

        return invocation.proceed();
    }
　　　// 核心业务处理
    private String handleReplace(String sql) throws JSQLParserException {
        Statement stmt = CCJSqlParserUtil.parse(sql);
        //需要sql校验。
        String schemeName = String.format("`%s`", tenantProperties.getTenantTable());
        if(stmt instanceof Insert){
            Insert insert = (Insert)stmt;
            return SqlParser.doInsert(insert, schemeName);
        }else if(stmt instanceof Update){
            Update update = (Update) stmt;
            return SqlParser.doUpdate(update, schemeName);
        }else if(stmt instanceof Delete){
            Delete delete = (Delete) stmt;
            return SqlParser.doDelete(delete, schemeName);
        }else if(stmt instanceof Select){
            Select select = (Select)stmt;
            return SqlParser.doSelect(select, schemeName);
        }
        throw new RuntimeException("非法sql！");
    }





}

4.新增语句处理

public static String doInsert(Insert insert, String schemaName) {
        String tableName = insert.getTable().getName();
        //校验系统非追加表
        if (tenantProperties.getIgnoreTables().contains(tableName)){
            return insert.toString();
        }
        //获取表对应实体路劲
        String entityPath = EntityTableCache.getInstance().getCacheData(tableName).toString();
        //判断实体是否有createdBy属性,追加create_by
        if (EntityUtils.isHaveAttr(entityPath, TenantGlobalColumnHandler.COLUMN_CREATED_BY_ENTITY)) {
            handleColumnsAndExpressions(insert, TenantGlobalColumnHandler.COLUMN_CREATED_BY);
        }
        //判断实体是否有updateBy属性,追加update_by
        if (EntityUtils.isHaveAttr(entityPath,TenantGlobalColumnHandler.COLUMN_UPDATED_BY_ENTITY)) {
            handleColumnsAndExpressions(insert,TenantGlobalColumnHandler.COLUMN_UPDATED_BY);
        }
        //追加tenant_id
        insert.getColumns().add(new Column(TenantGlobalColumnHandler.COLUMN_TENANT_ID));
        ((ExpressionList) insert.getItemsList()).getExpressions().add(TenantGlobalColumnHandler.getTenantId());
        //是否设置库名
        Table table = insert.getTable();
        table.setSchemaName(schemaName);
        insert.setTable(table);
        return insert.toString();
    }

5.删除语句处理

public static String doDelete(Delete delete, String schemaName) {
        String tableName = delete.getTable().getName();
        //校验系统非追加表
        if (tenantProperties.getIgnoreTables().contains(tableName)){
            return delete.toString();
        }
        //构建where条件
        BinaryExpression binaryExpression = andExpression(delete.getTable(), delete.getWhere());
        //追加where条件
        delete.setWhere(binaryExpression);
        //设置库名
        Table t = delete.getTable();
        t.setSchemaName(schemaName);
        delete.setTable(t);
        return delete.toString();
    }

6.修改语句处理　

public static String doUpdate(Update update, String schemaName) throws JSQLParserException{
        String tableName = update.getTable().getName();
        //校验系统非追加表
        if (tenantProperties.getIgnoreTables().contains(tableName)){
            return update.toString();
        }
        //构建where条件
        BinaryExpression binaryExpression = andExpression(update.getTable(), update.getWhere());
        //追加where条件
        update.setWhere(binaryExpression);
        //获取表对应实体路劲
        String entityPath = EntityTableCache.getInstance().getCacheData(tableName).toString();
        //判断实体是否有updateBy属性,追加update_by
        if (EntityUtils.isHaveAttr(entityPath,TenantGlobalColumnHandler.COLUMN_UPDATED_BY_ENTITY)) {
            handleColumnsAndExpressions(update,TenantGlobalColumnHandler.COLUMN_UPDATED_BY);
        }

        //追加库名
        StringBuilder buffer = new StringBuilder();
        Table tb = update.getTable();
        tb.setSchemaName(schemaName);
        update.setTable(tb);
        // 处理from
        FromItem fromItem = update.getFromItem();
        if (fromItem != null) {
            Table tf = (Table) fromItem;
            tf.setSchemaName(schemaName);
        }
        // 处理join
        List<Join> joins = update.getJoins();
        if (joins != null && joins.size() > 0) {
            for (Object object : joins) {
                Join t = (Join) object;
                Table rightItem = (Table) t.getRightItem();
                rightItem.setSchemaName(schemaName);
                System.out.println();
            }
        }
        ExpressionDeParser expressionDeParser = new ExpressionDeParser();
        UpdateDeParser p = new UpdateDeParser(expressionDeParser, null, buffer);
        expressionDeParser.setBuffer(buffer);
        p.deParse(update);

        return update.toString();
    }

7.查询语句处理，如果不满足您的业务可参考Mybatis Puls中的TenantSqlParser自定义追加条件。

public static String doSelect(Select select, String schemaName){
        processPlainSelect((PlainSelect) select.getSelectBody());
        StringBuilder buffer = new StringBuilder();
        ExpressionDeParser expressionDeParser = new ExpressionDeParser();
        SQLParserSelect parser = new SQLParserSelect(expressionDeParser, buffer);
        parser.setSchemaName(schemaName);
        expressionDeParser.setSelectVisitor(parser);
        expressionDeParser.setBuffer(buffer);
        select.getSelectBody().accept(parser);

        return buffer.toString();
    }

六、执行过程

1.新增

2.删除

3.修改

 4.查询

 七、源码地址：https://gitee.com/fuzongle