欢迎来到尧图网

客户服务 关于我们

您的位置：首页 > 房产 > 家装 > SpringBoot多数据源配置详解

SpringBoot多数据源配置详解

2025/6/24 6:19:31 来源：https://blog.csdn.net/footless_bird/article/details/148838920  浏览:  次   关键词：SpringBoot多数据源配置详解

文章目录

  • 多数据源核心概念
  • 多数据源实现示例
    • 多数据源的配置文件以及配置类
    • JPA 多数据源配置
    • MyBatis 多数据源配置
    • 事务管理：跨数据源事务处理
      • 单数据源事务
      • 多数据源事务挑战
      • 事务管理器：DataSourceTransactionManager 和 JpaTransactionManager
      • 多数据源事务使用
    • 基于 AbstractRoutingDataSource 的动态数据源
  • 常见问题与解决方案
    • 典型问题排查表
    • 数据源切换失败案例分析
    • 多数据源与缓存集成
  • 总结与扩展

多数据源核心概念

多数据源是指在一个应用程序中同时连接和使用多个数据库的能力。在实际开发中，我们经常会遇到以下场景需要多数据源：

  • 同时连接生产数据库和报表数据库
  • 读写分离场景（主库写，从库读）
  • 微服务架构中需要访问其他服务的数据库
  • 多租户系统中每个租户有独立数据库

多数据源实现示例

多数据源的配置文件以及配置类

  • application.yml 配置示例

    spring:datasource:jdbc-url: jdbc:mysql://localhost:3306/db1 # 主数据源username: rootpassword: root123driver-class-name: com.mysql.cj.jdbc.Driverhikari:pool-name: PrimaryHikariPool# 最大连接数 maximum-pool-size: 20# 最小空闲连接minimum-idle: 5# 空闲连接超时时间(ms)idle-timeout: 30000# 连接最大生命周期(ms)max-lifetime: 1800000# 获取连接超时时间(ms)connection-timeout: 30000connection-test-query: SELECT 1second-datasource:jdbc-url: jdbc:mysql://localhost:3306/db2 # 主数据源username: rootpassword: root123driver-class-name: com.mysql.cj.jdbc.Driverhikari:pool-name: SecondHikariPoolmaximum-pool-size: 20minimum-idle: 5idle-timeout: 30000max-lifetime: 1800000connection-timeout: 30000connection-test-query: SELECT 1

  • 多数据源配置类

    import org.springframework.boot.autoconfigure.jdbc.DataSourceProperties;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import javax.sql.DataSource;@Configuration
public class DbConfig {@Bean("db1DataSourceProperties")@ConfigurationProperties(prefix = "spring.datasource")public DataSourceProperties db1DataSourceProperties() {return new DataSourceProperties();}@Bean(name = "db1DataSource")public DataSource dataSource() {return db1DataSourceProperties().initializeDataSourceBuilder().build();}@Bean("db2DataSourceProperties")@ConfigurationProperties(prefix = "spring.second-datasource")public DataSourceProperties db2DataSourceProperties() {return new DataSourceProperties();}@Bean(name = "db2DataSource")public DataSource db2DataSource() {return db2DataSourceProperties().initializeDataSourceBuilder().build();}
}

  • 禁用默认数据源

    多数据源时需在主类排除自动配置

    @SpringBootApplication(exclude = {DataSourceAutoConfiguration.class}) 
public class App {public static void main(String[] args) {SpringApplication.run(App.class, args);}
}

JPA 多数据源配置

  • 主数据源 JAP 配置

    import com.querydsl.jpa.impl.JPAQueryFactory;
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.orm.jpa.vendor.HibernateJpaVendorAdapter;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import javax.persistence.EntityManager;
import javax.sql.DataSource;
import java.util.HashMap;
import java.util.Objects;@Configuration
// 启用 Spring 的事务管理功能，允许使用 @Transactional 注解来管理事务
@EnableTransactionManagement
// 启用 JPA 仓库的自动扫描和注册功能
@EnableJpaRepositories(// 指定要扫描的 JPA 仓库接口所在的包路径basePackages = "com.example.db1",// 指定使用的实体管理器工厂的 Bean 名称entityManagerFactoryRef = "db1EntityManagerFactory",// 指定使用的事务管理器的 Bean 名称transactionManagerRef = "db1TransactionManager"
)
public class Db1JpaConfig {/*** 创建实体管理器工厂的 Bean，并将其标记为主要的实体管理器工厂 Bean*/@Bean(name = "db1EntityManagerFactory")public LocalContainerEntityManagerFactoryBean entityManagerFactory(@Qualifier("db1DataSource")DataSource dataSource,JpaProperties jpaProperties) {return new EntityManagerFactoryBuilder(new HibernateJpaVendorAdapter(), new HashMap<>(), null)// 设置数据源.dataSource(dataSource)// 指定要扫描的实体类所在的包路径.packages("com.example.db1")// 设置持久化单元的名称.persistenceUnit("db1")// 设置 JPA 的属性.properties(jpaProperties.getProperties()).build();}/*** 创建事务管理器的 Bean，并将其标记为主要的事务管理器 Bean*/@Bean(name = "db1TransactionManager")public PlatformTransactionManager transactionManager(@Qualifier("db1EntityManagerFactory") LocalContainerEntityManagerFactoryBean entityManagerFactory) {return new JpaTransactionManager(Objects.requireNonNull(entityManagerFactory.getObject()));}/*** QueryDSL的核心组件*/@Bean(name = "db1JPAQueryFactory")public JPAQueryFactory db1JPAQueryFactory(@Qualifier("db1EntityManagerFactory") EntityManager entityManager) {return new JPAQueryFactory(entityManager);}
}

  • 从数据源 JAP 集成配置（略）


MyBatis 多数据源配置

  • 主数据源 MyBatis 配置

    import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.SqlSessionTemplate;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;
import javax.sql.DataSource;@Configuration
// 此注解用于指定 MyBatis Mapper 接口的扫描范围和对应的 SqlSessionFactory 引用
@MapperScan(// 指定要扫描的 Mapper 接口所在的基础包路径basePackages = "com.example.mapper.db1",// 配置使用的 SqlSessionFactory Bean 的名称sqlSessionFactoryRef = "db1SqlSessionFactory"
)
public class Db1MyBatisConfig {/*** 创建 SqlSessionFactory Bean*/@Bean("db1SqlSessionFactory")public SqlSessionFactory db1SqlSessionFactory(@Qualifier("db1DataSource") DataSource dataSource) throws Exception {// 创建 SqlSessionFactoryBean 实例，用于创建 SqlSessionFactorySqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();// 设置 SqlSessionFactory 使用的数据源sessionFactory.setDataSource(dataSource);// 设置 Mapper XML 文件的位置，使用 PathMatchingResourcePatternResolver 来查找匹配的资源sessionFactory.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:mapper/db1/*.xml"));// 获取并返回 SqlSessionFactory 实例return sessionFactory.getObject();}/*** 创建 SqlSessionTemplate Bean*/@Bean("db1SqlSessionTemplate")public SqlSessionTemplate db1SqlSessionTemplate(@Qualifier("db1SqlSessionFactory") SqlSessionFactory sqlSessionFactory) {// 创建并返回 SqlSessionTemplate 实例，用于简化 MyBatis 的操作return new SqlSessionTemplate(sqlSessionFactory);}/*** 创建事务管理器的 Bean，并将其标记为主要的事务管理器 Bean*/@Bean("db1TransactionManager")public PlatformTransactionManager transactionManager(@Qualifier("db1DataSource") DataSource dataSource) {return new DataSourceTransactionManager(dataSource);}
}

  • 从数据源 MyBatis 配置（略）


事务管理：跨数据源事务处理

单数据源事务

  • 在单数据源场景下，Spring的事务管理非常简单：

    @Service
public class AccountService {@Transactional  // 使用默认事务管理器public void transfer(Long fromId, Long toId, BigDecimal amount) {// do some thing ...}
}

多数据源事务挑战

多数据源事务面临的主要问题是分布式事务的挑战。Spring 的 @Transactional 注解默认只能管理单个事务管理器，无法直接协调多个数据源的事务。

解决方案对比：

方案原理优点缺点适用场景
JTA (Java Transaction API)使用全局事务协调器强一致性性能开销大，配置复杂需要强一致性的金融系统
最终一致性 (Saga模式)通过补偿操作实现高性能，松耦合实现复杂，需要补偿逻辑高并发，可接受短暂不一致
本地消息表通过消息队列保证可靠性高需要额外表存储消息需要可靠异步处理的场景

事务管理器：DataSourceTransactionManager 和 JpaTransactionManager

DataSourceTransactionManager 和 JpaTransactionManager 是 Spring 框架中针对不同持久层技术的事务管理器。

技术栈适配差异

  • DataSourceTransactionManager

    • 适用场景：纯 JDBC、MyBatis、JdbcTemplate 等基于原生 SQL 的数据访问技术
    • 事务控制对象：直接管理 java.sql.Connection ，通过数据库连接实现事务
    • 局限性：
      • 无法自动绑定 JPA 或 Hibernate 的 EntityManager/Session 到当前事务上下文
      • 混合使用 JDBC 和 JPA 时可能导致连接隔离（各自使用独立连接），破坏事务一致性

  • JpaTransactionManager

    • 适用场景：JPA 规范实现（如 Hibernate、EclipseLink）
    • 事务控制对象：管理 JPA EntityManager，通过其底层连接协调事务
    • 核心优势：
      • 自动将 EntityManager 绑定到线程上下文，确保同一事务中多次操作使用同一连接
      • 支持 JPA 的延迟加载（Lazy Loading）、缓存同步等特性

  • 混合技术栈的特殊情况

    • 混合技术栈需严格隔离事务管理器，并考虑分布式事务需求

      JPA操作使用JpaTransactionManager，MyBatis操作使用DataSourceTransactionManager

      跨数据源事务需引入分布式事务（如Atomikos），否则不同数据源的事务无法保证原子性

    • 若一个 Service 方法同时使用 JPA和 Mybatis（未验证）：

      • 使用 DataSourceTransactionManager 可能导致两个操作使用不同连接，违反 ACID
      • 使用 JpaTransactionManager 能保证两者共享同一连接（因 JPA 底层复用 DataSource 连接）

事务同步机制对比

特性DataSourceTransactionManagerJpaTransactionManager
连接资源管理直接管理 Connection通过 EntityManager 间接管理连接
跨技术兼容性仅限 JDBC 系技术支持 JPA 及其混合场景（如 JPA+JDBC）
高级 ORM 功能支持不支持（如延迟加载）完整支持 JPA 特性
配置复杂度简单（仅需 DataSource）需额外配置 EntityManagerFactory

多数据源事务使用

  • 事务配置详见上文

  • 多数据源事务使用示例

    import org.springframework.transaction.annotation.Transactional;@Service
public class AccountService {@Transactional(transactionManager = "db1TransactionManager")  // 指定事务管理器public void transfer(Long fromId, Long toId, BigDecimal amount) {// do some thing ...}
}

基于 AbstractRoutingDataSource 的动态数据源

  • 动态数据源上下文

    public class DynamicDataSourceContextHolder {// 使用ThreadLocal保证线程安全private static final ThreadLocal<String> CONTEXT_HOLDER = new ThreadLocal<>();// 数据源列表public static final String PRIMARY_DS = "primary";public static final String SECONDARY_DS = "secondary";public static void setDataSourceType(String dsType) {CONTEXT_HOLDER.set(dsType);}public static String getDataSourceType() {return CONTEXT_HOLDER.get();}public static void clearDataSourceType() {CONTEXT_HOLDER.remove();}
}

  • 动态数据源配置

    import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;
import javax.sql.DataSource;
import java.util.HashMap;
import java.util.Map;@Configuration
public class DynamicDataSourceConfig {/*** 创建动态数据源 Bean，并将其设置为主要的数据源 Bean*/@Bean@Primarypublic DataSource dynamicDataSource(@Qualifier("db1DataSource") DataSource db1DataSource,@Qualifier("db2DataSource") DataSource db2DataSource) {// 用于存储目标数据源的映射，键为数据源标识，值为数据源实例Map<Object, Object> targetDataSources = new HashMap<>();// 将主数据源添加到目标数据源映射中，使用自定义的主数据源标识targetDataSources.put(DynamicDataSourceContextHolder.PRIMARY_DS, db1DataSource);// 将从数据源添加到目标数据源映射中，使用自定义的从数据源标识targetDataSources.put(DynamicDataSourceContextHolder.SECONDARY_DS, db2DataSource);// 创建自定义的动态数据源实例DynamicDataSource dynamicDataSource = new DynamicDataSource();// 设置动态数据源的目标数据源映射dynamicDataSource.setTargetDataSources(targetDataSources);// 设置动态数据源的默认目标数据源为主数据源dynamicDataSource.setDefaultTargetDataSource(db1DataSource);return dynamicDataSource;}/*** 自定义动态数据源类，继承自 AbstractRoutingDataSource*/private static class DynamicDataSource extends AbstractRoutingDataSource {/*** 确定当前要使用的数据源的标识* @return 当前数据源的标识*/@Overrideprotected Object determineCurrentLookupKey() {// 从上下文持有者中获取当前要使用的数据源类型return DynamicDataSourceContextHolder.getDataSourceType();}}
}

  • 基于AOP的读写分离实现

    @Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface ReadOnly {// 标记为读操作
}@Aspect
@Component
public class ReadWriteDataSourceAspect {@Before("@annotation(readOnly)")public void beforeSwitchDataSource(JoinPoint point, ReadOnly readOnly) {DynamicDataSourceContextHolder.setDataSourceType(DynamicDataSourceContextHolder.SECONDARY_DS);}@After("@annotation(readOnly)")public void afterSwitchDataSource(JoinPoint point, ReadOnly readOnly) {DynamicDataSourceContextHolder.clearDataSourceType();}
}

  • 使用示例

    @Service
public class ProductService {@Autowiredprivate ProductRepository productRepository;@Transactionalpublic void createProduct(Product product) {// 默认使用主数据源(写)productRepository.save(product);}@ReadOnly  // 执行该注解标记的方法时，前后都会执行ReadWriteDataSourceAspect切面类方法@Transactionalpublic Product getProduct(Long id) {// 使用从数据源(读)return productRepository.findById(id).orElse(null);}@ReadOnly@Transactionalpublic List<Product> listProducts() {// 使用从数据源(读)return productRepository.findAll();}
}

常见问题与解决方案

典型问题排查表

方案原理优点缺点适用场景
JTA (Java Transaction API)使用全局事务协调器强一致性性能开销大，配置复杂需要强一致性的金融系统
最终一致性 (Saga模式)通过补偿操作实现高性能，松耦合实现复杂，需要补偿逻辑高并发，可接受短暂不一致
本地消息表通过消息队列保证可靠性高需要额外表存储消息需要可靠异步处理的场景

数据源切换失败案例分析

  • 问题描述：

    在动态数据源切换场景下，有时切换不生效，仍然使用默认数据源。

  • 原因分析：

    1. 数据源切换代码被异常绕过，未执行
    2. 线程池场景下线程复用导致上下文污染
    3. AOP 顺序问题导致切换时机不对

  • 解决方案：

    @Aspect
@Component
@Order(Ordered.HIGHEST_PRECEDENCE)  // 确保最先执行
public class DataSourceAspect {@Around("@annotation(targetDataSource)")public Object around(ProceedingJoinPoint joinPoint, TargetDataSource targetDataSource) throws Throwable {String oldKey = DynamicDataSourceContextHolder.getDataSourceType();try {DynamicDataSourceContextHolder.setDataSourceType(targetDataSource.value());return joinPoint.proceed();} finally {// 恢复为原来的数据源if (oldKey != null) {DynamicDataSourceContextHolder.setDataSourceType(oldKey);} else {DynamicDataSourceContextHolder.clearDataSourceType();}}}
}// 线程池配置确保清理上下文
@Configuration
public class ThreadPoolConfig {@Beanpublic ExecutorService asyncExecutor() {ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();executor.setCorePoolSize(5);executor.setMaxPoolSize(10);executor.setQueueCapacity(100);executor.setThreadNamePrefix("Async-");executor.setTaskDecorator(runnable -> {String dsKey = DynamicDataSourceContextHolder.getDataSourceType();return () -> {try {if (dsKey != null) {DynamicDataSourceContextHolder.setDataSourceType(dsKey);}runnable.run();} finally {DynamicDataSourceContextHolder.clearDataSourceType();}};});executor.initialize();return executor.getThreadPoolExecutor();}
}

多数据源与缓存集成

  • 当多数据源与缓存（如 Redis）一起使用时，需要注意缓存键的设计：

    @Service
public class CachedUserService {@Autowiredprivate PrimaryUserRepository primaryUserRepository;@Autowiredprivate SecondaryUserRepository secondaryUserRepository;@Autowiredprivate RedisTemplate<String, User> redisTemplate;private String getCacheKey(String source, Long userId) {return String.format("user:%s:%d", source, userId);}@Cacheable(value = "users", key = "#root.target.getCacheKey('primary', #userId)")public User getPrimaryUser(Long userId) {return primaryUserRepository.findById(userId).orElse(null);}@Cacheable(value = "users", key = "#root.target.getCacheKey('secondary', #userId)")public User getSecondaryUser(Long userId) {return secondaryUserRepository.findById(userId).orElse(null);}@CacheEvict(value = "users", allEntries = true)public void clearAllUserCache() {// 清除所有用户缓存}
}

总结与扩展

技术选型建议

场景推荐方案理由
简单多数据源，无交叉访问独立配置多个数据源简单直接，易于维护
需要动态切换数据源AbstractRoutingDataSource灵活，可运行时决定数据源
需要强一致性事务JTA(XA)保证ACID，但性能较低
高并发，最终一致性可接受Saga模式高性能，松耦合
读写分离AOP+注解方式透明化，对业务代码侵入小

版权声明:

本网仅为发布的内容提供存储空间，不对发表、转载的内容提供任何形式的保证。凡本网注明“来源：XXX网络”的作品，均转载自其它媒体，著作权归作者所有，商业转载请联系作者获得授权，非商业转载请注明出处。

我们尊重并感谢每一位作者，均已注明文章来源和作者。如因作品内容、版权或其它问题，请及时与我们联系，联系邮箱：809451989@qq.com，投稿邮箱：809451989@qq.com

相关资讯

热文排行

最新新闻

推荐新闻

热搜词