springboot【10】数据访问之多数据源配置使用

最新推荐文章于 2024-05-06 09:45:49 发布
最新推荐文章于 2024-05-06 09:45:49 发布
阅读量2.4k 收藏 6
点赞数 2
分类专栏： ⊹●springboot Spring Boot基础篇 文章标签： springboot教程 springboot springboot多数据源 spring数据访问 Spring-data-jpa
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/IT_lyd/article/details/76619660
版权

        之前在介绍使用JdbcTemplate和Spring-data-jpa时，都使用了单数据源。在单数据源的情况下，Spring Boot的配置非常简单，只需要在application.properties文件中配置连接参数即可。但是往往随着业务量发展，我们通常会进行数据库拆分或是引入其他数据库，从而我们需要配置多个数据源，下面基于之前的JdbcTemplate和Spring-data-jpa例子分别介绍两种多数据源的配置方式。

多数据源配置

对应的application.properties配置如下：

#数据源一
spring.datasource.primary.url=jdbc:mysql://localhost:3306/springboot
spring.datasource.primary.username=root
spring.datasource.primary.password=root
spring.datasource.primary.driver-class-name=com.mysql.jdbc.Driver
#数据源二
spring.datasource.secondary.url=jdbc:mysql://localhost:3306/springboot1
spring.datasource.secondary.username=root
spring.datasource.secondary.password=root
spring.datasource.secondary.driver-class-name=com.mysql.jdbc.Driver


创建一个Spring配置类，定义两个DataSource用来读取application.properties中的不同配置。如下例子中，主数据源配置为spring.datasource.primary开头的配置，第二数据源配置为spring.datasource.secondary开头的配置。

package com.lyd;

import javax.sql.DataSource;

import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.jdbc.DataSourceBuilder;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * 
 * <p>Title: DataSourceConfig.java</p>
 * <p>Description: 多数据源配置读取</p>
 * @author lyd
 * @date 2017年8月3日
 * @version 1.0
 * @blog springboot学习http://blog.csdn.net/IT_lyd/article/category/6692929
 */
@Configuration
public class DataSourceConfig {

	@Bean(name = "primaryDataSource")
	@Qualifier("primaryDataSource")
	@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();
	}
}


一、JdbcTemplate支持

对JdbcTemplate的支持比较简单，只需要为其注入对应的datasource即可，如下例子，在创建JdbcTemplate的时候分别注入名为primaryDataSource和secondaryDataSource的数据源来区分不同的JdbcTemplate。

package com.lyd;

import javax.sql.DataSource;

import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.jdbc.DataSourceBuilder;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.jdbc.core.JdbcTemplate;

/**
 * 
 * <p>
 * Title: DataSourceConfig.java
 * </p>
 * <p>
 * Description: 多数据源配置读取
 * </p>
 * 
 * @author lyd
 * @date 2017年8月3日
 * @version 1.0
 * @blog springboot学习http://blog.csdn.net/IT_lyd/article/category/6692929
 */
@Configuration
public class DataSourceConfig {

	/**
	 * 获取多数据源 </p>
	 */
	@Bean(name = "primaryDataSource")
	@Primary
	@Qualifier("primaryDataSource")
	@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();
	}

	/**
	 * JdbcTemplate支持
	 * @author lyd
	 * @date 2017年8月3日
	 * @param dataSource
	 * @return
	 */
	@Bean(name = "primaryJdbcTemplate")
	public JdbcTemplate primaryJdbcTemplate(
			@Qualifier("primaryDataSource") DataSource dataSource) {
		return new JdbcTemplate(dataSource);
	}

	@Bean(name = "secondaryJdbcTemplate")
	public JdbcTemplate secondaryJdbcTemplate(
			@Qualifier("secondaryDataSource") DataSource dataSource) {
		return new JdbcTemplate(dataSource);
	}
}


接下来通过测试用例来演示如何使用这两个针对不同数据源的JdbcTemplate。

package com.lyd;

import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.test.SpringApplicationConfiguration;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@SpringApplicationConfiguration(Application.class)
public class ApplicationTest {

	@Autowired
	@Qualifier("primaryJdbcTemplate")
	protected JdbcTemplate jt1;

	@Autowired
	@Qualifier("secondaryJdbcTemplate")
	protected JdbcTemplate jt2;

	@Before
	public void setUp() {
		jt1.update("DELETE FROM USER");
		jt2.update("DELETE FROM USER");
	}

	@Test
	public void test() {
		
		// 往第一个数据源中插入两条数据
		jt1.update("INSERT INTO user(id,name,age) VALUES(?,?,?)",1,"AAA",10);
		jt1.update("INSERT INTO user(id,name,age) VALUES(?,?,?)",2,"BBB",20);
		
		// 往第二个数据源中插入一条数据，若插入的是第一个数据源，则会主键冲突报错
		jt2.update("INSERT INTO user(id,name,age) VALUES(?,?,?)",1,"AAA",10);
		
		// 查一下第一个数据源中是否有两条数据，验证插入是否成功
		Assert.assertEquals("2", jt1.queryForObject("SELECT COUNT(*) FROM user", String.class));
		
		// 查一下第二个数据源中是否有两条数据，验证插入是否成功
		Assert.assertEquals("1", jt2.queryForObject("SELECT COUNT(*) FROM user", String.class));
	}
}


二、Spring-data-jpa支持

对于数据源的配置可以沿用上例中DataSourceConfig的实现。

新增对第一数据源的JPA配置，注意两处注释的地方，用于指定数据源对应的Entity实体和Repository定义位置，用@Primary区分主数据源。

PrimaryConfig.java：

package com.lyd;

import java.util.Map;

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

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
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.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;

@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(
		entityManagerFactoryRef="entityManagerFactoryPrimary",
		transactionManagerRef="transactionManagerPrimary",
		basePackages={"com.lyd.domain.p"} //设置Repository所在位置
		)
public class PrimaryConfig {

	@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(primaryDataSource))
				.packages("com.lyd.domain.p") //设置实体类所在位置
				.persistenceUnit("primaryPersistenceUnit")
				.build();
	}
	
	@Autowired
	private JpaProperties jpaProperties;
	
	private Map<String, String> getVendorProperties(DataSource dataSource){
		return jpaProperties.getHibernateProperties(dataSource);
	}
	
	
	
	@Primary
	@Bean(name = "transactionManagerPrimary")
	public PlatformTransactionManager transactionManagerPrimary(EntityManagerFactoryBuilder builder){
		return new JpaTransactionManager(entityManagerFactoryPrimary(builder).getObject());
	}
}



新增对第二数据源的JPA配置，内容与第一数据源类似，具体如下：

SecondConfig.java：

package com.lyd;

import java.util.Map;

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

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
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.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;

@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(
		entityManagerFactoryRef="entityManagerFactorySecondary",
		transactionManagerRef="transactionManagerSecondary",
		basePackages={"com.lyd.domain.s"} //设置Repository所在位置
		)
public class SecondaryConfig {

	@Autowired
	@Qualifier("secondaryDataSource")
	private DataSource secondaryDataSource;
	
	@Bean(name = "entityManagerSecondary")
	public EntityManager entityManager(EntityManagerFactoryBuilder builder){
		return entityManagerFactorySecondary(builder).getObject().createEntityManager();
	}
	
	@Bean(name = "entityManagerFactorySecondary")
	public LocalContainerEntityManagerFactoryBean entityManagerFactorySecondary(EntityManagerFactoryBuilder builder){
		return builder
				.dataSource(secondaryDataSource)
				.properties(getVendorProperties(secondaryDataSource))
				.packages("com.lyd.domain.s") //设置实体类所在位置
				.persistenceUnit("secondaryPersistenceUnit")
				.build();
	}
	
	@Autowired
	private JpaProperties jpaProperties;
	
	private Map<String, String> getVendorProperties(DataSource dataSource){
		return jpaProperties.getHibernateProperties(dataSource);
	}
	
	
	@Bean(name = "transactionManagerSecondary")
	public PlatformTransactionManager transactionManagerSecondary(EntityManagerFactoryBuilder builder){
		return new JpaTransactionManager(entityManagerFactorySecondary(builder).getObject());
	}
}



完成了以上配置之后，主数据源的实体和数据访问对象位于：com.lyd.domain.p，次数据源的实体和数据访问接口位于：com.lyd.domain.s。

分别在这两个package下创建各自的实体和数据访问接口

  • 主数据源下，创建User实体和对应的Repository接口
package com.lyd.domain.p;

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

@Entity
public class User {

	@Id
	@GeneratedValue
	private Long id;
	
	@Column(nullable = false)
	private String name;
	
	@Column(nullable = false)
	private Integer age;
	
	// 构造函数
	// get/set方法。。。
}


UserRepository.java

package com.lyd.domain.p;

import org.springframework.data.jpa.repository.JpaRepository;
/**
 * 
 * <p>Title: UserRepository.java</p>
 * <p>Description: 主数据源下UserRepository接口</p>
 * @author lyd
 * @date 2017年8月4日
 * @version 1.0
 * @blog springboot学习http://blog.csdn.net/IT_lyd/article/category/6692929
 */
public interface UserRepository extends JpaRepository<User, Long>{

}


  • 从数据源下，创建Message实体和对应的Repository接口
package com.lyd.domain.s;

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

@Entity
public class Message {

	@Id
	@GeneratedValue
	private Long id;
	
	@Column(nullable = false)
	private String name;
	
	@Column(nullable = false)
	private String content;
	
	// 构造函数
	// get/set方法。。。
}


MessageResitory.java

package com.lyd.domain.s;

import org.springframework.data.jpa.repository.JpaRepository;
/**
 * 
 * <p>Title: UserRepository.java</p>
 * <p>Description: 从数据源下MessageRepository接口</p>
 * @author lyd
 * @date 2017年8月4日
 * @version 1.0
 * @blog springboot学习http://blog.csdn.net/IT_lyd/article/category/6692929
 */
public interface MessageRepository extends JpaRepository<Message, Long>{

}



接下来通过测试用例来验证使用这两个针对不同数据源的配置进行数据操作。

package com.lyd;

import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.SpringApplicationConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import com.lyd.domain.p.User;
import com.lyd.domain.p.UserRepository;
import com.lyd.domain.s.Message;
import com.lyd.domain.s.MessageRepository;

@RunWith(SpringJUnit4ClassRunner.class)
@SpringApplicationConfiguration(Application.class)
public class ApplicationTest {

	@Autowired
	private UserRepository userService;
	
	@Autowired
	private MessageRepository messageService;
	
	@Before()
	public void serUp(){
		
	}
	
	@Test
	public void test(){
		
		userService.save(new User("aaa", 10));
		userService.save(new User("bbb", 20));
		userService.save(new User("ccc", 30));
		userService.save(new User("ddd", 40));
		userService.save(new User("eee", 50));
		
		Assert.assertEquals(5, userService.findAll().size());
		
		messageService.save(new Message("o1", "aaa"));
		messageService.save(new Message("o2", "bbb"));
		messageService.save(new Message("o3", "ccc"));
		
		Assert.assertEquals(3, messageService.findAll().size());
	}
}


下面是完整项目结构：





JeeLearner
关注
  • 2
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
以Springboot为例，如何连接多个数据库（源）
qq_48607414的博客
02-14 5537
在Spring Boot中连接多个数据库，可以通过配置多个数据源来实现。可以在配置文件中定义多个数据源的配置，每个数据源有一个唯一的名称和对应的数据源属性。然后，通过在需要访问特定数据源的地方，使用对应的数据源名称来访问该数据源。
SpringBoot配置多个数据源
xudegang123的博客
03-01 1902
springboot配置多个数据源
springboot项目连接多种数据库如何操作？
最新发布
weixin_43149534的博客
05-06 2407
在项目的开发中，经常会遇到需要连接多个多种数据库的情况，mysql、oracle等等，下面详细讲解如何在一个服务中进行多种数据库的配置。
Spring Boot配置多数据源的四种方式
qq_45515182的博客
08-14 3万+
在日常的项目中我们的开发都是采用单数据库的模式，但是在高并发的时代，单数据库已经无法承载大数据量的访问，所以就需要使用多个数据库进行对数据的读写分离。
SpringBoot多数据源配置
上善若泪
03-27 3万+
文章目录1 SpringBoot分库配置1.1 准备数据1.2 springboot+mybatis使用分包方式整合1.2.1 pom.xml1.2.2 application.yml 配置文件1.2.3 连接数据源配置文件1.2.3.1 连接源配置一1.2.3.2 连接源配置二1.2.4 项目结构1.3 springboot+druid+mybatisplus使用注解整合1.3.1 pom.xml1.3.2 application.yml 配置文件1.3.3 使用@DS区分数据源1.4 读写分离库1.4.
【Spring Boot】Spring Boot整合多数据源
DreamSun的博客
08-24 1613
在实际的开发工作中，我们经常会遇到需要整合多个数据源的情况，比如同时连接多个数据库、读写分离、跨数据库查询等。本文将介绍如何使用Spring Boot来实现多数据源的整合，对于刚刚接触开发的小伙伴可能有一些帮助。在一个应用程序中使用多个数据源意味着我们需要在不同的数据源之间进行切换，以便从不同的数据源中获取数据。多数据源可以是关系数据库、NoSQL 数据库、平面文件、XML 文件等。在一个应用程序中使用多数据源的好处是，我们可以根据应用程序的需求选择最合适的数据源，从而提高应用程序的性能和可扩展性。
SpringBoot配置多数据源实现动态切换数据源
06-29
多数据源配置允许我们灵活地管理这些数据。 SpringBoot实现多数据源主要依靠Spring的`@Configuration`和`@DataSourceConfiguration`注解，以及Spring JDBC的`DataSource`接口。下面是一个基本的配置示例： ```java...
springboot 多数据源配置.zip
07-13
在Spring Boot应用中，多数据源配置是一项重要的技术实践，特别是在大型系统中，可能需要连接到多个数据库，例如，一个用于存储主业务数据，另一个用于日志或审计数据。本项目提供了一种基于Spring Boot的多数据源...
springboot动态多数据源配置
07-10
在Spring Boot应用中，动态多数据源配置是一项关键特性，尤其在处理多个数据库环境或不同数据存储需求的项目中。Spring Boot的灵活性使得我们可以轻松地整合JPA（Java Persistence API）来实现这一功能，通过注解的...
SpringBoot整合Oracle数据库使用双数据源
05-22
本文将详细讲解如何利用SpringBoot整合Oracle数据库实现双数据源的配置和使用，帮助开发者构建可扩展、高可用的应用系统。 首先，我们需要理解"双数据源"的概念。双数据源意味着应用程序可以同时访问两个不同的...
通过springboot+mybatis+druid配置动态数据源
08-25
我们可以创建一个数据源配置类，用于管理多个数据源： ```java @Configuration public class DynamicDataSourceConfig { @Bean public DataSource dataSource() { DynamicDataSource dynamicDataSource = new ...
springboot+mybatis多数据源+动态数据源配置(连接池)
09-09
springboot+mybatis多数据源+动态数据源配置(连接池),mysql数据库，代码实现了简单的读写分离，但是不建议这种操作，建议使用数据库中间件进行读写分离，例如使用mycat进行读写分离主从热备，使用该代码对于多个mycat集群资源进行多数据源动态访问
Spring boot 连接多数据源过程详解
08-25
主要介绍了Spring boot 连接多数据源过程详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
SpringBoot-SpringData-多数据源
BraveWangDev
10-31 3548
实际项目中可能需要操作多个数据源,今天写一个SpringData多数据源的Demo此Demo以SpringBoot集成代码 Maven构建SpringBoot项目 为基础,一步一步实现1,pom.xml加入SpringData-Jpa依赖,我们使用mysql数据库<!-- mySql驱动--> <dependency> <groupId>mysql</groupId> <artifa
spring boot配置多个数据源
qq_35261162的博客
08-22 1541
spring boot配置多个数据源
SpringBoot实现多数据源的两种方式
m0_67401761的博客
08-02 6754
公司项目有连接多个不同数据库的需求，特研究了一下，根据网上的资料，造了一个基于AOP方式的数据源切换轮子，但继续探索，突然发现有开源的多数据源管理启动器。不过，本篇两种方式都会介绍。dynamic-datasource-spring-boot-starter是一个基于springboot的快速集成多数据源的启动器。其支持//标记注解可使用在方法与类上//默认值为MASTER}...
springboot 多数据源配置
真实的菜的博客
05-20 1328
springboot 多数据源配置 yml文件修改多数据源 spring: datasource: dynamic: primary: master # 配置默认数据库 # master master: #基本属性 jdbc-url: jdbc:mysql://183.2.181.238:3306/jointcloud_login?useUnicode=true&characterEncoding=utf-8&use
手把手教你用springboot配置多数据源
热门推荐
lyy的博客
09-28 12万+
1.文件结构： 2.pom： <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://mave...
（43）. Spring Boot动态数据源（多数据源自动切换）【从零开始学Spring Boot】
weixin_34133829的博客
06-04 357
在上一篇我们介绍了多数据源，但是我们会发现在实际中我们很少直接获取数据源对象进行操作，我们常用的是jdbcTemplate或者是jpa进行操作数据库。那么这一节我们将要介绍怎么进行多数据源动态切换。添加本文实现的代码之后，只需要配置要数据源就可以直接通过注解使用，在实际使用的时候特别的简单。那么本章主要分以下几个步骤进行实战。 本章大纲 写道 （1）新建maven java proje...
springboot多数据源配置
04-19
好的，关于springboot多数据源配置，我可以为您提供一些帮助和建议。通常，我们使用多个数据源是为了在一个应用程序中访问多个数据库。在Spring Boot中，可以通过配置多个数据源来实现这一功能。您可以使用@Primary...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值