基于Hibernate多租户实现单持久化单元访问多数据源

import org.hibernate.engine.jdbc.connections.spi.MultiTenantConnectionProvider;
import org.springframework.beans.factory.annotation.Autowired; // 示例中使用Spring，实际可根据DI框架调整
import org.springframework.stereotype.Component;

import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

// 假设我们通过JNDI查找数据源，或者预先配置好数据源映射
// 在Wildfly中，通常通过JNDI名称来查找数据源
@Component // 示例：使用Spring注解，实际项目中可能通过CDI或其他方式管理
public class TenantConnectionProvider implements MultiTenantConnectionProvider {

    private final Map<String, DataSource> dataSourceMap = new ConcurrentHashMap<>();

    // 实际项目中，这些JNDI名称可能从配置文件或数据库中动态加载
    public TenantConnectionProvider() {
        // 示例：硬编码两个数据源，实际应动态配置
        try {
            InitialContext context = new InitialContext();
            dataSourceMap.put("tenantA", (DataSource) context.lookup("java:/jdbc/TenantADataSource"));
            dataSourceMap.put("tenantB", (DataSource) context.lookup("java:/jdbc/TenantBDataSource"));
            // 可以在此处加载更多租户的数据源配置
        } catch (NamingException e) {
            throw new RuntimeException("Error looking up data sources", e);
        }
    }

    @Override
    public Connection getConnection(String tenantIdentifier) throws SQLException {
        DataSource dataSource = dataSourceMap.get(tenantIdentifier);
        if (dataSource == null) {
            // 可以抛出异常，或返回默认数据源的连接
            throw new IllegalStateException("No data source found for tenant: " + tenantIdentifier);
        }
        return dataSource.getConnection();
    }

    @Override
    public Connection getAnyConnection() throws SQLException {
        // 当没有租户标识时，或者在某些元数据操作时调用。
        // 可以返回一个默认的连接，或者抛出异常。
        if (dataSourceMap.isEmpty()) {
            throw new IllegalStateException("No data sources configured.");
        }
        // 返回任意一个数据源的连接，例如第一个
        return dataSourceMap.values().iterator().next().getConnection();
    }

    @Override
    public void releaseConnection(String tenantIdentifier, Connection connection) throws SQLException {
        // 将连接返回给对应的连接池
        connection.close();
    }

    @Override
    public void releaseAnyConnection(Connection connection) throws SQLException {
        connection.close();
    }

    @Override
    public boolean supportsAggressiveRelease() {
        return false; // 通常设置为false，让连接池管理连接
    }

    @Override
    public boolean is </pre>
    <pre>  ConnectionHandlingCapable() {
        return true;
    }
}

import org.hibernate.context.spi.CurrentTenantIdentifierResolver;
import org.springframework.stereotype.Component;

// 示例：使用Spring注解，实际项目中可能通过CDI或其他方式管理
@Component
public class TenantIdentifierResolver implements CurrentTenantIdentifierResolver {

    // 使用ThreadLocal存储当前租户标识
    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 clearTenantId() {
        currentTenant.remove();
    }

    @Override
    public String resolveCurrentTenantIdentifier() {
        String tenantId = currentTenant.get();
        if (tenantId != null) {
            return tenantId;
        }
        // 如果没有设置租户ID，可以返回一个默认值或抛出异常
        // 在某些场景下，例如公共数据（非租户特定）查询时，可能需要一个默认租户
        // 或者，如果没有租户ID，就抛出异常，强制业务代码设置
        return "defaultTenant"; // 示例：返回一个默认租户，实际情况应根据业务决定
    }

    @Override
    public boolean validateExistingCurrentSessions() {
        return true; // 通常设置为true
    }
}

<persistence xmlns="http://xmlns.jcp.org/xml/ns/persistence"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence
             http://xmlns.jcp.org/xml/ns/persistence/persistence_2_2.xsd"
             version="2.2">
    <persistence-unit name="myPersistenceUnit" transaction-type="JTA">
        <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
        <jta-data-source>java:/jdbc/DefaultDataSource</jta-data-source> <!-- 这里的JTA数据源可以是一个默认的或用于元数据操作的 -->
        <properties>
            <!-- 启用Hibernate多租户模式：SCHEMA 或 DATABASE -->
            <!-- 这里选择DATABASE模式，因为我们是切换不同的数据库实例 -->
            <property name="hibernate.multiTenancy" value="DATABASE"/>

            <!-- 配置自定义的MultiTenantConnectionProvider -->
            <property name="hibernate.multi_tenant_connection_provider"
                      value="com.example.multi.tenancy.TenantConnectionProvider"/>

            <!-- 配置自定义的CurrentTenantIdentifierResolver -->
            <property name="hibernate.tenant_identifier_resolver"
                      value="com.example.multi.tenancy.TenantIdentifierResolver"/>

            <!-- 其他Hibernate属性，例如方言、DDL生成等 -->
            <property name="hibernate.dialect" value="org.hibernate.dialect.PostgreSQLDialect"/>
            <property name="hibernate.hbm2ddl.auto" value="update"/>
            <property name="hibernate.show_sql" value="true"/>
            <property name="hibernate.format_sql" value="true"/>
        </properties>
    </persistence-unit>
</persistence>

import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;

@WebFilter("/*")
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 {
        HttpServletRequest httpRequest = (HttpServletRequest) request;
        // 假设租户ID从请求头中获取，例如 "X-Tenant-ID"
        String tenantId = httpRequest.getHeader("X-Tenant-ID");

        if (tenantId == null || tenantId.isEmpty()) {
            // 如果没有提供租户ID，可以抛出异常，或者使用默认租户
            // response.sendError(HttpServletResponse.SC_BAD_REQUEST, "Missing X-Tenant-ID header");
            // return;
            tenantId = "defaultTenant"; // 示例：如果未提供，使用默认租户
        }

        TenantIdentifierResolver.setTenantId(tenantId);
        try {
            chain.doFilter(request, response);
        } finally {
            // 确保在请求处理完成后清理ThreadLocal
            TenantIdentifierResolver.clearTenantId();
        }
    }

    @Override
    public void destroy() {
        // 销毁逻辑
    }
}

import javax.ejb.Stateless;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import java.util.List;

@Stateless
public class CustomerService {

    @PersistenceContext(unitName = "myPersistenceUnit")
    private EntityManager em;

    public Customer findCustomerById(Long id) {
        // Hibernate会根据当前ThreadLocal中的租户ID自动路由到正确的数据库
        return em.find(Customer.class, id);
    }

    public void saveCustomer(Customer customer) {
        em.persist(customer);
    }

    public List<Customer> getAllCustomers() {
        return em.createQuery("SELECT c FROM Customer c", Customer.class).getResultList();
    }
}