多租户（Multi-Tenant）是指一个软件系统同时服务多个客户（租户），每个租户拥有独立的业务空间，但共享相同的基础设施。SaaS 系统的多租户架构设计需要解决两个核心问题：

• • 数据隔离： 确保租户之间的数据互不干扰，满足安全和合规要求。
• • 资源配额： 控制每个租户使用的系统资源（如存储、API 调用次数），避免资源滥用。

1. 数据隔离方案对比

常见的数据隔离方案有三种，各有优缺点：

2. 数据库级别隔离实现

架构设计：

核心代码实现（数据源动态切换） ：

/**
 * 动态数据源路由
 */
publicclassTenantRoutingDataSourceextendsAbstractRoutingDataSource {
    
    @Override
    protected Object determineCurrentLookupKey() {
        // 从线程上下文中获取当前租户ID
        return TenantContextHolder.getTenantId();
    }
}

/**
 * 租户上下文持有者（使用ThreadLocal存储租户ID）
 */
publicclassTenantContextHolder {
    
    privatestaticfinal ThreadLocal<String> CONTEXT = newThreadLocal<>();
    
    publicstaticvoidsetTenantId(String tenantId) {
        CONTEXT.set(tenantId);
    }
    
    publicstatic String getTenantId() {
        return CONTEXT.get();
    }
    
    publicstaticvoidclear() {
        CONTEXT.remove();
    }
}

/**
 * 数据源配置
 */
@Configuration
publicclassDataSourceConfig {
    
    @Bean
    public DataSource dataSource() {
        TenantRoutingDataSourceroutingDataSource=newTenantRoutingDataSource();
        
        // 初始化所有租户的数据源
        Map<Object, Object> targetDataSources = newHashMap<>();
        for (TenantConfig tenant : tenantConfigService.getAllTenants()) {
            targetDataSources.put(tenant.getTenantId(), 
                    createDataSource(tenant.getDbUrl(), tenant.getDbUser(), tenant.getDbPassword()));
        }
        
        routingDataSource.setDefaultTargetDataSource(defaultDataSource());
        routingDataSource.setTargetDataSources(targetDataSources);
        return routingDataSource;
    }
    
    // 其他配置方法...
}

3. 表级别隔离实现

架构设计：

核心代码实现（表名动态生成） ：

/**
 * 表名处理器（基于MyBatis拦截器）
 */
@Intercepts({
    @Signature(type = StatementHandler.class, method = "prepare", args = {Connection.class, Integer.class})
})
publicclassTableNameInterceptorimplementsInterceptor {
    
    @Override
    public Object intercept(Invocation invocation)throws Throwable {
        StatementHandlerstatementHandler= (StatementHandler) invocation.getTarget();
        BoundSqlboundSql= statementHandler.getBoundSql();
        StringoriginalSql= boundSql.getSql();
        StringtenantId= TenantContextHolder.getTenantId();
        
        // 替换表名（添加租户前缀）
        StringmodifiedSql= replaceTableNames(originalSql, tenantId);
        
        // 通过反射修改SQL
        FieldsqlField= boundSql.getClass().getDeclaredField("sql");
        sqlField.setAccessible(true);
        sqlField.set(boundSql, modifiedSql);
        
        return invocation.proceed();
    }
    
    private String replaceTableNames(String sql, String tenantId) {
        // 简单实现，实际应使用正则表达式或SQL解析器
        return sql.replaceAll("\b(user|order)\b", tenantId + "_$1");
    }
}

4. 行级别隔离实现

架构设计：

​

核心代码实现（自动注入租户 ID） ：

/**
 * MyBatis拦截器：自动注入租户ID
 */
@Intercepts({
    @Signature(type = Executor.class, method = "update", args = {MappedStatement.class, Object.class})
})
publicclassTenantIdInterceptorimplementsInterceptor {
    
    @Override
    public Object intercept(Invocation invocation)throws Throwable {
        Objectparameter= invocation.getArgs()[1];
        StringtenantId= TenantContextHolder.getTenantId();
        
        // 如果参数是实体类，自动注入tenantId
        if (parameter instanceof BaseEntity) {
            ((BaseEntity) parameter).setTenantId(tenantId);
        }
        
        return invocation.proceed();
    }
}

/**
 * JPA规范：自动添加租户ID条件
 */
publicclassTenantAwareJpaRepository<T, ID> extendsSimpleJpaRepository<T, ID> {
    
    privatefinal EntityManager entityManager;
    privatefinal Class<T> domainClass;
    
    publicTenantAwareJpaRepository(JpaEntityInformation<T, ?> entityInformation, 
                                  EntityManager entityManager) {
        super(entityInformation, entityManager);
        this.entityManager = entityManager;
        this.domainClass = entityInformation.getJavaType();
    }
    
    @Override
    public List<T> findAll() {
        CriteriaBuildercb= entityManager.getCriteriaBuilder();
        CriteriaQuery<T> query = cb.createQuery(domainClass);
        Root<T> root = query.from(domainClass);
        
        // 添加租户ID条件
        query.where(cb.equal(root.get("tenantId"), TenantContextHolder.getTenantId()));
        
        return entityManager.createQuery(query).getResultList();
    }
}

1. 资源配额管理模型

设计一个通用的资源配额模型，支持多种资源类型：

/**
 * 资源配额实体
 */
@Entity
@Table(name = "tenant_quota")
publicclassTenantQuota {
    
    @Id
    private String tenantId;
    
    // 存储配额（MB）
    private Long storageQuota;
    
    // 已使用存储（MB）
    private Long storageUsed;
    
    // API调用次数配额
    private Long apiCallQuota;
    
    // 已使用API调用次数
    private Long apiCallsUsed;
    
    // 并发用户数配额
    private Integer concurrentUserQuota;
    
    // 上次更新时间
    private LocalDateTime lastUpdateTime;
    
    // 资源使用记录方法
    publicbooleancanUseStorage(long size) {
        return (storageUsed + size) <= storageQuota;
    }
    
    publicbooleanuseStorage(long size) {
        if (!canUseStorage(size)) {
            returnfalse;
        }
        this.storageUsed += size;
        returntrue;
    }
    
    // 其他资源使用方法...
}

2. 基于拦截器的配额控制实现

/**
 * API调用配额拦截器
 */
publicclassQuotaInterceptorimplementsHandlerInterceptor {
    
    @Autowired
    private TenantQuotaService quotaService;
    
    @Override
    publicbooleanpreHandle(HttpServletRequest request, 
                             HttpServletResponse response, 
                             Object handler)throws Exception {
        
        StringtenantId= getTenantIdFromRequest(request);
        TenantQuotaquota= quotaService.getQuota(tenantId);
        
        // 检查API调用配额
        if (quota.getApiCallsUsed() >= quota.getApiCallQuota()) {
            response.setStatus(HttpStatus.TOO_MANY_REQUESTS.value());
            response.getWriter().write("API调用超出配额");
            returnfalse;
        }
        
        // 记录API调用
        quotaService.recordApiCall(tenantId);
        returntrue;
    }
}

3. 分布式环境下的配额控制

使用 Redis 实现分布式计数器，确保并发场景下的配额精确控制：

/**
 * 基于Redis的分布式配额服务
 */
@Service
publicclassRedisQuotaServiceImplimplementsQuotaService {
    
    @Autowired
    private RedisTemplate<String, Long> redisTemplate;
    
    privatestaticfinalStringQUOTA_KEY_PREFIX="tenant:quota:";
    privatestaticfinalStringUSAGE_KEY_PREFIX="tenant:usage:";
    
    @Override
    publicbooleancheckAndConsume(String tenantId, String resourceType, long amount) {
        StringquotaKey= QUOTA_KEY_PREFIX + tenantId + ":" + resourceType;
        StringusageKey= USAGE_KEY_PREFIX + tenantId + ":" + resourceType;
        
        // 获取配额
        Longquota= redisTemplate.opsForValue().get(quotaKey);
        if (quota == null || quota <= 0) {
            returnfalse;
        }
        
        // 使用Lua脚本原子性检查并消费资源
        Stringscript=
            "local usage = redis.call('GET', KEYS[2]) or 0 " +
            "if usage + ARGV[1] > tonumber(ARGV[2]) then " +
            "  return 0 " +
            "else " +
            "  return redis.call('INCRBY', KEYS[2], ARGV[1]) " +
            "end";
        
        Longresult= redisTemplate.execute(
            newDefaultRedisScript<>(script, Long.class),
            Arrays.asList(quotaKey, usageKey),
            amount, quota);
            
        return result != null && result > 0;
    }
}

1. 租户识别与认证

/**
 * JWT过滤器：从Token中提取租户ID
 */
publicclassJwtAuthenticationFilterextendsOncePerRequestFilter {
    
    @Override
    protectedvoiddoFilterInternal(HttpServletRequest request, 
                                    HttpServletResponse response, 
                                    FilterChain filterChain)throws ServletException, IOException {
        
        Stringtoken= extractToken(request);
        if (token != null) {
            try {
                Claimsclaims= Jwts.parser()
                    .setSigningKey(secretKey)
                    .parseClaimsJws(token)
                    .getBody();
                
                // 提取租户ID并设置到上下文中
                StringtenantId= claims.get("tenantId", String.class);
                TenantContextHolder.setTenantId(tenantId);
            } catch (Exception e) {
                response.setStatus(HttpStatus.UNAUTHORIZED.value());
                return;
            }
        }
        
        filterChain.doFilter(request, response);
    }
}

2. 细粒度权限控制

使用 Spring Security 实现基于租户的权限控制：

/**
 * 租户权限表达式
 */
publicclassTenantSecurityExpressionRootextendsSecurityExpressionRoot
        implementsMethodSecurityExpressionOperations {
    
    private Object filterObject;
    private Object returnObject;
    
    publicTenantSecurityExpressionRoot(Authentication authentication) {
        super(authentication);
    }
    
    /**
     * 判断当前用户是否属于指定租户
     */
    publicbooleanisTenantUser(String tenantId) {
        StringcurrentTenantId= TenantContextHolder.getTenantId();
        return currentTenantId != null && currentTenantId.equals(tenantId);
    }
    
    // 其他权限方法...
    
    @Override
    publicvoidsetFilterObject(Object filterObject) {
        this.filterObject = filterObject;
    }
    
    @Override
    public Object getFilterObject() {
        return filterObject;
    }
    
    @Override
    publicvoidsetReturnObject(Object returnObject) {
        this.returnObject = returnObject;
    }
    
    @Override
    public Object getReturnObject() {
        return returnObject;
    }
    
    @Override
    public Object getThis() {
        returnthis;
    }
}

1. 数据隔离方案选择建议

2. 资源配额控制最佳实践

• • 分层控制： 同时实现应用层和基础设施层的配额控制。
• • 预付费机制： 支持按使用量计费（Pay-as-you-go）和预付费模式。
• • 弹性扩展： 当租户资源使用接近配额时，提供升级提示。
• • 监控与告警： 实时监控资源使用情况，设置异常使用告警。