Spring Boot + JPA 多数据源配置

最新推荐文章于 2023-10-16 12:06:13 发布
最新推荐文章于 2023-10-16 12:06:13 发布
阅读量234 收藏 2
点赞数
分类专栏： spring boot 文章标签： 多数据源
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq1031893936/article/details/100893755
版权

前言

在实际的开发中，大多数时候一个项目用到的数据库源都只有一个，但是难免遇到特例，如果遇到了同个项目需要连接两个或更多数据源我们该怎么呢？

本文带你了解 Spring Boot 配置多数据源。

准备工作

  • 准备数据库，我这里使用同一个Mysql中的两个不同的数据库，并且分别在两个数据库中创建了一张数据表

  • primary_table表结构

  • secondary_table表结构

主要代码

引入依赖

<dependencies>
    <!-- JPA -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    <!-- MVC -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- Mysql Driver -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>
    <!-- Test -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
    <!-- lombok -->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <scope>provided</scope>
    </dependency>
</dependencies>

实体类

  • PrimaryTable

    package com.imxushuai.entity.primary;

import lombok.Data;

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

@Data
@Entity
public class PrimaryTable {

    @Id
    private Long id;

    @Column
    private String username;

    @Column
    private String password;

    @Column
    private String p;

}

  • SecondaryTable

    package com.imxushuai.entity.secondary;

import lombok.Data;

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

@Data
@Entity
public class SecondaryTable {

    @Id
    private Long id;

    @Column
    private String username;

    @Column
    private String password;

    @Column
    private String s;

}

我这里使用lombok，不需要写get和set方法，使用@Data注解在编译时会自动生成。

编写配置文件

由于有多个数据源，所以这里在配置文件里，我们需要配置多个数据源信息。（本例中采用的是两个Mysql数据库，若你想连接不同的数据库只需要修改jdbc-url以及驱动类）

spring:
  datasource:
    # primary数据库
    primary:
      jdbc-url: jdbc:mysql:///primary?characterEncoding=utf-8&serverTimezone=GMT
      username: root
      password: 123456
      driver-class-name: com.mysql.jdbc.Driver
    # secondary数据库
    secondary:
      jdbc-url: jdbc:mysql:///secondary?characterEncoding=utf-8&serverTimezone=GMT
      username: root
      password: 123456
      driver-class-name: com.mysql.jdbc.Driver

注意：

Spring Boot 2.x中数据库URL的配置字段为：jdbc-url

Spring Boot 1.x中数据库URL的配置字段为：url

配置双数据源

package com.imxushuai.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;

@Configuration
public class DataSourceConfig {

    @Primary
    @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();
    }

}
  • 多个数据源，必须使用@Primary注解指定一个主数据源

配置多个数据源的连接信息

由于Spring Boot 1.x和Spring Boot 2.x配置多数据源有一些差别，所以这里我分为1.x和2.x两块，具体用哪部分根据Spring Boot版本决定。

准确的来说是：2.0.6版本以后和之前的版本有较大区别。

**注意：**两个数据源的实体类和Repository需要分包存放，参考下面的包结构

1.x

  • 配置Primary数据源

    package com.ensat.config;

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;

import javax.persistence.EntityManager;
import javax.sql.DataSource;
import java.util.Map;

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

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

    @Autowired
    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(getVendorProperties(primaryDataSource))
                .packages("com.imxushuai.entity.primary") //设置实体类所在位置
                .persistenceUnit("primaryPersistenceUnit")
                .build();
    }



    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());
    }

}

  • 配置Secondary数据源

    package com.ensat.config;

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

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

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

    @Autowired
    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(getVendorProperties(secondaryDataSource))
                .packages("com.imxushuai.entity.secondary") //设置实体类所在位置
                .persistenceUnit("secondaryPersistenceUnit")
                .build();
    }



    private Map<String, String> getVendorProperties(DataSource dataSource) {
        return jpaProperties.getHibernateProperties(dataSource);
    }

    @Bean(name = "transactionManagerSecondary")
    PlatformTransactionManager transactionManagerSecondary(EntityManagerFactoryBuilder builder) {
        return new JpaTransactionManager(entityManagerFactorySecondary(builder).getObject());
    }

}

2.x

  • 配置Primary数据源

    package com.imxushuai.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.orm.jpa.HibernateProperties;
import org.springframework.boot.autoconfigure.orm.jpa.HibernateSettings;
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.JpaRepository;
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.Map;

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

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

    @Autowired
    private HibernateProperties hibernateProperties;

    @Autowired
    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) {
        // 在2.0.6以上版本，jpaProperties中没有直接获取HibernateProperties的方法了
        Map<String, Object> properties = hibernateProperties
                .determineHibernateProperties(jpaProperties.getProperties(), new HibernateSettings());
        return builder
                .dataSource(primaryDataSource)
                .properties(properties)
                .packages("com.imxushuai.entity.primary") //设置实体类所在位置
                .persistenceUnit("primaryPersistenceUnit")
                .build();
    }


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

}

  • 配置Secondary数据源

    package com.imxushuai.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.orm.jpa.HibernateProperties;
import org.springframework.boot.autoconfigure.orm.jpa.HibernateSettings;
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;

import javax.persistence.EntityManager;
import javax.sql.DataSource;
import java.util.Map;

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

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

    @Autowired
    private HibernateProperties hibernateProperties;

    @Autowired
    private JpaProperties jpaProperties;

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

    @Bean(name = "entityManagerFactorySecondary")
    public LocalContainerEntityManagerFactoryBean entityManagerFactorySecondary (EntityManagerFactoryBuilder builder) {
        // 在2.x中jpaProperties中没有直接获取HibernateProperties的方法了
        Map<String, Object> properties = hibernateProperties
                .determineHibernateProperties(jpaProperties.getProperties(), new HibernateSettings());
        return builder
                .dataSource(secondaryDataSource)
                .properties(properties)
                .packages("com.imxushuai.entity.secondary") //设置实体类所在位置
                .persistenceUnit("secondaryPersistenceUnit")
                .build();
    }

    @Bean(name = "transactionManagerSecondary")
    PlatformTransactionManager transactionManagerSecondary(EntityManagerFactoryBuilder builder) {
        return new JpaTransactionManager(entityManagerFactorySecondary(builder).getObject());
    }

}

Repository

这个没什么说的，继承CrudRepository

package com.imxushuai.repository.primary;

import com.imxushuai.entity.primary.PrimaryTable;
import org.springframework.data.repository.CrudRepository;

public interface PrimaryRepository extends CrudRepository<PrimaryTable, Long> {
}

package com.imxushuai.repository.secondary;

import com.imxushuai.entity.secondary.SecondaryTable;
import org.springframework.data.repository.CrudRepository;

public interface SecondaryRepository extends CrudRepository<SecondaryTable, Long> {
}

测试

编写测试类

package com.imxushuai;

import com.imxushuai.entity.primary.PrimaryTable;
import com.imxushuai.entity.secondary.SecondaryTable;
import com.imxushuai.repository.primary.PrimaryRepository;
import com.imxushuai.repository.secondary.SecondaryRepository;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)
@SpringBootTest
public class MultipleDatasourceTest {

    @Autowired
    private PrimaryRepository primaryRepository;

    @Autowired
    private SecondaryRepository secondaryRepository;

    @Test
    public void testAdd() {
        PrimaryTable primary = new PrimaryTable();
        primary.setId(1L);
        primary.setUsername("PrimaryTable 1");
        primary.setPassword("PrimaryTable 1");
        primary.setP("This primary 1");

        primaryRepository.save(primary);

        SecondaryTable secondaryTable = new SecondaryTable();
        secondaryTable.setId(1L);
        secondaryTable.setUsername("SecondaryTable 1");
        secondaryTable.setPassword("SecondaryTable 1");
        secondaryTable.setS("This secondary 1");

        secondaryRepository.save(secondaryTable);

        System.out.println(primaryRepository.findById(1L));
        System.out.println(secondaryRepository.findById(1L));
    }

}

运行结果：

新增成功并且成功查询到数据。

我这里的截图是Spring Boot 2.x，findById出来结果使用Optional包裹的。

代码获取

Github：

参考

Spring Boot多数据源配置与使用

Spring boot issue

imxushuai
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringBoot+Jpa多数据源配置
huang_wei_cai的专栏
09-18 341
关于 有时候，随着业务的发展，项目关联的数据来源会变得越来越复杂，使用的数据库会比较分散，这个时候就会采用多数据源的方式来获取数据。另外，多数据源也有其他好处，例如分布式数据库的读写分离，集成多种数据库等等。下面分享我在实际项目中配置多数据源的案例。 步骤 1.application.yml文件中，配置数据库源。这里primary是主库，secondary是从库。 server: p...
基于Spring Boot与Spring Data JPA的多数据源配置
热门推荐
gabriel_2的专栏
06-02 1万+
由于项目需要，最近研究了一下基于Spring Boot与Spring Data JPA的多数据源配置问题。以下是传统的单数据源配置代码。这里使用的是Spring的Annotation在代码内部直接配置的方式，没有使用任何XML文件。 @Configuration @EnableJpaRepositories(basePackages = "org.lyndon.repository") @Ena
Spring Data JPA 之 多数据源配置
曾小二的博客
08-14 6012
我们都知道 DataSource 的本质是获得数据库连接，⽽ AbstractRoutingDataSource 帮我们实现了动态获得数据源的可能性。
JPA多数据源配置
qq_51711350的博客
12-03 2232
JPA多数据源配置
springboot jpa 多数据源配置
chenxing1990的专栏
02-07 6734
springboot 多数据源切换。
避坑版：springboot+JPA如何配多种数据源（postgresql+mysql）
u013232219的博客
09-08 2732
注意： JPA和mybatis是不同的持久层，各自特点独特， 与mybatis相比，JPA需要考虑对数据源的映射和操作， 通常我们设置在项目启动时，JPA就会根据设置去创建或者更新表， 因此不能像mybayis那样等到调用时再去告诉方法用哪个数据源， JPA需要一开始就设定好repository和entity所对应的数据源， 在下列文件repository里你可以看到相关设置； 坑，请注意，网上有很多的JPA配多种数据源，但是他们都缺失一点，连方言都没有设置，有的压根不知道这回事，要知道，JPA
SpringBoot-JPA多数据源
月弦YueXian
06-02 3934
SpringBoot-JPA多数据源
Spring Boot+Jpa多数据源配置Demo（支持不同数据库）
04-11
总结来说，Spring Boot + JPA 的多数据源配置需要对Spring的配置机制有深入理解，包括自动配置、bean的创建、数据源的切换等。同时，合理组织实体类和数据库访问层，确保代码的可维护性和扩展性。这个名为`...
Spring Boot+Jpa多数据源配置的完整步骤
08-26
Spring Boot+Jpa多数据源配置的完整步骤 Spring Boot作为一款现代化的Java开发框架，提供了许多优秀的特性和配置项，其中JPA（Java Persistence API）是Java EE中的一种持久化API，用于简化数据库操作。然而，在...
Spring Boot使用spring-data-jpa配置Mysql多数据源
12-17
在Spring Boot应用中，使用`spring-data-jpa`来配置MySQL多数据源是一项常见的需求，尤其是在构建大型分布式系统时，为了实现数据隔离、负载均衡或读写分离等目的。本教程将详细介绍如何在Spring Boot项目中配置多个...
springboot+JPA 多数据源配置
08-29
通过以上步骤，你就可以在Spring Boot项目中成功配置并使用JPA进行多数据源操作了。这种方式允许你灵活地管理不同数据库的数据，对于复杂的分布式系统和多租户应用特别有用。在实际开发中，还可能需要考虑数据源的...
详解基于Spring Boot与Spring Data JPA的多数据源配置
08-30
基于Spring Boot与Spring Data JPA的多数据源配置可以满足各种复杂的数据源配置需求，提供了非常实用的解决方案，并且可以与Spring Boot的其他功能很好地集成，例如使用Spring Boot的starter依赖项来简化配置，使用...
springboot2+JPA 配置多数据源（不同类型数据库）
qq_43082438的博客
06-24 6676
springboot2+JPA配置多数据源（不同数据库）
SpringBoot—JPA和Mybatis多数据源配置和使用
qq_32015565的博客
04-18 1968
后续有新的学习，继续补充上来。
springdata-jpa多数据源配置
weixin_43278573的博客
10-16 874
jpa配置多数据源就是配置多个repository，每个 repository对应操作不同的数据源。
SpringBoot整合(六)多数据源和 JPA、MyBatis、JdbcTemplate 的集成
qq_44665283的博客
02-27 1440
SpringBoot整合(六)多数据源和 JPA、MyBatis、JdbcTemplate 的集成
【SpringBoot】Spring data JPA的多数据源实现
Robin的博客
03-21 2531
表，message数据能正确的插入testdb2的message表，则JPA的多数据源实现正确。下面的实体对象和Repository，并使用primary数据源。仿造这段代码再写一套。配置实体扫描以及事务管理,注意看@Primary和带注释的地方。的Bean对象创建并注入Spring上下文，分别对应。的配置使用secondary数据源。如果article数据能正确插入。里面的两套数据源配置。
SpringBoot2.7+ 动态数据数据源以及多数据源自动配置
MCN的博客
08-19 3338
内容包括动态数据源以及多数据源的自动配置包括jpa和mybatis，包含源码以及使用方法。动态数据源开关和jpa多数据源开关以及mybatis多数据源开关三者同时只能开启一个当三个开关都没开启时，默认会使用动态数据源模式jpa和mybatis的多数据源配置基本一样，引入不同的依赖就行了httpshttps。......
大学生创业计划书(4)三篇文件.docx
最新发布
07-11
大学生创业计划书(4)三篇文件.docx
springboot+jpa+druid多数据源配置
12-01
通过以上步骤配置好多数据源后，就可以在Spring Boot应用程序中使用多个数据源进行数据库的操作。可以根据需要在Service或Controller中使用@PersistenceContext注解指定具体的数据源，或者使用@Primary注解指定默认...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值