SpringBoot+MyBatis多数据源实战:跨库数据同步方案解析

SpringBoot+MyBatis多数据源实战:跨库数据同步与事务管理 本文详细介绍了在SpringBoot项目中整合MyBatis实现多数据源的完整实战方案。通过具体案例,讲解了如何配置多个数据源、管理独立的SqlSessionFactory,并重点探讨了跨库数据同步场景下的核心挑战——事务管理,提供了编程式事务控制等实用策略,确保数据操作的一致性与可靠性。 阅读详情

1. 为什么你的项目需要多数据源?

如果你正在开发一个稍微复杂点的企业应用,大概率会遇到一个头疼的问题:数据不在同一个地方。我见过太多项目,一开始图省事,所有表都塞进一个数据库里。结果呢?业务发展起来,用户量上来了,或者需要对接外部系统,数据就开始“分家”了。比如,核心的用户订单数据放在公司自建的MySQL主库,而用户行为日志为了分析方便,得实时同步到另一个专门的ClickHouse库;又或者,你需要从A系统的Oracle数据库里定时拉取客户信息,清洗转换后,写入到你自己系统的MySQL库中。

这种“跨库操作”的需求,就是多数据源配置的典型场景。它不是什么高深莫测的黑科技,而是一个解决实际数据孤岛问题的工程化方案。简单来说,就是让你的一个SpringBoot应用,能同时“认识”并“操作”多个不同的数据库连接。原始文章里提到了从A库读、往B库写的例子,这其实只是最基础的一种。在实际工作中,场景要丰富得多:

  • 读写分离:为了应对高并发,主库负责写,多个从库负责读。应用需要根据操作类型动态选择数据源。
  • 分库分表:数据量太大,单库扛不住,按业务或用户ID分到不同的物理数据库上。
  • 多租户架构:一个SaaS平台,每个租户的数据独立存放在一个数据库实例中,应用需要根据当前登录的租户动态切换连接。
  • 异构数据源同步:就像前面说的,数据来源五花八门,可能是MySQL、PostgreSQL,也可能是Oracle甚至MongoDB,你需要在一个服务里搞定它们。

只用SpringBoot默认的单数据源配置,遇到这些情况就抓瞎了。你会发现自己被困在一个数据库里,想访问另一个库的数据,要么走别扭的数据库链路(如FEDERATED引擎),要么就得额外写一个服务,引入不必要的网络开销和复杂度。直接在应用层配置多数据源,把数据交互的逻辑收拢在业务代码内部,往往是更清晰、更可控的选择。

所以,掌握SpringBoot+MyBatis多数据源配置,不是一个“炫技”的技能,而是一个后端开发者解决真实数据存取问题的基本功。它能让你设计的系统更灵活,更好地适应业务的变化。接下来,我们就抛开理论,直接上手,看看怎么从零开始搭建一个能“左右逢源”的多数据源项目。

2. 五分钟快速搭建双数据源环境

好了,道理讲完了,我们直接动手。我保证,只要你跟着步骤走,五分钟内就能让项目连接上两个数据库。这里我们沿用最经典的场景:一个本地MySQL数据库(local_db),一个远程测试环境MySQL数据库(dev_db)。我们的目标是配置好它们,并且能成功进行测试查询。

2.1 项目初始化与核心依赖

首先,用你喜欢的IDE(比如IntelliJ IDEA)或者通过Spring Initializr网站,创建一个标准的SpringBoot项目。在选择依赖时,勾选上 Spring Web、MyBatis Framework 和 MySQL Driver。不过,通过Initializr添加的MyBatis依赖可能不是最新版,为了更稳定,我习惯在pom.xml里明确指定版本。

下面是我在实际项目中常用的依赖配置,比原始文章里的更全面一些,加入了Druid连接池(性能好,监控功能强大)和Lombok(简化代码):

<dependencies>
    <!-- SpringBoot Web基础 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- JDBC支持,必须 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-jdbc</artifactId>
    </dependency>
    <!-- MyBatis官方与SpringBoot的整合启动器 -->
    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
        <version>2.3.0</version> <!-- 使用稳定版本 -->
    </dependency>
    <!-- MySQL驱动 -->
    <dependency>
        <groupId>com.mysql</groupId>
        <artifactId>mysql-connector-j</artifactId>
        <scope>runtime</scope>
    </dependency>
    <!-- 阿里Druid连接池 -->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid-spring-boot-starter</artifactId>
        <version>1.2.20</version>
    </dependency>
    <!-- 简化POJO开发 -->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
    <!-- 测试 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

注意:这里没有排除SpringBoot的自动数据源配置,因为我们后面会手动配置多个数据源,所以需要在主启动类上做点手脚,这个稍后说。

2.2 多数据源配置的“心脏”:application.yml

配置文件是区别单数据源和多数据源的关键。单数据源时,spring.datasource下面直接跟url、username等属性。多数据源时,我们需要把它们“包”起来,给每个数据源起个名字。

原始文章里提到了用jdbcUrl替代url,这是因为当配置顶级属性是spring.datasource时,SpringBoot会自动绑定标准属性。但当我们将其作为子属性(如spring.datasource.dev)时,使用jdbc-url或jdbcUrl是Druid或HikariCP连接池能正确识别的属性名。为了清晰和兼容性,我推荐以下写法:

spring:
  datasource:
    # 第一个数据源,命名为 local
    local:
      driver-class-name: com.mysql.cj.jdbc.Driver
      jdbc-url: jdbc:mysql://localhost:3306/local_db?useSSL=false&useUnicode=true&characterEncoding=utf8&serverTimezone=Asia/Shanghai
      username: root
      password: your_local_password
      type: com.alibaba.druid.pool.DruidDataSource
      # Druid连接池可选配置(根据性能调整)
      druid:
        initial-size: 5
        min-idle: 5
        max-active: 20
        test-on-borrow: true
        validation-query: SELECT 1

    # 第二个数据源,命名为 dev
    dev:
      driver-class-name: com.mysql.cj.jdbc.Driver
      jdbc-url: jdbc:mysql://192.168.1.100:3306/dev_db?useSSL=false&useUnicode=true&characterEncoding=utf8&serverTimezone=Asia/Shanghai
      username: dev_user
      password: your_dev_password
      type: com.alibaba.druid.pool.DruidDataSource
      druid:
        initial-size: 5
        min-idle: 5
        max-active: 20

看,是不是很直观?local和dev就是两个数据源的标识符,后面在Java代码里我们会用到它们。请务必将jdbc-url、username和password替换成你自己数据库的真实信息。

2.3 告别自动配置:主启动类的关键一步

配置写好了,但如果你现在启动项目,SpringBoot还是会试图根据默认规则去创建单个DataSource Bean,这肯定会报错,因为它发现配置里有local和dev,不知道用哪个。

所以,我们需要在主启动类上,排除掉SpringBoot关于DataSource的自动配置类,告诉它:“这个我自己来管”。

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;

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

加上exclude = {DataSourceAutoConfiguration.class}这一句,就等于关掉了SpringBoot在数据源配置上的“自动驾驶”模式,切换到了我们手动操作的“手动挡”。这是实现多数据源配置非常关键且容易忽略的一步。

3. 核心配置解析:如何让MyBatis认识两个“家”

配置文件只是定义了数据源的信息,就像给了你两个仓库的地址和钥匙。接下来,我们需要在Java代码里,根据这些信息,分别打造两把专用的“钥匙”(DataSource Bean),并为MyBatis分别配置两个“管家”(SqlSessionFactory),让它们各司其职,管理各自仓库的货物(Mapper和SQL)。

3.1 数据源配置类:打造两把专属钥匙

我们不能让Spring自动创建DataSource了,那就自己来。通常,我会为每个数据源创建一个独立的配置类,这样逻辑清晰,便于维护。这里以local数据源为例,dev数据源完全类似。

LocalDataSourceConfig.java

import com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceBuilder;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary; // 注意这个注解
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;

import javax.sql.DataSource;

@Configuration
// 重点1:指定这个SqlSessionFactory管理的Mapper接口所在包
@MapperScan(basePackages = "com.yourpackage.mapper.local",
           sqlSessionFactoryRef = "localSqlSessionFactory")
public class LocalDataSourceConfig {

    // 重点2:创建名为“localDataSource”的Bean,并从配置文件中加载前缀为“spring.datasource.local”的属性
    @Primary // 重点3:在多个同类型Bean中,标记这个为主要(默认)的。通常指定一个数据源为@Primary。
    @Bean(name = "localDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.local")
    public DataSource localDataSource() {
        // 使用Druid的Builder来构建,它会自动绑定上面prefix指定的所有属性
        return DruidDataSourceBuilder.create().build();
    }

    // 重点4:创建名为“localSqlSessionFactory”的Bean,它使用上面创建的localDataSource
    @Bean(name = "localSqlSessionFactory")
    public SqlSessionFactory localSqlSessionFactory(
            @Qualifier("localDataSource") DataSource dataSource) throws Exception {
        SqlSessionFactoryBean sessionFactoryBean = new SqlSessionFactoryBean();
        // 注入专属数据源
        sessionFactoryBean.setDataSource(dataSource);
        // 指定该数据源对应的MyBatis XML映射文件位置(可选,但推荐)
        sessionFactoryBean.setMapperLocations(
                new PathMatchingResourcePatternResolver()
                       .getResources("classpath:mapper/local/*.xml"));
        // 如果你有全局的mybatis配置(如驼峰命名转换),也可以在这里设置
        // sessionFactoryBean.setConfigLocation(...);
        return sessionFactoryBean.getObject();
    }
}

逐行解析关键点:

  1. @MapperScan:这是MyBatis-Spring整合的核心注解。basePackages指定了这个数据源对应的Mapper接口所在的包路径。sqlSessionFactoryRef则明确告诉Spring,扫描到这个包下的Mapper接口时,应该绑定到哪个SqlSessionFactory Bean上(这里就是localSqlSessionFactory)。这是实现Mapper与数据源一一对应的关键!
  2. @Bean(name = "localDataSource"):在Spring容器中注册一个名为localDataSource的DataSource类型的Bean。名字很重要,后面注入时要用到。
  3. @ConfigurationProperties(prefix = "spring.datasource.local"):魔法发生的地方。这个注解会将application.yml中所有以spring.datasource.local开头的属性(jdbc-url, username, druid.*等),自动赋值给这个DataSource Bean的对应属性。
  4. @Primary:当一个接口有多个实现Bean时(比如这里有localDataSource和devDataSource,它们都是DataSource类型),@Primary标记的Bean会被优先作为默认注入项。在多数据源场景下,你必须且只能选择一个数据源加上@Primary注解,否则在一些需要自动注入DataSource而又未指定名称的地方,Spring会因无法选择而报错。通常选择你最常用的、或者作为默认写库的数据源。
  5. SqlSessionFactoryBean:这是创建MyBatis核心对象SqlSessionFactory的工厂Bean。我们为每个数据源都创建一个,并为其设置专属的DataSource和可选的MapperLocations(XML文件路径)。这样,不同包下的Mapper就自然关联到了不同的数据库连接。

对于dev数据源,创建另一个配置类DevDataSourceConfig.java,内容几乎一样,只需将所有的local替换为dev,并且不要在devDataSource上添加@Primary注解(除非你想让它成为默认数据源)。

3.2 目录结构规划:让代码井井有条

清晰的目录结构能极大避免混乱。我推荐这样组织你的项目:

src/main/java/com/yourpackage/
├── MultiDataSourceApplication.java
├── config/
│   ├── LocalDataSourceConfig.java
│   └── DevDataSourceConfig.java
├── mapper/
│   ├── local/          # 对应local数据源的Mapper接口
│   │   └── LocalTestMapper.java
│   └── dev/           # 对应dev数据源的Mapper接口
│       └── DevTestMapper.java
├── entity/            # 实体类,如果两边表结构一样可以共用
│   └── TestEntity.java
└── service/           # 业务服务层
    └── DataSyncService.java

src/main/resources/
├── application.yml
└── mapper/            # MyBatis XML文件(如果使用)
    ├── local/
    │   └── LocalTestMapper.xml
    └── dev/
        └── DevTestMapper.xml

把不同数据源的Mapper接口和XML文件(如果用的话)分开放到不同的子包下,这与配置类中的@MapperScan设置完全对应,一目了然。

4. 实战演练:实现跨库数据同步

环境搭好了,配置也清楚了,是时候干点“实事”了。我们来实现一个最常见的场景:从dev数据库的source_table表读取数据,经过一些简单的处理(比如字段映射、逻辑判断),然后写入到local数据库的target_table表中。

4.1 定义Mapper:各为其主

首先,定义两个Mapper接口,它们分别位于被@MapperScan扫描的对应包下。

DevTestMapper.java (在 mapper.dev 包下)

package com.yourpackage.mapper.dev;

import com.yourpackage.entity.TestEntity;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;
import java.util.List;

@Mapper // 这个注解可加可不加,因为@MapperScan已经扫描了这个包
public interface DevTestMapper {
    /**
     * 从dev数据源查询数据
     */
    @Select("SELECT id, name, create_time FROM source_table WHERE status = 1")
    List<TestEntity> selectActiveData();
}

LocalTestMapper.java (在 mapper.local 包下)

package com.yourpackage.mapper.local;

import com.yourpackage.entity.TestEntity;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface LocalTestMapper {
    /**
     * 向local数据源插入数据
     * 注意:这里假设target_table表有 id, name, sync_time 字段
     * 我们演示一个简单的字段映射:source的create_time -> target的sync_time
     */
    @Insert("INSERT INTO target_table(name, sync_time) VALUES (#{name}, #{createTime})")
    int insertData(TestEntity entity);
}

TestEntity.java

package com.yourpackage.entity;

import lombok.Data;
import java.time.LocalDateTime;

@Data // Lombok注解,自动生成getter, setter等
public class TestEntity {
    private Long id;
    private String name;
    private LocalDateTime createTime;
    // 可以包含其他字段...
}

注意,两个Mapper接口因为被不同的SqlSessionFactory管理,所以它们会自然而然地使用各自配置的数据源。你不需要在代码里做任何切换数据源的操作,这是配置阶段就决定好的。

4.2 编写服务层:串联业务流程

现在,我们在服务层注入这两个Mapper,并编写同步逻辑。

DataSyncService.java

package com.yourpackage.service;

import com.yourpackage.entity.TestEntity;
import com.yourpackage.mapper.dev.DevTestMapper;
import com.yourpackage.mapper.local.LocalTestMapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

@Service
@Slf4j // Lombok的日志注解
public class DataSyncService {

    @Autowired
    private DevTestMapper devTestMapper; // 操作dev库

    @Autowired
    private LocalTestMapper localTestMapper; // 操作local库

    /**
     * 简单的跨库数据同步方法
     * 从dev库读,写入local库
     */
    @Transactional // 注意事务管理器,见下文分析
    public void syncDataFromDevToLocal() {
        log.info("开始从DEV库同步数据到LOCAL库...");
        // 1. 从dev数据源查询
        List<TestEntity> dataList = devTestMapper.selectActiveData();
        if (dataList.isEmpty()) {
            log.info("未查询到待同步数据。");
            return;
        }
        log.info("查询到 {} 条待同步数据。", dataList.size());

        int successCount = 0;
        // 2. 遍历并写入local数据源
        for (TestEntity entity : dataList) {
            try {
                int rows = localTestMapper.insertData(entity);
                if (rows > 0) {
                    successCount++;
                    // 这里可以添加更复杂的业务逻辑,比如数据转换、校验等
                    log.debug("成功同步数据: ID={}, Name={}", entity.getId(), entity.getName());
                }
            } catch (Exception e) {
                // 处理单条插入失败,可以根据业务决定是记录日志继续,还是抛出异常回滚
                log.error("同步数据失败: {}", entity, e);
                // 如果希望单条失败不影响整体,可以 continue
                // 如果希望任意失败则整体回滚,可以 throw e;
            }
        }
        log.info("数据同步完成。总计处理 {} 条,成功 {} 条。", dataList.size(), successCount);
    }
}

4.3 事务管理的坑与解决之道

上面代码中的@Transactional注解,在单数据源时工作得很好。但在多数据源环境下,它默认使用那个被标记为@Primary的数据源所对应的事务管理器。这意味着,如果localDataSource是@Primary,那么@Transactional只会管理localTestMapper.insertData操作的事务,而devTestMapper.selectActiveData的查询并不在一个事务里(不过查询通常也不需要事务)。

问题来了:如果我们希望dev的查询和local的写入作为一个分布式事务(要么都成功,要么都失败),默认的@Transactional是做不到的。这是一个典型的分布式事务问题。

对于跨库数据同步这种场景,我的实战经验是,根据业务对一致性的要求,采取不同策略:

  1. 最终一致性(推荐):大多数同步场景,如日志同步、数据备份、非核心数据迁移,并不需要强一致性。我们可以去掉方法上的@Transactional,采用“记录错误+重试+补偿”的机制。就像上面代码里的try-catch,单条失败记录日志,继续同步下一条。然后通过定时任务重新处理失败的数据。这种方式性能好,实现简单。
  2. 强一致性(复杂):如果业务要求极高,比如金融转账涉及两个独立数据库,就必须引入分布式事务解决方案。例如:
    • Seata (AT模式):阿里开源的分布式事务框架,对代码侵入小,但需要部署额外的TC(事务协调器)服务。
    • XA协议:使用支持XA的数据库驱动和JTA(Java Transaction API)管理器。配置复杂,性能较差,通常不推荐。
    • 最大努力通知型:基于可靠消息队列(如RocketMQ的事务消息),保证本地事务和消息发送的最终一致性。

在单纯的SpringBoot多数据源项目中,我强烈建议你先采用最终一致性方案。它足够应对90%的跨库同步场景。当你真的需要强一致性时,再去调研和引入Seata这类框架,那将是另一个层面的架构设计了。

4.4 运行与测试

最后,我们写个测试类或者一个简单的Controller来触发这个同步任务。

MultiDataSourceApplicationTests.java

import com.yourpackage.service.DataSyncService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class MultiDataSourceApplicationTests {

    @Autowired
    private DataSyncService dataSyncService;

    @Test
    void testCrossDatabaseSync() {
        dataSyncService.syncDataFromDevToLocal();
        // 你可以在这里添加断言,查询local库的数据来验证同步结果
    }
}

运行这个测试方法。如果一切配置正确,你会在控制台看到日志输出,并且能在local数据库的target_table表中找到从dev库同步过来的数据。

5. 进阶:动态数据源与更多实战场景

基础的双数据源固定配置已经掌握了,但在更复杂的生产环境中,数据源的选择可能不是写死在代码里的。比如在多租户系统中,租户的数据库连接信息是动态从配置中心获取的;或者在读写分离场景下,需要在运行时根据SQL是读还是写来动态切换数据源。这就需要动态数据源技术。

5.1 动态数据源路由原理

动态数据源的核心是抽象路由。我们不再直接注入固定的DataSource,而是注入一个AbstractRoutingDataSource。这个类持有一个“目标数据源”的映射表(Map),并提供了一个determineCurrentLookupKey()方法。每次执行数据库操作前,Spring都会调用这个方法,获取一个“查找键”(比如local或dev),然后根据这个键去映射表里找到对应的真实DataSource来使用。

那么,如何设置这个“查找键”呢?通常的做法是使用ThreadLocal。ThreadLocal可以为每个线程单独保存一个变量副本。我们在执行DAO方法前,将当前线程要使用的数据源标识(如dev)存入ThreadLocal,然后在determineCurrentLookupKey()方法中取出这个标识返回即可。

5.2 实现一个简单的动态数据源

这里给出一个高度简化的实现思路,让你感受一下其脉络:

  1. 定义数据源上下文持有者:使用ThreadLocal存储数据源键。

    public class DynamicDataSourceContextHolder {
        private static final ThreadLocal<String> CONTEXT_HOLDER = new ThreadLocal<>();
    
        public static void setDataSourceKey(String key) {
            CONTEXT_HOLDER.set(key);
        }
    
        public static String getDataSourceKey() {
            return CONTEXT_HOLDER.get();
        }
    
        public static void clearDataSourceKey() {
            CONTEXT_HOLDER.remove();
        }
    }
    
  2. 继承AbstractRoutingDataSource:

    @Configuration
    public class DynamicDataSourceConfig {
        @Bean
        @Primary // 动态数据源作为主数据源
        public DataSource dynamicDataSource(
                @Qualifier("localDataSource") DataSource localDataSource,
                @Qualifier("devDataSource") DataSource devDataSource) {
            Map<Object, Object> targetDataSources = new HashMap<>();
            targetDataSources.put("local", localDataSource);
            targetDataSources.put("dev", devDataSource);
    
            DynamicRoutingDataSource routingDataSource = new DynamicRoutingDataSource();
            routingDataSource.setDefaultTargetDataSource(localDataSource); // 设置默认数据源
            routingDataSource.setTargetDataSources(targetDataSources);
            return routingDataSource;
        }
    
        static class DynamicRoutingDataSource extends AbstractRoutingDataSource {
            @Override
            protected Object determineCurrentLookupKey() {
                // 关键:从这里获取当前线程指定的数据源键
                return DynamicDataSourceContextHolder.getDataSourceKey();
            }
        }
    }
    
  3. 使用AOP或自定义注解切换数据源:你可以定义一个注解,如@DataSource("dev"),然后通过Spring AOP,在方法执行前,根据注解值调用DynamicDataSourceContextHolder.setDataSourceKey(...),方法执行后清理ThreadLocal。

这样,你的Service方法就可以通过注解来灵活指定使用哪个数据源了。当然,一个成熟的动态数据源方案还需要考虑事务传播、连接池管理、失败回退等很多细节,通常会直接使用成熟的开源组件,比如MyBatis-Plus的多数据源模块。

5.3 使用MyBatis-Plus简化多数据源配置

如果你觉得上面的原生配置和动态数据源实现太繁琐,强烈推荐使用MyBatis-Plus (MP)。它对多数据源的支持非常优雅,几乎可以做到“开箱即用”。

  1. 添加依赖:

    <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>dynamic-datasource-spring-boot-starter</artifactId>
        <version>3.6.1</version> <!-- 使用最新稳定版 -->
    </dependency>
    
  2. 简化配置:

    spring:
      datasource:
        dynamic:
          primary: local # 设置默认数据源
          strict: false # 是否严格匹配数据源,默认false
          datasource:
            local:
              url: jdbc:mysql://localhost:3306/local_db?...
              username: root
              password: ...
              driver-class-name: com.mysql.cj.jdbc.Driver
            dev:
              url: jdbc:mysql://192.168.1.100:3306/dev_db?...
              username: dev_user
              password: ...
              driver-class-name: com.mysql.cj.jdbc.Driver
    
  3. 使用注解切换:在Service方法或Mapper接口上使用@DS("dev")注解,即可切换到dev数据源。MP会自动处理路由和ThreadLocal的清理,无需你手动编写任何配置类。

    @Service
    public class SomeService {
        @DS("dev") // 指定使用dev数据源
        public List<User> getUsersFromDev() {
            return userMapper.selectList(null);
        }
    
        @DS("local") // 指定使用local数据源
        public void saveToLocal(User user) {
            userMapper.insert(user);
        }
    }
    

MyBatis-Plus的动态数据源功能极大地降低了多数据源的使用门槛,是我在快速开发项目时的首选方案。

6. 避坑指南与性能优化

配置和使用多数据源的过程中,我踩过不少坑,这里分享几个最常见的,帮你提前绕过去。

坑1:启动报错 Consider marking one of the beans as @Primary 这是最经典的错误。根本原因是Spring容器里存在多个同类型(DataSource或SqlSessionFactory)的Bean,而某些地方(比如事务管理器、JdbcTemplate自动配置)需要自动注入一个,它不知道选哪个。解决方案:确保在你的多个数据源配置类中,有且仅有一个DataSource Bean被标记为@Primary。通常选择你最常用的那个。

坑2:Mapper扫描冲突或找不到 症状是启动时报“找不到Mapper”或者“Bean创建失败”。原因:@MapperScan注解配置错误,导致多个SqlSessionFactory都去扫描了同一个包,或者该包的Mapper没有被任何SqlSessionFactory扫描到。解决方案:严格按照我们之前的配置,确保每个@MapperScan的basePackages指向不同的、独立的包路径,并且sqlSessionFactoryRef指向正确的工厂Bean名字。

坑3:事务不生效或混乱 如前所述,多数据源下默认的@Transactional只对@Primary数据源生效。如果你在非主数据源的操作上加了@Transactional,事务可能不会按你预期回滚。解决方案:对于需要跨多个非主数据源的事务,考虑使用最终一致性方案或引入Seata。如果只是单个非主数据源需要事务,可以为该数据源单独配置一个DataSourceTransactionManager,然后在@Transactional注解中指定使用哪个事务管理器(transactionManager = "devTransactionManager")。

坑4:连接池配置不当导致性能问题 为每个数据源都配置了连接池,但参数不合理。比如max-active(最大连接数)设置过大,可能导致数据库连接耗尽;设置过小,则在高并发时排队等待。优化建议:

  • 根据数据库服务器的性能和业务并发量,合理设置max-active、min-idle、max-wait等参数。
  • 为不同重要性的数据源设置不同的连接池参数。核心业务库可以给更多连接,分析型日志库可以少一些。
  • 启用Druid的监控功能(stat-view-servlet),定期观察连接池的使用情况,如活跃连接数、等待次数等,进行动态调整。

坑5:忽视连接泄露 在复杂的业务逻辑或异常处理中,如果数据库连接没有正确关闭,会导致连接泄露,最终连接池被占满,服务不可用。解决方案:

  • 确保使用MyBatis时,SqlSession被正确关闭(通常框架会自动处理)。
  • 使用Druid连接池,并开启remove-abandoned等泄露检测功能。
  • 在代码中,对于手动获取的Connection,务必在finally块中关闭。

多数据源配置是项目架构中一个非常实用的技能点,从简单的双库同步到复杂的动态路由,其核心思想都是对数据库连接进行精细化管理。理解其原理,掌握至少一种实现方式,并能规避常见陷阱,你的后端技术工具箱里就又多了一件趁手的兵器。记住,技术选型没有绝对的好坏,适合业务场景、团队能力和维护成本的,才是最好的。先从简单的静态多数据源开始,随着业务复杂度的提升,再逐步演进到动态数据源或引入分布式事务框架,这才是稳健的架构演进之路。

Springboot+Mybatis+通用Mapper多数据源实现数据同步 有个需求需要查询远程数据库,然后将远程数据库中的数据抓取到本地,远程数据库中的数据是每天都增加的,所以就需要写个程序自动实现实时抓取。 这里我用到的框架是Springboot2.0+Mybatis+Mapper,涉及的数据库有SqlServer,Oracle,Mysql 添加依赖 &lt;dependencies&gt; &lt;dependency&gt; ... 阅读详情

相关推荐

MyBatis整合Springboot多数据源实现

数据源,实际就是数据库连接池,负责管理数据库连接,在Springboot中,数据源通常以一个bean的形式存在于IOC容器中,也就是我们可以通过依赖注入的方式拿到数据源,然后再从数据源中获取数据库连接。那么什么是多数据源呢,其实就是IOC容器中有多个数据源的bean,这些数据源可以是不同的数据源类型,也可以连接不同的数据库。本文将对多数据如何加载,如何结合MyBatis使用进行说明,知识点脑图如下所示。数据源,其实就是数据库连接池,负责数据库连接的管理和借出。目前使用较多也是性能较优的有如下几款数据源。

m0_71777195的博客 2303

SpringBoot+Mybatis配置多数据源并且实现事务一致性

最近博客写得少,不知道怎么说开场白了。呃,本文一共分三部分:SpringBoot+Mybatis环境搭建、两种方式配置多数据源、两种方式实现跨数据源事务,您可以直接跳到喜欢的部分,不过按顺序看完也不会花很多时间。。。 一、搭建SpringBoot+Mybatis框架环境 看标题就知道,这部分不是重点,所以简单说一下(如果你是小白那对不起了~)。 1、引入依赖 Mybatis整合包和jdbc...

周先生丶的博客 1万+

MyBatis-Flex多数据源实战:SpringBoot3中实现跨库查询与事务管理

本文详细介绍了在SpringBoot3中使用MyBatis-Flex实现多数据源管理的实战方案,包括跨库查询与事务管理的最佳实践。通过注解驱动的方式简化配置,结合具体代码示例展示如何实现动态数据源切换、跨库查询以及分布式事务集成,帮助开发者高效处理多数据库操作场景。

weixin_29251567的博客 377

SpringBoot 多数据源配置(读写分离基础)

掌握这一套,你就理解了读写分离的底层原理,再去用 Sharding-JDBC、dynamic-datasource 这类框架会非常轻松。:主库、从库读,减轻单库压力。随着项目变大,单数据扛不住压力很常见的事,这时候一般会先做。这样不同包下的 Mapper 会自动走不同数据源,实现。5. 事务注意:多数据源下跨库事务需要额外处理。• 主库写入、从库读取(读写分离基础版)五、手动配置主数据源(Master)六、手动配置从数据源(Slave)七、项目结构划分(按包区分数据源)

。。。 959

SpringBoot+Mybatis-plus多数据源实战:跨库操作避坑指南

本文详细介绍了SpringBoot与Mybatis-plus结合实现多数据源管理的实战指南,涵盖基础配置、动态数据源切换、事务管理及性能优化等关键点。特别针对跨库操作中的常见陷阱提供了解决方案,帮助开发者高效处理多数据库场景下的技术挑战。

weixin_29210727的博客 123

Python爬取拼多多商品数据保姆级教程(附源码及效果图)

本文介绍了使用Python爬取拼多多商品数据的完整教程。通过DrissionPage库模拟浏览器操作,利用正则表达式提取嵌入在HTML中的商品数据(关键步骤是从window.rawData变量获取),解析后转换为结构化数据并导出Excel。教程包含八大步骤:环境配置、浏览器初始化、网络监听、搜索模拟、数据提取(核心是正则匹配JSON)、数据验证、字段解析和Excel导出,最后提供了封装好的函数可直接调用。该方法特别适合课程作业或毕业设计获取电商数据,能爬取商品名称、价格、销量等关键信息,处理了价格单位转换等

weixin_46449236的博客 2086

SpringBoot集成MyBatis plus 多数据源实现【附源码】

最近写文章发布到【笑小枫】小程序和个人网站上,因为个人网站用的是halo框架搭建,两边数据结构不一致,导致我每次维护文章都需要两边维护,这就很烦~ 于是,本文就诞生了。通过项目连接这两个数据库,我在维护文章的时候,同时同步下个人网站的博客。

笑小枫 1487

AD9026芯片开发实战指南:从硬件配置到射频校准

本文为AD9026芯片开发实战指南,详细解析了从硬件设计、电源时钟配置、SPI初始化到多芯片同步与JESD204高速链路建立的完整流程。重点探讨了射频校准技术,包括初始化校准与跟踪校准,以保障5G、MIMO等现代通信系统所需的射频性能。旨在帮助开发者系统掌握这颗高性能射频收发器的应用,规避常见设计陷阱。

tomato的博客 854

SpringBoot+MyBatisPlus多数据源实战:MySQL与SqlServer无缝切换方案

在复杂业务系统中,数据分散存储是常态,如何在不迁移数据的前提下统一访问多个数据库,成为架构设计中的关键问题。多数据源技术通过动态路由机制,让应用能够根据业务场景灵活切换底层数据库连接,在读写分离、跨库联查等场景中发挥着核心作用。本文从数据源抽象原理出发,深入剖析AbstractRoutingDataSource与ThreadLocal的协作机制,并基于dynamic-datasource组件结合MyBatisPlus展示一套完整的MySQL与SqlServer共存方案。针对实践中最常遇到的MyBatisPl

weixin_28702105的博客 205

DIY音频必备:手把手教你用AB类功放模块打造高保真桌面音响(含电路图)

本文详细指导如何利用AB类功放模块DIY高保真桌面音响,涵盖选型指南、核心元器件清单、电路搭建与焊接工艺,以及系统调试与音质优化技巧。AB类功放以其接近A类功放的音质和B类功放的效率,成为音频爱好者的理想选择,适合有一定电子基础的实践者。

weixin_42665725的博客 447

从FinFET到NanoSheet:一文看懂TSMC制程技术的架构革命与性能飞跃

本文深入解析了TSMC从FinFET到NanoSheet的制程技术架构革命。FinFET通过三维立体结构解决了短沟道效应,而NanoSheet采用环绕栅极设计,实现了更强的静电控制与设计灵活性,结合EUV光刻技术,共同推动了芯片性能与能效的飞跃,为下一代AI与高性能计算奠定基石。

i3j4k5的博客 292

【实战】SpringBoot整合多数据源

项目多数据源业务场景在开发中时常会出现,本文通过实战的方式,介绍SpringBoot结合Mybatis和Mybatis-plus实现多数据源整合应用。

1万+

NE564锁相环FM解调电路设计:10.7MHz中频实测与3种失真优化方案

本文详细解析了NE564锁相环在10.7MHz中频FM解调电路中的设计与优化方案。通过分析锁相环技术基础、电路架构设计及典型失真问题,提供了3种有效的失真优化方法,包括限幅增强、VCO频偏补偿和环路滤波优化,显著提升解调性能。文章还涵盖了PCB布局要点和系统测试验证,为高频电子线路设计提供实用参考。

weixin_33314040的博客 350

实战指南,SpringBoot + Mybatis 如何对接多数据源

在我们开发一些具有综合功能的项目时,往往会碰到一种情况,需要同时连接多个数据库,这个时候就需要用到多数据源的设计。而Spring 与 Myabtis 其实做了多数据源的适配,只需少许改动即可对接多数据源。本期我们就贴近实战,以一个单数据源的Demo为例,讲述将其改为多数据源项目的过程,希望大家能有所体会`

战斧的博客 1万+

车载毫米波雷达实战:用MATLAB复现DDMA-MIMO雷达的Empty-band算法(附代码解析)

本文详细介绍了车载毫米波雷达中DDMA-MIMO技术的实战应用,重点解析了Empty-band算法的原理与MATLAB实现。通过搭建仿真环境,文章深入探讨了发射天线通道解调与相位法速度解模糊两大核心难题的解决方案,并提供了完整的代码解析,为雷达算法工程师提供了从理论到实践的清晰指南。

hill8的博客 565

YOLOv8【第四章:注意力机制篇·第20节】一文讲透,注意力机制设计原则与选择指南 - 从原理到实践的系统化方法论!

🏆 本文收录于 《YOLOv8实战:从入门到深度优化》,该专栏持续复现网络上各种热门内容(全网YOLO改进最全最新的专栏,质量分97分+,全网顶流),改进内容支持(分类、检测、分割、追踪、关键点、OBB检测)。且专栏会随订阅人数上升而涨价(毕竟不断更新),当前性价比极高,有一定的参考&学习价值,部分内容会基于现有的国内外顶尖人工智能AIGC等AI大模型技术总结改进而来,嘎嘎硬核。    ✨ 特惠福利:目前活动一折秒杀价!一次订阅,永久免费,所有后续更新内容均免费阅读!

**My Coding Family** 900

SpringBoot整合Mybatis-plus(二) 多数据源Druid监控,Atomikos处理事务,跨库连表查询

因为很多时候,在开发中,并不会只有一个数据库,在保存一条数据的时候,可能需要向几个数据库保存,那么当发生异常时候,就会面临事务问题了,需要将保存的数据进行回滚,所以,本文开始讲解,整合 Mp 多数据源下的druid监控以及事务处理

胖虎儿的博客 8340

DiffusionDriveV2 (1) : 端到端自动驾驶中受强化学习约束的截断扩散建模

DiffusionDriveV2:强化学习约束的截断扩散模型在端到端自动驾驶中的应用 本文针对端到端自动驾驶中扩散模型面临的模式崩溃问题,提出DiffusionDriveV2框架。该方法通过引入强化学习约束,解决了DiffusionDrive依赖模仿学习导致的多样性与持续高质量之间的困境。主要创新包括: 采用尺度自适应乘法噪声促进广泛探索 提出锚点内GRPO管理单个锚点样本间的优势估计 设计锚点间截断GRPO整合全局视角,避免不同驾驶意图间的不当比较 实验表明,该方法在NAVSIM基准测试中达到最先进水平(

@bangbang的博客 382

springboot整合mybatis进行跨库查询

业务场景: 当一个公司大了之后就会将各种业务进行分开,最简单的就是例如:公司的机构表,那么就会将他们分成开来,那么就会在一个实例中, 如果要获取相关信息就会去关联这张表进行关联查询 从而导致了跨库关联多表查询: 首先看sql: select f.id as id, m.name as name from fr_db.person...

maxchenBug的博客 9149

贝叶斯统计 [韦来生编]

贝叶斯(Bayes)统计是近几十年来迅速发展起来的数理统计的一个重要分支。贝叶斯方法与经典统计方法的主要不同之处是进行统计推断时除了利用样本信息外,还要利用参数的先验信息,因此可以提高统计推断或统计决策的效果。它在经济、金融、生物、医学、自然科学和社会科学等许多领域具有广泛的应用。贝叶斯方法的研究已渗透到了统计学的几乎所有领域。作者在给中国科学技术大学概率论与数理统计专业本科生开设的“数理统计”课程中有一章专门讲授“贝叶斯方法和统计决策理论”,近十年来也给中国科学技术大学概率统计专业研究生开设过几次“贝叶斯分析”课。本书是在对过去讲稿的内容作了适当的增减和调整的基础上完成的。  本书共分六章。第1章是绪论,介绍了贝叶斯统计的若干基本概念,同时对必要的数理统计的基础知识有重点地作了回顾。第二章介绍了确定先验分布的若干可供选择的方法。第三章介绍了几类常见统计模型参数的后验分布的主要结果和计算方法。第四章和第五章分别介绍了“贝叶斯统计推断”和“贝叶斯统计决策”的内容。第六章介绍了贝叶斯统计计算的若干方法,包括蒙特卡洛方法和马尔可夫链蒙特卡洛(MCMC)方法以及相关统计软件的简介。本书的每一章附右大量的例题和习题,书末附有常用的几个表格和部分习题解答供读者查用。  大约可在54学时内讲授本书的第1章至第六章的主要内容,教师可根据学时需要选讲本书第1章至第六章的部分内容。书中标“*”号的章节可略去不讲,留给读者作为阅读材料。第六章例题中的R代码和部分例题的数据文件等可从作者个人主页下载。  作者在编写本书的过程中参考了J.O.Berger教授的《统计决策论及贝叶斯分析》和茆诗松教授编写的《贝叶斯统计》等书中的一些内容,以及《贝叶斯分析》一书中由张伟平博士编写的有关贝叶斯统计计算的一些内容。在此表示衷心感谢。  本书编写准备过程中,中国科学技术大学统计与金融系的几个研究生帮助完成了本书部分中文的录入和排版,作者对他们的辛勤工作表示真诚的感谢。高等教育出版社为本书的出版给予了大力支持。在此一并致谢。

WINCC7.3破解文件

WINCC7.3硬件够破解文件,有需要的下载!WINCC7.3硬件够破解文件,有需要的下载!

springboot整合mybatis跨库操作、配置多个数据源DataSource

声明,使用JDK8、idea、lombok、springboot2.0进行测试: 》 》 1、mybatis多数据源的使用场景: 操作同一台服务器上不同的数据库,或者多地机器上的相同或不相同数据库。 进行跨库操作、多数据源进行分离数据; 使得程序得以扩展,当一台或者部分服务器宕机,不影响整个应用的服务; 2、多数据源配置的思路: 数据隔离,把数据分别存放在test、test02这两个数据库...

Syntacticsugar's blog 1万+

SAP B1中文培訓教材_SDK

公司内部培训资料,对开发工具 ,DIAPI, UIAPI,Add-ON有详细解说

MyBatis多数据源全解析:从静态到动态,实战踩坑指南

MyBatis 多数据源是指在一个应用中同时连接并操作多个数据库的技术场景。常见于主从读写分离、分布式系统跨库访问、多租户隔离等业务需求。本文将从核心概念、实现方式、动态切换、事务管理、常见问题等方面详细解析。

weixin_42148384的博客 1594

复分析 阿尔福斯(Ahlfors) 第三版答案 英文

答案分为十章,有部分习题没有答案,全英文复分析阿尔福斯(Ahlfors) 第三版答案

SpringBoot整合Mybatis连接SQLServer实现跨库批量插入:助力高效数据处理

SpringBoot整合Mybatis连接SQLServer实现跨库批量插入:助力高效数据处理 去发现同类优质开源项目:https://gitcode.com/ 在当今大数据时代,数据库操作的高效性至关重要。本文将向您推荐一个开源项目——SpringBoot整合Mybatis连接SQLServer实现跨库批量插入,该项目的核心功能是实现在SpringBoot项目中通过Mybatis框架连接SQLS...

gitblog_06704的博客 644

SpringBoot实现多数据源配置

SpringBoot实现多数据源配置

北执南念的博客 3325
上一篇: SpringBoot与Flink集群集成实战:从本地开发到云端部署
下一篇: 【嵌入式】NTC热敏电阻分段拟合算法在MCU资源优化中的实战解析
python9snake
博客等级 码龄1天 0粉丝 1724原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符  | 博主筛选后可见
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值