Spring Boot中的多租户架构设计：单一实例支持多个客户

引言

大家好，欢迎来到今天的讲座！今天我们要聊一聊如何在Spring Boot中实现多租户架构。想象一下，你正在开发一个SaaS（Software as a Service）应用，这个应用需要同时服务于多个客户。每个客户都有自己独立的数据和配置，但你又不想为每个客户都部署一个单独的实例。那么，多租户架构就是你的救星！

在接下来的时间里，我们将一起探讨如何通过Spring Boot实现多租户架构，让一个实例能够同时支持多个客户。我们会用轻松诙谐的语言，结合代码示例，帮助你理解这一复杂但非常有用的技术。

什么是多租户架构？

首先，让我们来了解一下什么是多租户架构。简单来说，多租户架构是指在一个应用程序中，多个客户（或“租户”）可以共享同一个实例，但每个客户的数据和配置是相互隔离的。这样做的好处是：

• 资源利用率高：不需要为每个客户单独部署应用，节省了服务器资源。
• 维护成本低：只需要维护一个代码库，减少了更新和打补丁的工作量。
• 扩展性强：可以根据客户需求灵活添加或删除租户，而不会影响其他租户。

多租户架构有多种实现方式，常见的有以下几种：

1. 数据库分离：每个租户使用独立的数据库。
2. 模式分离：所有租户共享同一个数据库，但每个租户有自己的数据库模式（Schema）。
3. 数据分离：所有租户共享同一个数据库和表，但在表中增加一个tenant_id字段来区分不同租户的数据。

今天我们主要讨论的是第三种方式——数据分离，因为它最常见且易于实现。

数据分离的基本思路

在数据分离的方式下，我们会在每张表中增加一个tenant_id字段，用来标识数据属于哪个租户。例如，假设我们有一个用户表users，结构如下：

CREATE TABLE users (
    id BIGINT AUTO_INCREMENT PRIMARY KEY,
    tenant_id VARCHAR(50) NOT NULL,  -- 租户ID
    username VARCHAR(100) NOT NULL,
    email VARCHAR(100),
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

每次查询或插入数据时，我们都需要确保tenant_id是正确的，这样才能保证不同租户的数据不会混淆。为了实现这一点，我们需要在应用程序中动态地设置tenant_id，并在每次数据库操作时自动加上这个条件。

如何动态设置 tenant_id？

在Spring Boot中，我们可以使用ThreadLocal来存储当前请求的tenant_id。ThreadLocal是一个线程局部变量，每个线程都有自己独立的副本，因此可以安全地存储与当前请求相关的数据。

我们可以通过一个过滤器（Filter）来截获每个请求，并从中提取出tenant_id，然后将其存入ThreadLocal中。下面是一个简单的实现：

import org.springframework.stereotype.Component;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import java.io.IOException;

@Component
public class TenantFilter implements Filter {

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        // 初始化过滤器
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        // 从请求头中获取租户ID
        String tenantId = ((HttpServletRequest) request).getHeader("X-Tenant-ID");
        if (tenantId != null) {
            // 将租户ID存入ThreadLocal
            TenantContext.setTenantId(tenantId);
        }
        try {
            // 继续处理请求
            chain.doFilter(request, response);
        } finally {
            // 请求结束后清理ThreadLocal
            TenantContext.clear();
        }
    }

    @Override
    public void destroy() {
        // 销毁过滤器
    }
}

在这里，我们通过X-Tenant-ID请求头来传递租户ID，并将其存入TenantContext类的ThreadLocal中。TenantContext类的实现如下：

public class TenantContext {
    private static final ThreadLocal<String> currentTenant = new ThreadLocal<>();

    public static void setTenantId(String tenantId) {
        currentTenant.set(tenantId);
    }

    public static String getTenantId() {
        return currentTenant.get();
    }

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

自动添加 tenant_id 条件

接下来，我们需要确保每次执行数据库查询时，都会自动加上tenant_id的条件。在Spring Data JPA中，我们可以通过自定义Repository来实现这一点。

首先，创建一个自定义的TenantAwareQueryDslPredicateExecutor接口，继承自QueryDslPredicateExecutor，并添加对tenant_id的支持：

public interface TenantAwareQueryDslPredicateExecutor<T> extends QueryDslPredicateExecutor<T> {
    default Predicate withTenant(Predicate predicate) {
        String tenantId = TenantContext.getTenantId();
        if (tenantId == null) {
            return predicate;
        }
        QUser user = QUser.user;  // 假设我们有一个QUser类
        return predicate.and(user.tenantId.eq(tenantId));
    }
}

然后，创建一个自定义的TenantAwareJpaRepository接口，继承自JpaRepository和TenantAwareQueryDslPredicateExecutor：

public interface TenantAwareJpaRepository<T, ID> extends JpaRepository<T, ID>, TenantAwareQueryDslPredicateExecutor<T> {
}

最后，在你的实体仓库中使用TenantAwareJpaRepository，而不是默认的JpaRepository：

public interface UserRepository extends TenantAwareJpaRepository<User, Long> {
}

现在，每次调用UserRepository的查询方法时，都会自动加上tenant_id的条件，确保返回的数据只属于当前租户。

多租户配置管理

除了数据分离，多租户架构还需要考虑配置的隔离。不同的租户可能有不同的配置，比如数据库连接、API密钥、邮件服务器等。为了实现这一点，我们可以使用Spring的@ConfigurationProperties注解来动态加载租户的配置。

首先，创建一个TenantProperties类，用于存储租户的配置：

import org.springframework.boot.context.properties.ConfigurationProperties;
import java.util.Map;

@ConfigurationProperties(prefix = "tenants")
public class TenantProperties {
    private Map<String, TenantConfig> configs;

    public Map<String, TenantConfig> getConfigs() {
        return configs;
    }

    public void setConfigs(Map<String, TenantConfig> configs) {
        this.configs = configs;
    }

    public static class TenantConfig {
        private String databaseUrl;
        private String apiKey;
        private String mailServer;

        // Getters and Setters
    }
}

然后，在application.yml中配置多个租户的属性：

tenants:
  config:
    tenant1:
      database-url: jdbc:mysql://localhost:3306/tenant1_db
      api-key: abc123
      mail-server: smtp.tenant1.com
    tenant2:
      database-url: jdbc:mysql://localhost:3306/tenant2_db
      api-key: def456
      mail-server: smtp.tenant2.com

最后，编写一个TenantConfigResolver类，根据当前的tenant_id动态加载相应的配置：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class TenantConfigResolver {

    private final TenantProperties tenantProperties;

    @Autowired
    public TenantConfigResolver(TenantProperties tenantProperties) {
        this.tenantProperties = tenantProperties;
    }

    public TenantProperties.TenantConfig resolve(String tenantId) {
        return tenantProperties.getConfigs().get(tenantId);
    }
}

通过这种方式，你可以在运行时根据租户ID动态加载不同的配置，确保每个租户都能使用自己独立的设置。

总结

好了，今天的讲座就到这里！我们详细讨论了如何在Spring Boot中实现多租户架构，特别是通过数据分离的方式，让一个实例能够同时支持多个客户。我们还介绍了如何使用ThreadLocal来动态设置tenant_id，并通过自定义Repository来确保每次查询都带上正确的租户条件。最后，我们探讨了如何通过@ConfigurationProperties来实现租户配置的隔离。

希望今天的分享对你有所帮助！如果你有任何问题或想法，欢迎在评论区留言交流。下次再见！