attempt to use new way of configuring multiple datasources

.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "java.compile.nullAnalysis.mode": "automatic"
+}

pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-parent</artifactId>
-        <version>3.4.0-RC1</version>
+        <version>3.4.0-SNAPSHOT</version>
         <relativePath /> <!-- lookup parent from repository -->
     </parent>
     <groupId>com.example</groupId>
@@ -18,8 +18,7 @@
         <java.version>21</java.version>
 
         <spotless.version>2.43.0</spotless.version>
-        <springdoc-openapi.version>2.6.0</springdoc-openapi.version>
-
+
         <project.testresult.directory>${project.build.directory}/test-results</project.testresult.directory>
         <jacoco-maven-plugin.version>0.8.12</jacoco-maven-plugin.version>
         <jacoco.minimum.coverage>0.80</jacoco.minimum.coverage>
@@ -50,11 +49,6 @@
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-validation</artifactId>
         </dependency>
-        <dependency>
-            <groupId>org.springdoc</groupId>
-            <artifactId>springdoc-openapi-starter-webmvc-ui</artifactId>
-            <version>${springdoc-openapi.version}</version>
-        </dependency>
 
         <!-- Database Drivers -->
         <dependency>
@@ -314,24 +308,40 @@
     </build>
 
     <repositories>
-        <repository>
-            <id>spring-milestones</id>
-            <name>Spring Milestones</name>
-            <url>https://repo.spring.io/milestone</url>
-            <snapshots>
-                <enabled>false</enabled>
-            </snapshots>
-        </repository>
-    </repositories>
-    <pluginRepositories>
-        <pluginRepository>
-            <id>spring-milestones</id>
-            <name>Spring Milestones</name>
-            <url>https://repo.spring.io/milestone</url>
-            <snapshots>
-                <enabled>false</enabled>
-            </snapshots>
-        </pluginRepository>
-    </pluginRepositories>
+    <repository>
+      <id>spring-milestones</id>
+      <name>Spring Milestones</name>
+      <url>https://repo.spring.io/milestone</url>
+      <snapshots>
+        <enabled>false</enabled>
+      </snapshots>
+    </repository>
+    <repository>
+      <id>spring-snapshots</id>
+      <name>Spring Snapshots</name>
+      <url>https://repo.spring.io/snapshot</url>
+      <releases>
+        <enabled>false</enabled>
+      </releases>
+    </repository>
+  </repositories>
+  <pluginRepositories>
+    <pluginRepository>
+      <id>spring-milestones</id>
+      <name>Spring Milestones</name>
+      <url>https://repo.spring.io/milestone</url>
+      <snapshots>
+        <enabled>false</enabled>
+      </snapshots>
+    </pluginRepository>
+    <pluginRepository>
+      <id>spring-snapshots</id>
+      <name>Spring Snapshots</name>
+      <url>https://repo.spring.io/snapshot</url>
+      <releases>
+        <enabled>false</enabled>
+      </releases>
+    </pluginRepository>
+  </pluginRepositories>
 
 </project>

src/main/java/com/example/multipledatasources/configuration/CardHolderDataSourceConfiguration.java

@@ -6,54 +6,82 @@
 import jakarta.persistence.EntityManagerFactory;
 import javax.sql.DataSource;
 import org.springframework.beans.factory.ObjectProvider;
+import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.boot.autoconfigure.jdbc.DataSourceProperties;
 import org.springframework.boot.autoconfigure.orm.jpa.JpaProperties;
 import org.springframework.boot.context.properties.ConfigurationProperties;
 import org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
+import org.springframework.orm.jpa.JpaTransactionManager;
+import org.springframework.orm.jpa.JpaVendorAdapter;
 import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
 import org.springframework.orm.jpa.persistenceunit.PersistenceUnitManager;
+import org.springframework.orm.jpa.vendor.AbstractJpaVendorAdapter;
+import org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter;
 import org.springframework.transaction.PlatformTransactionManager;
 
-@Configuration
+@Configuration(proxyBeanMethods = false)
 @EnableJpaRepositories(
         basePackageClasses = CardHolderRepository.class,
         entityManagerFactoryRef = "cardHolderEntityManagerFactory",
         transactionManagerRef = "cardHolderTransactionManager")
-public class CardHolderDataSourceConfiguration extends BaseDataSourceConfiguration {
+public class CardHolderDataSourceConfiguration {
 
-    public CardHolderDataSourceConfiguration(
-            ObjectProvider<PersistenceUnitManager> persistenceUnitManager, JpaProperties jpaProperties) {
-        super(persistenceUnitManager, jpaProperties);
+    private final PersistenceUnitManager persistenceUnitManager;
+
+    public CardHolderDataSourceConfiguration(ObjectProvider<PersistenceUnitManager> persistenceUnitManager) {
+        this.persistenceUnitManager = persistenceUnitManager.getIfAvailable();
     }
 
-    @Bean
+    @Qualifier("second") @Bean(defaultCandidate = false)
     @ConfigurationProperties("app.datasource.cardholder")
     DataSourceProperties cardHolderDataSourceProperties() {
         return new DataSourceProperties();
     }
 
-    @Bean
-    @ConfigurationProperties("app.datasource.cardholder.hikari")
-    DataSource cardholderDataSource() {
-        return cardHolderDataSourceProperties()
+    @Qualifier("second") @Bean(defaultCandidate = false)
+    @ConfigurationProperties("app.datasource.cardholder.configuration")
+    DataSource cardholderDataSource(@Qualifier("second") DataSourceProperties dataSourceProperties) {
+        return dataSourceProperties
                 .initializeDataSourceBuilder()
                 .type(HikariDataSource.class)
                 .build();
     }
 
-    @Bean
-    LocalContainerEntityManagerFactoryBean cardHolderEntityManagerFactory(DataSource cardholderDataSource) {
-        EntityManagerFactoryBuilder builder = createEntityManagerFactoryBuilder();
-        return builder.dataSource(cardholderDataSource)
+    @Qualifier("second") @Bean(defaultCandidate = false)
+    LocalContainerEntityManagerFactoryBean cardHolderEntityManagerFactory(
+            @Qualifier("second") DataSource dataSource, JpaProperties jpaProperties) {
+        EntityManagerFactoryBuilder builder = createEntityManagerFactoryBuilder(jpaProperties);
+        return builder.dataSource(dataSource)
                 .packages(CardHolder.class)
+                .persistenceUnit("cardholder")
                 .build();
     }
 
-    @Bean
-    PlatformTransactionManager cardHolderTransactionManager(EntityManagerFactory cardHolderEntityManagerFactory) {
-        return createTransactionManager(cardHolderEntityManagerFactory);
+    protected EntityManagerFactoryBuilder createEntityManagerFactoryBuilder(JpaProperties jpaProperties) {
+        JpaVendorAdapter jpaVendorAdapter = createJpaVendorAdapter(jpaProperties);
+        return new EntityManagerFactoryBuilder(
+                jpaVendorAdapter, jpaProperties.getProperties(), this.persistenceUnitManager);
+    }
+
+    protected JpaVendorAdapter createJpaVendorAdapter(JpaProperties jpaProperties) {
+        AbstractJpaVendorAdapter adapter = new HibernateJpaVendorAdapter();
+        adapter.setShowSql(jpaProperties.isShowSql());
+        if (jpaProperties.getDatabase() != null) {
+            adapter.setDatabase(jpaProperties.getDatabase());
+        }
+        if (jpaProperties.getDatabasePlatform() != null) {
+            adapter.setDatabasePlatform(jpaProperties.getDatabasePlatform());
+        }
+        adapter.setGenerateDdl(jpaProperties.isGenerateDdl());
+        return adapter;
+    }
+
+    @Qualifier("second") @Bean(defaultCandidate = false)
+    PlatformTransactionManager cardHolderTransactionManager(
+            @Qualifier("cardHolderEntityManagerFactory") EntityManagerFactory cardHolderEntityManagerFactory) {
+        return new JpaTransactionManager(cardHolderEntityManagerFactory);
     }
 }

src/main/java/com/example/multipledatasources/configuration/MemeberJPAConfiguration.java

@@ -0,0 +1,12 @@
+package com.example.multipledatasources.configuration;
+
+import com.example.multipledatasources.model.member.Member;
+import com.example.multipledatasources.repository.member.MemberRepository;
+import org.springframework.boot.autoconfigure.domain.EntityScan;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
+
+@Configuration(proxyBeanMethods = false)
+@EntityScan(basePackageClasses = Member.class)
+@EnableJpaRepositories(basePackageClasses = MemberRepository.class, entityManagerFactoryRef = "entityManagerFactory")
+class MemeberJPAConfiguration {}

src/main/resources/application.properties

@@ -1,26 +1,26 @@
 spring.application.name=boot-data-multipledatasources
 
 #Store card holder (cardholder name, zip)
-app.datasource.member.url=jdbc:postgresql://localhost:5432/memberdb?createDatabaseIfNotExist=true
-app.datasource.member.username=postgres
-app.datasource.member.password=postgres
-app.datasource.member.driverClassName=org.postgresql.Driver
-app.datasource.member.configuration.connectionTimeout=30000
-app.datasource.member.configuration.idleTimeout=600000
-app.datasource.member.configuration.maxLifetime=1800000
-app.datasource.member.configuration.poolName=memberHikariPool
-app.datasource.member.configuration.autoCommit=false
+spring.datasource.url=jdbc:postgresql://localhost:5432/memberdb?createDatabaseIfNotExist=true
+spring.datasource.username=postgres
+spring.datasource.password=postgres
+spring.datasource.driverClassName=org.postgresql.Driver
+spring.datasource.hikari.connectionTimeout=30000
+spring.datasource.hikari.idleTimeout=600000
+spring.datasource.hikari.maxLifetime=1800000
+spring.datasource.hikari.poolName=memberHikariPool
+spring.datasource.hikari.autoCommit=false
 
 #card number  (cardholder id, cardnumber)
 app.datasource.cardholder.url=jdbc:mysql://localhost:3306/cardholderdb?createDatabaseIfNotExist=true
 app.datasource.cardholder.username=user
 app.datasource.cardholder.password=password
 app.datasource.cardholder.driverClassName=com.mysql.cj.jdbc.Driver
-app.datasource.cardholder.hikari.connectionTimeout=30000
-app.datasource.cardholder.hikari.idleTimeout=600000
-app.datasource.cardholder.hikari.maxLifetime=1800000
-app.datasource.cardholder.hikari.poolName=cardHolderHikariPool
-app.datasource.cardholder.hikari.autoCommit=false
+app.datasource.cardholder.configuration.connectionTimeout=30000
+app.datasource.cardholder.configuration.idleTimeout=600000
+app.datasource.cardholder.configuration.maxLifetime=1800000
+app.datasource.cardholder.configuration.poolName=cardHolderHikariPool
+app.datasource.cardholder.configuration.autoCommit=false
 
 ## Common Properties
 spring.jpa.hibernate.ddl-auto=validate
@@ -43,9 +43,9 @@ spring.flyway.user=${app.datasource.cardholder.username}
 spring.flyway.password=${app.datasource.cardholder.password}
 
 ## Liquibase used postgres Database
-spring.liquibase.url=${app.datasource.member.url}
-spring.liquibase.user=${app.datasource.member.username}
-spring.liquibase.password=${app.datasource.member.password}
+spring.liquibase.url=${spring.datasource.url}
+spring.liquibase.user=${spring.datasource.username}
+spring.liquibase.password=${spring.datasource.password}
 
 spring.mvc.problemdetails.enabled=true
 spring.threads.virtual.enabled=true