Spring Boot offers an opinionated way to bootstrap applications by favoring auto-configuration and making reasonable assumptions about how your application operates.
To configure a data source using Spring Data, you can add the following properties to application.properties:
spring.datasource.url=jdbc:mysql://localhost:3306/my_database spring.datasource.username=sqluser spring.datasource.password=p@55w0rd Under the hood, Spring Boot will instantiate and wire up all of the classes needed to connect to your database.
But what happens if you need to connect to multiple databases? In this post, I'll show you how to configure Spring Boot to work with two entities on two separate databases.
Create a New Spring Boot Project
The Spring Initializr can be used to make a new Spring Boot project.
You can also access the Initializr with curl:
curl https://start.spring.io/starter.zip -d dependencies=data-jpa,h2 \ -d language=kotlin \ -d packageName=com.smcrow.demo \ -d artifactId=spring-boot-multiple-datasources \ -d groupId=com.smcrow.demo \ -d baseDir=spring-boot-multiple-datasource | tar -xzvf - Create the Entities
For this example, you're going to create two entities:
-
com.smcrow.demo.farm.Animalwill be used to access information from theAnimaltable of theFarmdatabase. -
com.smcrow.demo.factory.Workerwill be used to access information from theWorkertable of theFactorydatabase.
Create the Animal Entity
First, create a new class to represent an Animal. This class will be created in the com.smcrow.demo.farm package:
package com.smcrow.demo.farm import org.springframework.data.jpa.repository.JpaRepository import org.springframework.stereotype.Repository import javax.persistence.Entity import javax.persistence.GeneratedValue import javax.persistence.GenerationType import javax.persistence.Id @Entity class Animal( @Id @GeneratedValue(strategy = GenerationType.IDENTITY) val id: Long = 0, val name: String ) @Repository interface AnimalRepository : JpaRepository<Animal, Long> I like to put my JpaRepository interfaces inside of the same file as the class.
Create the Worker Entity
Now, create a new class to represent a Worker. This class will be created in the com.smcrow.demo.factory package. Separating the Worker and Animal classes into different packages will help later with configuration:
package com.smcrow.demo.factory import org.springframework.data.jpa.repository.JpaRepository import org.springframework.stereotype.Repository import javax.persistence.Entity import javax.persistence.GeneratedValue import javax.persistence.GenerationType import javax.persistence.Id @Entity class Worker( @Id @GeneratedValue(strategy = GenerationType.IDENTITY) val id: Long = 0, val name: String ) @Repository interface WorkerRepository : JpaRepository<Worker, Long> Add Database Configuration to application.properties
Since the worker and the animal tables exist in different databases, two configuration blocks are necessary.
You can define multiple data sources inside of application.properties:
# Farm DB Connection spring.datasource-farm.jdbcUrl=jdbc:h2:mem:farm spring.datasource-farm.username=sa spring.datasource-farm.password= # Factory DB Connection spring.datasource-factory.jdbcUrl=jdbc:h2:mem:factory spring.datasource-factory.username=sa spring.datasource-factory.password= Register the Database Connections
Normally, Spring Boot expects to find database credentials as part of the spring.datasource.* configuration prefix. Instead of using the automatic configuration, the data sources must be defined manually.
Create the Farm Data Source Configuration
Create a new class inside of the com.smcrow.demo.farm package called FarmDataSourceConfiguration:
package com.smcrow.demo.farm import org.springframework.boot.context.properties.ConfigurationProperties import org.springframework.boot.jdbc.DataSourceBuilder 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.LocalContainerEntityManagerFactoryBean import org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter import javax.sql.DataSource @Configuration @EnableJpaRepositories( basePackages = ["com.smcrow.demo.farm"], entityManagerFactoryRef = "farmEntityManager", transactionManagerRef = "farmTransactionManager" ) class FarmDataSourceConfiguration { @Bean @ConfigurationProperties(prefix = "spring.datasource-farm") fun farmDataSource(): DataSource = DataSourceBuilder.create().build() @Bean fun farmEntityManager(): LocalContainerEntityManagerFactoryBean = (LocalContainerEntityManagerFactoryBean()).apply { dataSource = farmDataSource() setPackagesToScan("com.smcrow.demo.farm") jpaVendorAdapter = HibernateJpaVendorAdapter() } @Bean fun farmTransactionManager() = JpaTransactionManager(farmEntityManager().`object`!!) } Create the Factory Data Source Configuration
Create a new class inside of the com.smcrow.demo.factory package called FactoryDataSourceConfiguration:
package com.smcrow.demo.factory import org.springframework.boot.context.properties.ConfigurationProperties import org.springframework.boot.jdbc.DataSourceBuilder 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.LocalContainerEntityManagerFactoryBean import org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter import javax.sql.DataSource @Configuration @EnableJpaRepositories( basePackages = ["com.smcrow.demo.factory"], entityManagerFactoryRef = "factoryEntityManager", transactionManagerRef = "factoryTransactionManager" ) class FactoryDataSourceConfiguration { @Bean @ConfigurationProperties(prefix = "spring.datasource-factory") fun factoryDataSource(): DataSource = DataSourceBuilder.create().build() @Bean fun factoryEntityManager(): LocalContainerEntityManagerFactoryBean = (LocalContainerEntityManagerFactoryBean()).apply { dataSource = factoryDataSource() setPackagesToScan("com.smcrow.demo.factory") jpaVendorAdapter = HibernateJpaVendorAdapter() } @Bean fun factoryTransactionManager() = JpaTransactionManager(factoryEntityManager().`object`!!) } More Detail
Now let's break down the configuration classes.
Each configuration class has an @EnableJpaRepositories annotation. This enables package scanning for interfaces annotated with @Repository.
The basePackages is an array of packages that contain the @Repositories that will be associated with the specific data source being configured.
There are three beans that are created in each configuration class.
The first is the data source which represents a connection to a physical data source. The @ConfigurationProperties annotation allows the properties from spring.datasource-factory to be loaded into the DataSource.
@Bean @ConfigurationProperties(prefix = "spring.datasource-factory") fun factoryDataSource(): DataSource = DataSourceBuilder.create().build() The next bean is the LocalContainerEntityManagerFactoryBean which is used to create the EntityManagerFactory
@Bean fun factoryEntityManager(): LocalContainerEntityManagerFactoryBean = (LocalContainerEntityManagerFactoryBean()).apply { dataSource = factoryDataSource() setPackagesToScan("com.smcrow.demo.factory") jpaVendorAdapter = HibernateJpaVendorAdapter() } And the third is the JpaTransactionManager:
@Bean fun factoryTransactionManager() = JpaTransactionManager(factoryEntityManager().`object`!!) Summary
I hope that this helps serve as a quick reference guide for setting up multiple data sources in Spring Boot and Kotlin.
The full code repository can be found on GitHub: cr0wst/spring-boot-multiple-datasource
I've found a few other resources for configuring this in Java, but none of them were written with Kotlin in mind. They can be found here:
Top comments (2)
Thanks! This setup worked for me except that I needed to install jakarta persistence package as I was facing issue with unmet dependency for javax.persistence.
thanks!