多租户Spring Data JPA应用中为动态数据源配置自动DDL

安全阿岳

2026-8-15

动态多租户数据源如何启用Hibernate自动DDL生成与验证

我正在开发基于Spring Data JPA的多租户Spring Boot原型应用，采用Hibernate官方文档中的Database多租户策略。租户数据库在应用启动时不可知，因此每当遇到未见过的租户标识符时，需从服务查询数据库连接信息并动态初始化DataSource。为满足启动配置（无租户标识符场景），我会从查询服务返回的首个租户创建“默认”数据源，其架构与数据库厂商和其他租户一致。

目前多数功能已正常运行：我的MultiTenantConnectionProvider实现会在运行时为请求租户匹配正确的DataSource，并按需创建新数据源。但问题在于，仅默认数据源会应用Spring/Hibernate的自动DDL配置。因此在使用嵌入式数据库且设置spring.jpa.hibernate.ddl-auto=create的开发环境中，默认租户可正常生成预期架构，其他租户则报错：

org.h2.jdbc.JdbcSQLSyntaxErrorException: Table "my_table" not found (this database is empty);

生产环境中，我不打算通过应用代码自动填充架构，但希望通过spring.jpa.hibernate.ddl-auto=validate进行架构验证。

我见过诸多动态初始化数据源的示例，但这些示例均假设架构已存在。请问如何让动态加载的数据源也能利用Spring/Hibernate的自动DDL生成与验证功能？

相关实现代码

多租户通用配置

@Configuration
public class TenantConfiguration implements WebMvcConfigurer, HibernatePropertiesCustomizer {

    private final String tenantHeader;
    private final TenantIdentifierResolver tenantIdentifierResolver;
    private final TenantConnectionProvider tenantConnectionProvider;

    public TenantConfiguration(final String tenantHeader,
            final TenantIdentifierResolver tenantIdentifierResolver,
            final TenantConnectionProvider tenantConnectionProvider) {
        this.tenantHeader = Objects.requireNonNull(tenantHeader);
        this.tenantIdentifierResolver = Objects.requireNonNull(tenantIdentifierResolver);
        this.tenantConnectionProvider = Objects.requireNonNull(tenantConnectionProvider);
    }

    @Override
    public void addInterceptors(final InterceptorRegistry registry) {
        registry.addInterceptor(new TenantRequestInterceptor(tenantHeader));
    }

    @Override
    public void customize(Map<String, Object> hibernateProperties) {
        hibernateProperties.put(AvailableSettings.MULTI_TENANT, MultiTenancyStrategy.DATABASE);
        hibernateProperties.put(AvailableSettings.MULTI_TENANT_IDENTIFIER_RESOLVER, tenantIdentifierResolver);
        hibernateProperties.put(AvailableSettings.MULTI_TENANT_CONNECTION_PROVIDER, tenantConnectionProvider);
    }

}

MultiTenantConnectionProvider实现

@Component
public class TenantConnectionProvider extends AbstractDataSourceBasedMultiTenantConnectionProviderImpl {

    private final DataSourceProperties dsProperties;
    private final TenantClient tenantClient;  // 前文提到的"查询服务"
    private final TenantIdentifierResolver tenantIdResolver;
    private final ConcurrentMap<String, DataSource> tenantDataSources;

    public TenantConnectionProvider(final DataSourceProperties dsProperties, final TenantClient tenantClient,
            final TenantIdentifierResolver tenantIdResolver) {
        this.dsProperties = Objects.requireNonNull(dsProperties);
        this.tenantClient = Objects.requireNonNull(tenantClient);
        this.tenantIdResolver = Objects.requireNonNull(tenantIdResolver);
        this.tenantDataSources = new ConcurrentHashMap<>();
    }

    @Override
    protected DataSource selectAnyDataSource() {
        return selectDataSource(null);
    }

    @Override
    protected DataSource selectDataSource(final String tenantId) {
        final String resolvedId = (tenantId == null) ? tenantIdResolver.resolveCurrentTenantIdentifier() : tenantId;
        return tenantDataSources.computeIfAbsent(resolvedId, v -> createDataSource(resolvedId));
    }

    private DataSource createDataSource(final String tenantId) {
        final TenantDatabase database = tenantClient.getTenantDatabase(tenantId);
        return dsProperties.initializeDataSourceBuilder()
                .url(String.format("jdbc:h2:mem:tenant-%s", tenantId)) // TODO: 替换为非硬编码的开发环境URL
                .username(database.getUser())
                .password(database.getPassword())
                .build();
    }
}

开发环境应用配置

spring.datasource.name=Multi-Tenant Data Source
spring.datasource.driver-class-name=org.h2.Driver
spring.datasource.type=com.zaxxer.hikari.HikariDataSource
spring.jpa.database=H2
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect
spring.jpa.hibernate.ddl-auto=create

解决方案

核心思路

Hibernate仅在启动阶段对默认数据源执行DDL操作，动态创建的租户数据源不会自动触发该流程。我们需要在每个租户数据源初始化完成后，手动调用Hibernate的Schema管理API，根据配置执行生成或验证操作。

具体实现步骤

扩展TenantConnectionProvider，添加Schema管理逻辑
注入EntityManagerFactory和Environment，在创建租户数据源后，根据spring.jpa.hibernate.ddl-auto配置执行对应DDL操作：

@Component
public class TenantConnectionProvider extends AbstractDataSourceBasedMultiTenantConnectionProviderImpl {

    // 新增依赖注入
    private final EntityManagerFactory entityManagerFactory;
    private final Environment environment;
    // 记录已初始化的租户，避免重复执行DDL
    private final Set<String> initializedTenants = ConcurrentHashMap.newKeySet();

    public TenantConnectionProvider(final DataSourceProperties dsProperties, final TenantClient tenantClient,
            final TenantIdentifierResolver tenantIdResolver, EntityManagerFactory entityManagerFactory,
            Environment environment) {
        this.dsProperties = Objects.requireNonNull(dsProperties);
        this.tenantClient = Objects.requireNonNull(tenantClient);
        this.tenantIdResolver = Objects.requireNonNull(tenantIdResolver);
        this.tenantDataSources = new ConcurrentHashMap<>();
        this.entityManagerFactory = Objects.requireNonNull(entityManagerFactory);
        this.environment = Objects.requireNonNull(environment);
    }

    private DataSource createDataSource(final String tenantId) {
        final TenantDatabase database = tenantClient.getTenantDatabase(tenantId);
        DataSource dataSource = dsProperties.initializeDataSourceBuilder()
                .url(String.format("jdbc:h2:mem:tenant-%s", tenantId))
                .username(database.getUser())
                .password(database.getPassword())
                .build();
        
        // 仅首次创建数据源时执行DDL
        if (initializedTenants.add(tenantId)) {
            executeSchemaManagement(dataSource);
        }
        return dataSource;
    }

    private void executeSchemaManagement(DataSource dataSource) {
        // 获取Hibernate核心服务
        SessionFactory sessionFactory = entityManagerFactory.unwrap(SessionFactory.class);
        ServiceRegistry serviceRegistry = sessionFactory.getSessionFactoryOptions().getServiceRegistry();
        JdbcServices jdbcServices = serviceRegistry.getService(JdbcServices.class);
        Dialect dialect = jdbcServices.getDialect();
        
        // 读取DDL配置
        String ddlAuto = environment.getProperty("spring.jpa.hibernate.ddl-auto", "none");
        
        // 创建Schema管理器并执行对应操作
        SchemaManager schemaManager = SchemaManager.create(jdbcServices.getJdbcConnectionAccess(dataSource::getConnection), dialect);
        switch (ddlAuto) {
            case "create":
                schemaManager.create(true);
                break;
            case "create-drop":
                schemaManager.drop(true);
                schemaManager.create(true);
                break;
            case "update":
                schemaManager.update(true);
                break;
            case "validate":
                schemaManager.validate();
                break;
            default:
                // 无操作
                break;
        }
    }
}

确保租户上下文隔离
如果你的TenantIdentifierResolver通过ThreadLocal存储当前租户，执行DDL时需临时切换租户上下文，避免污染后续请求：

// 修改executeSchemaManagement方法，添加上下文切换逻辑
private void executeSchemaManagement(DataSource dataSource, String tenantId) {
    TenantIdentifierResolverImpl resolver = (TenantIdentifierResolverImpl) tenantIdResolver;
    String originalTenant = resolver.resolveCurrentTenantIdentifier();
    
    try {
        // 临时设置当前租户
        resolver.setCurrentTenant(tenantId);
        // 原有的Schema管理代码...
    } finally {
        // 恢复原有租户上下文
        resolver.setCurrentTenant(originalTenant);
    }
}

// 对应的TenantIdentifierResolver实现需扩展setCurrentTenant方法
@Component
public class TenantIdentifierResolverImpl implements TenantIdentifierResolver {
    private final ThreadLocal<String> currentTenant = new ThreadLocal<>();
    private final TenantClient tenantClient;

    public TenantIdentifierResolverImpl(TenantClient tenantClient) {
        this.tenantClient = tenantClient;
        // 初始化默认租户
        currentTenant.set(tenantClient.getDefaultTenantId());
    }

    @Override
    public String resolveCurrentTenantIdentifier() {
        return currentTenant.get();
    }

    @Override
    public boolean validateExistingCurrentSessions() {
        return true;
    }

    // 新增方法：设置当前租户
    public void setCurrentTenant(String tenantId) {
        currentTenant.set(tenantId);
    }
}

生产环境优化建议
- 生产环境将spring.jpa.hibernate.ddl-auto设为validate，仅验证架构一致性，避免意外修改数据库结构。
- 若租户数据库预先创建，可将DDL验证逻辑放在租户首次请求时执行一次，后续不再重复操作（通过initializedTenants集合控制）。

替代方案：启动时初始化已知租户

如果系统中租户列表可在启动时获取，可通过ApplicationRunner提前初始化所有已知租户的数据源并执行DDL：

@Component
public class TenantInitializer implements ApplicationRunner {

    private final TenantClient tenantClient;
    private final TenantConnectionProvider connectionProvider;

    public TenantInitializer(TenantClient tenantClient, TenantConnectionProvider connectionProvider) {
        this.tenantClient = tenantClient;
        this.connectionProvider = connectionProvider;
    }

    @Override
    public void run(ApplicationArguments args) throws Exception {
        // 获取所有已知租户ID
        List<String> tenantIds = tenantClient.getAllTenantIds();
        for (String tenantId : tenantIds) {
            // 触发数据源创建和DDL执行
            connectionProvider.selectDataSource(tenantId);
        }
    }
}

内容的提问来源于stack exchange，提问作者chaserb

多租户Spring Data JPA应用中为动态数据源配置自动DDL

相关实现代码 #

多租户通用配置 #

MultiTenantConnectionProvider实现 #

开发环境应用配置 #

解决方案 #

核心思路 #

具体实现步骤 #

替代方案：启动时初始化已知租户 #