Regarding the configuration of multiple data sources in springboot, I made notes today and shared them with friends in need. The power node Mr. Wang He said in the video,
The springboot tutorial explained by Mr. Wang He of the power node, from the shallower to the deeper, takes you to experience the extremely fast development process of Spring Boot. It is rich in content, covers all aspects of SpringBoot development, and is updated to the latest version of the Spring Boot 2.x series.
1. Directory structure
Directory Structure
2. Dependency package (pom.xml)
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-configuration-processor</artifactId>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.2</version>
</dependency>
</dependencies>
3. Configuration file
server:
port: 8080
spring:
datasource:
first:
driver-class-name: com.mysql.jdbc.Driver
jdbc-url: jdbc:mysql://localhost:3306/first?useUnicode=true&characterEncoding=utf8&allowMultiQueries=true
username: root
password: root
second:
driver-class-name: com.mysql.jdbc.Driver
jdbc-url: jdbc:mysql://localhost:3306/second?useUnicode=true&characterEncoding=utf8&allowMultiQueries=true
username: root
password: root
jpa:
hibernate:
ddl-auto: update
naming:
physical-strategy: org.springframework.boot.orm.jpa.hibernate.SpringPhysicalNamingStrategy
implicit-strategy: org.springframework.boot.orm.jpa.hibernate.SpringImplicitNamingStrategy
show-sql: true
database-platform: org.hibernate.dialect.MySQL5InnoDBDialect
database: mysql
4. Multiple data source configuration (jpa)
1. DataSourceConfiguration
package com.cetc.config;
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.context.annotation.Primary;
import javax.sql.DataSource;
/**
* 数据库配置
*/
@Configuration
public class DataSourceConfiguration {
/**
* 第一个数据连接,默认优先级最高
* @return
*/
@Bean(name = "dataSourceFirst")
@Primary
@ConfigurationProperties(prefix = "spring.datasource.first")
public DataSource dataSourceFirst() {
//这种方式的配置默认只满足spring的配置方式,如果使用其他数据连接(druid),需要自己独立获取配置
return DataSourceBuilder.create().build();
}
/**
* 第二个数据源
* @return
*/
@Bean(name = "dataSourceSecond")
@ConfigurationProperties(prefix = "spring.datasource.second")
public DataSource dataSourceSecond() {
return DataSourceBuilder.create().build();
}
}
Explanation: In fact, the configuration here has been completed, and two data sources are configured here. You can add the corresponding JdbcTemplate, which is relatively simple and will not be introduced here.
2. JpaFirstConfiguration
package com.cetc.config;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.domain.EntityScan;
import org.springframework.boot.autoconfigure.orm.jpa.HibernateSettings;
import org.springframework.boot.autoconfigure.orm.jpa.JpaProperties;
import org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import javax.persistence.EntityManager;
import javax.sql.DataSource;
/**
* 第一个数据源,jpa的相关配置
*/
@Configuration
@EntityScan(basePackages = "com.cetc.domain.first")
//1、实体扫描
//2、实体管理ref
//3、事务管理
@EnableJpaRepositories(
basePackages = "com.cetc.repository.first",
entityManagerFactoryRef = "firstEntityManagerFactoryBean",
transactionManagerRef = "firstTransactionManager")
@EnableTransactionManagement
public class JpaFirstConfiguration {
//第一个数据源,可以不加Qualifier
@Autowired
@Qualifier("dataSourceFirst")
private DataSource dataSource;
//jpa其他参数配置
@Autowired
private JpaProperties jpaProperties;
//实体管理工厂builder
@Autowired
private EntityManagerFactoryBuilder factoryBuilder;
/**
* 配置第一个实体管理工厂的bean
* @return
*/
@Bean(name = "firstEntityManagerFactoryBean")
@Primary
public LocalContainerEntityManagerFactoryBean entityManagerFactoryBean() {
return factoryBuilder.dataSource(dataSource)
//这一行的目的是加入jpa的其他配置参数比如(ddl-auto: update等)
//当然这个参数配置可以在事务配置的时候也可以
.properties(jpaProperties.getHibernateProperties(new HibernateSettings()))
.packages("com.cetc.domain.first")
.persistenceUnit("firstPersistenceUnit")
.build();
}
/**
* EntityManager不过解释,用过jpa的应该都了解
* @return
*/
@Bean(name = "firstEntityManager")
@Primary
public EntityManager entityManager() {
return entityManagerFactoryBean().getObject().createEntityManager();
}
/**
* jpa事务管理
* @return
*/
@Bean(name = "firstTransactionManager")
@Primary
public JpaTransactionManager transactionManager() {
JpaTransactionManager jpaTransactionManager = new JpaTransactionManager();
jpaTransactionManager.setEntityManagerFactory(entityManagerFactoryBean().getObject());
return jpaTransactionManager;
}
}
3. JpaSecondConfiguration
package com.cetc.config;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.domain.EntityScan;
import org.springframework.boot.autoconfigure.orm.jpa.HibernateSettings;
import org.springframework.boot.autoconfigure.orm.jpa.JpaProperties;
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.LocalContainerEntityManagerFactoryBean;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import javax.persistence.EntityManager;
import javax.sql.DataSource;
/**
* 第二个数据源,jpa的相关配置
*/
@Configuration
@EntityScan(basePackages = "com.cetc.domain.second")
//1、实体扫描
//2、实体管理ref
//3、事务管理
@EnableJpaRepositories(
basePackages = "com.cetc.repository.second",
entityManagerFactoryRef = "secondEntityManagerFactoryBean",
transactionManagerRef = "secondTransactionManager")
@EnableTransactionManagement
public class JpaSecondConfiguration {
//第二个数据源,必须加Qualifier
@Autowired
@Qualifier("dataSourceSecond")
private DataSource dataSource;
//jpa其他参数配置
@Autowired
private JpaProperties jpaProperties;
//实体管理工厂builder
@Autowired
private EntityManagerFactoryBuilder factoryBuilder;
/**
* 配置第二个实体管理工厂的bean
* @return
*/
@Bean(name = "secondEntityManagerFactoryBean")
public LocalContainerEntityManagerFactoryBean entityManagerFactoryBean() {
return factoryBuilder.dataSource(dataSource)
.properties(jpaProperties.getHibernateProperties(new HibernateSettings()))
.packages("com.cetc.domain.second")
.persistenceUnit("secondPersistenceUnit")
.build();
}
/**
* EntityManager不过解释,用过jpa的应该都了解
* @return
*/
@Bean(name = "secondEntityManager")
public EntityManager entityManager() {
return entityManagerFactoryBean().getObject().createEntityManager();
}
/**
* jpa事务管理
* @return
*/
@Bean(name = "secondTransactionManager")
public JpaTransactionManager transactionManager() {
JpaTransactionManager jpaTransactionManager = new JpaTransactionManager();
jpaTransactionManager.setEntityManagerFactory(entityManagerFactoryBean().getObject());
return jpaTransactionManager;
}
}