Spring data 配置多数据源

最新推荐文章于 2024-08-25 09:43:49 发布
最新推荐文章于 2024-08-25 09:43:49 发布
阅读量1.4k 收藏 1
点赞数
分类专栏： Java spring boot 文章标签： java spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41525524/article/details/122070020
版权

配置多数据源

创建一个Spring配置类，定义两个DataSourceConfig用来读取application.properties中的不同配置。如下例子中，主数据源配置为spring.datasource.primary开头的配置，第二数据源配置为spring.datasource.secondary开头的配置。
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.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.jdbc.core.JdbcTemplate;

/**
 * @Description:
 * @Auther: Wangtianming
 * @Date: 2021/12/21 17:08
 */
@Configuration
public class DataSourceConfig {

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

    @Bean
    @Qualifier("secondaryDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.secondary")
    public DataSource secondaryDataSource() {
        return DataSourceBuilder.create().build();
    }
    //JdbcTemplate支持配置
    //对JdbcTemplate的支持比较简单，只需要为其注入对应的datasource即可，如下例子，在创建JdbcTemplate的时候分别注入名为primaryDataSource和secondaryDataSource的数据源来区分不同的JdbcTemplate。
    @Bean
    public JdbcTemplate primaryJdbcTemplate(@Qualifier("primaryDataSource") DataSource primaryDataSource) {
        return new JdbcTemplate(primaryDataSource);
    }

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

}
PrimaryConfig主库配置
import javax.annotation.Resource;
import javax.persistence.EntityManager;
import javax.sql.DataSource;

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;

/**
 * @Description:
 * @Auther: Wangtianming
 * @Date: 2021/12/22 11:12
 */
@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(
        entityManagerFactoryRef="entityManagerFactoryPrimary",
        transactionManagerRef="transactionManagerPrimary",
        basePackages= { "com.wtm.demo.repository.primary" }) //设置Repository所在位置
public class PrimaryConfig {

    @Resource
    @Qualifier("primaryDataSource")
    private DataSource primaryDataSource;

    @Resource
    private JpaProperties jpaProperties;

    @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(jpaProperties.getProperties())
                .packages("com.wtm.demo.model.primary") //设置实体类所在位置
                .persistenceUnit("primaryPersistenceUnit")
                .build();

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

}
SecondaryConfig
import javax.annotation.Resource;
import javax.persistence.EntityManager;
import javax.sql.DataSource;

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.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;

/**
 * @Description:
 * @Auther: Wangtianming
 * @Date: 2021/12/22 11:40
 */
@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(
        entityManagerFactoryRef="entityManagerFactorySecondary",
        transactionManagerRef="transactionManagerSecondary",
        basePackages= { "com.wtm.demo.repository.secondary" }) //设置Repository所在位置
public class SecondaryConfig {

    @Resource
    @Qualifier("secondaryDataSource")
    private DataSource secondaryDataSource;

    @Resource
    private JpaProperties jpaProperties;

    @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(jpaProperties.getProperties())
                .packages("com.wtm.demo.model.secondary") //设置实体类所在位置
                .persistenceUnit("secondaryPersistenceUnit")
                .build();
    }

    @Bean(name = "transactionManagerSecondary")
    PlatformTransactionManager transactionManagerSecondary(EntityManagerFactoryBuilder builder) {
        return new JpaTransactionManager(entityManagerFactorySecondary(builder).getObject());
    }
}
application.properties配置
spring.datasource.primary.jdbc-url=jdbc:mysql://localhost:3306/test1
spring.datasource.primary.username=root
spring.datasource.primary.password=root
spring.datasource.primary.driver-class-name=com.mysql.jdbc.Driver

spring.datasource.secondary.jdbc-url=jdbc:mysql://localhost:3306/test2
spring.datasource.secondary.username=root
spring.datasource.secondary.password=root
spring.datasource.secondary.driver-class-name=com.mysql.jdbc.Driver
启动类

@SpringBootApplication
public class SpringbootMybatisApplication {

    public static void main(String[] args) {
        SpringApplication.run(SpringbootMybatisApplication.class, args);
    }

}
model

Student

import java.io.Serializable;

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

import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.ToString;

/**
 * @Description: 学生信息StringData
 * @Auther: Wangtianming
 * @Date: 2021/12/18 23:05
 */
@Data
@ApiModel("学生信息StringData")
@Entity
@Table(name = "student")
@ToString(callSuper = true)
public class Student implements Serializable {
    @Id
    @Column(name = "id", nullable = false)
    private Long id;

    @ApiModelProperty("用户姓名")
    @Column(name = "user_name")
    private String userName;

    @ApiModelProperty("用户id")
    @Column(name = "user_id")
    private String userId;

}

Teacher

import java.io.Serializable;

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

import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.ToString;

/**
 * @Description: 老师信息
 * @Auther: Wangtianming
 * @Date: 2021/12/22 22:22
 */
@Data
@ApiModel("老师信息")
@Entity
@Table(name = "teacher")
@ToString(callSuper = true)
public class Teacher implements Serializable {
    @Id
    @Column(name = "id", nullable = false)
    private Long id;

    @ApiModelProperty("用户姓名")
    @Column(name = "user_name")
    private String userName;

    @ApiModelProperty("用户id")
    @Column(name = "user_id")
    private String userId;
}
Repository

自己封装的BaseRepository

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.repository.NoRepositoryBean;

/**
 * @Description:
 * @Auther: Wangtianming
 * @Date: 2021/12/18 23:31
 */
@NoRepositoryBean
public interface BaseRepository <T, ID> extends JpaRepository<T, ID>, JpaSpecificationExecutor<T> {

}

StudentRepository

import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import org.springframework.stereotype.Repository;
import com.wtm.demo.model.primary.Student;
import com.wtm.demo.repository.BaseRepository;

/**
 * @Description: 学生信息
 * @Auther: Wangtianming
 * @Date: 2021/12/18 23:34
 */
@Repository
public interface StudentRepository extends BaseRepository<Student, Long> {
}

TeacherRepository

import org.springframework.stereotype.Repository;

import com.wtm.demo.model.secondary.Teacher;
import com.wtm.demo.repository.BaseRepository;

/**
 * @Description:
 * @Auther: Wangtianming
 * @Date: 2021/12/22 22:39
 */
@Repository
public interface TeacherRepository extends BaseRepository<Teacher, Long> {
}
Controller
import java.util.List;
import java.util.Map;
import javax.annotation.Resource;

import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.wtm.demo.model.primary.Student;
import com.wtm.demo.model.secondary.Teacher;
import com.wtm.demo.repository.primary.StudentRepository;
import com.wtm.demo.repository.secondary.TeacherRepository;
import com.wtm.demo.util.Response;

import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;

/**
 * @Description: 测试controller
 * @Auther: Wangtianming
 * @Date: 2021/12/21 17:21
 */
@Api(tags = "多数据源")
@Slf4j
@RestController
@RequestMapping(path = "/demo/datasourcetest")
public class DataSourceTestController {

    @Resource
    @Qualifier("primaryJdbcTemplate")
    protected JdbcTemplate jdbcTemplate1;

    @Resource
    @Qualifier("secondaryJdbcTemplate")
    protected JdbcTemplate jdbcTemplate2;

    @Resource
    private StudentRepository studentRepository;

    @Resource
    private TeacherRepository teacherRepository;


    @ApiOperation(value = "primaryJdbcTemplate", notes = "primaryJdbcTemplate")
    @GetMapping("/primaryJdbcTemplate")
    public Response<List<Map<String, Object>>> primaryJdbcTemplate() {
        return Response.ok(jdbcTemplate1.queryForList("select * from student "));
    }

    @ApiOperation(value = "secondaryJdbcTemplate", notes = "secondaryJdbcTemplate")
    @GetMapping("/secondaryJdbcTemplate")
    public Response<List<Map<String, Object>>> secondaryJdbcTemplate() {
        return Response.ok(jdbcTemplate2.queryForList("select * from teacher  "));
    }

    @ApiOperation(value = "primarySpringData", notes = "primarySpringData")
    @GetMapping("/primarySpringData")
    public Response<List<Student>> primarySpringData() {
        return Response.ok(studentRepository.findAll());
    }

    @ApiOperation(value = "secondarySpringData", notes = "secondarySpringData")
    @GetMapping("/secondarySpringData")
    public Response<List<Teacher>> secondarySpringData() {
        return Response.ok(teacherRepository.findAll());
    }
}

目录
请添加图片描述

sql脚本

test1库

DROP TABLE IF EXISTS `student`;
CREATE TABLE `student` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `User_Name` varchar(25) DEFAULT NULL,
  `User_Id` varchar(25) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=14 DEFAULT CHARSET=utf8;

BEGIN;
INSERT INTO `student` VALUES (1, '张三01', '20210901');
INSERT INTO `student` VALUES (2, '张三02', '20210902');
INSERT INTO `student` VALUES (3, '张三03', '20210903');
INSERT INTO `student` VALUES (4, '张三04', '20210904');
INSERT INTO `student` VALUES (5, '张三05', '20210905');
INSERT INTO `student` VALUES (6, '张三06', '20210906');
INSERT INTO `student` VALUES (7, '张三07', '20210907');
INSERT INTO `student` VALUES (8, '张三08', '20210908');
INSERT INTO `student` VALUES (9, '张三09', '20210909');
INSERT INTO `student` VALUES (10, '张三10', '20210906');
INSERT INTO `student` VALUES (11, '张三11', '20210911');
INSERT INTO `student` VALUES (12, '张三12', '20210912');
INSERT INTO `student` VALUES (13, '张三13', '20210913');
COMMIT;

SET FOREIGN_KEY_CHECKS = 1;

test2库

DROP TABLE IF EXISTS `teacher`;
CREATE TABLE `teacher` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `User_Name` varchar(25) DEFAULT NULL,
  `User_Id` varchar(25) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=14 DEFAULT CHARSET=utf8;

BEGIN;
INSERT INTO `teacher` VALUES (1, '老师01', '20210901');
INSERT INTO `teacher` VALUES (2, '老师02', '20210902');
INSERT INTO `teacher` VALUES (3, '老师03', '20210903');
INSERT INTO `teacher` VALUES (4, '老师04', '20210904');
INSERT INTO `teacher` VALUES (5, '老师05', '20210905');
INSERT INTO `teacher` VALUES (6, '老师06', '20210906');
INSERT INTO `teacher` VALUES (7, '老师07', '20210907');
INSERT INTO `teacher` VALUES (8, '老师08', '20210908');
INSERT INTO `teacher` VALUES (9, '老师09', '20210909');
INSERT INTO `teacher` VALUES (10, '老师10', '20210906');
INSERT INTO `teacher` VALUES (11, '老师11', '20210911');
INSERT INTO `teacher` VALUES (12, '老师12', '20210912');
INSERT INTO `teacher` VALUES (13, '老师13', '20210913');
COMMIT;

SET FOREIGN_KEY_CHECKS = 1;

参考资料
https://blog.didispace.com/springbootmultidatasource/
Github：https://github.com/dyc87112/SpringBoot-Learning
Gitee：https://gitee.com/didispace/SpringBoot-Learning

会飞的天明
关注
专栏目录
Spring Boot入门教程(十五): spring-data-jpa 多数据源
人不风流枉少年
03-29 1615
1. pom.xml<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> </dependency><dependency> <groupId>mysql</groupId> <artifactId
SpringBoot-SpringData-多数据源
10-31
SpringData多数据源实现,博文地址:http://blog.csdn.net/ABAP_Brave/article/details/52980885
Spring Boot 多数据源配置教程
最新发布
gitblog_00319的博客
08-25 272
Spring Boot 多数据源配置教程 springboot-multiple-dataSources项目地址:https://gitcode.com/gh_mirrors/sp/springboot-multiple-dataSources 项目介绍 本项目旨在展示如何在Spring Boot应用中配置和使用多个数据源。通过本项目，开发者可以学习到如何为不同的数据库配置独立的DataSour...
Spring Data JPA --多数据源配置
LING
04-22 404
Spring Data JPA 多数据源配置 -- MYSQLyml文件配置信息实体定义接口定义数据源配置 yml文件配置信息 spring: datasource: test: continueOnError: true jdbcUrl: jdbc:mysql://XXX.XXX.XX.XX:XXX/test?useSSL=false&useUnicode=true&characterEncoding=utf-8 username:
Spring Data与多数据源配置
聚娃科技开发者博客
07-01 748
通过本文的介绍，我们展示了如何在Spring Data中配置和使用多个数据源。我们首先配置了数据源，然后为每个数据源创建了单独的配置类和JPA仓库，最后验证了多数据源配置的正确性。这个示例展示了Spring Boot在处理多数据源时的灵活性和强大功能，希望对大家有所帮助。本文将详细讲解如何在Spring Boot中使用Spring Data配置多个数据源，并提供具体的Java代码示例。今天我们来探讨如何在Spring Data中配置和使用多个数据源。最后，我们编写一个测试类，验证多数据源配置是否成功。
详解基于Spring Boot与Spring Data JPA的多数据源配置
08-30
基于Spring Boot与Spring Data JPA的多数据源配置 Spring Boot作为当前最流行的Java Web框架之一，提供了许多实用的功能和配置项，然而，在实际项目中，我们经常会遇到多数据源配置的问题，例如在一个项目中需要...
Spring Boot使用spring-data-jpa配置Mysql多数据源
12-17
在Spring Boot应用中，使用`spring-data-jpa`来配置MySQL多数据源是一项常见的需求，尤其是在构建大型分布式系统时，为了实现数据隔离、负载均衡或读写分离等目的。本教程将详细介绍如何在Spring Boot项目中配置多个...
Spring Boot+Jpa多数据源配置Demo（支持不同数据库）
04-11
总结来说，Spring Boot + JPA 的多数据源配置需要对Spring的配置机制有深入理解，包括自动配置、bean的创建、数据源的切换等。同时，合理组织实体类和数据库访问层，确保代码的可维护性和扩展性。这个名为`...
spring+Jpa多数据源配置的方法示例
08-27
Spring+JPA多数据源配置方法示例 Spring+JPA多数据源配置是指在 Spring 框架中使用 JPA（Java Persistence API）来访问多个数据源的配置方法。该配置方法允许开发者在一个应用程序中访问多个数据库，实现数据的集成...
spring boot多数据源配置
08-14
在Spring Boot应用中，多数据源配置是一项关键的技术，它允许我们同时管理多个数据库，比如主库和从库，或者不同类型的数据库。本教程将详细阐述如何在Spring Boot项目中实现这一功能，从数据源配置、实体管理到...
Spring Boot 优雅配置多数据源
程序员高级码农的博客
01-19 1373
最常见的单一应用中最多涉及到一个数据库，即是一个数据源（Datasource那么顾名思义，多数据源就是在一个单一应用中涉及到了两个及以上的数据库了。urlusernamepassword这三个属性已经唯一确定了一个数据库了，DataSource则是依赖这三个创建出来的。则多数据源即是配置多个DataSource（暂且这么理解）。动态数据源简单的说就是能够自由切换的数据源，类似于一个动态路由的感觉，Spring 提供了一个抽象类是一个Map结构，所有需要切换的数据源都存放在其中，根据指定的。
spring多数据源解决方案及分析
打怪升级
07-20 683
spring
Spring Data Jpa 配置多数据源
皓亮君的博客
03-26 1661
文章目录1.配置数据库连接信息2.编写数据源配置类3.编写数据库配置4.目录结构 1.配置数据库连接信息 spring: datasource: db1: # 1.0 Datasource url: jdbc:mysql://127.0.0.1:3306/test1?useSSL=false&serverTimezone=GMT%2b8&characterEncoding=utf8&connectTimeout=1000&socketTimeout=
SpringBoot实践（十一）：DataSource多数据源配置
叶子叶来
09-08 7563
经常有对多个数据源（同类或非同类数据库）查询处理的场景，比如需要查询的student和teacher信息分别来自于mysql和postgresql，或者都是用mysql但jdbc连接串不同，这个时候在application.properties中需要配置多个数据源，相应地需要多个配置类、多个mapper映射。 连接池配置 因为student和teacher来自于有不同的jdbc连接串，在springboot的配置文件application.properties配置不同的durid连接池（这里配置文件是pr
剖析Spring多数据源
beidaol的专栏
06-09 332
在实际开发中，经常会遇到应用要访问多个库的情况，需要配置多个数据源。本文会介绍spring多数据源的典型场景，如何优雅的实现多数据源，并结合spring、mybatis源码进行分析，为什么在事务中，不能切换数据源。最后，还会提供一个多数据源的完整源码案例。 1 多数据源的典型使用场景 在实际开发中，经常可能遇到在一个应用中可能需要访问多个数据库的情况，以下是两种典型场景。 1.1 业务复杂 数据分布在不同的数据库中，笔者见过一个相对比较复杂的业务，一个业务中同时操作了9个库，业...
Spring系列之多个数据源配置
a1901149的博客
04-17 845
DataSourceAutoConfiguration、DataSourceTransactionManagerAutoConfiguration、JdbcTemplateAutoConfiguration三个类，然后就可以自己定义DataSource了。我个人觉得面试也像是一场全新的征程，失败和胜利都是平常之事。.forEach(row -> log.info(“记录：”+row.toString()));.forEach(row -> log.info(“记录：”+row.toString()));
spring 项目 配置多数据源（已上生产，亲测有效）
Chen_chenjiasheng的博客
05-16 3738
🌸 修改配置文件，添加数据源配置 🌸 修改application.yaml spring: datasource: type: com.alibaba.druid.pool.DruidDataSource druid: db1: enable: true driver-class-name: com.mysql.cj.jdbc.Driver max-active: 100 min-idle: 100
Spring多数据源配置
weixin_51743274的博客
09-03 951
首先附上AbstractRoutingDataSource的类图结构AbstractRoutingDataSource的代码实现} //省略set方法... public void afterPropertiesSet() {} else {});= null) {} else {} //找到目标数据源 protected DataSource determineTargetDataSource() {} else {
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值