学习篇：基于springBoot-2.1.7 Jpa多数据源的配置

最新推荐文章于 2023-04-08 17:51:28 发布

原创最新推荐文章于 2023-04-08 17:51:28 发布 · 1.9k 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#spring #spring boot #java

springboot 专栏收录该内容

4 篇文章

订阅专栏

本文详细介绍如何在SpringBoot 2.1.7版本中配置并使用多数据源，包括主库与备份库的设置，以及如何通过不同方式注入数据源配置。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

文章目录

- - - - 一、基于springBoot-2.1.7多数据源的配置
      - 1. 多数据源的配置文件，采用application.yml
        2. 注入数据源 DataSourceConfig
        3. 主库配置 PrimaryDataSourceConfig
        4. 备份库配置 BackDataSourceConfig

一、基于springBoot-2.1.7多数据源的配置

1. 多数据源的配置文件，采用application.yml

spring:
  datasource:
    primary:
      # 直接通过配置文件获取DataSource 使用jdbc-url
      jdbc-url: jdbc:mysql://127.0.0.1:3306/seller
      # 使用DataSourceProperties注入数据源配置获取DataSource时使用url
      # url: jdbc:mysql://127.0.0.1:3306/seller
      driver-class-name: com.mysql.jdbc.Driver
      username: root
      password: root
    backup:
      jdbc-url: jdbc:mysql://127.0.0.1:3306/seller-backup
      driver-class-name: com.mysql.jdbc.Driver
      username: root
      password: root
  jpa:
    hibernate:
      primary-dialect: org.hibernate.dialect.MySQL5Dialect
      backup-dialect: org.hibernate.dialect.MySQL5Dialect
    show-sql: true

注意：jdbc-url 和 url的区别。
当我们通过DataSourceProperties方式注入数据源配置，获取DataSource时，这个时候需要使用url
如果是直接通过配置获取DataSource，那必须是jdbc-url。
如果是单数据源，非手动获取配置注入数据源的不考虑该问题。

2. 注入数据源 DataSourceConfig

package com.laogoubi.seller.config;

import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.jdbc.DataSourceProperties;
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;

/**
 * @ClassName DataSourceConfig
 * @Description 数据源相关配置
 * @Author eastern
 * @Date 2019/12/29 下午6:03
 * @Version 1.0
 **/
@Configuration
public class DataSourceConfig {

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

    @Bean
    @Primary
    @ConfigurationProperties(prefix = "spring.datasource.primary")
    public DataSourceProperties primaryDataSourceProperties() {
        return new DataSourceProperties();
    }

    @Primary
    @Bean(name = "primaryDataSource")
    @Qualifier(value = "primaryDataSource")
    public DataSource primaryDataSource() {
        return primaryDataSourceProperties().initializeDataSourceBuilder().build();
    }

    @Bean(name = "backupDataSource")
    @Qualifier("backupDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.backup")
    public DataSource backupDataSource() {
        return DataSourceBuilder.create().build();
    }

}

上面提供了两种写法，也就是前面说的不用的注入数据源配置获取DataSource的方式

方式一：通过DataSourceProperties的方式获取DataSource
方式二：直接通过配置获取DataSource

3. 主库配置 PrimaryDataSourceConfig

package com.laogoubi.seller.config;

import com.laogoubi.entity.Order;
import com.laogoubi.seller.repositories.primary.OrderRepository;
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.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.sql.DataSource;
import java.util.Map;

/**
 * @ClassName PrimaryDataSourceConfig
 * @Description 主库相关配置
 * @Author eastern
 * @Date 2019/12/29 下午6:01
 * @Version 1.0
 **/
@Configuration
// 开启事务管理
@EnableTransactionManagement
// 开启JpaRepositories
@EnableJpaRepositories(
        // 在这个JpaRepositories中用到的事务管理器，这里是Ref，即引用
        transactionManagerRef = "primaryTransactionManager",
        // 实体类工厂
        entityManagerFactoryRef = "primaryEntityManagerFactory",
        // JpaRepositories所在的包名，这也是为什么我们要细分包名的原因
        basePackageClasses= OrderRepository.class
)
public class PrimaryDataSourceConfig {
    /**
     *  这里必须要要加 @Qualifier(value = "primaryDatasource")注解
     *  否则Spring将不会知道用哪个Bean
     */
    @Autowired
    @Qualifier(value = "primaryDataSource")
    private DataSource primaryDataSource;

    /**
     * JpaProperties，Spring自动配置会自动加载该Bean
     */
    @Autowired
    private JpaProperties jpaProperties;


    @Autowired
    private HibernateProperties hibernateProperties;


    /**
     * @Bean 配置实体类工厂
     * @Primary 在数据源的配置中，我们将primary配置成了主库，所以必须在这里有@Primary注解
     * @param builder
     * @return
     */
    @Bean(name = "primaryEntityManagerFactory")
    @Primary
    public LocalContainerEntityManagerFactoryBean primaryEntityManagerFactory(EntityManagerFactoryBuilder builder) {
        //创建一个工厂
        return builder
                // 数据源实例，在这里指的就是primaryDatasource这个实例
                .dataSource(primaryDataSource)
                // 加Jpa的属性配置加入进来
                .properties(jpaProperties.getProperties())
//                .properties(getVendorProperties())
                // 实体类包名
                .packages(Order.class)
                .persistenceUnit("primary")
                .build();
    }

    /**
     * @Primary 和上面一样，必须要有该注解
     * @param entityManagerFactory
     * @return
     */
    @Bean(name = "primaryTransactionManager")
    @Primary
    public PlatformTransactionManager primaryTransactionManager(@Qualifier(value = "primaryEntityManagerFactory") LocalContainerEntityManagerFactoryBean entityManagerFactory) {
        return new JpaTransactionManager(entityManagerFactory.getObject());
    }

//    private Map<String, Object> getVendorProperties() {
//        return hibernateProperties.determineHibernateProperties(jpaProperties.getProperties(), new HibernateSettings());
//    }

}

注意：LocalContainerEntityManagerFactoryBean方法中的properties

方式一：可以通过hibernateProperties获取
方式二：直接通过注入的JpaProperties获取

4. 备份库配置 BackDataSourceConfig

package com.laogoubi.seller.config;

import com.laogoubi.seller.repositories.backup.VerificationOrderRepository;
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.sql.DataSource;

/**
 * @ClassName BackDataSourceConfig
 * @Description 从库相关配置
 * @Author eastern
 * @Date 2019/12/29 下午6:02
 * @Version 1.0
 **/
@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(
        transactionManagerRef = "backupTransactionManager",
        entityManagerFactoryRef = "backupEntityManagerFactory",
        basePackageClasses = VerificationOrderRepository.class
)
public class BackDataSourceConfig {

    @Autowired
    @Qualifier(value = "backupDataSource")
    private DataSource backupDataSource;

    @Autowired
    private JpaProperties jpaProperties;

    @Bean(name = "backupEntityManagerFactory")
    public LocalContainerEntityManagerFactoryBean backupEntityManagerFactory(EntityManagerFactoryBuilder builder) {
        return builder
                .dataSource(backupDataSource)
                .properties(jpaProperties.getProperties())
                // 实体包
                .packages("com.laogoubi.entity")
                .persistenceUnit("backup")
                .build();
    }

    @Bean(name = "backupTransactionManager")
    public PlatformTransactionManager backupTransactionManager(@Qualifier(value = "backupEntityManagerFactory") LocalContainerEntityManagerFactoryBean entityManagerFactory) {
        return new JpaTransactionManager(entityManagerFactory.getObject());
    }

}