Spring Boot 多数据源配置完整指南

最新推荐文章于 2025-04-23 17:25:44 发布
最新推荐文章于 2025-04-23 17:25:44 发布
阅读量751 收藏 7
点赞数 19
分类专栏： java 文章标签： spring boot 后端 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_16242613/article/details/147360775
版权

在这里插入图片描述

文章目录

在复杂的企业应用中，经常需要连接多个数据库。Spring Boot 提供了灵活的多数据源配置方式，以下是详细的实现方案。

一、基础多数据源配置

1. 添加依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>
<!-- 或者使用其他数据库驱动 -->

2. 配置多个数据源

# 主数据源
spring.datasource.primary.url=jdbc:mysql://localhost:3306/db1
spring.datasource.primary.username=root
spring.datasource.primary.password=123456
spring.datasource.primary.driver-class-name=com.mysql.cj.jdbc.Driver

# 次数据源
spring.datasource.secondary.url=jdbc:mysql://localhost:3306/db2
spring.datasource.secondary.username=root
spring.datasource.secondary.password=123456
spring.datasource.secondary.driver-class-name=com.mysql.cj.jdbc.Driver

3. 配置数据源Bean

@Configuration
public class DataSourceConfig {

    // 主数据源
    @Bean
    @Primary
    @ConfigurationProperties(prefix="spring.datasource.primary")
    public DataSource primaryDataSource() {
        return DataSourceBuilder.create().build();
    }

    // 次数据源
    @Bean
    @ConfigurationProperties(prefix="spring.datasource.secondary")
    public DataSource secondaryDataSource() {
        return DataSourceBuilder.create().build();
    }
}

二、JPA多数据源配置

1. 配置主数据源JPA

@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(
    basePackages = "com.example.repository.primary",
    entityManagerFactoryRef = "primaryEntityManagerFactory",
    transactionManagerRef = "primaryTransactionManager"
)
public class PrimaryJpaConfig {
    
    @Autowired @Qualifier("primaryDataSource")
    private DataSource primaryDataSource;
    
    @Primary
    @Bean
    public LocalContainerEntityManagerFactoryBean primaryEntityManagerFactory(
            EntityManagerFactoryBuilder builder) {
        return builder
            .dataSource(primaryDataSource)
            .packages("com.example.entity.primary")
            .persistenceUnit("primaryPersistenceUnit")
            .properties(jpaProperties())
            .build();
    }
    
    private Map<String, Object> jpaProperties() {
        Map<String, Object> props = new HashMap<>();
        props.put("hibernate.hbm2ddl.auto", "update");
        props.put("hibernate.dialect", "org.hibernate.dialect.MySQL8Dialect");
        return props;
    }
    
    @Primary
    @Bean
    public PlatformTransactionManager primaryTransactionManager(
            @Qualifier("primaryEntityManagerFactory") EntityManagerFactory emf) {
        return new JpaTransactionManager(emf);
    }
}

2. 配置次数据源JPA

@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(
    basePackages = "com.example.repository.secondary",
    entityManagerFactoryRef = "secondaryEntityManagerFactory",
    transactionManagerRef = "secondaryTransactionManager"
)
public class SecondaryJpaConfig {
    
    @Autowired @Qualifier("secondaryDataSource")
    private DataSource secondaryDataSource;
    
    @Bean
    public LocalContainerEntityManagerFactoryBean secondaryEntityManagerFactory(
            EntityManagerFactoryBuilder builder) {
        return builder
            .dataSource(secondaryDataSource)
            .packages("com.example.entity.secondary")
            .persistenceUnit("secondaryPersistenceUnit")
            .properties(jpaProperties())
            .build();
    }
    
    private Map<String, Object> jpaProperties() {
        Map<String, Object> props = new HashMap<>();
        props.put("hibernate.hbm2ddl.auto", "update");
        props.put("hibernate.dialect", "org.hibernate.dialect.MySQL8Dialect");
        return props;
    }
    
    @Bean
    public PlatformTransactionManager secondaryTransactionManager(
            @Qualifier("secondaryEntityManagerFactory") EntityManagerFactory emf) {
        return new JpaTransactionManager(emf);
    }
}

三、MyBatis多数据源配置

1. 主数据源配置

@Configuration
@MapperScan(
    basePackages = "com.example.mapper.primary",
    sqlSessionFactoryRef = "primarySqlSessionFactory"
)
public class PrimaryMyBatisConfig {

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

    @Primary
    @Bean
    public SqlSessionFactory primarySqlSessionFactory(
            @Qualifier("primaryDataSource") DataSource dataSource) throws Exception {
        SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();
        sessionFactory.setDataSource(dataSource);
        sessionFactory.setMapperLocations(
            new PathMatchingResourcePatternResolver()
                .getResources("classpath:mapper/primary/*.xml"));
        return sessionFactory.getObject();
    }

    @Primary
    @Bean
    public SqlSessionTemplate primarySqlSessionTemplate(
            @Qualifier("primarySqlSessionFactory") SqlSessionFactory sqlSessionFactory) {
        return new SqlSessionTemplate(sqlSessionFactory);
    }
}

2. 次数据源配置

@Configuration
@MapperScan(
    basePackages = "com.example.mapper.secondary",
    sqlSessionFactoryRef = "secondarySqlSessionFactory"
)
public class SecondaryMyBatisConfig {

    @Bean
    @ConfigurationProperties(prefix = "spring.datasource.secondary")
    public DataSource secondaryDataSource() {
        return DataSourceBuilder.create().build();
    }

    @Bean
    public SqlSessionFactory secondarySqlSessionFactory(
            @Qualifier("secondaryDataSource") DataSource dataSource) throws Exception {
        SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();
        sessionFactory.setDataSource(dataSource);
        sessionFactory.setMapperLocations(
            new PathMatchingResourcePatternResolver()
                .getResources("classpath:mapper/secondary/*.xml"));
        return sessionFactory.getObject();
    }

    @Bean
    public SqlSessionTemplate secondarySqlSessionTemplate(
            @Qualifier("secondarySqlSessionFactory") SqlSessionFactory sqlSessionFactory) {
        return new SqlSessionTemplate(sqlSessionFactory);
    }
}

四、动态数据源配置（运行时切换）

1. 抽象路由数据源

public class DynamicDataSource extends AbstractRoutingDataSource {

    @Override
    protected Object determineCurrentLookupKey() {
        return DataSourceContextHolder.getDataSourceType();
    }
}

2. 数据源上下文持有者

public class DataSourceContextHolder {

    private static final ThreadLocal<String> contextHolder = new ThreadLocal<>();

    public static void setDataSourceType(String dataSourceType) {
        contextHolder.set(dataSourceType);
    }

    public static String getDataSourceType() {
        return contextHolder.get();
    }

    public static void clearDataSourceType() {
        contextHolder.remove();
    }
}

3. 配置动态数据源

@Configuration
public class DynamicDataSourceConfig {

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

    @Bean
    @ConfigurationProperties(prefix="spring.datasource.secondary")
    public DataSource secondaryDataSource() {
        return DataSourceBuilder.create().build();
    }

    @Primary
    @Bean
    public DataSource dynamicDataSource(
            @Qualifier("primaryDataSource") DataSource primaryDataSource,
            @Qualifier("secondaryDataSource") DataSource secondaryDataSource) {
        
        Map<Object, Object> targetDataSources = new HashMap<>();
        targetDataSources.put("primary", primaryDataSource);
        targetDataSources.put("secondary", secondaryDataSource);
        
        DynamicDataSource dynamicDataSource = new DynamicDataSource();
        dynamicDataSource.setTargetDataSources(targetDataSources);
        dynamicDataSource.setDefaultTargetDataSource(primaryDataSource);
        
        return dynamicDataSource;
    }
}

4. 使用AOP切换数据源

@Aspect
@Component
public class DataSourceAspect {

    @Pointcut("@annotation(com.example.annotation.TargetDataSource)")
    public void dataSourcePointCut() {}

    @Before("dataSourcePointCut()")
    public void before(JoinPoint point) {
        MethodSignature signature = (MethodSignature) point.getSignature();
        Method method = signature.getMethod();
        TargetDataSource ds = method.getAnnotation(TargetDataSource.class);
        
        if (ds == null) {
            DataSourceContextHolder.setDataSourceType("primary");
        } else {
            DataSourceContextHolder.setDataSourceType(ds.value());
        }
    }

    @After("dataSourcePointCut()")
    public void after(JoinPoint point) {
        DataSourceContextHolder.clearDataSourceType();
    }
}

5. 自定义注解

@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface TargetDataSource {
    String value() default "primary";
}

6. 使用示例

@Service
public class UserService {

    @Autowired
    private UserMapper userMapper;
    
    // 使用主数据源
    public User getPrimaryUser(Long id) {
        return userMapper.selectById(id);
    }
    
    // 使用次数据源
    @TargetDataSource("secondary")
    public User getSecondaryUser(Long id) {
        return userMapper.selectById(id);
    }
}

五、多数据源事务管理

1. JTA分布式事务（Atomikos）

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jta-atomikos</artifactId>
</dependency>

2. 配置JTA数据源

# 主数据源
spring.jta.atomikos.datasource.primary.unique-resource-name=primaryDS
spring.jta.atomikos.datasource.primary.xa-data-source-class-name=com.mysql.cj.jdbc.MysqlXADataSource
spring.jta.atomikos.datasource.primary.xa-properties.url=jdbc:mysql://localhost:3306/db1
spring.jta.atomikos.datasource.primary.xa-properties.user=root
spring.jta.atomikos.datasource.primary.xa-properties.password=123456

# 次数据源
spring.jta.atomikos.datasource.secondary.unique-resource-name=secondaryDS
spring.jta.atomikos.datasource.secondary.xa-data-source-class-name=com.mysql.cj.jdbc.MysqlXADataSource
spring.jta.atomikos.datasource.secondary.xa-properties.url=jdbc:mysql://localhost:3306/db2
spring.jta.atomikos.datasource.secondary.xa-properties.user=root
spring.jta.atomikos.datasource.secondary.xa-properties.password=123456

3. 使用分布式事务

@Service
public class OrderService {

    @Transactional // 跨数据源事务
    public void placeOrder(Order order) {
        // 操作主数据源
        primaryRepository.save(order);
        
        // 操作次数据源
        auditRepository.logOrder(order);
        
        // 如果此处抛出异常，两个操作都会回滚
    }
}

六、最佳实践

  1. 命名规范：

    • 为每个数据源使用清晰的命名（如customerDS, orderDS）
    • 包结构按数据源分离（com.example.repository.primary / .secondary）

  2. 连接池配置：

    spring.datasource.primary.hikari.maximum-pool-size=10
spring.datasource.secondary.hikari.maximum-pool-size=5

  3. 监控指标：

    • 为每个数据源配置独立的监控
    • 使用Spring Actuator暴露数据源健康指标

  4. 性能考虑：

    • 高频访问的数据源使用更大的连接池
    • 读写分离场景考虑主从数据源

  5. 测试策略：

    • 为每个数据源编写独立的测试类
    • 测试跨数据源事务的回滚行为

七、常见问题解决

问题1：循环依赖

// 解决方法：使用@DependsOn
@Bean
@DependsOn("dynamicDataSource")
public PlatformTransactionManager transactionManager() {
    return new DataSourceTransactionManager(dynamicDataSource());
}

问题2：MyBatis缓存冲突

// 解决方法：为每个SqlSessionFactory配置独立的缓存环境
sqlSessionFactory.setConfiguration(configuration);
configuration.setEnvironment(new Environment(
    "primaryEnv", 
    transactionFactory, 
    dataSource
));

问题3：事务传播行为异常

// 解决方法：明确指定事务管理器
@Transactional(transactionManager = "primaryTransactionManager")
public void primaryOperation() {...}

通过以上配置，Spring Boot应用可以灵活地支持多数据源场景，无论是简单的多库连接还是复杂的动态数据源切换需求。根据实际业务场景选择最适合的配置方式，并注意事务管理和性能调优。

在这里插入图片描述

Spring Boot入门(20)：使用Mybatis-plus实现Spring Boot多数据源配置，轻松实现数据库读写分离！
**My Coding Family**
08-22 1万+
如何实现多数据源的配置及项目使用，此文教会你，超级简单，开箱即用。
springboot---使用jta+atomikos管理多数据源事务
gentle!!
08-28 8729
在实际开发中，我们一个项目可能会用到多个数据库，通常一个数据库对应一个数据源。这时候就要管理多数据源事务。 什么是jta：https://www.ibm.com/developerworks/cn/java/j-lo-jta/ pom.xml 注意这里的druid用1.1.9 &lt;dependency&gt; &lt;groupId&gt;org.springframewor...
springboot 分布式事务的解决方案(JTA+Atomic+多数据源)（^_^^_^）
jaryle的专栏
03-18 2万+
首先，到底啥是分布式事务呢，比如我们在执行一个业务逻辑的时候有两步分别操作A数据源和B数据源，当我们在A数据源执行数据更改后，在B数据源执行时出现运行时异常，那么我们必须要让B数据源的操作回滚，并回滚对A数据源的操作；这种情况在支付业务时常常出现；比如买票业务在最后支付失败，那之前的操作必须全部回滚，如果之前的操作分布在多个数据源中，那么这就是典型的分布式事务回滚； 了解了什么是分布式事务，那分...
SpringBoot使用jta+atomikos解决多数据源分布式事务
qq_36525300的博客
12-18 2057
多数据源的两种情况 SpringBoot 中多数据源大致可以分为两种： 垂直分割模式 类似水平分割模式 垂直分割模式，将整个数据库根据模块拆分成多个数据库，每个数据库是单独一个数据源，这样就涉及到多数据源的分布式事务问题。 类似水平分割模式，不同区域都拥有数据库，每个区域的数据库数据相同，通过不同区域的账户选择登录哪个数据库。 ...
Spring-boot下的mybatis多数据源JTA配置
04-27 3612
一.配置properties spring.jta.enabled=true #spring.jta.atomikos.properties.service==com.atomikos.icatch.standalone.UserTransactionServiceFactory #spring.jta.atomikos.properties.max-actives=200 #spring.jt
springboot整合多数据源和使用（jta+atomikos）解决传统分布式事务！！！
iiiiiir的博客
05-02 1451
本文基于 包路径 区分多数据源，当然还有 注解方式 实现多数据源，本文不作叙述！ 配置文件建立多个sql源 # Mysql 1 mysql.datasource.test1.url = jdbc:mysql://localhost:3306/test01?useUnicode=true&characterEncoding=utf-8 mysql.datasource.test1...
springboot中使用jta+atomikos处理多数据源分布式事务问题
weixin_38111348的博客
11-21 2766
springboot中使用jta+atomikos处理多数据源分布式事务问题 多数据源拆分思路： 例子：公司分为两个数据库，一个数据库专门存放共同配置文件，一个数据库是垂直业务数据库 垂直： 业务划分具体数据库 在一个项目中可以有无限个数据源，具体多少根据内存大小 在一个项目多数据源如何划分： （1）分包名： （常用） com.lqr.test01 — datasource1 com.lqr.te...
Spring Boot 多数据源配置实战指南：从入门到精通
Zyj_0101的博客
11-07 964
通过本文的详细介绍，我们了解了在 Spring Boot 项目中配置多数据源的基本步骤和进阶技巧。多数据源配置不仅能够满足复杂的业务需求，还能提高系统的扩展性和性能。希望本文能为你提供实用的参考和指导，帮助你在实际项目中更好地应用多数据源配置。
Spring Boot多数据源配置与注解数据源切换指南
1. **Spring Boot多数据源配置**：在Spring Boot中配置多数据源，通常需要以下几个步骤： - 配置多个数据源实例，包括数据库URL、用户名、密码、驱动类等信息。 - 为每个数据源配置一个DataSource Bean。 - 配置...
Spring Boot多数据源配置与实践教程
在深入探讨Spring Boot多数据源配置实例之前，我们先要了解Spring Boot这一流行的Java框架，它用于简化新Spring应用的初始搭建以及开发过程。Spring Boot具有许多内置的特性，比如嵌入式web服务器，无需部署war文件...
Spring Boot多数据源配置与使用实战指南
本资源标题为"Spring Boot中使用多个数据源 数据库.zip_常用数据库数据源"，表明该资源包含的是关于在Spring Boot中配置和使用多个数据源的介绍，并且涉及到了常用的数据库数据源信息。 2. 描述解读 描述部分提供了...
SpringBoot多数据源 + Atomikos事务
NickWU博客
12-13 2283
多数据源配置多数据源配置，可以参考翟永超的博客http://blog.didispace.com/springbootmultidatasource/本人前期摸索学习也是参考他的这个博客地址学习的 本人侧重点是讲解多数据源事务多数据源事务有几种方式 1. 指定事务管理器，每个Service只有允许一个事务管理器 2. 根据Service中的数据源，自动切换事务管理器 3. 多数据源跨库真正意
SpringBoot - 多数据源、jta事务。
qq_41341288的博客
07-09 508
首先pom.xml <!-- jta 整合事务 --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-jta-atomi...
springboot整合多数据源及传统的分布式事务解决方法jta-atomikos
zp的博客
08-28 4037
所谓的多数据源，简而言之就是:在一个项目中，有多个jdbc连接。 那么我们在在实际项目中，应该怎么样搭建多数据源并区分数据源呢? 举个例子 : 我们这个项目需要访问Test和Test1两个不同的数据库，我们可以采用分包结构,设置读取不同的数据源前缀，选择连接不同数据源。 分包结构 cn.itcats.test--- 访问Test数据库         dao         service ...
Spring Boot Druid 多数据源 Atomikos 分布式事务
热门推荐
追逐梦想的专栏
07-21 3万+
1、前言由于最近需要做一个接口平台，用到了两个数据库(业务库和系统库分离)，需要考虑同时操作两个数据库的数据时事务的管理，这时搜索了下资料，发现使用分布式事务可满足现状需求。之前也没接触过分布式事务，在baidu、google了一遍之后，根据相关的示例也未成功搭建。在一番折腾之后，终于搭建成功， 现将其记录下来，也为将来有此需求的朋友提供一点帮助。2、名词解释1、Spring Boot：Spring
SpringBoot2 整合JTA组件，多数据源事务管理
【积累】，是一个长期持续的过程。
07-12 2366
JTA即Java-Transaction-API，JTA允许应用程序执行分布式事务处理，即在两个或多个网络计算机资源上访问并且更新数据。JDBC驱动程序对JTA的支持极大地增强了数据访问能力。XA协议是数据库层面的一套分布式事务管理的规范,JTA是XA协议在Java中的实现,多个数据库或是消息厂商实现JTA接口,开发人员只需要调用SpringJTA接口即可实现JTA事务管理功能。JTA事务比JDBC事务更强大。一个JTA事务可以有多个参与者，而一个JDBC事务则被限定在一个单一的数据库连接。...
Spring Boot 应用优雅关闭
howeres的博客
04-22 170
写这篇文章是因为看到 “线程池在使用结束后应该正确关闭.” 那么如果我们的 Spring 应用都无法正确关闭, 那么线程池肯定也无从保障。
spring，spring boot， spring cloud三者区别
帅帅的廉颇的博客
04-23 404
Spring（基础） → Spring Boot（快速开发） → Spring Cloud（分布式扩展）
Spring Boot 请求参数接收控制指南
最新发布
m0_63949203的博客
04-23 362
Spring Boot 请求参数接收控制指南
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

北辰alk

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值