SpringBoot配置多数据源JPA

最新推荐文章于 2022-04-01 11:59:32 发布
最新推荐文章于 2022-04-01 11:59:32 发布
阅读量249 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44131142/article/details/103696453
版权
titletoclayoutcategoriestagsdate
SpringBoot + Hikari +JPA 多数据源
true
SpringBoot
SpringBoot
SpringBoot
Hikari
JPA
2018/07/19 9:55:23

{{title}}

SpringBoot2.0 Hikari 多数据源 —— JPA

SpringBoot 连接多数据源使用 JPA 查询应用记录.

pom.xml依赖配置

<!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-data-jpa -->
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

注：SpringBoot 2.0默认的数据连接池为Hikari，故不需要添加 Hikari 依赖

多数据源配置

  1. primaryDataSource 配置
package com.learnning.config;

import javax.persistence.EntityManager;
import javax.sql.DataSource;

import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.DataSourceBuilder;
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.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;

import com.zaxxer.hikari.HikariDataSource;

/**
 * 
 * @ClassName: HikariDataSourceConfig
 * @Description: Hikari 多数据源配置(第一数据源配置)
 * @author time
 * @date 2018/10/29
 * {@link {@link http://blog.didispace.com/springbootmultidatasource/}}
 */
@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(entityManagerFactoryRef = "primaryEntityManagerFactory", //
		transactionManagerRef = "primaryTransactionManager", //
		basePackages = { "com.learnning.domain.p" }) // 设置Repository所在位置
public class PrimaryConfig {

	@Primary
	@Bean(name = "primaryDataSource")
	@Qualifier(value = "primaryDataSource")
	@ConfigurationProperties(prefix = "spring.datasource.primary")
	public DataSource primaryDataSource() {
		return DataSourceBuilder.create().type(HikariDataSource.class).build();
	}

	@Primary
	@Bean(name = "primaryEntityManager")
	public EntityManager entityManager(EntityManagerFactoryBuilder builder) {
		return primaryEntityManagerFactory(builder).getObject().createEntityManager();
	}

	@Primary
	@Bean(name = "primaryEntityManagerFactory")
	public LocalContainerEntityManagerFactoryBean primaryEntityManagerFactory(EntityManagerFactoryBuilder builder) {
		return builder//
				.dataSource(primaryDataSource()) //
				.packages("com.learnning.domain.p")//
				.persistenceUnit("primaryPersistenceUnit")//
				.build();
	}

	@Primary
	@Bean(name = "primaryTransactionManager")
	public PlatformTransactionManager transactionManager(EntityManagerFactoryBuilder builder) {
		return new JpaTransactionManager(primaryEntityManagerFactory(builder).getObject());
	}

}
  1. sencondaryDataSource 配置
package com.learnning.config;

import javax.persistence.EntityManager;
import javax.sql.DataSource;

import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.DataSourceBuilder;
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.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;

import com.zaxxer.hikari.HikariDataSource;

/**
 * 
 * @ClassName: HikariDataSourceConfig
 * @Description: Hikari 多数据源配置(第一数据源配置)
 * @author time
 * @date 2018/10/29
 * {@link {@link http://blog.didispace.com/springbootmultidatasource/}}
 */
@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(entityManagerFactoryRef = "secondaryEntityManagerFactory", //
		transactionManagerRef = "secondaryTransactionManager", //
		basePackages = { "com.learnning.domain.s" }) // 设置Repository所在位置
public class SecondaryConfig {

	@Bean(name = "sencondaryDataSource")
	@Qualifier(value = "sencondaryDataSource")
	@ConfigurationProperties(prefix = "spring.datasource.secondary")
	public DataSource sencondaryDataSource() {
		return DataSourceBuilder.create().type(HikariDataSource.class).build();
	}

	@Bean(name = "secondaryEntityManager")
	public EntityManager entityManager(EntityManagerFactoryBuilder builder) {
		return secondaryEntityManagerFactory(builder).getObject().createEntityManager();
	}

	@Bean(name = "secondaryEntityManagerFactory")
	public LocalContainerEntityManagerFactoryBean secondaryEntityManagerFactory(EntityManagerFactoryBuilder builder) {
		return builder//
				.dataSource(sencondaryDataSource()) //
				.packages("com.learnning.domain.s")//
				.persistenceUnit("secondaryPersistenceUnit")//
				.build();
	}

	@Bean(name = "secondaryTransactionManager")
	PlatformTransactionManager transactionManager(EntityManagerFactoryBuilder builder) {
		return new JpaTransactionManager(secondaryEntityManagerFactory(builder).getObject());
	}

}

JPA 使用多数据源查询

划重点：

  1. JPA的entity与table因为有映射关系，所以实体类路径需要映射到对应的DataSource中

  2. JPA查询接口最好也根据不同数据源区分开

primary数据源配置

  • primary数据源实体类
package com.learnning.domain.p;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name = "t_account")
public class User {

	@Id
	@GeneratedValue
	private Long account_id;

	private String user_name;

	private Integer validity;

	public Long getAccount_id() {
		return account_id;
	}

	public void setAccount_id(Long account_id) {
		this.account_id = account_id;
	}


	public String getUser_name() {
		return user_name;
	}

	public void setUser_name(String user_name) {
		this.user_name = user_name;
	}

	public Integer getValidity() {
		return validity;
	}

	public void setValidity(Integer validity) {
		this.validity = validity;
	}

	@Override
	public String toString() {
		return "{\"account_id\":\"" + account_id + "\",\"user_name\":\"" + user_name + "\",\"validity\":\"" + validity
				+ "\"}";
	}
}
  • primary 数据源Repository
package com.learnning.domain.p.repository;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;

import com.learnning.domain.p.User;

public interface UserRepository extends JpaRepository<User, Long> {

	/**
	 * 
	 * @Title: findByAccount_id
	 * @Description: 查询用户 User 信息
	 * 	nativeQuery：指定为原生SQL查询
	 * @param account_id
	 * @return
	 * User
	 */
	/// 模糊匹配
	@Query(value = "select account_id,user_name,validity from t_account where account_id = ?", nativeQuery = true)
	User findByAccount_id(Long account_id);

}

secondary 数据源配置

  • secondary 实体类
package com.learnning.domain.s;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name = "t_user")
public class PopUser {

	@Id
	@GeneratedValue
	private Long pop_id;

	private String pop_name;

	private String ip_start;

	private String ip_end;

	private String netmask;

	private String description;

	private String start_num;

	private String end_num;

	private String platform;

	private Integer ipgap;

	private Integer pop_type;

	public Long getPop_id() {
		return pop_id;
	}

	public void setPop_id(Long pop_id) {
		this.pop_id = pop_id;
	}

	public String getPop_name() {
		return pop_name;
	}

	public void setPop_name(String pop_name) {
		this.pop_name = pop_name;
	}

	public String getIp_start() {
		return ip_start;
	}

	public void setIp_start(String ip_start) {
		this.ip_start = ip_start;
	}

	public String getIp_end() {
		return ip_end;
	}

	public void setIp_end(String ip_end) {
		this.ip_end = ip_end;
	}

	public String getNetmask() {
		return netmask;
	}

	public void setNetmask(String netmask) {
		this.netmask = netmask;
	}

	public String getDescription() {
		return description;
	}

	public void setDescription(String description) {
		this.description = description;
	}

	public String getStart_num() {
		return start_num;
	}

	public void setStart_num(String start_num) {
		this.start_num = start_num;
	}

	public String getEnd_num() {
		return end_num;
	}

	public void setEnd_num(String end_num) {
		this.end_num = end_num;
	}

	public String getPlatform() {
		return platform;
	}

	public void setPlatform(String platform) {
		this.platform = platform;
	}

	public Integer getIpgap() {
		return ipgap;
	}

	public void setIpgap(Integer ipgap) {
		this.ipgap = ipgap;
	}

	public Integer getPop_type() {
		return pop_type;
	}

	public void setPop_type(Integer pop_type) {
		this.pop_type = pop_type;
	}

	@Override
	public String toString() {
		return "{\"pop_id\":\"" + pop_id + "\",\"pop_name\":\"" + pop_name + "\",\"ip_start\":\"" + ip_start
				+ "\",\"ip_end\":\"" + ip_end + "\",\"netmask\":\"" + netmask + "\",\"description\":\"" + description
				+ "\",\"start_num\":\"" + start_num + "\",\"end_num\":\"" + end_num + "\",\"platform\":\"" + platform
				+ "\",\"ipgap\":\"" + ipgap + "\",\"pop_type\":\"" + pop_type + "\"}";
	}

}
  • secondary 数据源 Repository
package com.learnning.domain.s.repository;

import java.util.List;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;

import com.learnning.domain.s.PopUser;

public interface PopUserRepository extends JpaRepository<PopUser, Long> {

	@Query(value = "select pop_name,pop_id,ip_start,ip_end,netmask,description,start_num,end_num,platform,ipgap,pop_type from t_user where rownum<= 10", nativeQuery = true)
	List<PopUser> queryPopUserPage1();

}

测试类

@Autowired
private UserRepository userRepository;

@Autowired
private PopUserRepository popUserRepository;

@Test
public void testPrimarySession() {
	User users = userRepository.findByAccount_id(1L);
	System.out.println(users.toString());

	List<PopUser> page = popUserRepository.queryPopUserPage1();
	System.out.println(page.toString());

}

注： SpringBoot官方建议使用构造函数的方式注入依赖，上述测试代码为在测试类中使用.

使用构造函数注入如下：

private UserRepository userRepository;

private PopUserRepository popUserRepository;

@Autowired
public MyErrorController(UserRepository userRepository, PopUserRepository popUserRepository) {
	this.userRepository = userRepository;
	this.popUserRepository = popUserRepository;
}
焦虑的肉松面包
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
SpringBoot操作多数据源（JPA+JdbcTemplate）
04-29
SpringBoot操作多数据源（JPA+JdbcTemplate）使用HikariCP数据源进行示例。
SpringBoot整合Jpa实现多数据源
橙子君的博客
07-25 4284
SpringBoot整合Jpa实现多数据源 前言： 最近工作中需要用到两个数据源，刚好是SpringBoot项目整合的JPA，之前有写过SpringBoo Mybatis Druid配置多数据源 的文章，不过这次是 SpringBoot JPA Hikari 配置多数据源。好了，废话不多说，直接进入正题。 首先，我这里的SpringBoot版本是<version>2.3.1.RELEASE</version>，这个很重要，如果你的版本是低于2.1.x的，可能会有些依赖不一样，导致程序
Spring boot 2.3 + Spring Data JPA配置多数据源
theoffspring的专栏
06-08 851
sss
Spring Boot （三）： ORM 框架 JPA 与连接池 Hikari
极客挖掘机
09-22 1635
前面两篇文章我们介绍了如何快速创建一个 Spring Boot 工程《Spring Boot（一）：快速开始》和在 Spring Boot 中如何使用模版引擎 Thymeleaf 渲染一个Web页面《Spring Boot （二）：模版引擎 Thymeleaf 渲染 Web 页面》，本篇文章我们继续介绍在 Spring Boot 中如何使用数据库。 1. 概述 数据库方面我们选用 Mys...
SpringBoot配置JPA多数据源
在下的博客
05-22 7940
SpringBoot版本 不同的版本其配置方式可能有所区别，我采用的是SpringBoot2.0.4.RELEASE。 多数据源配置 application.yml配置如下： spring: application: name: test jpa: hibernate: ddl-auto: update show-sql: true datasour...
springboot+JPA 多数据源配置
08-29
通过以上步骤，你就可以在Spring Boot项目中成功配置并使用JPA进行多数据源操作了。这种方式允许你灵活地管理不同数据库的数据，对于复杂的分布式系统和多租户应用特别有用。在实际开发中，还可能需要考虑数据源的...
springboot动态多数据源配置
07-10
本文将深入探讨如何在Spring Boot中配置动态多数据源以及使用JPA的相关知识点。 首先，我们需要理解“多数据源”概念。多数据源意味着应用程序可以连接到不止一个数据库，这在需要分离业务数据、历史数据或者需要...
springboot+jpa配置多数据源.zip
12-06
首先，`springboot+jpa配置多数据源.zip`这个压缩包可能包含了一个示例项目，用于演示如何在Spring Boot中集成JPA并配置多个数据源。JPA是Java平台上的ORM（Object-Relational Mapping）标准，它简化了与关系型...
springBoot Jpa多数据源配置.rar
11-11
在Spring Boot中，我们可以使用`DataSource` bean来配置数据源。 对于多数据源配置，我们需要创建至少两个`DataSource` bean，每个对应一个不同的数据库。通常，我们会为每个数据源创建一个配置类，例如`...
springboot配置多数据源+jpa实现
零度的博客专栏
06-06 4954
配置文件： #db1 conf db1.spring.datasource.name=yunpub db1.spring.datasource.url=jdbc:mysql://10.31.xx.xx:3306/db1?useUnicode=true&autoReconnect=true&characterEncoding=utf-8&generateSimplePar...
Spring技术内幕之Spring Data JPA-自定义Repository实现
diaojin6880的博客
07-04 412
1.自定义Repository方法接口,让接口的实现类来继承这个中间接口而不是Repository接口package com.data.jpa.dao; import java.io.Serializable;import java.util.List;import java.util.Map; import org.springframework.da...
SpringBoot之使用jpa/hibernate
li123128的博客
02-16 653
　　Springboot版本是2.1.3.RELEASE 　　 　　１、依赖 　　 　　List-1.1 　　 　　&lt;dependency&gt; 　　 　　&lt;groupId&gt;org.springframework.boot&lt;/groupId&gt; 　　 　　&lt;artifactId&gt;spring-boot-starter-jdbc&lt;/artifactId...
No qualifying bean of type 'org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder' available:
Daopin Blog
05-18 7181
DEBUG o.s.b.diagnostics.LoggingFailureAnalysisReporter - Application failed to start due to an exceptionorg.springframework.beans.factory.NoSuchBeanDefinitionException: No qualifying bean of type 'org...
Spring Data JPA框架系列(二)-Spring Data JPA的核心概念和Repository接口概述
最爱嫣夜来
04-01 1333
1、核心概念 Spring Data存储库抽象的中心接口是Repository。它把要管理的实体类以及实体类的ID类型作为类型参数。这个接口主要是作为一个标记接口，用来捕捉工作中的类型，并帮助你发现扩展这个接口的接口。CrudRepository接口为被管理的实体类提供复杂的CRUD功能。 自己可以看看Repository的扩展接口以及实现类 IDEA中将光标定位在Repository.java文件中， ctrl+h快捷键就可以看。 类图继承关系如下: 1.2 CrudRepository接口 这个接
使用 Spring Data Repositories（上）
IT胶囊
09-18 267
原标题：Spring认证|使用 Spring Data Repositories（上） Spring Data repository 抽象的目标是显着减少为各种持久性存储实现数据访问层所需的样板代码量。 Spring Data 存储库文档和您的模块 本章解释了 Spring Data 存储库的核心概念和接口。本章中的信息来自 Spring Data Commons 模块。它使用 Java Persistence API (JPA) 模块的配置和代码示例。您应该将 XML 命名空间声明和要扩展的类型调整为您使
SpringBoot +Spring Data JPA 集成HikariCP 数据库连接池
zhouzhiwengang的专栏
09-22 4317
我们在上篇文章中：https://blog.csdn.net/zhouzhiwengang/article/details/82766397，已经讲解SpringBoot +Spring-Data-JPA 的集成，今天在此基础之上在添加HikariCP 数据库连接池。 在讲解集成HikariCP 数据库连接池，我们需要讲解：Spring-Data-JPA 自动的默认数据库连接池。 首先看一张截...
SpringBoot集成JPA+hikariCP连接池实现增删改查以及相关的注意事项
三生三石光润木子
11-05 1414
目录 一、新建工程： 二、关键依赖 三、配置文件 application.yml 四.创建实体 五.创建repository 六.创建controller 注意事项： 1.Caused by: com.mysql.cj.exceptions.InvalidConnectionAttributeException 2.org.hibernate.id.IdentifierGenerationException 3.com.mysql.cj.jdbc.exceptions.MysqlDat.
springboot jpa hikari连接池配置
你当像鸟飞往你的山~~
06-22 5199
springboot jpa与hikari连接池配置 application.properties文件配置： spring.jpa.hibernate.ddl-auto=update spring.datasource.hikari.driver-class-name=com.mysql.jdbc.Driver spring.datasource.url=jdbc:mysql://...
springBoot jpa配置多数据源
qq_28318079的博客
08-03 168
springBoot配置多数据源有多种方式，最近做的项目中需要连接多个数据源，用到，咨询了下同事，用到过这种，亲测可以。 前提:项目是之前就写完的，所以想在不改变原因配置文件的基础上，添加一个新的数据源 1先创建一个实体类User @Entity // 是lambok 的 优化bean，不用设置get set @Table(schema = "spring_jpa_user"...
springboot配置jpa多数据源
最新发布
08-23
在Spring Boot中配置JPA多数据源的方法如下： 1. 首先，在pom.xml文件中添加必要的依赖项，包括Spring Boot、JPA和数据库驱动程序。 2. 创建对应的数据源配置类，包括数据库连接信息、用户名、密码等。可以创建多个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值