刚好碰到过类似的场景，我来给你梳理下完美适配的解决方案——你现在是单领域模型对应两个独立数据源，既要启动时自动建表，又得在调用Repository时明确指定操作哪个库，确实不能用Hibernate多租户（它是共享表结构，不符合你的多数据源独立表需求），也没法用RoutingDataSource（它是动态切换，做不到显式绑定Repository到数据源）。最合适的路子就是给每个数据源单独配一套完整的JPA组件，下面是具体的实现步骤和示例：

核心思路 #

给每个数据源单独配置EntityManagerFactory、TransactionManager，再通过@EnableJpaRepositories把特定的Repository绑定到对应的JPA组件上。这种方式既能让每个数据源独立控制Hibernate的建表逻辑，又能让你在调用时直接通过注入不同的Repository来显式选择操作的数据库，完全避开了多租户和RoutingDataSource的限制。

1. 公共领域模型 #

把你的实体类放在公共包下（比如com.example.entity），让所有数据源的EntityManagerFactory都能扫描到它，这样每个数据库都会生成对应的表：

@Entity
@Table(name = "foo")
public class Foo {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    // getter、setter、构造方法按需添加
}

2. 第一个数据源配置（法国库，基于你的代码扩展） #

完善你给出的FranceDbConfig，把数据源、EntityManagerFactory（重点配置建表策略）、TransactionManager都配置齐全：

@Configuration
@EnableJpaRepositories(
    entityManagerFactoryRef = "franceEntityManagerFactory",
    transactionManagerRef = "franceTransactionManager",
    basePackageClasses = FooRepositoryFrance.class // 用Repository类绑定专属范围，比写包名灵活
)
public class FranceDbConfig {

    // 1. 配置法国数据源，用配置文件前缀绑定参数
    @Bean(name = "franceDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.france")
    public DataSource franceDataSource() {
        return DataSourceBuilder.create().build();
    }

    // 2. 配置法国EntityManagerFactory，指定建表策略
    @Bean(name = "franceEntityManagerFactory")
    public LocalContainerEntityManagerFactoryBean franceEntityManagerFactory(
            EntityManagerFactoryBuilder builder,
            @Qualifier("franceDataSource") DataSource dataSource) {
        Map<String, Object> hibernateProps = new HashMap<>();
        hibernateProps.put("hibernate.hbm2ddl.auto", "update"); // 启动自动建表/更新表结构，按需改成create/create-drop
        hibernateProps.put("hibernate.dialect", "org.hibernate.dialect.MySQL8Dialect"); // 根据你的数据库类型调整

        return builder
                .dataSource(dataSource)
                .packages(Foo.class) // 扫描公共领域模型
                .persistenceUnit("francePU") // 唯一标识，避免多数据源冲突
                .properties(hibernateProps)
                .build();
    }

    // 3. 配置法国专属事务管理器
    @Bean(name = "franceTransactionManager")
    public PlatformTransactionManager franceTransactionManager(
            @Qualifier("franceEntityManagerFactory") EntityManagerFactory entityManagerFactory) {
        return new JpaTransactionManager(entityManagerFactory);
    }
}

3. 第二个数据源配置（示例：德国库） #

按照同样的逻辑配置第二个数据源，绑定另一组专属Repository：

@Configuration
@EnableJpaRepositories(
    entityManagerFactoryRef = "germanyEntityManagerFactory",
    transactionManagerRef = "germanyTransactionManager",
    basePackageClasses = FooRepositoryGermany.class
)
public class GermanyDbConfig {

    @Bean(name = "germanyDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.germany")
    public DataSource germanyDataSource() {
        return DataSourceBuilder.create().build();
    }

    @Bean(name = "germanyEntityManagerFactory")
    public LocalContainerEntityManagerFactoryBean germanyEntityManagerFactory(
            EntityManagerFactoryBuilder builder,
            @Qualifier("germanyDataSource") DataSource dataSource) {
        Map<String, Object> hibernateProps = new HashMap<>();
        hibernateProps.put("hibernate.hbm2ddl.auto", "update");
        hibernateProps.put("hibernate.dialect", "org.hibernate.dialect.MySQL8Dialect");

        return builder
                .dataSource(dataSource)
                .packages(Foo.class)
                .persistenceUnit("germanyPU")
                .properties(hibernateProps)
                .build();
    }

    @Bean(name = "germanyTransactionManager")
    public PlatformTransactionManager germanyTransactionManager(
            @Qualifier("germanyEntityManagerFactory") EntityManagerFactory entityManagerFactory) {
        return new JpaTransactionManager(entityManagerFactory);
    }
}

4. 专属Repository定义 #

为每个数据源创建独立的Repository接口，不用写额外逻辑，继承JpaRepository即可：

// 法国库专属Repository
public interface FooRepositoryFrance extends JpaRepository<Foo, Long> {
    // 自定义查询方法按需添加
}

// 德国库专属Repository
public interface FooRepositoryGermany extends JpaRepository<Foo, Long> {
    // 自定义查询方法按需添加
}

5. 业务代码中使用 #

直接注入对应的Repository，就能明确操作指定数据库，完全不需要手动切换数据源：

@Service
public class FooService {
    private final FooRepositoryFrance franceFooRepo;
    private final FooRepositoryGermany germanyFooRepo;

    // 构造注入（推荐）
    public FooService(FooRepositoryFrance franceFooRepo, FooRepositoryGermany germanyFooRepo) {
        this.franceFooRepo = franceFooRepo;
        this.germanyFooRepo = germanyFooRepo;
    }

    public void saveToFrance(Foo foo) {
        franceFooRepo.save(foo); // 直接操作法国库
    }

    public void saveToGermany(Foo foo) {
        germanyFooRepo.save(foo); // 直接操作德国库
    }
}

关键细节说明 #

• 自动建表：每个EntityManagerFactory都配置了hibernate.hbm2ddl.auto，启动时Hibernate会为对应数据源自动生成或更新表结构，完全满足你的需求。
• 显式选库：通过注入不同的Repository实现明确选库，没有任何隐式切换逻辑，符合你“调用Repository时显式选择数据库”的要求。
• 避免冲突：每个数据源的persistenceUnit名称唯一，JPA会自动区分不同的实体管理器，不会出现数据源混淆的问题。

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