服务器之家:专注于服务器技术及软件下载分享
分类导航

PHP教程|ASP.NET教程|Java教程|ASP教程|编程技术|正则表达式|C/C++|IOS|C#|Swift|Android|VB|R语言|JavaScript|易语言|vb.net|

服务器之家 - 编程语言 - Java教程 - springboot + JPA 配置双数据源实战

springboot + JPA 配置双数据源实战

2021-12-27 14:04Frankenstein_ Java教程

这篇文章主要介绍了springboot + JPA 配置双数据源实战,具有很好的参考价值,希望对大家有所帮助。如有错误或未考虑完全的地方,望不吝赐教

springboot + JPA 配置双数据源

1、首先配置application.yml文件设置主从数据库

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
spring:
  servlet:
    multipart:
      max-file-size: 20MB
      max-request-size: 20MB
  profiles:
    active: @activatedProperties@
  thymeleaf:
    mode: LEGACYHTML5
    encoding: UTF-8
    cache: false
  http:
    encoding:
      charset: UTF-8
      enabled: true
      force: true
  jpa:
    hibernate:
      ddl-auto: none
    properties:
      hibernate:
        dialect: org.hibernate.dialect.MySQL5Dialect
    show-sql: true
    database: mysql
 
  datasource:
    primary:
      jdbc-url: jdbc:mysql://192.168.2.180:3306/ssdt-rfid?serverTimezone=Asia/Shanghai
      username: root
      password: root
      driver-class-name: com.mysql.cj.jdbc.Driver
 
    secondary:
      jdbc-url: jdbc:mysql://127.0.0.1:3306/isite?serverTimezone=Asia/Shanghai
      username: root
      password: 654321
      driver-class-name: com.mysql.cj.jdbc.Driver
  • 在datasource中存在primary(主数据源) 和secondary (副数据源)两个配置,
  • dialect: org.hibernate.dialect.MySQL5Dialect配置
  • MySQLDialect是MySQL5.X之前的版本,MySQL5Dialect是MySQL5.X之后的版本

2、使用配置类读取application.yml配置的两个数据源

并将其注入到Spring的IOC容器中

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
package com.springboot.***.***.config;
import org.springframework.beans.factory.annotation.Qualifier;
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;
 
/**
 * @author: SUN
 * @version: 1.0
 * @date: 2019/12/24 13:12
 * @description:
 */
@Configuration
public class DataSourceConfig { 
    @Bean(name = "primaryDataSource")
    @Qualifier("primaryDataSource")
    @Primary
    @ConfigurationProperties(prefix = "spring.datasource.primary"//  读取配置文件主数据源参数
    public DataSource primaryDataSource() {
        return DataSourceBuilder.create().build();
    }
 
    @Bean(name = "secondaryDataSource")
    @Qualifier("secondaryDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.secondary"//  读取配置文件副数据源参数
    public DataSource secondaryDataSource() {
        return DataSourceBuilder.create().build();
    }
}

注解解释:

  • @Configuration:SpringBoot启动将该类作为配置类,同配置文件一起加载
  • @Bean:将该实体注入到IOC容器中
  • @Qualifier:指定数据源名称,与Bean中的name属性原理相同,主要是为了确保注入成功
  • @Primary:指定主数据源
  • @ConfigurationProperties:将配置文件中的数据源读取进到方法中,进行build

3、然后通过类的方式配置两个数据源

对于主次数据源的DAO层接口以及实体POJO类需放在不同目录下,由以下两个配置类中分别指定路径

(1)主数据源

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
package com.springboot.****.****.config;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
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.core.env.Environment;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import javax.persistence.EntityManager;
import javax.sql.DataSource;
import java.util.HashMap;
import java.util.Map;
 
/**
 * @author: SUN
 * @version: 1.0
 * @date: 2019/12/24 13:25
 * @description:
 */
@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(
        entityManagerFactoryRef = "entityManagerFactoryPrimary",
        transactionManagerRef = "transactionManagerPrimary",
        basePackages = {"com.springboot.****.****.repository"})    // 指定该数据源操作的DAO接口包与副数据源作区分
public class PrimaryConfig {
    private String url;
 
    public String getUrl() {
        return url;
    }
 
    public void setUrl(String url) {
        this.url = url;
    }
 
    @Autowired
    @Qualifier("primaryDataSource")
    private DataSource primaryDataSource;
 
    @Primary
    @Bean(name = "entityManagerPrimary")
    public EntityManager entityManager(EntityManagerFactoryBuilder builder) {
        return entityManagerFactoryPrimary(builder).getObject().createEntityManager();
    }
 
    @Primary
    @Bean(name = "entityManagerFactoryPrimary")
    public LocalContainerEntityManagerFactoryBean entityManagerFactoryPrimary(EntityManagerFactoryBuilder builder) {
        return builder
                .dataSource(primaryDataSource)
                .properties(getVendorProperties())
                .packages("com.springboot.****.****.domain.entity")         //设置实体类所在位置与副数据源区分
                .persistenceUnit("primaryPersistenceUnit")
                .build();
    }
 
    private Map getVendorProperties() {
        HashMap<String, Object> properties = new HashMap<>();
        properties.put("hibernate.dialect",
                env.getProperty("hibernate.dialect"));
        properties.put("hibernate.ddl-auto",
                "create");
        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");
        return properties;
    }
 
    @Autowired
    private Environment env;
    @Primary
    @Bean(name = "transactionManagerPrimary")
    public PlatformTransactionManager transactionManagerPrimary(EntityManagerFactoryBuilder builder) {
        return new JpaTransactionManager(entityManagerFactoryPrimary(builder).getObject());
    }
}

(2)次数据源

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
package com.springboot.****.****.config;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.env.Environment;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import javax.persistence.EntityManager;
import javax.sql.DataSource;
import java.util.HashMap;
import java.util.Map;
/**
 * @author: SUN
 * @version: 1.0
 * @date: 2019/12/24 13:59
 * @description:
 */
@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(
        entityManagerFactoryRef = "entityManagerFactorySecondary",
        transactionManagerRef = "transactionManagerSecondary",
        basePackages = {"com.springboot.****.****.secRepository"}) //设置DAO接口层所在包位置与主数据源区分
public class SecondaryConfig {
 
    @Autowired
    @Qualifier("secondaryDataSource")
    private DataSource secondaryDataSource;
 
    @Bean(name = "entityManagerSecondary")
    public EntityManager entityManager(EntityManagerFactoryBuilder builder) {
        return entityManagerFactorySecondary(builder).getObject().createEntityManager();
    }
 
    @Bean(name = "entityManagerFactorySeAcondary")
    public LocalContainerEntityManagerFactoryBean entityManagerFactorySecondary(EntityManagerFactoryBuilder builder) {
        return builder
                .dataSource(secondaryDataSource)
                .properties(getVendorProperties())
                .packages("com.springboot.****.****.secEntity")      //设置实体类所在包的位置与主数据源区分
                .persistenceUnit("primaryPersistenceUnit")
                .build();
    }
 
    private Map getVendorProperties() {
        HashMap<String, Object> properties = new HashMap<>();
        properties.put("hibernate.hbm2ddl.auto",
                env.getProperty("hibernate.hbm2ddl.auto"));
        properties.put("hibernate.ddl-auto",
                env.getProperty("update"));
        properties.put("hibernate.dialect",
                env.getProperty("hibernate.dialect"));
        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");
        return properties;
    }
 
    @Autowired
    private Environment env;
 
    @Bean(name = "transactionManagerSecondary")
    PlatformTransactionManager transactionManagerSecondary(EntityManagerFactoryBuilder builder) {
        return new JpaTransactionManager(entityManagerFactorySecondary(builder).getObject());
    }
}

这两个类主要配置每个数据源,包括事务管理器、以及实体管理器等配置。

注:必须要指定DAO接口所在的包以及实体类所在的包。每个数据源主要操作它指定的资源(DAO接口CURD、实体类)

4、启动类主函数入口

SpringBoot启动类需关闭注解 --程序启动加载的仓库(@EnableJpaRepositories),因为在数据源配置类中已经开启了

?
1
2
3
4
5
6
7
8
@SpringBootApplication
@EnableAsync //开启异步调用
//@EnableJpaRepositories(basePackages = {""}
public class TouchPmsApplication {
    public static void main(String[] args) {
        SpringApplication.run(TouchPmsApplication.class, args);
    }
}

以上为个人经验,希望能给大家一个参考,也希望大家多多支持服务器之家。

原文链接:https://blog.csdn.net/Frankenstein_/article/details/103728652

延伸 · 阅读

精彩推荐
  • Java教程java编写创建数据库和表的程序

    java编写创建数据库和表的程序

    这篇文章主要为大家详细介绍了java编写创建数据库和表的程序,具有一定的参考价值,感兴趣的小伙伴们可以参考一下...

    DamonWong10692021-01-15
  • Java教程解决Spring Batch框架job任务只跑一次的问题

    解决Spring Batch框架job任务只跑一次的问题

    这篇文章主要介绍了解决Spring Batch框架job任务只跑一次的问题,具有很好的参考价值,希望对大家有所帮助。如有错误或未考虑完全的地方,望不吝赐教...

    201901154232021-12-22
  • Java教程java数据结构与算法之简单选择排序详解

    java数据结构与算法之简单选择排序详解

    这篇文章主要介绍了java数据结构与算法之简单选择排序,结合实例形式分析了选择排序的原理、实现方法与相关操作技巧,需要的朋友可以参考下...

    android小猪5162020-09-23
  • Java教程Java完美实现2048小游戏

    Java完美实现2048小游戏

    本文给大家分享的是一则根据网友的代码改编的2048小游戏的源码,个人认为已经非常完美了,推荐给大家,有需要的小伙伴可以参考下。 ...

    hebedich4982019-12-14
  • Java教程java nio基础使用示例

    java nio基础使用示例

    传统的io技术为阻塞的,java新nio是非阻塞的,注册一个op_read事件,注册到selector对象上,当有数据到来时候,selector回通知之前注册事件的对象,进行read处...

    java技术网5342019-10-21
  • Java教程Java 添加数字签名到excel及检测,删除签名

    Java 添加数字签名到excel及检测,删除签名

    这篇文章主要介绍了Java 添加数字签名到excel及检测,删除签名的方法,帮助大家更好的理解和学习使用Java,感兴趣的朋友可以了解下...

    E-iceblue12142021-09-01
  • Java教程Java编程二项分布的递归和非递归实现代码实例

    Java编程二项分布的递归和非递归实现代码实例

    这篇文章主要介绍了Java编程二项分布的递归和非递归实现代码实例,小编觉得还是挺不错的,具有一定借鉴价值,需要的朋友可以参考下...

    ChuanjieZhu7442021-03-26
  • Java教程Java中Thread.join()的使用方法

    Java中Thread.join()的使用方法

    这篇文章主要介绍了Java中Thread.join()的使用方法,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面...

    huangzejun1772020-08-01