使用同一持久化单元访问不同数据源的教程：基于 Hibernate 多租户实现

本文档介绍了如何在使用 Java 17、Wildfly 25.0.1 和 JPA over Hibernate 5.3 的环境中，通过编程方式选择不同的数据源，并使用相同的持久化单元访问不同客户的数据库副本。核心思路是利用 Hibernate 的多租户特性，通过实现 MultitenantConnectionProvider 和 CurrentTenantIdentifierResolver 来动态切换数据源，从而避免为每个客户创建单独的持久化单元。

在多租户应用中，通常需要根据不同的租户（例如，不同的客户）访问不同的数据库实例。如果为每个租户都配置一个持久化单元，当租户数量增长时，配置和维护成本会显著增加。Hibernate 提供了多租户支持，允许我们使用相同的实体映射和持久化单元，但根据当前租户动态地切换数据源。

Hibernate 多租户实现的关键组件：

1. MultitenantConnectionProvider: 该接口负责提供与特定租户关联的数据库连接。我们需要实现这个接口，根据当前租户的标识符返回对应的 java.sql.Connection。

2. CurrentTenantIdentifierResolver: 该接口负责解析当前租户的标识符。我们需要实现这个接口，根据当前请求的上下文（例如，Session 或 Transaction Context）返回当前租户的标识符。

实现步骤：

1. 创建 MultitenantConnectionProvider 实现：

   import org.hibernate.engine.jdbc.connections.spi.MultiTenantConnectionProvider;
   import org.hibernate.service.spi.ServiceRegistryAwareService;
   import org.hibernate.service.spi.ServiceRegistryImplementor;
   import org.hibernate.cfg.AvailableSettings;
   
   import javax.sql.DataSource;
   import java.sql.Connection;
   import java.sql.SQLException;
   import java.util.Map;
   import java.util.HashMap;
   
   public class MyMultitenantConnectionProvider implements MultiTenantConnectionProvider, ServiceRegistryAwareService {
   
       private DataSource defaultDataSource;
       private Map<String, DataSource> tenantDataSources = new HashMap<>();
   
       @Override
       public void injectServices(ServiceRegistryImplementor serviceRegistry) {
           Map settings = serviceRegistry.getSettings();
           this.defaultDataSource = (DataSource) settings.get(AvailableSettings.DATASOURCE);
   
           // 假设你已经有了一个根据租户ID获取DataSource的方法
           // 实际应用中需要根据你的配置方式加载租户数据源
           tenantDataSources.put("tenant1", getDataSourceForTenant("tenant1"));
           tenantDataSources.put("tenant2", getDataSourceForTenant("tenant2"));
           // ...
       }
   
       private DataSource getDataSourceForTenant(String tenantId) {
           // 实现根据租户ID获取DataSource的逻辑
           // 例如，从JNDI获取、从配置文件读取等
           // 这部分代码取决于你的数据源配置方式
           // 示例:
           // try {
           //     Context ctx = new InitialContext();
           //     return (DataSource) ctx.lookup("java:jboss/datasources/" + tenantId + "DS");
           // } catch (NamingException e) {
           //     throw new RuntimeException("Failed to lookup datasource for tenant: " + tenantId, e);
           // }
           return null; // 替换为实际的数据源获取逻辑
       }
   
       @Override
       public Connection getAnyConnection() throws SQLException {
           return defaultDataSource.getConnection();
       }
   
       @Override
       public void releaseAnyConnection(Connection connection) throws SQLException {
           connection.close();
       }
   
       @Override
       public Connection getConnection(String tenantIdentifier) throws SQLException {
           DataSource dataSource = tenantDataSources.get(tenantIdentifier);
           if (dataSource == null) {
               // 如果找不到租户的数据源，可以使用默认数据源，或者抛出异常
               dataSource = defaultDataSource;
               if (dataSource == null) {
                   throw new IllegalStateException("No datasource found 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 true;
       }
   }

   登录后复制

2. 创建 CurrentTenantIdentifierResolver 实现：

   import org.hibernate.context.spi.CurrentTenantIdentifierResolver;
   
   public class MyCurrentTenantIdentifierResolver implements CurrentTenantIdentifierResolver {
   
       @Override
       public String resolveCurrentTenantIdentifier() {
           // 从当前请求的上下文中获取租户ID
           // 例如，从Session、ThreadLocal、HTTP Header等
           String tenantId = TenantContext.getTenantId(); // 假设TenantContext是一个ThreadLocal
           if (tenantId == null) {
               // 可以返回一个默认的租户ID，或者抛出异常
               return "default_tenant";
           }
           return tenantId;
       }
   
       @Override
       public boolean validateExistingCurrentSessions() {
           return true;
       }
   }

   登录后复制

   注意： 上面的代码中使用了一个 TenantContext 类，这通常是一个 ThreadLocal 变量，用于在请求的上下文中存储当前租户的标识符。 你需要根据你的实际应用场景实现 TenantContext。

   

   硅基智能

   基于Web3.0的元宇宙，去中心化的互联网，高质量、沉浸式元宇宙直播平台，用数字化重新定义直播

   62

   查看详情

3. 配置 Hibernate：

   在 persistence.xml 文件中，配置 Hibernate 使用你实现的 MultitenantConnectionProvider 和 CurrentTenantIdentifierResolver。

   <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>

   登录后复制

4. 使用：

   在使用 EntityManager 时，确保在调用数据库操作之前，设置正确的租户标识符。

   // 设置当前租户
   TenantContext.setTenantId("tenant1");
   
   // 执行数据库操作
   EntityManager em = entityManagerFactory.createEntityManager();
   em.getTransaction().begin();
   // ...
   em.getTransaction().commit();
   em.close();
   
   // 清除租户信息
   TenantContext.clear();

   登录后复制

注意事项：

• 确保你的数据源配置正确，并且每个租户都有对应的数据源。
• TenantContext 的实现需要线程安全，通常使用 ThreadLocal。
• 在事务边界内设置和清除租户信息，避免数据泄露。
• 在 Wildfly 中，数据源的配置可能需要通过 JNDI 查找，具体取决于你的部署方式。
• 需要仔细考虑默认租户的处理方式，避免未授权访问。
• 该方案要求所有租户的数据库结构相同。如果不同租户的数据库结构不同，则需要考虑其他多租户方案，例如schema隔离。

总结：

通过使用 Hibernate 的多租户特性，我们可以有效地管理多个租户的数据访问，并避免为每个租户创建单独的持久化单元。 关键在于正确地实现 MultitenantConnectionProvider 和 CurrentTenantIdentifierResolver，并确保在事务边界内设置和清除租户信息。 此外，根据实际应用场景，可能需要调整数据源的配置方式和租户信息的存储方式。

以上就是使用同一持久化单元访问不同数据源的教程：基于 Hibernate 多租户实现的详细内容，更多请关注php中文网其它相关文章！