多租户改造（字段隔离和表隔离混合模式）

多租户改造

一、多租户概念

1.多租户是什么意思？怎么理解？

​ 多租户是一种单个软件实例可以为多个不同用户组提供服务的软件架构。在云计算中，多租户也可以指共享主机，其服务器资源将在不同客户之间进行分配。与多租户相对应的是单租户，单租户是指软件实例或计算机系统中有 1 个最终用户或用户组。

2.多租户架构的优势

多租户可以节省成本。计算规模越大，成本就越低，并且多租户还允许对资源进行有效地整合和分配，最终节省运营成本。 对于个人用户而言，访问云服务或 SAAS 应用所需的费用通常要比运行单租户硬件和软件更具成本效益。多租户可以提高灵活性。如果您选择自行购置硬件和软件，那么在需求旺盛时可能会难以满足需求，而在需求疲软时则可能会闲置不用。另一方面，多租户云却可以根据用户的需要来灵活地扩展和缩减资源池。作为公共云提供商的客户，您可以在需要时获得额外容量，而在不需要时则无需付费。多租户可以提高效率。多租户消除了单个用户管理基础架构及处理更新和维护的必要。每个租户都可以依靠中央云提供商（而不用自己组建团队）来处理这些日常琐事。

2.多租户技术特点

多个租户共享平台。租户之间数据隔离。租户之间发布更新互不影响。

4.多租户数据隔离实现

目前saas多租户系统的数据隔离有三种解决方案，即为每个租户提供独立的数据库、独立的表空间、按字段区分租户，每种方案都有其各自的适用情况。

最终选用以字段隔离为主，表隔离为辅的方案，其好处就是成本低，改造小。

一、数据库隔离

1.方案

使用 MyBatis-Plus 中的 TenantLineInnerInterceptor（多租户）插件和 DynamicTableNameInnerInterceptor（动态表名）插件 实现租户间数据隔离

2.相关依赖

com.baomidou

mybatis-plus-boot-starter

3.5.2

com.alibaba

transmittable-thread-local

2.12.2

3.实现

（1）思路

(前提：前端发起请求时或者在网关转发时向header中添加租户id)

首先从过滤器中拿到 request header 中的 tenantId放到线程上下文中，后续获取

（2）线程上下文（用于存放租户id ）

import com.alibaba.ttl.TransmittableThreadLocal;

import lombok.experimental.UtilityClass;

/**

* 多租户上下文

*

* @author cherf

* @since 2022-9-1

*/

@UtilityClass

public class TenantContextHolder {

/**

* 支持父子线程数据传递

*/

private final ThreadLocal THREAD_LOCAL_TENANT = new TransmittableThreadLocal<>();

/**

* 设置租户ID

*

* @param tenantId 租户ID

*/

public void setTenantId(String tenantId) {

THREAD_LOCAL_TENANT.set(tenantId);

}

/**

* 获取租户ID

*

* @return String

*/

public String getTenantId() {

return THREAD_LOCAL_TENANT.get();

}

/**

* 清除tenantId

*/

public void clear() {

THREAD_LOCAL_TENANT.remove();

}

}

（3）过滤器(用户向上下文中添加租户id)

import lombok.SneakyThrows;

import lombok.extern.slf4j.Slf4j;

import org.springframework.core.Ordered;

import org.springframework.core.annotation.Order;

import org.springframework.stereotype.Component;

import org.springframework.web.filter.GenericFilterBean;

import javax.servlet.FilterChain;

import javax.servlet.ServletException;

import javax.servlet.ServletRequest;

import javax.servlet.ServletResponse;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import java.io.IOException;

/**

* 租户上下文过滤器

*

* @author cherf

* @date 2022-08-30 13:28:00

*/

@Slf4j

@Component

@Order(Ordered.HIGHEST_PRECEDENCE)

public class TenantContextHolderFilter extends GenericFilterBean {

@Override

@SneakyThrows

public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {

HttpServletRequest request = (HttpServletRequest) servletRequest;

HttpServletResponse response = (HttpServletResponse) servletResponse;

try {

String tenantId = request.getHeader(Constant.TENANT_ID);

if (StringUtil.isBlank(tenantId)) {

tenantId = Constant.TENANT_ID_DEFAULT;

}

log.info("获取到的租户ID为:{}", tenantId);

if (StringUtil.isNotBlank(tenantId)) {

TenantContextHolder.setTenantId(tenantId);

} else {

if (StringUtil.isBlank(TenantContextHolder.getTenantId())) {

TenantContextHolder.setTenantId(Constant.TENANT_ID_DEFAULT);

}

}

filterChain.doFilter(request, response);

} finally {

TenantContextHolder.clear();

}

}

}

/**

* 租户相关静态常量

*/

class Constant {

public static final String TENANT = "tenant";

/**

* header 中租户ID

*/

public static final String TENANT_ID = "tenantId";

/**

* 默认租户ID

*/

public static final String TENANT_ID_DEFAULT = "tenant_id_default";

}

（4）需要配置多租户表名配置

import lombok.Getter;

import lombok.Setter;

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

import org.springframework.cloud.context.config.annotation.RefreshScope;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;

/**

* @author cherf

* @description: 租户配置属性(可以写在yml配置文件里,也可以在这儿写死)

* @date 2022/08/30 13:57

**/

@Getter

@Setter

@RefreshScope

@ConfigurationProperties(prefix = "tenant")

public class TenantProperties {

/**

* 是否开启租户模式

*/

private Boolean enable = true;

/**

* 需要排除的多租户的表(根据自己需要修改)

*/

private List ignoreTables = Arrays.asList("t_menu", "t_oauth_client","t_tenant_info","t_server_info");

/**

* 动态表名的表(根据自己需要修改)

*/

private List dynamicTables = Arrays.asList("t_opt_log", "t_flow");

/**

* 多租户字段名称(根据实际项目修改)

*/

private String column = "tenant_id";

/**

* 排除不进行租户隔离的sql

* 样例全路径：com.cherf.system.sauth.mapper.AppAccessMapper.findList

*/

private List ignoreSqls = new ArrayList<>();

}

（5）mybatis插件配置

import com.baomidou.mybatisplus.annotation.DbType;

import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;

import com.baomidou.mybatisplus.extension.plugins.handler.TenantLineHandler;

import com.baomidou.mybatisplus.extension.plugins.inner.DynamicTableNameInnerInterceptor;

import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;

import com.baomidou.mybatisplus.extension.plugins.inner.TenantLineInnerInterceptor;

import com.cherf.system.common.constant.StringPool;

import com.cherf.system.common.context.TenantContextHolder;

import com.cherf.system.common.util.StringUtil;

import lombok.AllArgsConstructor;

import net.sf.jsqlparser.expression.Expression;

import net.sf.jsqlparser.expression.NullValue;

import net.sf.jsqlparser.expression.StringValue;

import org.springframework.boot.autoconfigure.AutoConfigureBefore;

import org.springframework.boot.context.properties.EnableConfigurationProperties;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

/**

* Mybatis-plus 插件,分页插件,多租户插件，动态表名插件

*

* @author cherf

* @date 2022年9月1日

*/

@Configuration

@AllArgsConstructor

@AutoConfigureBefore(MybatisPlusConfig.class)

@EnableConfigurationProperties(TenantProperties.class)

public class MybatisPlusConfig {

private final TenantProperties tenantProperties;

@Bean

public MybatisPlusInterceptor paginationInterceptor() {

MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();

//动态表名插件

DynamicTableNameInnerInterceptor dynamicTableNameInnerInterceptor = new DynamicTableNameInnerInterceptor();

dynamicTableNameInnerInterceptor.setTableNameHandler((sql, tableName) -> {

String tenantId = TenantContextHolder.getTenantId();

//符合的表名拼接租户号

if (tenantProperties.getDynamicTables().stream().anyMatch(

(t) -> t.equalsIgnoreCase(tableName))) {

return tableName + StringPool.UNDER_LINE + tenantId;

}

return tableName;

});

interceptor.addInnerInterceptor(dynamicTableNameInnerInterceptor);

// 新多租户插件配置,一缓和二缓遵循mybatis的规则,需要设置 MybatisConfiguration#useDeprecatedExecutor = false 避免缓存万一出现问题

//租户拦截器

interceptor.addInnerInterceptor(new TenantLineInnerInterceptor(new TenantLineHandler() {

/**

* 获取租户ID

* @return

*/

@Override

public Expression getTenantId() {

String tenantId = TenantContextHolder.getTenantId();

if (StringUtil.isNotEmpty(tenantId)) {

return new StringValue(tenantId);

}

return new NullValue();

}

/**

* 获取多租户的字段名

* @return String

*/

@Override

public String getTenantIdColumn() {

return tenantProperties.getColumn();

}

/**

* 过滤不需要根据租户隔离的表

* 这是 default 方法,默认返回 false 表示所有表都需要拼多租户条件

* @param tableName 表名

*/

@Override

public boolean ignoreTable(String tableName) {

return tenantProperties.getIgnoreTables().stream().anyMatch(

(t) -> tableName.startsWith(t) || tableName.equalsIgnoreCase(t)

);

}

}));

// 如果用了分页插件注意先 add TenantLineInnerInterceptor 再 add PaginationInnerInterceptor

interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));

return interceptor;

}

}

数据库隔离到此完成！

然后测试sql后自动拼接 tenant_id 条件

**注意：**如果不想让 sql 拼接 tenant_id 可以在mapper 上添加 @InterceptorIgnore(tenantLine = "true") 注解 ；

如图：

二、redis隔离

1.方案

可以参考大佬写的，很详细 https://blog.csdn.net/qq_41205473/article/details/123902395

原本思路是在 redis 每个操作的 key 前拼租户号，但是涉及的 太多 key ，挨个加太多，最终继承 RedisSerializer 类 重写方法，拼装租户id 实际实现如下：

package com.cherf.system.common.redis;

import com.cherf.system.common.constant.StringPool;

import com.cherf.system.common.context.TenantContextHolder;

import org.apache.commons.lang3.StringUtils;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.data.redis.serializer.RedisSerializer;

import org.springframework.data.redis.serializer.StringRedisSerializer;

import org.springframework.lang.Nullable;

import org.springframework.util.Assert;

import org.springframework.util.CollectionUtils;

import java.nio.charset.Charset;

import java.nio.charset.StandardCharsets;

import java.util.List;

/**

* @author cherf

* @Description 自定义序列化，用于保存租户号，隔离数据

* @Date 2022/9/5

*/

public class TenantStringRedisSerializer implements RedisSerializer {

private static final Logger logger = LoggerFactory.getLogger(TenantStringRedisSerializer.class);

private final Charset charset;

public static final StringRedisSerializer US_ASCII;

public static final StringRedisSerializer ISO_8859_1;

public static final StringRedisSerializer UTF_8;

private static final String TENANT_PREFIX = "tid";

private static final Boolean IS_LOG = false;

private RedisProperties redisProperties = new RedisProperties();

public TenantStringRedisSerializer() {

this(StandardCharsets.UTF_8);

}

public TenantStringRedisSerializer(Charset charset) {

Assert.notNull(charset, "Charset must not be null!");

this.charset = charset;

}

public String deserialize(@Nullable byte[] bytes) {

return (bytes == null ? null : new String(bytes, charset).replaceFirst(TenantContextHolder.getTenantId()+":", ""));

}

public byte[] serialize(@Nullable String string) {

if (StringUtils.isBlank(string)){

echoLog(string);

return null;

}

String tenantId = TenantContextHolder.getTenantId();

if (StringUtils.isBlank(tenantId)){

echoLog(string);

return string.getBytes(charset);

}

// 本身带有多租户ID的不拼接

if (string.indexOf(StringPool.COLON) > 0 && string.startsWith(TENANT_PREFIX)){

echoLog(string);

return string.getBytes(charset);

}

// true：拼接多租户ID

Boolean flag = true;

List ignoreEqualsKeys = redisProperties.getIgnoreEqualsKeys();

if (!CollectionUtils.isEmpty(ignoreEqualsKeys)){

for (String key: ignoreEqualsKeys

) {

if (key.equals(string)){

flag = false;

break;

}

}

}

if (flag){

List ignoreContainsKeys = redisProperties.getIgnoreContainsKeys();

if (!CollectionUtils.isEmpty(ignoreContainsKeys)){

for (String key: ignoreContainsKeys

) {

if (string.startsWith(key)){

flag = false;

break;

}

}

}

}

if (flag){

echoLog(tenantId + StringPool.COLON + string);

return (tenantId + StringPool.COLON + string).getBytes(charset);

}

echoLog(string);

return string.getBytes(charset);

}

private void echoLog(String key){

if (IS_LOG){

logger.info("redis的key:"+key);

}

}

public Class getTargetType() {

return String.class;

}

static {

US_ASCII = new StringRedisSerializer(StandardCharsets.US_ASCII);

ISO_8859_1 = new StringRedisSerializer(StandardCharsets.ISO_8859_1);

UTF_8 = new StringRedisSerializer(StandardCharsets.UTF_8);

}

}

redis config

package com.cherf.common.redis;

import com.fasterxml.jackson.annotation.JsonAutoDetect;

import com.fasterxml.jackson.annotation.PropertyAccessor;

import com.fasterxml.jackson.databind.ObjectMapper;

import com.cherf.common.redis.TenantStringRedisSerializer;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

import org.springframework.data.redis.connection.RedisConnectionFactory;

import org.springframework.data.redis.core.*;

import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;

import org.springframework.data.redis.serializer.StringRedisSerializer;

/**

* Redis配置

*

* @author cherf

* @date 2022-09-05 19:22

*/

@Configuration

public class RedisConfig {

@Bean("redisTemplate")

public RedisTemplate redisTemplate(RedisConnectionFactory factory) {

Jackson2JsonRedisSerializer