SpringBoot 项目使用 Mybatis Plus 实现多租户

pom文件

    <properties>
      <mybatis-plus.version>3.5.1</mybatis-plus.version>
    </properties>

    <!-- mybatis-plus 依赖配置 -->
    <dependency>
      <groupId>com.baomidou</groupId>
      <artifactId>mybatis-plus-boot-starter</artifactId>
      <version>${mybatis-plus.version}</version>
    </dependency>

    <dependency>
      <groupId>com.baomidou</groupId>
      <artifactId>mybatis-plus-extension</artifactId>
      <version>${mybatis-plus.version}</version>
</dependency>

bootstrap.yml配置

#多租户配置
tenant:
  enable: true
  column: tenant_id
  filterTables:
  ignoreTables:
    - sys_app
  ignoreLoginNames:

租户配置属性类

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;

/**
 * 多租户配置属性类
 */
@Data
@ConfigurationProperties(prefix = "tenant")
public class TenantProperties {
    /**
     * 是否开启多租户
     */
    private Boolean enable;

    /**
     * 租户id字段名
     */
    private String column;

    /**
     * 需要进行租户id过滤的表名集合
     */
    private List<String> filterTables;

    /**
     * 需要忽略的多租户的表，此配置优先filterTables，若此配置为空则启用filterTables
     */
    private List<String> ignoreTables;

    /**
     * 需要排除租户过滤的登录用户名
     */
    private List<String> ignoreLoginNames;
}

多租户校验逻辑处理

/**
 * 多租户处理器实现类
 */

import com.baomidou.mybatisplus.extension.plugins.handler.TenantLineHandler;
import net.sf.jsqlparser.expression.Expression;
import net.sf.jsqlparser.expression.StringValue;

public class MultiTenantHandler implements TenantLineHandler {

    private final TenantProperties properties;

    public MultiTenantHandler(TenantProperties properties) {
        this.properties = properties;
    }

    /**
     * 获取租户ID值表达式，只支持单个ID值 (实际应该从用户信息中获取)
     *
     * @return 租户ID值表达式
     */
    @Override
    public Expression getTenantId() {
        // 实际应该从用户信息中获取，框架一般都有获取用户信息的接口
        String tenant_id = ""；
        // 判空校验
        if (StringUtil.isNotEmpty(tenant_id)) {
            return new StringValue(tenant_id);
        }
        return new StringValue("");
    }

    /**
     * 获取租户字段名,默认字段名叫: tenant_id
     *
     * @return 租户字段名
     */
    @Override
    public String getTenantIdColumn() {
        return properties.getColumn();
    }

    /**
     * 根据表名判断是否忽略拼接多租户条件
     * <p>
     * 默认都要进行解析并拼接多租户条件
     *
     * @param tableName 表名
     * @return 是否忽略, true:表示忽略，false:需要解析并拼接多租户条件
     */
    @Override
    public boolean ignoreTable(String tableName) {
        // 自定义注解忽略拦截（可选，有的场景是获取不到登录用户信息的，比如系统内部调用接口，所以用一个内存变量来存储是否忽略校验）
        if (TenantContext.isInternalInvocation()) {
            return true;
        }

        // 可以自行增加一些校验比如获取不到用户就直接 return false 之类的。

        // 忽略指定用户对租户的数据过滤
        String username = "";
        if (null != ignoreLoginNames && ignoreLoginNames.contains(username)) {
            return true;
        }

        // 忽略指定表对租户数据的过滤
        List<String> ignoreTables = properties.getIgnoreTables();
        if (null != ignoreTables && ignoreTables.contains(tableName)) {
            return true;
        }
        return false;
    }
}

配置类

/**
 * Mybatis Plus 配置
 */
@EnableTransactionManagement(proxyTargetClass = true)
@Configuration("mybatisPlusConfig")
@EnableConfigurationProperties(TenantProperties.class)
public class MybatisPlusConfig {

    /**
     * 如果用了分页插件注意先 add TenantLineInnerInterceptor 再 add PaginationInnerInterceptor
     */
    @Bean("mybatisPlusInterceptor")
    public MybatisPlusInterceptor mybatisPlusInterceptor(TenantProperties tenantProperties) {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        if (Boolean.TRUE.equals(tenantProperties.getEnable())) {
            // 启用多租户插件拦截
            interceptor.addInnerInterceptor(new TenantLineInnerInterceptor(new MultiTenantHandler(tenantProperties)));
        }

        // 分页插件
        interceptor.addInnerInterceptor(paginationInnerInterceptor());
        // 乐观锁插件
        interceptor.addInnerInterceptor(optimisticLockerInnerInterceptor());
        // 阻断插件
        interceptor.addInnerInterceptor(blockAttackInnerInterceptor());

        return interceptor;
    }


    /**
     * 分页插件，自动识别数据库类型 https://baomidou.com/guide/interceptor-pagination.html
     */
    public PaginationInnerInterceptor paginationInnerInterceptor() {
        PaginationInnerInterceptor paginationInnerInterceptor = new PaginationInnerInterceptor();
        // 设置数据库类型为mysql
        paginationInnerInterceptor.setDbType(DbType.MYSQL);
        // 设置最大单页限制数量，默认 500 条，-1 不受限制
        paginationInnerInterceptor.setMaxLimit(-1L);
        return paginationInnerInterceptor;
    }

    /**
     * 乐观锁插件 https://baomidou.com/guide/interceptor-optimistic-locker.html
     */
    public OptimisticLockerInnerInterceptor optimisticLockerInnerInterceptor() {
        return new OptimisticLockerInnerInterceptor();
    }

    /**
     * 如果是对全表的删除或更新操作，就会终止该操作 https://baomidou.com/guide/interceptor-block-attack.html
     */
    public BlockAttackInnerInterceptor blockAttackInnerInterceptor() {
        return new BlockAttackInnerInterceptor();
    }
}

忽略校验自定义注解(可选)

/**
 * 忽略多租户校验
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface IgnoreTenant {
}

自定义注解切面类(可选)

/**
 * 自定义注解切面类
 */
@Aspect
@Component
public class TenantAspect {

    @Around("@annotation(xxx.xxx.IgnoreTenant)")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        try {
            TenantContext.setInternalInvocation(true);
            return joinPoint.proceed();
        } finally {
            TenantContext.clear();
        }
    }
}

提供操作内存变量的方法(可选)

/**
 * 租户上下文
 */
public class TenantContext {
    private static final ThreadLocal<Boolean> THREAD_LOCAL = ThreadLocal.withInitial(() -> false);

    public static void setInternalInvocation(boolean internal) {
        THREAD_LOCAL.set(internal);
    }

    public static boolean isInternalInvocation() {
        return THREAD_LOCAL.get();
    }

    public static void clear() {
        THREAD_LOCAL.remove();
    }
}