Spring RoutingDataSource validationQuery is not being injected

Spring RoutingDataSource validationQuery is not being injected - java

I'm using RoutingDataSource to dynamically create datasources for each tenant of our application. After 8 - 12 hours application application losts connection with database and I'm getting jpa transaction exception. I found that the following properties are responsible for validation and sustaining database connection so I placed them in my application.properties.
spring.datasource.initialize=false
spring.datasource.test-while-idle=true
spring.datasource.test-on-borrow=true
spring.datasource.validation-query=SELECT 1
Data source bean is created in the following class. How to inject above properties to each target datasource?
...
#Configuration
public class RoutingDataSourceConfiguration {
public static final String DEFAULT_TENANT_NAME = "default_tenant";
#Autowired
private RoutingDataSourceProperties routingProperties;
/**
* Defines the data source for the application
*
* #return
*/
#Bean
#ConfigurationProperties(prefix = "spring.datasource")
public DataSource dataSource() {
Map<Object, Object> dataSources = new HashMap<>();
for (Map.Entry<String, DataSourceProperties> entry : routingProperties.getDataSources().entrySet()) {
DataSourceProperties dataSourceProperties = entry.getValue();
dataSources.put(entry.getKey(), createDataSource(dataSourceProperties));
}
RoutingDataSource dataSource = new RoutingDataSource();
dataSource.setLenientFallback(false);
dataSource.setDefaultTargetDataSource(createDefaultDataSource());
dataSource.setTargetDataSources(dataSources);
dataSource.afterPropertiesSet();
return dataSource;
}
private DataSource createDataSource(DataSourceProperties dataSourceProperties) {
DataSourceBuilder dataSourceBuilder = new DataSourceBuilder(this.getClass().getClassLoader());
dataSourceBuilder.driverClassName(dataSourceProperties.getDriverClassName())
.url(dataSourceProperties.getUrl())
.username(dataSourceProperties.getUsername())
.password(dataSourceProperties.getPassword());
if (dataSourceProperties.getType() != null) {
dataSourceBuilder.type(dataSourceProperties.getType());
}
return dataSourceBuilder.build();
}
private DataSource createDefaultDataSource() {
Map<String, DataSourceProperties> dataSources = routingProperties.getDataSources();
if (!dataSources.containsKey(DEFAULT_TENANT_NAME)) {
throw new BeanCreationException(String.format(
"No configuration for default tenant '%s' found", DEFAULT_TENANT_NAME));
}
DataSourceProperties dataSourceProperties = dataSources.get(DEFAULT_TENANT_NAME);
return createDataSource(dataSourceProperties);
}
}

I needed to set validation-query query manually when creating a datasource pragmatically as per 77.2 (and in my case multiple datasources).
I know Springboot 1.4+ has changed the properties set, but this is not the issue you are having.
It's a bit ugly, but it worked for me. It assumes you are using Tomcat JDBC pooling (default when using spring-boot-starter-web):
#Value("${spring.datasource.validation-query}")
private String validationQuery;
#Bean
#ConfigurationProperties("spring.datasource")
#Primary
public DataSourceProperties ftmDataSourceProperties() {
return new DataSourceProperties();
}
#Bean
#ConfigurationProperties("spring.datasource")
#Primary
public DataSource ftmDataSource() {
DataSource ds = ftmDataSourceProperties().initializeDataSourceBuilder().build();
setTypeSpecificProperties(validationQuery,ds);
return ds;
}
private void setTypeSpecificProperties(String validationQuery, DataSource dataSource) {
org.apache.tomcat.jdbc.pool.DataSource typedDS = (org.apache.tomcat.jdbc.pool.DataSource) dataSource;
typedDS.setValidationQuery(validationQuery);
typedDS.setTestOnBorrow(true);
typedDS.setLogValidationErrors(true);
}

Related

How to Configure Two Data Sources JDBC in a Spring Boot Application?

JPA is not used.
project structure: each database has its own class-configurator.
file application.properties is
app.datasource.h2.jdbc-url=jdbc:h2:~/database/tester
app.datasource.h2.username=usr
app.datasource.h2.password=pwd
app.datasource.pg.jdbc-url=jdbc:postgresql://localhost:5432/tester
app.datasource.pg.username=usr
app.datasource.pg.password=pwd
config db H2 is DataSourcesConfigurationH2:
#Configuration
#EnableTransactionManagement
public class DataSourcesConfigurationH2 {
#Bean
#Primary
#ConfigurationProperties(prefix="app.datasource.h2")
public HikariDataSource dataSourceH2(DataSourceProperties dataSourceProperties) {
return dataSourceProperties.initializeDataSourceBuilder().type(HikariDataSource.class).build();
}
#Bean
#Primary
public NamedParameterJdbcTemplate jdbcH2(HikariDataSource dataSource) {
return new NamedParameterJdbcTemplate(dataSource);
}
#Bean
#Primary
TransactionManager transactionManagerH2(HikariDataSource dataSource) {
return new DataSourceTransactionManager(dataSource);
}
}
config db postgres is DataSourcesConfigurationPg:
#Configuration
#EnableTransactionManagement
public class DataSourcesConfigurationPg {
#Bean
#ConfigurationProperties(prefix="app.datasource.pg")
public HikariDataSource dataSourcePg(DataSourceProperties dataSourceProperties) {
return dataSourceProperties.initializeDataSourceBuilder().type(HikariDataSource.class).build();
}
#Bean
public NamedParameterJdbcTemplate jdbcPg(HikariDataSource dataSource) {
return new NamedParameterJdbcTemplate(dataSource);
}
#Bean
TransactionManager transactionManagerPg(HikariDataSource dataSource) {
return new DataSourceTransactionManager(dataSource);
}
}
however, when the application starts, the dataSourcePg value is not initialized.
dataSourceH2.getDriverClassName() is "org.h2.Driver"
and
dataSourcePg.getDriverClassName() is "org.h2.Driver"
how to initialize the value of dataSourcePg correctly ?

Just use three application.properties files. First one is to select the correct properties file. The other two is to have the two different data sourses.

the solution works for the environment:
JDK 11, Spring Boot 2.5.4
fragment application.yml
app:
datasourceh2:
jdbcUrl: jdbc:h2:~/database/tester
driverClassname: org.h2.Driver
username: usr
password: pwd
datasourcepg:
jdbcUrl: jdbc:postgresql://localhost:5432/tester
driverClassname: org.postgresql.Driver
username: usr
password: pwd
I repeat, each database has its own class-configurator.
config db H2 is DataSourcesConfigurationH2:
#Configuration
public class DataSourcesConfigurationH2 {
#Primary
#Bean
#ConfigurationProperties("app.datasourceh2")
public DataSourceProperties dataSourcePropertiesH2() {
return new DataSourceProperties();
}
#Primary
#Bean("dataSourceH2")
#ConfigurationProperties(prefix = "app.datasourceh2")
public HikariDataSource dataSourceH2() {
return dataSourcePropertiesH2()
.initializeDataSourceBuilder().type(HikariDataSource.class).build();
}
#Primary
#Bean
public NamedParameterJdbcTemplate jdbcTemplateH2()
{
DataSource ds = dataSourceH2();
return new NamedParameterJdbcTemplate(ds);
}
// JdbcRepository - is my class for data manipulation
#Primary
#Bean
JdbcRepository jdbcRepositoryH2() {
NamedParameterJdbcTemplate jdbc = jdbcTemplateH2();
return new JdbcRepository(jdbc);
};
}
config db postgres is DataSourcesConfigurationPg:
#Configuration
public class DataSourcesConfigurationPg {
#Bean
#ConfigurationProperties("app.datasourcepg")
public DataSourceProperties dataSourcePropertiesPg() {
return new DataSourceProperties();
}
#Bean("dataSourcePg")
#ConfigurationProperties(prefix = "app.datasourcepg")
public HikariDataSource dataSourcePg() {
return dataSourcePropertiesPg()
.initializeDataSourceBuilder().type(HikariDataSource.class).build();
}
#Bean("jdbcTemplatePg")
public NamedParameterJdbcTemplate jdbcTemplatePg()
{
HikariDataSource ds = dataSourcePg();
return new NamedParameterJdbcTemplate(ds);
}
#Bean("jdbcRepositoryPg")
JdbcRepository jdbcRepositoryPg() {
NamedParameterJdbcTemplate jdbc = jdbcTemplatePg();
return new JdbcRepository(jdbc);
};
}
the dependency injection should be as follows:
for db H2 Service:
#Service
public class DataAccessServiceH2 {
#Autowired
#Qualifier("jdbcRepositoryH2")
private JdbcRepository jdbcRepository;
...
}
for db Pg Service:
#Service
public class DataAccessServicePg {
#Autowired
#Qualifier("jdbcRepositoryPg")
private JdbcRepository jdbcRepository;
...
}
next you can call the db H2 methods from DataAccessServiceH2 or postgres methods from DataAccessServicePg.
to find the answer, I used:
http://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/#howto-two-datasources
https://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/#howto.data-access.configure-two-datasources

SpringBoot, manual control of two data sources, transaction failed

I'm using SpringBoot 2.1.8.RELEASE, I have two datasource, I manually control transactions.
transaction (marked"#Primary") works. But, transaction marked another datasource is not working properly.
Do you have any suggestions?
Maven configuration is as below
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
other omit...
One datasource configure as below:
#Configuration
#MapperScan(basePackages = {"com.XXX.XXXX.mapper","com.XXX.XXX.common.mapper"},sqlSessionFactoryRef = "masterSqlSessionFactory")
public class ProductDataSourceConfig {
static final String MAPPER_LOCATION = "classpath:mybatis/MYSQL/*.xml";
#Bean(name = "masterDataSource")
#ConfigurationProperties("spring.datasource.product")
public DataSource masterDataSource(){
return DataSourceBuilder.create().build();
}
#Bean(name = "masterTransactionManager")
public DataSourceTransactionManager masterTransactionManager() {
return new DataSourceTransactionManager(masterDataSource());
}
#Bean(name = "masterSqlSessionFactory")
public SqlSessionFactory masterSqlSessionFactory(#Qualifier("masterDataSource") DataSource masterDataSource)
throws Exception {
final SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();
sessionFactory.setDataSource(masterDataSource);
sessionFactory.setMapperLocations(new PathMatchingResourcePatternResolver()
.getResources(ProductDataSourceConfig.MAPPER_LOCATION));
return sessionFactory.getObject();
}
}
another datasource configure as below:
#Configuration
#MapperScan(basePackages = "com.XXX.XXX.mapperTest",sqlSessionFactoryRef = "secondSqlSessionFactory")
public class TestDataSourceConfig {
static final String MAPPER_LOCATION = "classpath:mybatis/TESTMYSQL/*.xml";
#Primary
#Bean(name = "secondDataSource")
#ConfigurationProperties("spring.datasource.test")
public DataSource clusterDataSource() {
return DataSourceBuilder.create().build();
}
#Primary
#Bean(name = "secondTransactionManager")
public DataSourceTransactionManager clusterTransactionManager() {
return new DataSourceTransactionManager(clusterDataSource());
}
#Primary
#Bean(name = "secondSqlSessionFactory")
public SqlSessionFactory clusterSqlSessionFactory(#Qualifier("secondDataSource") DataSource clusterDataSource)
throws Exception {
final SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();
sessionFactory.setDataSource(clusterDataSource);
sessionFactory.setMapperLocations(new PathMatchingResourcePatternResolver()
.getResources(TestDataSourceConfig.MAPPER_LOCATION));
return sessionFactory.getObject();
}
}
When configured as follows, submit as expected(in the "#Primary" db,record inserted ).
#Autowired
DataSourceTransactionManager dataSourceTransactionManager;
DefaultTransactionDefinition def = new DefaultTransactionDefinition();
def.setTimeout(500);
def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
TransactionStatus transactionStatus = dataSourceTransactionManager.getTransaction(def);
insertTmemberEnterRecord(bean);
dataSourceTransactionManager.commit(transactionStatus);
But the following configuration as follows, submit is not work(No data inserted into table),also no error message.
#Qualifier("masterTransactionManager")
#Autowired
DataSourceTransactionManager dataSourceTransactionManager;
DefaultTransactionDefinition def = new DefaultTransactionDefinition();
def.setTimeout(500);
def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
TransactionStatus transactionStatus = dataSourceTransactionManager.getTransaction(def);
insertTmemberEnterRecord(bean);
dataSourceTransactionManager.commit(transactionStatus);
Any suggestions are welcome.

I solved the problem.
The reason is that the corresponding mapper file should also be used.

Caused by: org.springframework.beans.factory.NoSuchBeanDefinitionException: No bean named 'entityManagerFactory' available

I want to configure Spring Boot to use 2 JNDI datasources. I tried this configuration:
application.properties
spring.production.datasource.jndi-name=java:/global/production_gateway
spring.production.datasource.driver-class-name=org.mariadb.jdbc.Driver
spring.production.datasource.jpa.properties.hibernate.dialect=org.hibernate.dialect.MariaDBDialect
spring.production.datasource.jpa.show-sql = true
spring.production.datasource.jpa.hibernate.ddl-auto = update
spring.warehouse.datasource.jndi-name=java:/global/production_warehouse
spring.warehouse.datasource.driver-class-name=org.mariadb.jdbc.Driver
spring.warehouse.datasource.jpa.properties.hibernate.dialect=org.hibernate.dialect.MariaDBDialect
spring.warehouse.datasource.jpa.show-sql = true
spring.warehouse.datasource.jpa.hibernate.ddl-auto = update
primary database
#Configuration
#EnableJpaRepositories(
basePackages = "org.datalis.plugin.production.entity",
entityManagerFactoryRef = "productionEntityManagerFactory",
transactionManagerRef = "productionTransactionManager"
)
#EnableTransactionManagement
public class ContextProductionDatasource {
#Primary
#Bean(name = "productionDataSourceProperties")
#ConfigurationProperties(prefix="spring.production.datasource")
public JndiPropertyHolder productionDataSourceProperties() {
return new JndiPropertyHolder();
}
#Primary
#Bean(name = "productionDataSource")
#ConfigurationProperties(prefix="spring.production.datasource")
public DataSource productionDataSource() {
JndiDataSourceLookup dataSourceLookup = new JndiDataSourceLookup();
DataSource dataSource = dataSourceLookup.getDataSource(productionDataSourceProperties().getJndiName());
return dataSource;
}
#Primary
#Bean(name = "productionEntityManager")
public EntityManager productionEntityManager(EntityManagerFactory emf) {
return emf.createEntityManager();
}
#Primary
#Bean(name = "productionEntityManagerFactory")
public LocalContainerEntityManagerFactoryBean productionEntityManagerFactory(
EntityManagerFactoryBuilder builder) {
Map<String, Object> properties = new HashMap<String, Object>();
properties.put("hibernate.hbm2ddl.auto", "update");
return builder
.dataSource(productionDataSource())
.packages("org.datalis.plugin.production.entity")
.persistenceUnit("production")
.properties(properties)
.build();
}
#Primary
#Bean(name = "productionTransactionManager")
public PlatformTransactionManager productionTransactionManager(final EntityManagerFactory emf) {
final JpaTransactionManager transactionManager = new JpaTransactionManager();
transactionManager.setEntityManagerFactory(emf);
return transactionManager;
}
#Primary
#Bean(name = "productionExceptionTranslation")
public PersistenceExceptionTranslationPostProcessor productionExceptionTranslation() {
return new PersistenceExceptionTranslationPostProcessor();
}
private static class JndiPropertyHolder {
private String jndiName;
public String getJndiName() {
return jndiName;
}
public void setJndiName(String jndiName) {
this.jndiName = jndiName;
}
}
}
second datasource:
#Configuration
#EnableJpaRepositories(
basePackages = "org.datalis.plugin.warehouse.entity",
entityManagerFactoryRef = "warehouseEntityManagerFactory",
transactionManagerRef = "warehouseTransactionManager"
)
#EnableTransactionManagement
public class ContextWarehouseDatasource {
#Bean(name = "warehouseDataSourceProperties")
#ConfigurationProperties(prefix="spring.warehouse.datasource")
public JndiPropertyHolder warehouseDataSourceProperties() {
return new JndiPropertyHolder();
}
#Bean(name = "warehouseDataSource")
#ConfigurationProperties(prefix="spring.warehouse.datasource")
public DataSource warehouseDataSource() {
JndiDataSourceLookup dataSourceLookup = new JndiDataSourceLookup();
DataSource dataSource = dataSourceLookup.getDataSource(warehouseDataSourceProperties().getJndiName());
return dataSource;
}
#Bean(name = "warehouseEntityManager")
public EntityManager warehouseEntityManager(EntityManagerFactory emf) {
return emf.createEntityManager();
}
#Bean(name = "warehouseEntityManagerFactory")
public LocalContainerEntityManagerFactoryBean warehouseEntityManagerFactory(
EntityManagerFactoryBuilder builder) {
Map<String, Object> properties = new HashMap<String, Object>();
properties.put("hibernate.hbm2ddl.auto", "update");
return builder
.dataSource(warehouseDataSource())
.packages("org.datalis.plugin.warehouse.entity")
.persistenceUnit("warehouse")
.properties(properties)
.build();
}
#Bean(name = "warehouseTransactionManager")
public PlatformTransactionManager warehouseTransactionManager(final EntityManagerFactory emf) {
final JpaTransactionManager transactionManager = new JpaTransactionManager();
transactionManager.setEntityManagerFactory(emf);
return transactionManager;
}
#Bean(name = "warehouseExceptionTranslation")
public PersistenceExceptionTranslationPostProcessor warehouseExceptionTranslation() {
return new PersistenceExceptionTranslationPostProcessor();
}
private static class JndiPropertyHolder {
private String jndiName;
public String getJndiName() {
return jndiName;
}
public void setJndiName(String jndiName) {
this.jndiName = jndiName;
}
}
}
When I deploy the code I get exception:
Caused by: org.springframework.beans.factory.NoSuchBeanDefinitionException: No bean named 'entityManagerFactory' available
Full error stack:
https://pastebin.com/bBZPZGfu
Do you know how I can solve this issue?
When I remove:
#Primary
#Bean(name = "productionEntityManagerFactory")
public LocalContainerEntityManagerFactoryBean productionEntityManagerFactory(
EntityManagerFactoryBuilder builder) {
Map<String, Object> properties = new HashMap<String, Object>();
properties.put("hibernate.hbm2ddl.auto", "update");
return builder
.dataSource(productionDataSource())
.packages("org.datalis.plugin.production.entity")
.persistenceUnit("production")
.properties(properties)
.build();
}
The package is properly deployed. Any idea why?

The main problem is to have 2 different Entity managers, which access different databases.
So the cause of the exception: Spring Data JPA tries to create a set of repositories but does not know which entity manager factory to use. By default, Spring Data JPA expects only one Entity manager factory bean, preferably named entityManagerFactory, but you do not have such.
So you have to be really precise in configuration: for example, you can organize your code in 2 packages: ...warehouse.* and app.production.*, then you can specify a precise configuration of Spring Data JPA: #EnableJpaRepositories(basePackages = "...warehouse.**", entityManagerFactoryRef = "warehouseEntityManagerFactory") and for production #EnableJpaRepositories(basePackages = "...production.**", entityManagerFactoryRef = "productionEntityManagerFactory").
The second step is to ensure that no default Data JPA instantiation is done: adding the configuration property spring.data.jpa.repositories.enabled=false will resolve this.
And looking through the configuration disable any kind of other #EnableJpaRepositories or #EntityScan except defined above precise configurations.
And during creation of LocalContainerEntityManagerFactoryBean do not use injected EntityManagerFactoryBuilder: dead simple new LocalContainerEntityManagerFactoryBean() will work better.
And last but not least, related to application in general: you have to think about 2-phase commit transactions: you have 2 data sources, which can be accessed within single transactions but each of them is managed by different transaction managers.

Put annotation #ConfigurationProperties("spring.datasource") on you datasource definitions, e.g. warehouseDataSource() and productionDataSource()

Eek! I'd advise following the database per microservice pattern and changing your solution/architecture to have one microservice with a production micro db, and one microservice with a warehouse micro db!

Using 2 DataSources for 2 DBs with Spring

I've been trying unsuccessfully to solve a problem of using 2 DBs with the same schema in Spring. The problem I'm trying to solve is creating a web page for a restaurant that is based in 2 different cities, so I thought using a separate database for each city would be the best solution.
I am only getting results from one database, the other one is for some reason unused. The databases are termed BA and KE for the city and I'm using a City enum with the same values.
BAConfig.java
#Configuration
#PropertySources(
{#PropertySource("classpath:jpa.properties"),
#PropertySource("classpath:jdbc.properties")})
#EnableTransactionManagement // Enable use of the #Transactional annotation
#ComponentScan(basePackages = "dao")
#EnableAspectJAutoProxy(proxyTargetClass = true)
public class BAConfig {
#Autowired
private Environment environment;
#Bean(name="dataSourceBA")
public DataSource buildDataSource()
{
HikariConfig hkcfg = new HikariConfig();
hkcfg.setJdbcUrl(environment.getRequiredProperty("jdbc.urlBA"));
hkcfg.setDriverClassName(environment.getRequiredProperty("jdbc.driverClassName"));
hkcfg.setUsername(environment.getRequiredProperty("jdbc.username"));
hkcfg.setPassword(environment.getRequiredProperty("jdbc.password"));
HikariDataSource ds = new HikariDataSource(hkcfg);
return ds;
}
public static LocalContainerEntityManagerFactoryBean entityManagerFactoryBuilder(DataSource ds)
{
LocalContainerEntityManagerFactoryBean emf = new LocalContainerEntityManagerFactoryBean();
emf.setDataSource(ds);
emf.setJpaVendorAdapter(new EclipseLinkJpaVendorAdapter());
emf.setPackagesToScan("model"); // Look for entities in this package
Properties props = new Properties();
props.setProperty("databasePlatform", "org.eclipse.persistence.platform.database.PostgreSQLPlatform");
props.setProperty("generateDdl", "true");
props.setProperty("showSql", "true");
props.setProperty("eclipselink.weaving", "false");
props.setProperty("eclipselink.ddl-generation", "create-tables");
emf.setJpaProperties(props);
return emf;
}
#Bean(name="BAEM")
public LocalContainerEntityManagerFactoryBean entityManagerFactory(#Qualifier("dataSourceBA") DataSource ds) {
return entityManagerFactoryBuilder(ds);
}
#Bean(name = "txManagerBA")
JpaTransactionManager transactionManager(#Qualifier("BAEM") EntityManagerFactory em) {
JpaTransactionManager transactionManager = new JpaTransactionManager(em);
return transactionManager;
}
}
KEConfig.java
#Configuration
#PropertySources(
{#PropertySource("classpath:jpa.properties"),
#PropertySource("classpath:jdbc.properties")})
#EnableTransactionManagement // Enable use of the #Transactional annotation
#ComponentScan(basePackages = "dao")
#EnableAspectJAutoProxy(proxyTargetClass = true)
public class KEConfig {
#Autowired
private Environment environment;
#Bean("dataSourceKE")
public DataSource buildDataSource()
{
HikariConfig hkcfg = new HikariConfig();
hkcfg.setJdbcUrl(environment.getRequiredProperty("jdbc.urlKE"));
hkcfg.setDriverClassName(environment.getRequiredProperty("jdbc.driverClassName"));
hkcfg.setUsername(environment.getRequiredProperty("jdbc.username"));
hkcfg.setPassword(environment.getRequiredProperty("jdbc.password"));
HikariDataSource ds = new HikariDataSource(hkcfg);
return ds;
}
#Bean(name="KEEM")
public LocalContainerEntityManagerFactoryBean entityManagerFactory(#Qualifier("dataSourceKE")DataSource ds) {
return BAConfig.entityManagerFactoryBuilder(ds);
}
#Bean(name = "txManagerKE")
JpaTransactionManager transactionManager(#Qualifier("KEEM") EntityManagerFactory em) {
JpaTransactionManager transactionManager = new JpaTransactionManager(em);
return transactionManager;
}
}
These are both imported into the MainConfig.java class and use the following properties file.
jdbc.properties
jdbc.driverClassName=org.postgresql.Driver
jdbc.urlBA=jdbc:postgresql://localhost:5432/BambooBA
jdbc.urlKE=jdbc:postgresql://localhost:5432/BambooKE
Here is the rest controller for the given entity.
ReservationsController.java
#RestController
#RequestMapping("/reservations")
public class ReservationsController {
#Autowired
private ReservationsService reservationsService;
#RequestMapping(value = "/getAll/{c}", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<List<Reservations>> getAll(#PathVariable City c) {
try {
List<Reservations> reservations = new ArrayList<Reservations>();
switch(c)
{
case BA: reservations = reservationsService.findAllBA(); break;
case KE: reservations = reservationsService.findAllKE(); break;
}
return new ResponseEntity<List<Reservations>>(reservations, HttpStatus.OK);
} catch (NoSuchElementException e)
{
return new ResponseEntity<List<Reservations>>(HttpStatus.NOT_FOUND);
}
}
}
Here is the reservations service, where i've been trying to pull dummy data (in both DBs the id is 1).
ReservationsService.java
#Service
public class ReservationsService {
#Autowired
private ReservationsDao reservationsDao;
#Transactional("txManagerBA")
public List<Reservations> findAllBA() throws NoSuchElementException {
reservationsDao.setEM(City.BA);
List<Reservations> reservations = new ArrayList<Reservations>();
reservations.add(reservationsDao.find(1));
if(reservations.size() == 0)
{
throw new NoSuchElementException();
}
return reservations;
}
#Transactional("txManagerKE")
public List<Reservations> findAllKE() throws NoSuchElementException {
reservationsDao.setEM(City.KE);
List<Reservations> reservations = new ArrayList<Reservations>();
reservations.add(reservationsDao.find(1));
if(reservations.size() == 0)
{
throw new NoSuchElementException();
}
return reservations;
}
}
And here is the DAO superclass (the particular DAO inherits from this class and only has a super constructor in it).
BaseDao.java
public abstract class BaseDao<T>{
#PersistenceContext(unitName = "BAEM")
EntityManager emBA;
#PersistenceContext(unitName = "KEEM")
EntityManager emKE;
EntityManager em;
protected final Class<T> type;
protected BaseDao(Class<T> type) {
this.type = type;
}
public void setEM(City c)
{
switch(c) {
case BA: em = emBA; break;
case KE: em = emKE; break;
}
}
public T find(Integer id) {
return em.find(type, id);
}
public List<T> findAll() {
return em.createQuery("SELECT e FROM " + type.getSimpleName() + " e", type).getResultList();
}
}
The debug (breakpoint set in BaseDAO in the find() function) shows that the correct persistence unit is being used to retrieve data (when i move all the way down to persistenceUnitInfo.nonJtaDataSource.jdbcUrl the URL is correct).
Yet only one of the databases is being used, no matter the request. I have also tried using an AbstractRoutingDataSource but with the same problem - the database would get set on the first request and from then only that database would be used, indifferent to the request.

Here is the configuration that we are using in our spring4 application with Hikaripool
The #Qualifier annotation will be useful to differentiate when you have multiple database data sources and #Primary to make the default datasource when used with #AutoWiredand when using other datasource make use of #Qualifier annotation along with #AutoWired
#Bean(destroyMethod = "close")
#Primary
#Qualifier("tspDataSource")
public DataSource dataSource() {
HikariConfig config = new HikariConfig("/hikari-tsp.properties");
config.addDataSourceProperty("cachePrepStmts", "true");
config.addDataSourceProperty("prepStmtCacheSize", "250");
config.addDataSourceProperty("prepStmtCacheSqlLimit", "2048");
final HikariDataSource ds = new HikariDataSource(config);
return ds;
}
and second one
#Bean(destroyMethod = "close")
#Qualifier("fdxDataSource")
public DataSource fdxDataSource() {
HikariConfig config = new HikariConfig("/hikari-fdx.properties");
config.addDataSourceProperty("cachePrepStmts", "true");
config.addDataSourceProperty("prepStmtCacheSize", "250");
config.addDataSourceProperty("prepStmtCacheSqlLimit", "2048");
final HikariDataSource ds = new HikariDataSource(config);
return ds;
}

Spring Boot configure and use two data sources

How can I configure and use two data sources?
For example, here is what I have for the first data source:
application.properties
#first db
spring.datasource.url = [url]
spring.datasource.username = [username]
spring.datasource.password = [password]
spring.datasource.driverClassName = oracle.jdbc.OracleDriver
#second db ...
Application class
#SpringBootApplication
public class SampleApplication
{
public static void main(String[] args) {
SpringApplication.run(SampleApplication.class, args);
}
}
How do I modify application.properties to add another data source? How do I autowire it to be used by a different repository?

Here you go.
Add in your application.properties file:
#first db
spring.datasource.url = [url]
spring.datasource.username = [username]
spring.datasource.password = [password]
spring.datasource.driverClassName = oracle.jdbc.OracleDriver
#second db ...
spring.secondDatasource.url = [url]
spring.secondDatasource.username = [username]
spring.secondDatasource.password = [password]
spring.secondDatasource.driverClassName = oracle.jdbc.OracleDriver
Add in any class annotated with #Configuration the following methods:
#Bean
#Primary
#ConfigurationProperties(prefix="spring.datasource")
public DataSource primaryDataSource() {
return DataSourceBuilder.create().build();
}
#Bean
#ConfigurationProperties(prefix="spring.secondDatasource")
public DataSource secondaryDataSource() {
return DataSourceBuilder.create().build();
}

Update 2022-05-29 with Spring Boot 1.5.8.RELEASE which should work with Spring Boot 2.x
Most answers do not provide how to use them (as datasource itself and as transaction), only how to config them.
Moreover you should know how to commit/rollback transactions of both datasources at the same time.
You can see the runnable example and some explanation in https://github.com/surasint/surasint-examples/tree/master/spring-boot-jdbi/10_spring-boot-two-databases (see what you can try in README.txt)
I copied some code here.
First you have to set application.properties like this
#Database
database1.datasource.url=jdbc:mysql://localhost/testdb
database1.datasource.username=root
database1.datasource.password=root
database1.datasource.driver-class-name=com.mysql.jdbc.Driver
database2.datasource.url=jdbc:mysql://localhost/testdb2
database2.datasource.username=root
database2.datasource.password=root
database2.datasource.driver-class-name=com.mysql.jdbc.Driver
Then define them as providers (#Bean) like this:
#Bean(name = "datasource1")
#ConfigurationProperties("database1.datasource")
#Primary
public DataSource dataSource(){
return DataSourceBuilder.create().build();
}
#Bean(name = "datasource2")
#ConfigurationProperties("database2.datasource")
public DataSource dataSource2(){
return DataSourceBuilder.create().build();
}
Note that I have #Bean(name="datasource1") and #Bean(name="datasource2"), then you can use it when we need datasource as #Qualifier("datasource1") and #Qualifier("datasource2") , for example
#Qualifier("datasource1")
#Autowired
private DataSource dataSource;
If you do care about transaction, you have to define DataSourceTransactionManager for both of them, like this:
#Bean(name="tm1")
#Autowired
#Primary
DataSourceTransactionManager tm1(#Qualifier ("datasource1") DataSource datasource) {
DataSourceTransactionManager txm = new DataSourceTransactionManager(datasource);
return txm;
}
#Bean(name="tm2")
#Autowired
DataSourceTransactionManager tm2(#Qualifier ("datasource2") DataSource datasource) {
DataSourceTransactionManager txm = new DataSourceTransactionManager(datasource);
return txm;
}
Then you can use it like
#Transactional //this will use the first datasource because it is #primary
or
#Transactional("tm2")
The most important part, which you will hardly find an example in anywhere: if you want a method to commit/rollback transactions of both databases, you need ChainedTransactionManager for tm1 and tm2 , like this:
#Bean(name = "chainedTransactionManager")
public ChainedTransactionManager getChainedTransactionManager(#Qualifier ("tm1") DataSourceTransactionManager tm1, #Qualifier ("tm2") DataSourceTransactionManager tm2){
return new ChainedTransactionManager(tm1, tm2);
}
To use it, add this annotation in a method #Transactional(value="chainedTransactionManager") for example
#Transactional(value="chainedTransactionManager")
public void insertAll() {
UserBean test = new UserBean();
test.setUsername("username" + new Date().getTime());
userDao.insert(test);
userDao2.insert(test);
}
This should be enough. See example and detail in the link above.

Refer the official documentation
Creating more than one data source works same as creating the first one. You might want to mark one of them as #Primary if you are using the default auto-configuration for JDBC or JPA (then that one will be picked up by any #Autowired injections).
#Bean
#Primary
#ConfigurationProperties(prefix="datasource.primary")
public DataSource primaryDataSource() {
return DataSourceBuilder.create().build();
}
#Bean
#ConfigurationProperties(prefix="datasource.secondary")
public DataSource secondaryDataSource() {
return DataSourceBuilder.create().build();
}

I also had to setup connection to 2 datasources from Spring Boot application, and it was not easy - the solution mentioned in the Spring Boot documentation didn't work. After a long digging through the internet I made it work and the main idea was taken from this article and bunch of other places.
The following solution is written in Kotlin and works with Spring Boot 2.1.3 and Hibernate Core 5.3.7. Main issue was that it was not enough just to setup different DataSource configs, but it was also necessary to configure EntityManagerFactory and TransactionManager for both databases.
Here is config for the first (Primary) database:
#Configuration
#EnableJpaRepositories(
entityManagerFactoryRef = "firstDbEntityManagerFactory",
transactionManagerRef = "firstDbTransactionManager",
basePackages = ["org.path.to.firstDb.domain"]
)
#EnableTransactionManagement
class FirstDbConfig {
#Bean
#Primary
#ConfigurationProperties(prefix = "spring.datasource.firstDb")
fun firstDbDataSource(): DataSource {
return DataSourceBuilder.create().build()
}
#Primary
#Bean(name = ["firstDbEntityManagerFactory"])
fun firstDbEntityManagerFactory(
builder: EntityManagerFactoryBuilder,
#Qualifier("firstDbDataSource") dataSource: DataSource
): LocalContainerEntityManagerFactoryBean {
return builder
.dataSource(dataSource)
.packages(SomeEntity::class.java)
.persistenceUnit("firstDb")
// Following is the optional configuration for naming strategy
.properties(
singletonMap(
"hibernate.naming.physical-strategy",
"org.hibernate.boot.model.naming.PhysicalNamingStrategyStandardImpl"
)
)
.build()
}
#Primary
#Bean(name = ["firstDbTransactionManager"])
fun firstDbTransactionManager(
#Qualifier("firstDbEntityManagerFactory") firstDbEntityManagerFactory: EntityManagerFactory
): PlatformTransactionManager {
return JpaTransactionManager(firstDbEntityManagerFactory)
}
}
And this is config for second database:
#Configuration
#EnableJpaRepositories(
entityManagerFactoryRef = "secondDbEntityManagerFactory",
transactionManagerRef = "secondDbTransactionManager",
basePackages = ["org.path.to.secondDb.domain"]
)
#EnableTransactionManagement
class SecondDbConfig {
#Bean
#ConfigurationProperties("spring.datasource.secondDb")
fun secondDbDataSource(): DataSource {
return DataSourceBuilder.create().build()
}
#Bean(name = ["secondDbEntityManagerFactory"])
fun secondDbEntityManagerFactory(
builder: EntityManagerFactoryBuilder,
#Qualifier("secondDbDataSource") dataSource: DataSource
): LocalContainerEntityManagerFactoryBean {
return builder
.dataSource(dataSource)
.packages(EntityFromSecondDb::class.java)
.persistenceUnit("secondDb")
.build()
}
#Bean(name = ["secondDbTransactionManager"])
fun secondDbTransactionManager(
#Qualifier("secondDbEntityManagerFactory") secondDbEntityManagerFactory: EntityManagerFactory
): PlatformTransactionManager {
return JpaTransactionManager(secondDbEntityManagerFactory)
}
}
The properties for datasources are like this:
spring.datasource.firstDb.jdbc-url=
spring.datasource.firstDb.username=
spring.datasource.firstDb.password=
spring.datasource.secondDb.jdbc-url=
spring.datasource.secondDb.username=
spring.datasource.secondDb.password=
Issue with properties was that I had to define jdbc-url instead of url because otherwise I had an exception.
p.s.
Also you might have different naming schemes in your databases, which was the case for me. Since Hibernate 5 does not support all previous naming schemes, I had to use solution from this answer - maybe it will also help someone as well.

Here is the Complete solution
#First Datasource (DB1)
db1.datasource.url: url
db1.datasource.username:user
db1.datasource.password:password
#Second Datasource (DB2)
db2.datasource.url:url
db2.datasource.username:user
db2.datasource.password:password
Since we are going to get access two different databases (db1, db2), we need to configure each data source configuration separately like:
public class DB1_DataSource {
#Autowired
private Environment env;
#Bean
#Primary
public LocalContainerEntityManagerFactoryBean db1EntityManager() {
LocalContainerEntityManagerFactoryBean em = new LocalContainerEntityManagerFactoryBean();
em.setDataSource(db1Datasource());
em.setPersistenceUnitName("db1EntityManager");
HibernateJpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter();
em.setJpaVendorAdapter(vendorAdapter);
HashMap<string, object=""> properties = new HashMap<>();
properties.put("hibernate.dialect",
env.getProperty("hibernate.dialect"));
properties.put("hibernate.show-sql",
env.getProperty("jdbc.show-sql"));
em.setJpaPropertyMap(properties);
return em;
}
#Primary
#Bean
public DataSource db1Datasource() {
DriverManagerDataSource dataSource
= new DriverManagerDataSource();
dataSource.setDriverClassName(
env.getProperty("jdbc.driver-class-name"));
dataSource.setUrl(env.getProperty("db1.datasource.url"));
dataSource.setUsername(env.getProperty("db1.datasource.username"));
dataSource.setPassword(env.getProperty("db1.datasource.password"));
return dataSource;
}
#Primary
#Bean
public PlatformTransactionManager db1TransactionManager() {
JpaTransactionManager transactionManager
= new JpaTransactionManager();
transactionManager.setEntityManagerFactory(
db1EntityManager().getObject());
return transactionManager;
}
}
Second Datasource :
public class DB2_DataSource {
#Autowired
private Environment env;
#Bean
public LocalContainerEntityManagerFactoryBean db2EntityManager() {
LocalContainerEntityManagerFactoryBean em
= new LocalContainerEntityManagerFactoryBean();
em.setDataSource(db2Datasource());
em.setPersistenceUnitName("db2EntityManager");
HibernateJpaVendorAdapter vendorAdapter
= new HibernateJpaVendorAdapter();
em.setJpaVendorAdapter(vendorAdapter);
HashMap<string, object=""> properties = new HashMap<>();
properties.put("hibernate.dialect",
env.getProperty("hibernate.dialect"));
properties.put("hibernate.show-sql",
env.getProperty("jdbc.show-sql"));
em.setJpaPropertyMap(properties);
return em;
}
#Bean
public DataSource db2Datasource() {
DriverManagerDataSource dataSource
= new DriverManagerDataSource();
dataSource.setDriverClassName(
env.getProperty("jdbc.driver-class-name"));
dataSource.setUrl(env.getProperty("db2.datasource.url"));
dataSource.setUsername(env.getProperty("db2.datasource.username"));
dataSource.setPassword(env.getProperty("db2.datasource.password"));
return dataSource;
}
#Bean
public PlatformTransactionManager db2TransactionManager() {
JpaTransactionManager transactionManager
= new JpaTransactionManager();
transactionManager.setEntityManagerFactory(
db2EntityManager().getObject());
return transactionManager;
}
}
Here you can find the complete Example on my blog :
Spring Boot with Multiple DataSource Configuration

# Here '1stDB' is the database name
spring.datasource.url=jdbc:mysql://localhost/A
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
# Here '2ndDB' is the database name
spring.second-datasourcee.url=jdbc:mysql://localhost/B
spring.second-datasource.username=root
spring.second-datasource.password=root
spring.second-datasource.driver-class-name=com.mysql.jdbc.Driver
#Bean
#Primary
#ConfigurationProperties(prefix = "spring.datasource")
public DataSource firstDataSource() {
return DataSourceBuilder.create().build();
}
#Bean
#ConfigurationProperties(prefix = "spring.second-datasource")
public DataSource secondDataSource() {
return DataSourceBuilder.create().build();
}

My requirement was slightly different but used two data sources.
I have used two data sources for same JPA entities from same package. One for executing DDL at the server startup to create/update tables and another one is for DML at runtime.
The DDL connection should be closed after DDL statements are executed, to prevent further usage of super user previlleges anywhere in the code.
Properties
spring.datasource.url=jdbc:postgresql://Host:port
ddl.user=ddluser
ddl.password=ddlpassword
dml.user=dmluser
dml.password=dmlpassword
spring.datasource.driver-class-name=org.postgresql.Driver
Data source config classes
//1st Config class for DDL Data source
public class DatabaseDDLConfig {
#Bean
public LocalContainerEntityManagerFactoryBean ddlEntityManagerFactoryBean() {
LocalContainerEntityManagerFactoryBean entityManagerFactoryBean = new LocalContainerEntityManagerFactoryBean();
PersistenceProvider persistenceProvider = new
org.hibernate.jpa.HibernatePersistenceProvider();
entityManagerFactoryBean.setDataSource(ddlDataSource());
entityManagerFactoryBean.setPackagesToScan(new String[] {
"com.test.two.data.sources"});
HibernateJpaVendorAdapter vendorAdapter = new
HibernateJpaVendorAdapter();
entityManagerFactoryBean.setJpaVendorAdapter(vendorAdapter);
HashMap<String, Object> properties = new HashMap<>();
properties.put("hibernate.dialect",
"org.hibernate.dialect.PostgreSQLDialect");
properties.put("hibernate.physical_naming_strategy",
"org.springframework.boot.orm.jpa.hibernate.
SpringPhysicalNamingStrategy");
properties.put("hibernate.implicit_naming_strategy",
"org.springframework.boot.orm.jpa.hibernate.
SpringImplicitNamingStrategy");
properties.put("hibernate.hbm2ddl.auto", "update");
entityManagerFactoryBean.setJpaPropertyMap(properties);
entityManagerFactoryBean.setPersistenceUnitName("ddl.config");
entityManagerFactoryBean.setPersistenceProvider(persistenceProvider);
return entityManagerFactoryBean;
}
#Bean
public DataSource ddlDataSource() {
DriverManagerDataSource dataSource = new DriverManagerDataSource();
dataSource.setDriverClassName(env.getProperty("spring.datasource.driver-class-name"));
dataSource.setUrl(env.getProperty("spring.datasource.url"));
dataSource.setUsername(env.getProperty("ddl.user");
dataSource.setPassword(env.getProperty("ddl.password"));
return dataSource;
}
#Bean
public PlatformTransactionManager ddlTransactionManager() {
JpaTransactionManager transactionManager = new JpaTransactionManager();
transactionManager.setEntityManagerFactory(ddlEntityManagerFactoryBean().getObject());
return transactionManager;
}
}
//2nd Config class for DML Data source
public class DatabaseDMLConfig {
#Bean
#Primary
public LocalContainerEntityManagerFactoryBean dmlEntityManagerFactoryBean() {
LocalContainerEntityManagerFactoryBean entityManagerFactoryBean = new LocalContainerEntityManagerFactoryBean();
PersistenceProvider persistenceProvider = new org.hibernate.jpa.HibernatePersistenceProvider();
entityManagerFactoryBean.setDataSource(dmlDataSource());
entityManagerFactoryBean.setPackagesToScan(new String[] { "com.test.two.data.sources" });
JpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter();
entityManagerFactoryBean.setJpaVendorAdapter(vendorAdapter);
entityManagerFactoryBean.setJpaProperties(defineJpaProperties());
entityManagerFactoryBean.setPersistenceUnitName("dml.config");
entityManagerFactoryBean.setPersistenceProvider(persistenceProvider);
return entityManagerFactoryBean;
}
#Bean
#Primary
public DataSource dmlDataSource() {
DriverManagerDataSource dataSource = new DriverManagerDataSource();
dataSource.setDriverClassName(env.getProperty("spring.datasource.driver-class-name"));
dataSource.setUrl(envt.getProperty("spring.datasource.url"));
dataSource.setUsername("dml.user");
dataSource.setPassword("dml.password");
return dataSource;
}
#Bean
#Primary
public PlatformTransactionManager dmlTransactionManager() {
JpaTransactionManager transactionManager = new JpaTransactionManager();
transactionManager.setEntityManagerFactory(dmlEntityManagerFactoryBean().getObject());
return transactionManager;
}
}
//Usage of DDL data sources in code.
public class DDLServiceAtStartup {
//Import persistence unit ddl.config for ddl purpose.
#PersistenceUnit(unitName = "ddl.config")
private EntityManagerFactory entityManagerFactory;
public void executeDDLQueries() throws ContentServiceSystemError {
try {
EntityManager entityManager = entityManagerFactory.createEntityManager();
entityManager.getTransaction().begin();
entityManager.createNativeQuery("query to create/update table").executeUpdate();
entityManager.flush();
entityManager.getTransaction().commit();
entityManager.close();
//Close the ddl data source to avoid from further use in code.
entityManagerFactory.close();
} catch(Exception ex) {}
}
//Usage of DML data source in code.
public class DDLServiceAtStartup {
#PersistenceUnit(unitName = "dml.config")
private EntityManagerFactory entityManagerFactory;
public void createRecord(User user) {
userDao.save(user);
}
}

#Primary annotation when used against a method like below works good if the two data sources are on the same db location/server.
#Bean(name = "datasource1")
#ConfigurationProperties("database1.datasource")
#Primary
public DataSource dataSource(){
return DataSourceBuilder.create().build();
}
#Bean(name = "datasource2")
#ConfigurationProperties("database2.datasource")
public DataSource dataSource2(){
return DataSourceBuilder.create().build();
}
If the data sources are on different servers its better to use #Component along with #Primary annotation. The following code snippet works well on two different data sources at different locations
database1.datasource.url = jdbc:mysql://127.0.0.1:3306/db1
database1.datasource.username = root
database1.datasource.password = mysql
database1.datasource.driver-class-name=com.mysql.jdbc.Driver
database2.datasource1.url = jdbc:mysql://192.168.113.51:3306/db2
database2.datasource1.username = root
database2.datasource1.password = mysql
database2.datasource1.driver-class-name=com.mysql.jdbc.Driver
#Configuration
#Primary
#Component
#ComponentScan("com.db1.bean")
class DBConfiguration1{
#Bean("db1Ds")
#ConfigurationProperties(prefix="database1.datasource")
public DataSource primaryDataSource() {
return DataSourceBuilder.create().build();
}
}
#Configuration
#Component
#ComponentScan("com.db2.bean")
class DBConfiguration2{
#Bean("db2Ds")
#ConfigurationProperties(prefix="database2.datasource1")
public DataSource primaryDataSource() {
return DataSourceBuilder.create().build();
}
}

I used mybatis - springboot 2.0 tech stack,
solution:
//application.properties - start
sp.ds1.jdbc-url=jdbc:mysql://localhost:3306/mydb?useSSL=false
sp.ds1.username=user
sp.ds1.password=pwd
sp.ds1.testWhileIdle=true
sp.ds1.validationQuery=SELECT 1
sp.ds1.driverClassName=com.mysql.jdbc.Driver
sp.ds2.jdbc-url=jdbc:mysql://localhost:4586/mydb?useSSL=false
sp.ds2.username=user
sp.ds2.password=pwd
sp.ds2.testWhileIdle=true
sp.ds2.validationQuery=SELECT 1
sp.ds2.driverClassName=com.mysql.jdbc.Driver
//application.properties - end
//configuration class
#Configuration
#ComponentScan(basePackages = "com.mypkg")
public class MultipleDBConfig {
public static final String SQL_SESSION_FACTORY_NAME_1 = "sqlSessionFactory1";
public static final String SQL_SESSION_FACTORY_NAME_2 = "sqlSessionFactory2";
public static final String MAPPERS_PACKAGE_NAME_1 = "com.mypg.mymapper1";
public static final String MAPPERS_PACKAGE_NAME_2 = "com.mypg.mymapper2";
#Bean(name = "mysqlDb1")
#Primary
#ConfigurationProperties(prefix = "sp.ds1")
public DataSource dataSource1() {
System.out.println("db1 datasource");
return DataSourceBuilder.create().build();
}
#Bean(name = "mysqlDb2")
#ConfigurationProperties(prefix = "sp.ds2")
public DataSource dataSource2() {
System.out.println("db2 datasource");
return DataSourceBuilder.create().build();
}
#Bean(name = SQL_SESSION_FACTORY_NAME_1)
#Primary
public SqlSessionFactory sqlSessionFactory1(#Qualifier("mysqlDb1") DataSource dataSource1) throws Exception {
System.out.println("sqlSessionFactory1");
SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
sqlSessionFactoryBean.setTypeHandlersPackage(MAPPERS_PACKAGE_NAME_1);
sqlSessionFactoryBean.setDataSource(dataSource1);
SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBean.getObject();
sqlSessionFactory.getConfiguration().setMapUnderscoreToCamelCase(true);
sqlSessionFactory.getConfiguration().setJdbcTypeForNull(JdbcType.NULL);
return sqlSessionFactory;
}
#Bean(name = SQL_SESSION_FACTORY_NAME_2)
public SqlSessionFactory sqlSessionFactory2(#Qualifier("mysqlDb2") DataSource dataSource2) throws Exception {
System.out.println("sqlSessionFactory2");
SqlSessionFactoryBean diSqlSessionFactoryBean = new SqlSessionFactoryBean();
diSqlSessionFactoryBean.setTypeHandlersPackage(MAPPERS_PACKAGE_NAME_2);
diSqlSessionFactoryBean.setDataSource(dataSource2);
SqlSessionFactory sqlSessionFactory = diSqlSessionFactoryBean.getObject();
sqlSessionFactory.getConfiguration().setMapUnderscoreToCamelCase(true);
sqlSessionFactory.getConfiguration().setJdbcTypeForNull(JdbcType.NULL);
return sqlSessionFactory;
}
#Bean
#Primary
public MapperScannerConfigurer mapperScannerConfigurer1() {
System.out.println("mapperScannerConfigurer1");
MapperScannerConfigurer configurer = new MapperScannerConfigurer();
configurer.setBasePackage(MAPPERS_PACKAGE_NAME_1);
configurer.setSqlSessionFactoryBeanName(SQL_SESSION_FACTORY_NAME_1);
return configurer;
}
#Bean
public MapperScannerConfigurer mapperScannerConfigurer2() {
System.out.println("mapperScannerConfigurer2");
MapperScannerConfigurer configurer = new MapperScannerConfigurer();
configurer.setBasePackage(MAPPERS_PACKAGE_NAME_2);
configurer.setSqlSessionFactoryBeanName(SQL_SESSION_FACTORY_NAME_2);
return configurer;
}
}
Note :
1)#Primary -> #primary
2)---."jdbc-url" in properties -> After Spring Boot 2.0 migration: jdbcUrl is required with driverClassName

declaring a data source in Spring Boot application.properties
spring.datasource.company.url=jdbc:mysql://localhost/company_db?createDatabaseIfNotExist=true&autoReconnect=true&useSSL=false&allowPublicKeyRetrieval=true
spring.datasource.company.username=root
spring.datasource.company.password=root
spring.datasource.company.platform=mysql
spring.datasource.employee.url=jdbc:mysql://localhost/employee_db?createDatabaseIfNotExist=true&autoReconnect=true&useSSL=false&allowPublicKeyRetrieval=true
spring.datasource.employee.username=root
spring.datasource.employee.password=root
spring.datasource.employee.platform=mysql
use multiple data sources, we need to declare multiple beans with
different mappings within Spring's application context.
using a configuration class
#Configuration
#EnableJpaRepositories(basePackages = "com.example.multiple.datasources.entity.company",
entityManagerFactoryRef = "companyEntityManagerFactory",
transactionManagerRef = "companyTransactionManager")
public class CompanyDataSourceConfiguration {
#Bean
#ConfigurationProperties("spring.datasource.company")
public DataSourceProperties companyDataSourceProperties() {
return new DataSourceProperties();
}
#Bean
#ConfigurationProperties("spring.datasource.company.configuration")
public DataSource companyDataSource() {
return companyDataSourceProperties().initializeDataSourceBuilder()
.type(HikariDataSource.class).build();
}
#Bean(name = "companyEntityManagerFactory")
public LocalContainerEntityManagerFactoryBean companyEntityManagerFactory(EntityManagerFactoryBuilder builder) {
return builder.dataSource(companyDataSource()).packages(Company.class).build();
}
#Bean
public PlatformTransactionManager companyTransactionManager(
final #Qualifier("companyEntityManagerFactory") LocalContainerEntityManagerFactoryBean companyEntityManagerFactory
) {
return new JpaTransactionManager(companyEntityManagerFactory.getObject());
}
}
we need to declare one of the datasources as #Primary. This is because
EntityManagerFactoryBuilder is declared in JpaBaseConfiguration and
this class need a single data source injected.
#Configuration
#EnableJpaRepositories(basePackages = "com.example.multiple.datasources.entity.employee",
entityManagerFactoryRef = "employeeEntityManagerFactory",
transactionManagerRef = "employeeTransactionManager")
public class EmployeeDatasourceConfiguration {
#Bean
#Primary
#ConfigurationProperties("spring.datasource.employee")
public DataSourceProperties employeeDataSourceProperties() {
return new DataSourceProperties();
}
#Bean
#Primary
#ConfigurationProperties("spring.datasource.employee.configuration")
public DataSource employeeDataSource() {
return employeeDataSourceProperties().initializeDataSourceBuilder().type(HikariDataSource.class).build();
}
#Primary
#Bean("employeeEntityManagerFactory")
public LocalContainerEntityManagerFactoryBean employeeEntityManagerFactory(EntityManagerFactoryBuilder builder) {
return builder.dataSource(employeeDataSource()).packages(Employee.class).build();
}
#Primary
#Bean
public PlatformTransactionManager employeeTransactionManager(
final #Qualifier("employeeEntityManagerFactory") LocalContainerEntityManagerFactoryBean employeeEntityManagerFactory
) {
return new JpaTransactionManager(employeeEntityManagerFactory.getObject());
}
}

We Keep Coding

Java is a programming language and computing platform first released by Sun Microsystems in 1995.