使用同一持久化单元访问不同数据源的教程

import org.hibernate.engine.jdbc.connections.spi.MultiTenantConnectionProvider;
import java.sql.Connection;
import java.sql.SQLException;
import javax.sql.DataSource;
import org.hibernate.HibernateException;
import org.hibernate.engine.config.spi.ConfigurationService;
import org.hibernate.engine.jdbc.connections.spi.ConnectionProvider;
import org.hibernate.service.spi.Stoppable;
import org.hibernate.service.spi.ServiceRegistryAwareService;
import org.hibernate.service.spi.ServiceRegistryImplementor;

public class MyMultiTenantConnectionProvider implements MultiTenantConnectionProvider, ServiceRegistryAwareService, Stoppable {

    private DataSource defaultDataSource;
    private Map<String, DataSource> tenantDataSources = new HashMap<>();

    @Override
    public void injectServices(ServiceRegistryImplementor serviceRegistry) {
        // 获取默认数据源
        defaultDataSource = (DataSource) serviceRegistry.getService(DataSource.class);

        // 初始化租户数据源，可以从配置文件或数据库加载
        // 示例： tenantDataSources.put("tenant1", createDataSource("jdbc:mysql://localhost:3306/tenant1", "user1", "password"));
        //       tenantDataSources.put("tenant2", createDataSource("jdbc:mysql://localhost:3306/tenant2", "user2", "password"));
    }

    @Override
    public Connection getConnection(String tenantIdentifier) throws SQLException {
        DataSource dataSource = tenantDataSources.getOrDefault(tenantIdentifier, defaultDataSource);
        if (dataSource == null) {
            throw new HibernateException("No datasource configured for tenant: " + tenantIdentifier);
        }
        return dataSource.getConnection();
    }

    @Override
    public void releaseConnection(String tenantIdentifier, Connection connection) throws SQLException {
        connection.close();
    }

    @Override
    public boolean isUnwrappableAs(Class unwrapType) {
        return false;
    }

    @Override
    public <T> T unwrap(Class<T> unwrapType) {
        return null;
    }

    @Override
    public boolean supportsAggressiveRelease() {
        return false;
    }

    @Override
    public void stop() {
        // 清理资源
        tenantDataSources.clear();
    }

    private DataSource createDataSource(String url, String user, String password) {
        // 创建数据源，例如使用 HikariCP
        HikariConfig config = new HikariConfig();
        config.setJdbcUrl(url);
        config.setUsername(user);
        config.setPassword(password);
        return new HikariDataSource(config);
    }
}

import org.hibernate.context.spi.CurrentTenantIdentifierResolver;

public class MyCurrentTenantIdentifierResolver implements CurrentTenantIdentifierResolver {

    private static final ThreadLocal<String> currentTenant = new ThreadLocal<>();

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

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

    @Override
    public String resolveCurrentTenantIdentifier() {
        String tenantId = currentTenant.get();
        return (tenantId != null) ? tenantId : "default"; // 返回默认租户标识
    }

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

<persistence-unit name="myPersistenceUnit">
    <properties>
        <property name="hibernate.multiTenancy" value="DATABASE"/>
        <property name="hibernate.multi_tenant_connection_provider" value="com.example.MyMultiTenantConnectionProvider"/>
        <property name="hibernate.tenant_identifier_resolver" value="com.example.MyCurrentTenantIdentifierResolver"/>
        <!-- 其他Hibernate配置 -->
    </properties>
</persistence-unit>

@PersistenceUnit(unitName = "myPersistenceUnit")
EntityManagerFactory emf;

public void doSomething(String tenantId) {
    MyCurrentTenantIdentifierResolver.setCurrentTenant(tenantId);
    EntityManager em = emf.createEntityManager();
    try {
        // 执行数据库操作
    } finally {
        em.close();
        MyCurrentTenantIdentifierResolver.clearCurrentTenant(); // 清理ThreadLocal
    }
}