formulario - spring mvc form example

Creación de múltiples fuentes de datos y esquemas en Spring Boot

Question

Estoy usando Spring Boot. Finalmente logré configurar dos fuentes de datos, pero ahora estoy enfrentando otro problema.

1. con dos fuentes de datos en su lugar spring.jpa.hibernate.ddl-auto=create parece dejar de funcionar en mi aplicación de arranque de primavera, solo spring.jpa.generate-ddl=true hace el trabajo ahora

2. No logro seleccionar la estrategia de creación automática para cada fuente de datos. Preferiría crear el esquema para el origen de datos uno, y simplemente usar el esquema creado en el segundo DB con el origen de datos dos.

¿Algún cuerpo tiene idea de cómo resolver alguno de estos problemas? Tenga en cuenta que no quiero descartar por completo la configuración automática si es posible. Ni siquiera sé aún si hibernate puede simplemente inicializar el esquema en una unidad de persistencia.

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

MW

Answer 1

spring.jpa.hibernate.ddl-auto=create ha dejado de funcionar, no porque tenga dos DataSources, sino porque su aplicación está creando sus propios LocalContainerEntityManagerFactoryBean . Esto tiene el efecto de deshabilitar la configuración automática de LocalContainerEntityManagerFactoryBean por lo que ahora debe configurarlo usted mismo.

Puede configurar los dos administradores de entidades para que tengan un comportamiento de generación de esquema diferente como este (el primero hace la actualización, el segundo la crea):

@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();
}