Spring Boot中创建多个数据源和模式 [英] Multiple data source and schema creation in Spring Boot

问题描述

我正在使用Spring Boot。我终于设法设置了两个数据源，但现在我面临着另一个问题。

1. 有两个数据源 spring.jpa.hibernate.ddl-auto = create code>似乎停止在我的spring启动应用程序中工作，只有 spring.jpa.generate-ddl = true 现在就开始工作




2. 我无法为每个数据源选择自动创建策略。我宁愿为数据源一创建模式，只在第二个数据库中使用第二个数据源创建的模式。
   





任何机构都有想法如何解决这些问题？注意如果可能的话，我不想完全丢弃自动配置。我甚至不知道，如果hibernate能够在一个持久化单元中初始化模式。





application.properties

  spring.datasource-internal.url = jdbc：hsqldb：mem：testdb 
 spring.datasource-internal.username = sa 
 spring.datasource-internal.password = sa 
 spring.datasource-internal.driver-class-name = org.hsqldb.jdbcDriver 
 spring.datasource-internal.jpa.database-platform = org。 hibernate.dialect.HSQLDialect 
 
 spring.datasource-external.url = jdbc：hsqldb：mem：testexternal 
 spring.datasource-external.username = sa 
 spring.datasource-external .password = sa 
 spring.datasource-external.driver-class-name = org.hsqldb.jdbcDriver 
 spring.datasource-external.jpa.database-platform = org.hibernate.dialect.HSQLDialect 
 
 flyway.enabled = false 
 spring.jpa.hibernate.ddl-auto =创建
 spring.jpa.show-sql = true 
 spring.jpa.generate-ddl = true 
  

DBIn ternalConfig



  @Configuration 
 @EnableTransactionManagement 
 @EnableJpaRepositories（basePackages = cz.data.internal，
 entityManagerFactoryRef =internalEntityManagerFactory，
 transactionManagerRef =internalTransactionManager）
公共类DBConfigInternal {
 
 
 public static final String INTERNAL =internal; 
 
 @Bean（name =internalDataSource）
 @Primary 
 @ConfigurationProperties（prefix =spring.datasource-internal）
 public DataSource internalDataSource（）{ 
返回DataSourceBuilder.create（）。build（）; （b 
 
 
 
 
 $ b $初始
公共LocalContainerEntityManagerFactoryBean internalEntityManagerFactory（
 EntityManagerFactoryBuilder构建器）{
 return builder 
 .dataSource（internalDataSource（））
 .packages（cz.data.internal.entity）
 .persistenceUnit（INTERNAL）
 .build（）; 
 
 $ b bBean（name =internalTransactionManager）
 @Primary 
 Public PlatformTransactionManager internalTransactionManager（）{
 JpaTransactionManager jpaTransactionManager = new JpaTransactionManager（）; 
 jpaTransactionManager.setDataSource（internalDataSource（））; 
 jpaTransactionManager.setPersistenceUnitName（INTERNAL）; 
返回jpaTransactionManager; 
 
 
  

DBExternalConfig



  @Configuration 
 @EnableTransactionManagement 
 @EnableJpaRepositories（
 basePackages =cz.data.external， 
 entityManagerFactoryRef =externalEntityManagerFactory，
 transactionManagerRef =externalTransactionManager）
 public class DBConfigExternal {
 
 
 public static final String EXTERNAL =external; 
 
 @Bean（name =externalDataSource）
 @ConfigurationProperties（prefix =spring.datasource-external）
 public DataSource externalDataSource（）{
 return DataSourceBuilder .create（）建立（）; 
 
 $ b $Bean（name =externalEntityManagerFactory）
 public LocalContainerEntityManagerFactoryBean externalEntityManagerFactory（
 EntityManagerFactoryBuilder builder）{
 return builder 
 .dataSource （externalDataSource（））
 .packages（cz.data.external.entity）
 .persistenceUnit（EXTERNAL）
 .build（）; 
 
 $ b @Bean（name =externalTransactionManager）
 public PlatformTransactionManager externalTransactionManager（）{
 JpaTransactionManager jpaTransactionManager = new JpaTransactionManager（）; 
 jpaTransactionManager.setDataSource（externalDataSource（））; 
 jpaTransactionManager.setPersistenceUnitName（EXTERNAL）; 
返回jpaTransactionManager; 
 
 
 
 
 $ b $ MW 
 
 
  spring.jpa.hibernate.ddl-auto = create 已停止工作，不是因为您有两个DataSources，但是因为你的应用程序创建了自己的 LocalContainerEntityManagerFactoryBean  s。这会导致禁用 LocalContainerEntityManagerFactoryBean 的自动配置，所以您现在必须自己配置它。
 
 
 
您可以将两个实体管理器配置为具有不同的模式生成行为（第一个执行更新，第二个执行创建）： 
 
 
  @Bean（name =externalEntityManagerFactory）
 public LocalContainerEntityManagerFactoryBean externalEntityManagerFactory（
 EntityManagerFactoryBuilder builder）{
 Map< String，Object> properties = new HashMap< String，Object>（）; 
 properties.put（hibernate.hbm2ddl.auto，update）; 
 return builder 
 .dataSource（externalDataSource（））
 .packages（cz.data.external.entity）
 .persistenceUnit（EXTERNAL）
 .properties（属性）
 .build（）; （
 
 
 $ b $）（$ name =internalEntityManagerFactory）
 @Primary 
 public LocalContainerEntityManagerFactoryBean internalEntityManagerFactory（
 EntityManagerFactoryBuilder builder）{
 Map<字符串，对象> properties = new HashMap< String，Object>（）; 
 properties.put（hibernate.hbm2ddl.auto，create）; 
 return builder 
 .dataSource（internalDataSource（））
 .packages（cz.data.internal.entity）
 .persistenceUnit（INTERNAL）
 .properties（属性）
 .build（）; 
} 
  
 
I'm using Spring Boot. I finally managed to setup two data sources, but now I'm facing another issue. 

with two data sources in place spring.jpa.hibernate.ddl-auto=create seems to stop working in my spring boot application, only spring.jpa.generate-ddl=true do the job now
I can not manage to select the auto-creation strategy for each of the data sources. I would prefer to create the schema for data source one, and just use the created schema in second DB with data source two. 
Any body have idea how to resolve any of these issues? Note I don't want to completely throw away the auto-config if possible. I don't even know yet, if hibernate is able to just initialize schema in one persistence unit.


application.properties
spring.datasource-internal.url=jdbc:hsqldb:mem:testdb
spring.datasource-internal.username=sa
spring.datasource-internal.password=sa
spring.datasource-internal.driver-class-name=org.hsqldb.jdbcDriver
spring.datasource-internal.jpa.database-platform=org.hibernate.dialect.HSQLDialect

spring.datasource-external.url=jdbc:hsqldb:mem:testexternal
spring.datasource-external.username=sa
spring.datasource-external.password=sa
spring.datasource-external.driver-class-name=org.hsqldb.jdbcDriver
spring.datasource-external.jpa.database-platform=org.hibernate.dialect.HSQLDialect

flyway.enabled=false
spring.jpa.hibernate.ddl-auto=create
spring.jpa.show-sql=true
spring.jpa.generate-ddl=true
DBInternalConfig
@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(basePackages = "cz.data.internal",
        entityManagerFactoryRef = "internalEntityManagerFactory",
        transactionManagerRef = "internalTransactionManager")
public class DBConfigInternal {


    public static final String INTERNAL = "internal";

    @Bean(name = "internalDataSource")
    @Primary
    @ConfigurationProperties(prefix = "spring.datasource-internal")
    public DataSource internalDataSource() {
        return DataSourceBuilder.create().build();
    }

    @Bean(name = "internalEntityManagerFactory")
    @Primary
    public LocalContainerEntityManagerFactoryBean internalEntityManagerFactory(
            EntityManagerFactoryBuilder builder) {
        return builder
                .dataSource(internalDataSource())
                .packages("cz.data.internal.entity")
                .persistenceUnit(INTERNAL)
                .build();
    }

    @Bean(name = "internalTransactionManager")
    @Primary
    public PlatformTransactionManager internalTransactionManager() {
        JpaTransactionManager jpaTransactionManager = new JpaTransactionManager();
        jpaTransactionManager.setDataSource(internalDataSource());
        jpaTransactionManager.setPersistenceUnitName(INTERNAL);
        return jpaTransactionManager;
    }
}
DBExternalConfig
@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(
        basePackages = "cz.data.external",
        entityManagerFactoryRef = "externalEntityManagerFactory",
        transactionManagerRef = "externalTransactionManager")
public class DBConfigExternal {


    public static final String EXTERNAL = "external";

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

    @Bean(name = "externalEntityManagerFactory")
    public LocalContainerEntityManagerFactoryBean externalEntityManagerFactory(
            EntityManagerFactoryBuilder builder) {
        return builder
                .dataSource(externalDataSource())
                .packages("cz.data.external.entity")
                .persistenceUnit(EXTERNAL)
                .build();
    }

    @Bean(name = "externalTransactionManager")
    public PlatformTransactionManager externalTransactionManager() {
        JpaTransactionManager jpaTransactionManager = new JpaTransactionManager();
        jpaTransactionManager.setDataSource(externalDataSource());
        jpaTransactionManager.setPersistenceUnitName(EXTERNAL);
        return jpaTransactionManager;
    }
}
M.W.
解决方案
spring.jpa.hibernate.ddl-auto=create has stopped working, not because you have two DataSources, but because your application's creating its own LocalContainerEntityManagerFactoryBeans. This has the effect of disabling the auto-configuration of a LocalContainerEntityManagerFactoryBean so you now have to configure it yourself.

You can configure the two entity managers to have different schema generation behaviour like this (the first's doing update, the second's doing create):
@Bean(name = "externalEntityManagerFactory")
public LocalContainerEntityManagerFactoryBean externalEntityManagerFactory(
        EntityManagerFactoryBuilder builder) {
    Map<String, Object> properties = new HashMap<String, Object>();
    properties.put("hibernate.hbm2ddl.auto", "update");
    return builder
            .dataSource(externalDataSource())
            .packages("cz.data.external.entity")
            .persistenceUnit(EXTERNAL)
            .properties(properties)
            .build();
}

@Bean(name = "internalEntityManagerFactory")
@Primary
public LocalContainerEntityManagerFactoryBean internalEntityManagerFactory(
        EntityManagerFactoryBuilder builder) {
    Map<String, Object> properties = new HashMap<String, Object>();
    properties.put("hibernate.hbm2ddl.auto", "create");
    return builder
            .dataSource(internalDataSource())
            .packages("cz.data.internal.entity")
            .persistenceUnit(INTERNAL)
            .properties(properties)
            .build();
}


                        
这篇关于Spring Boot中创建多个数据源和模式的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！