springboot 集成hibernate 多数据源链接

因为第一次接触双数据源，所以记录学习一下

此处我链接mysql数据源、SQL Server数据源

pom.xml文件：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-log4j</artifactId>
    <version>1.3.8.RELEASE</version>
</dependency>

<dependency>
    <groupId>com.microsoft.sqlserver</groupId>
    <artifactId>mssql-jdbc</artifactId>
    <scope>runtime</scope>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <scope>runtime</scope>
</dependency>
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <optional>true</optional>
</dependency>

properties配置文件如下：

#mysql部分：

spring.datasource.hikari.middledb.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.hikari.middledb.jdbc-url=jdbc:mysql://127.0.0.1:3306/test1?serverTimezone=CTT&useUnicode=true&characterEncoding=UTF-8
spring.datasource.hikari.middledb.username=你的用户名
spring.datasource.hikari.middledb.password=你的密码
#spring.datasource.hikari.middledb.password=123456
spring.jpa.properties.hibernate.middledb.ddl-auto=update
spring.jpa.properties.middledb.database-platform=org.hibernate.dialect.MySQL5Dialect

#SQL Server部分：spring.datasource.hikari.erpdb.driver-class-name=com.microsoft.sqlserver.jdbc.SQLServerDriver

spring.datasource.hikari.erpdb.jdbc-url=jdbc:sqlserver://127.0.0.1;SelectMethod=cursor;DatabaseName=test2
spring.datasource.hikari.erpdb.username=你的用户名
spring.datasource.hikari.erpdb.password=你的密码
spring.jpa.properties.hibernate.erpdb.ddl-auto=update
spring.jpa.properties.erpdb.database-platform=org.hibernate.dialect.SQLServer2012Dialect
#sql日志设置spring.jpa.show-sql=truespring.jpa.properties.hibernate.format_sql=true

logging.level.org.hibernate.type.descriptor.sql.BasicBinder=trace
spring.jackson.serialization.indent-output=true
spring.jpa.hibernate.naming.physical-strategy=org.hibernate.boot.model.naming.PhysicalNamingStrategyStandardImpl

#编码设置
spring.http.encoding.force=true
spring.http.encoding.charset=UTF-8
spring.http.encoding.enabled=true
server.tomcat.uri-encoding=UTF-8
server.port=8011

接着需要添加数据源的配置类：

DataSourceConfig.java

 1 import javax.sql.DataSource;
 2 import org.springframework.beans.factory.annotation.Qualifier;
 3 import org.springframework.boot.context.properties.ConfigurationProperties;
 4 import org.springframework.boot.jdbc.DataSourceBuilder;
 5 import org.springframework.context.annotation.Bean;
 6 import org.springframework.context.annotation.Configuration;
 7 import org.springframework.context.annotation.Primary;
 8 
 9 @Configuration
10 public class DataSourceConfig {
11     
12     @Bean(name = "middleDataSource") #配置到spring的容器中
13     @Qualifier("middleDataSource")   #Qualifiler()的作用是准确绑定mysqlDataSource名字
14     @Primary   #表示主数据源
15     @ConfigurationProperties(prefix = "spring.datasource.hikari.middledb")
16     public DataSource middleDataSource() {
17         return DataSourceBuilder.create().build();
18     }
19 
20     @Bean(name = "erpserverDataSource")
21     @Qualifier("erpserverDataSource")
22     @ConfigurationProperties(prefix = "spring.datasource.hikari.erpdb")
23     public DataSource erpDataSource() {
24         return DataSourceBuilder.create().build();
25     }
26 }


次数据源的配置类：即 ErpDataSourceConfig.java

 1 import java.util.Map;
 2 import java.util.Objects;
 3 
 4 import javax.persistence.EntityManager;
 5 import javax.sql.DataSource;
 6 
 7 import org.springframework.beans.factory.annotation.Autowired;
 8 import org.springframework.beans.factory.annotation.Qualifier;
 9 import org.springframework.beans.factory.annotation.Value;
10 import org.springframework.boot.autoconfigure.orm.jpa.HibernateProperties;
11 import org.springframework.boot.autoconfigure.orm.jpa.HibernateSettings;
12 import org.springframework.boot.autoconfigure.orm.jpa.JpaProperties;
13 import org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder;
14 import org.springframework.context.annotation.Bean;
15 import org.springframework.context.annotation.Configuration;
16 import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
17 import org.springframework.orm.jpa.JpaTransactionManager;
18 import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
19 import org.springframework.transaction.PlatformTransactionManager;
20 import org.springframework.transaction.annotation.EnableTransactionManagement;
21 
22 @Configuration
23 @EnableTransactionManagement
24 @EnableJpaRepositories(entityManagerFactoryRef = "entityManagerFactoryErp", transactionManagerRef = "transactionManagerErp", basePackages = {"com.kwg.sap.dao.erp"})
25 public class ErpDatasourceConfig {
26 
27     private final DataSource erpDataSource;
28 
29     private final JpaProperties jpaProperties;
30 
31     private final HibernateProperties hibernateProperties;
32 
33     @Value("${spring.jpa.properties.erpdb.database-platform}")
34     private String erpDialect;// 获取对应的数据库方言
35 
36     @Value("${spring.jpa.properties.hibernate.erpdb.ddl-auto}")
37     private String erpDdlAuto;// 获取对应的数据库方言
38 
39     @Autowired
40     public ErpDatasourceConfig(@Qualifier("erpDataSource") DataSource erpDataSource, JpaProperties jpaProperties, HibernateProperties hibernateProperties) {
41         this.erpDataSource = erpDataSource;
42         this.jpaProperties = jpaProperties;
43         this.hibernateProperties = hibernateProperties;
44     }
45 
46     @Bean(name = "entityManagerErp")
47     public EntityManager entityManager(EntityManagerFactoryBuilder builder) {
48         return Objects.requireNonNull(entityManagerFactoryErp(builder).getObject()).createEntityManager();
49     }
50 
51     @Bean(name = "entityManagerFactoryErp")
52     public LocalContainerEntityManagerFactoryBean entityManagerFactoryErp(EntityManagerFactoryBuilder builder) {
53         return builder.dataSource(erpDataSource)
54                 .packages("com.kwg.sap.entity.erp").persistenceUnit("erpPersistenceUnit")
55                 .properties(getVendorProperties()).build();
56     }
57 
58     private Map<String, Object> getVendorProperties() {
59         jpaProperties.setDatabasePlatform(erpDialect);
60 //        jpaProperties.setShowSql(true);
61         System.err.println("当前选用方言：" + jpaProperties.getDatabasePlatform());
62         hibernateProperties.setDdlAuto(erpDdlAuto);
63         return hibernateProperties.determineHibernateProperties(jpaProperties.getProperties(), new HibernateSettings());
64     }
65 
66     @Bean(name = "transactionManagerErp")
67     public PlatformTransactionManager transactionManagerErp(EntityManagerFactoryBuilder builder) {
68         return new JpaTransactionManager(entityManagerFactoryErp(builder).getObject());
69     }
70 }

主数据源的配置类：

 1 import java.util.Map;
 2 import java.util.Objects;
 3 
 4 import javax.persistence.EntityManager;
 5 import javax.sql.DataSource;
 6 
 7 import org.springframework.beans.factory.annotation.Autowired;
 8 import org.springframework.beans.factory.annotation.Qualifier;
 9 import org.springframework.beans.factory.annotation.Value;
10 import org.springframework.boot.autoconfigure.orm.jpa.HibernateProperties;
11 import org.springframework.boot.autoconfigure.orm.jpa.HibernateSettings;
12 import org.springframework.boot.autoconfigure.orm.jpa.JpaProperties;
13 import org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder;
14 import org.springframework.context.annotation.Bean;
15 import org.springframework.context.annotation.Configuration;
16 import org.springframework.context.annotation.Primary;
17 import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
18 import org.springframework.orm.jpa.JpaTransactionManager;
19 import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
20 import org.springframework.transaction.PlatformTransactionManager;
21 import org.springframework.transaction.annotation.EnableTransactionManagement;
22 
23 @Configuration
24 @EnableTransactionManagement
25 @EnableJpaRepositories(entityManagerFactoryRef = "entityManagerFactoryMiddle", transactionManagerRef = "transactionManagerMiddle", basePackages = {
26         "com.kwg.sap.dao.middle"})
27 public class MiddleDatasourceConfig {
28 
29     private final DataSource middleDataSource;
30 
31     private final JpaProperties jpaProperties;
32 
33     private final HibernateProperties hibernateProperties;
34 
35     @Value("${spring.jpa.properties.middledb.database-platform}")
36     private String middleDialect;// 获取对应的数据库方言
37 
38     @Value("${spring.jpa.properties.hibernate.middledb.ddl-auto}")
39     private String middleDdlAuto;// 获取对应的数据库方言
40 
41     @Autowired
42     public MiddleDatasourceConfig(@Qualifier("middleDataSource") DataSource middleDataSource, JpaProperties jpaProperties, HibernateProperties hibernateProperties) {
43         this.middleDataSource = middleDataSource;
44         this.jpaProperties = jpaProperties;
45         this.hibernateProperties = hibernateProperties;
46     }
47 
48     @Primary
49     @Bean(name = "entityManagerMiddle")
50     public EntityManager entityManager(EntityManagerFactoryBuilder builder) {
51         return Objects.requireNonNull(entityManagerFactoryMiddle(builder).getObject()).createEntityManager();
52     }
53 
54     @Primary
55     @Bean(name = "entityManagerFactoryMiddle")
56     public LocalContainerEntityManagerFactoryBean entityManagerFactoryMiddle(EntityManagerFactoryBuilder builder) {
57         return builder.dataSource(middleDataSource)
58                 .packages("com.kwg.sap.entity.middle").persistenceUnit("middlePersistenceUnit")
59                 .properties(getVendorProperties()).build();
60     }
61 
62     private Map<String, Object> getVendorProperties() {
63         jpaProperties.setDatabasePlatform(middleDialect);
64 //        jpaProperties.setShowSql(true);
65         System.err.println("当前选用方言：" + jpaProperties.getDatabasePlatform());
66         hibernateProperties.setDdlAuto(middleDdlAuto);
67         return hibernateProperties.determineHibernateProperties(jpaProperties.getProperties(), new HibernateSettings());
68     }
69 
70     @Primary
71     @Bean(name = "transactionManagerMiddle")
72     public PlatformTransactionManager transactionManagerMiddle(EntityManagerFactoryBuilder builder) {
73         return new JpaTransactionManager(entityManagerFactoryMiddle(builder).getObject());
74     }
75 }

双数据源配置到此为止：至于数据库的调用层：DAO层如下（假设 UserDAO）,怎么操作，都是像单数据源一样操作，这里之所以能映射到对应数据库的User表，是因为在数据源配置类的时候，已经扫描了User所在的包，即已经绑定了是mysql数据库还是sql Server数据库
@Repository 
public interface UserDAO extends JpaRepository<User, Long> {