SpringBoot多数据源配置 MybatisPlus配置类

已于 2025-07-24 10:39:46 修改
阅读量922 收藏
点赞数
CC 4.0 BY-SA版权
文章标签： spring boot 后端 java
于 2023-08-11 13:56:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/hudeyong926/article/details/132229169
文章介绍了如何在SpringBoot应用中使用Druid数据源连接池实现多数据源的配置，包括手动切换和自动切换方案，以及注意事项，如事务管理和常见问题解决。

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

  Druid 可以说是国内使用最广泛的数据源连接池产品

<dependency>
   <groupId>com.alibaba</groupId>
   <artifactId>druid-spring-boot-starter</artifactId>
   <version>1.1.17</version>
</dependency>

application.yml配置

spring:
  datasource:
    pay:
      username: root
      password: root
      host: 192.168.37.133:3306
      jdbc-url: jdbc:mysql://${spring.datasource.pay.host}/${spring.datasource.pay.schema-name}?useUnicode=true&characterEncoding=utf8&useSSL=false
      schema-name: dlsms
    order:
      username: root
      password: root
      host: 192.168.37.134:3306
      jdbc-url: jdbc:mysql://${spring.datasource.order.host}/${spring.datasource.order.schema-name}?useUnicode=true&characterEncoding=utf8&useSSL=false
      schema-name: dlsms

方案一：手动切换数据源

适合没有分模块的功能，后期又需要加入多数据源

MyBatis-Plus配置类

作用：配置数据源和事务管理

import net.test.project.constants.DataSourceKey;

import com.alibaba.druid.pool.DruidDataSource;
import com.baomidou.mybatisplus.core.MybatisConfiguration;
import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
import com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean;
import java.util.HashMap;
import java.util.Map;
import javax.sql.DataSource;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.type.JdbcType;
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.Resource;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;


@MapperScan({"net.test.project.dao.mapper.*"})
@Configuration
public class DataSourceProxyConfig {

  /**
   * 配置默认数据源
   * @return
   */
  @Bean(name = "originOrder") // 声明其为Bean实例
  @ConfigurationProperties(prefix = "spring.datasource.order")
  public DataSource dataSourceOrder() {
    return new DruidDataSource();
  }

  @Bean(name = "originStorage") // 声明其为Bean实例
  @ConfigurationProperties(prefix = "spring.datasource.storage")
  public DataSource dataSourceStorage() {
    return new DruidDataSource();
  }

  @Bean(name = "originPay") // 声明其为Bean实例
  @ConfigurationProperties(prefix = "spring.datasource.pay")
  public DataSource dataSourcePay() {
    return new DruidDataSource();
  }

  /**
   * 设置多数据源，配置动态路由数据源
   * @return
   */
  @Bean("dynamicDataSource")
  public DataSource dynamicDataSource(@Qualifier("originOrder") DataSource dataSourceOrder,
      @Qualifier("originStorage") DataSource dataSourceStorage,
      @Qualifier("originPay") DataSource dataSourcePay) {
    Map<Object, Object> dataSourceMap = new HashMap<>();
    dataSourceMap.put(DataSourceKey.ORDER.name(), dataSourceOrder);
    dataSourceMap.put(DataSourceKey.STORAGE.name(), dataSourceStorage);
    dataSourceMap.put(DataSourceKey.PAY.name(), dataSourcePay);

    //设置默认
    DynamicDataSource dynamicRoutingDataSource = new DynamicDataSource();
    dynamicRoutingDataSource.setDefaultTargetDataSource(dataSourceOrder);
    dynamicRoutingDataSource.setTargetDataSources(dataSourceMap);

    return dynamicRoutingDataSource;
  }

  /**
   * 设置会话工厂
   *
   * @return
   * @throws Exception
   */
	/*@Bean(name="sqlSessionFactory")
	public SqlSessionFactoryBean sqlSessionFactoryBean(
			@Qualifier("dynamicDataSource") DataSource dataSource) {
		SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
		sqlSessionFactoryBean.setDataSource(dataSource);
		return sqlSessionFactoryBean;
	}*/

  @Bean(name="sqlSessionFactory")
  @Primary
  public SqlSessionFactory mybatisSqlSessionFactoryBean (
      @Qualifier("dynamicDataSource") DataSource dataSource) throws Exception {
    MybatisSqlSessionFactoryBean sqlSessionFactoryBean = new MybatisSqlSessionFactoryBean();
    sqlSessionFactoryBean.setDataSource(dataSource);
    // 设置别名扫描包（实体类所在包）
    sqlSessionFactoryBean.setTypeAliasesPackage("com.test.custom.entity");

    // 设置 Mapper XML 文件位置（与 application.yml 中配置一致）
    PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
    Resource[] mapperLocations = resolver.getResources("classpath*:mapper/*.xml");
    sqlSessionFactoryBean.setMapperLocations(mapperLocations);

    MybatisConfiguration configuration = new MybatisConfiguration();
    configuration.setJdbcTypeForNull(JdbcType.NULL);
    configuration.setMapUnderscoreToCamelCase(true);
    configuration.setCacheEnabled(false);

    sqlSessionFactoryBean.setConfiguration(configuration);
    sqlSessionFactoryBean.setPlugins(mybatisPlusInterceptor());
    return sqlSessionFactoryBean.getObject();
  }

  /**
   * 添加分页插件（可选）
   */
  @Bean
  public MybatisPlusInterceptor mybatisPlusInterceptor() {
    MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
    interceptor.addInnerInterceptor(new PaginationInnerInterceptor());
    return interceptor;
  }

  /**
   * 配置事务管理器
   *
   * @return
   */
  @Bean(name = "transactionManager")
  public PlatformTransactionManager transactionManager(@Qualifier("originOrder") DataSource dataSourceOrder,
      @Qualifier("originStorage") DataSource dataSourceStorage,
      @Qualifier("originPay") DataSource dataSourcePay) {
    return new DataSourceTransactionManager(dynamicDataSource(dataSourceOrder, dataSourceStorage, dataSourcePay));
  }
}

由于是MyBatsi-Plus，所以配的是MybatisSqlSessionFactoryBean，如果是MyBatis，则应该是SqlSessionFactoryBean

实现选择目标数据源

import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;

public class DynamicDataSource extends AbstractRoutingDataSource {
    /**
     * 取得当前使用哪个数据源
     * @return
     */
    @Override
    protected Object determineCurrentLookupKey() {
        log.info("当前数据源 [{}]", DynamicDataSourceContextHolder.getDataSourceType());
        return DynamicDataSourceContextHolder.getDataSourceType();
    }
}

数据源字典

public enum DataSourceKey {

  ORDER("order", "order数据库"),
  // 定义数据源类型为BASIC，表示基础数据库
  STORAGE("storage", "storage数据库"),
  // 定义数据源类型为BILL，表示账单计费数据库
  PAY("pay", "计费数据库"),
  ;

  // 数据源的类型标识
  private String type;
  // 数据源的名称
  private String name;

  /**
   * 构造函数，初始化数据源类型和名称
   *
   * @param type 数据源的类型标识
   * @param name 数据源的名称
   */
  DataSourceKey(String type, String name) {
    this.type = type;
    this.name = name;
  }

  /**
   * 获取数据源的类型标识
   *
   * @return 数据源的类型标识
   */
  public String getType() {
    return type;
  }

  /**
   * 设置数据源的类型标识
   *
   * @param type 数据源的类型标识
   */
  public void setType(String type) {
    this.type = type;
  }

  /**
   * 获取数据源的名称
   *
   * @return 数据源的名称
   */
  public String getName() {
    return name;
  }

  /**
   * 设置数据源的名称
   *
   * @param name 数据源的名称
   */
  public void setName(String name) {
    this.name = name;
  }

  /**
   * 根据类型标识获取对应的枚举值
   *
   * @param type 数据源的类型标识
   * @return 对应类型标识的枚举值，如果找不到匹配的，则返回NULL
   */
  public static DataSourceKey getEnumByType(String type) {
    // 默认返回值为NULL，即无数据源
    DataSourceKey e = NULL;

    // 如果传入的类型不为空，则遍历所有枚举值寻找匹配的类型
    if (type != null) {
      for (DataSourceKey o : values()) {
        // 如果找到匹配的类型，则更新返回值并终止遍历
        if (o.getType().equals(type)) {
          e = o;
          break;
        }
      }
    }

    // 返回找到的枚举值
    return e;
  }

}

切换数据源

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class DynamicDataSourceContextHolder {

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

  private static final ThreadLocal afterContextHolder = new ThreadLocal<>();

  public static void setAfterDbType(DataSourceKey dbTypeEnum) {
    afterContextHolder.set(dbTypeEnum.getType());
  }

  public static String getAfterDbType() {
    return (String) afterContextHolder.get();
  }

  public static void clearAfterDbType() {
    afterContextHolder.remove();
  }

  /**
   * 设置数据源
   *
   * @param dbTypeEnum
   */
  public static void setDataSourceType(DataSourceKey dbTypeEnum) {
    log.info("切换到{}数据源", dbTypeEnum.getName());
    contextHolder.set(dbTypeEnum.getType());
  }

  /**
   * 取得当前数据源
   *
   * @return
   */
  public static String getDataSourceType() {
    return (String) contextHolder.get();
  }

  /**
   * 清除上下文数据
   */
  public static void clearDataSourceType() {
    contextHolder.remove();
  }
}

使用方法：查前选库

DynamicDataSourceContextHolder.setDataSourceType(DataSourceKey.PAY);

多数据源下的事务问题

多数据源下使用事务时，需要在注解上明确是哪个数据源，类似下面这样，否则会报找不到事务管理实例的错误。

@Transactional(value = "transactionManager",rollbackFor = Exception.class)

方案二：

自动数据源切换

组织两个配置类。原理：mybatis多数据源的原理是根据不同包，调用不同的数据源，你只需要把你的mapper.java和mapper.xml写在某个package中，springboot自动帮你实现数据源切换。注意第二个配置类不需要@Primary

  • @MapperScan注解中的basePackages指向的是指定的Dao层。
  • @MapperScan注解中sqlSessionFactoryRef 用来指定使用某个SqlSessionFactory来操作数据源。
  • setMapperLocations指向的是操作执行数据库的Mapper层。
import com.alibaba.druid.pool.DruidDataSource;
import com.baomidou.mybatisplus.core.MybatisConfiguration;
import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
import com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean;
import javax.sql.DataSource;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.type.JdbcType;
import org.mybatis.spring.SqlSessionTemplate;
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 org.springframework.jdbc.datasource.DataSourceTransactionManager;

@Configuration
@MapperScan(basePackages = "com.example.dao.crm", sqlSessionTemplateRef = "crmSqlSessionTemplate")
public class CrmDataSourceConfig {

  @Bean(name = "crmDataSource")
  @ConfigurationProperties(prefix = "spring.datasource.crm")
  public DataSource crmDataSourceConfig() {
    return new DruidDataSource();
  }


  @Bean(name = "crmSqlSessionFactory")
  @Primary
  public SqlSessionFactory crmSqlSessionFactory(@Qualifier("crmDataSource") DataSource dataSource) throws Exception {
    MybatisSqlSessionFactoryBean sqlSessionFactory = new MybatisSqlSessionFactoryBean();
    sqlSessionFactory.setDataSource(dataSource);
    sqlSessionFactory.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath*:mapper/crm/*.xml"));

    MybatisConfiguration configuration = new MybatisConfiguration();
    configuration.setJdbcTypeForNull(JdbcType.NULL);
    configuration.setMapUnderscoreToCamelCase(true);
    configuration.setCacheEnabled(false);
    sqlSessionFactory.setConfiguration(configuration);
    sqlSessionFactory.setPlugins(mybatisPlusInterceptor());
    
    return sqlSessionFactory.getObject();
  }
  
  /**
   * 添加分页插件（可选）
   */
  @Bean
  public MybatisPlusInterceptor mybatisPlusInterceptor() {
    MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
    interceptor.addInnerInterceptor(new PaginationInnerInterceptor());
    return interceptor;
  }
  
  @Bean(name = "crmTransactionManager")
  @Primary
  public DataSourceTransactionManager crmTransactionManager(@Qualifier("crmDataSource") DataSource dataSource) {
    return new DataSourceTransactionManager(dataSource);
  }

  @Bean(name = "crmSqlSessionTemplate")
  @Primary
  public SqlSessionTemplate crmSqlSessionTemplate(@Qualifier("crmSqlSessionFactory") SqlSessionFactory sqlSessionFactory) {
    return new SqlSessionTemplate(sqlSessionFactory);
  }
}

切面自动切换

通过切面的包路径配置实现

import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

@Component
@Aspect
@Order(-10000) // 这是为了保证AOP在事务注解之前生效,Order的值越小,优先级越高
@Slf4j
public class DataSourceSwitchAspect {

  @Pointcut("execution(* net.est.test.api.service.order..*.*(..))")
  private void db3Aspect() {
  }


  @Pointcut("execution(* net.est.test.api.service.pay..*.*(..))\"")
  private void db5Aspect() {
  }


  @Before("db3Aspect()")
  public void rpt() {
    final String afterDbType = DynamicDataSourceContextHolder.getDataSourceType();
    final DataSourceKey afterDB = DataSourceKey.getEnumByType(afterDbType);
    DynamicDataSourceContextHolder.setAfterDbType(afterDB);
    log.debug("切换到{}数据源...", DataSourceKey.ORDER.name());
    DynamicDataSourceContextHolder.setDataSourceType(DataSourceKey.ORDER);
  }

  @Before("db5Aspect()")
  public void smsConfig() {
    final String afterDbType = DynamicDataSourceContextHolder.getDataSourceType();
    final DataSourceKey afterDB = DataSourceKey.getEnumByType(afterDbType);
    DynamicDataSourceContextHolder.setAfterDbType(afterDB);
    log.debug("切换到{}数据源...", DataSourceKey.PAY.name());
    DynamicDataSourceContextHolder.setDataSourceType(DataSourceKey.PAY);
  }

  @After("db3Aspect()||db5Aspect()")
  public void back() {
    final String afterDbType = DynamicDataSourceContextHolder.getAfterDbType();
    log.debug("切回到{}数据源...", afterDbType);
    if (StringUtils.isEmpty(afterDbType)) {
      DynamicDataSourceContextHolder.setDataSourceType(DataSourceKey.PAY);
    } else {
      final DataSourceKey afterByType = DataSourceKey.getEnumByType(afterDbType);
      DynamicDataSourceContextHolder.setDataSourceType(afterByType);
    }
  }
}

定义了一个基于 AOP 的数据源切换切面类 DataSourceSwitchAspect，该切面用于实现动态数据源切换，支持在不同业务模块访问不同数据库。其功能如下：
定义切点：分别针对 order 和 pay 包下的方法定义切点 db3Aspect 和 db5Aspect。
前置通知：

  • 在执行 order 包方法前，将数据源切换为 ORDER。
  • 在执行 pay 包方法前，将数据源切换为 PAY。

后置通知：在目标方法执行结束后，将数据源恢复为之前的状态。

以上两种方法都是通过不同的包来自动自动切换数据源

常见问题

druid抛出异常：javax.management.InstanceAlreadyExistsException: com.alibaba.druid:type=DruidDataSource,id=xxx

同一个domain里面的MBean要求name唯一，检查SpringBoot应用的application.properties等配置文件name配置

@航空母舰
关注
【SpringBoot笔记44】SpringBoot多数据源配置（方式一：配置多个mapper扫描不同的包路径实现多数据源配置）
✅ Java 开发工程师，从事 Web 应用程序的研发，擅长 Spring、SpringBoot 等技术。 ✅ 热爱编程，业余时间学习新知识，通过 优快云 记录学习心得和笔记内容。
05-28 747
在SpringBoot应用开发中，一般情况下，都是只会配置一个数据源信息，之后整个工程都是对当前数据源进行增删改查的操作。但是，在实际开发里面，也有可能会遇到多数据源的情况，例如：当前工程中除了需要访问自己应用的数据库，还需要直接连接第三方系统的数据库进行业务处理，这种情况下，就需要进行多数据源的配置。SpringBoot考虑到了这一点，所以它是支持多数据源的配置的，下面介绍一下如何配置多数据源。
SpringBoot3.x+MyBatisPlus+druid多数据源配置
D_J_Dragon的博客
09-03 3027
本章主要介绍SpringBoot3.x多数据源配置，以及在此基础上配置分页拦截，自动填充功等功能，源码链接在文章最后。下面列出几个重要文件进行介绍。
springboot多数据源配置
07-28
springboot多数据源配置
Spring Boot 多数据源配置
最新发布
mf97532的博客
06-26 350
这样写看起来确实有些麻烦，通常可能不会像这样在一个方法里操作多个数据库，就比如说假设这是一个管理后台，为了图省事把所有业务都写在这一个项目里，这个时候就需要配置多个数据源，各个数据库的业务互相没有关联，只是写在同一个项目中而已，这样的话如果每次都手动设置数据源太麻烦，可以定义一个AOP切面来自动切换数据源。由于是MyBatsi-Plus，所以配的是MybatisSqlSessionFactoryBean，如果是MyBatis，则应该是SqlSessionFactoryBean。2、定义切面、切点、通知。
SpringBoot多数据源配置
热门推荐
xugehahaha的博客
07-16 1万+
在日常开发过程中，使用多个数据源已经成为一种常见需求。本文将详细介绍如何在SpringBoot项目中配置和使用多数据源，包括静态配置和动态配置两种方式，从而实现不同数据源的动态切换，以及在实际项目中进行使用并验证。
Spring Boot配置多个DataSource
jaesonchen
04-29 640
使用Spring Boot时，默认情况下，配置DataSource非常容易。Spring Boot会自动为我们配置好一个DataSource。 如果在application.yml中指定了spring.datasource的相关配置，Spring Boot就会使用该配置创建一个DataSource。如果在application.yml中没有指定任何spring.datasource的相关配置，...
springboot切换多数据源 mybatisPlus
10-17
3. MybatisPlus配置：MybatisPlus是Mybatis的增强工具，在多数据源配置中，MybatisPlus的配置与Mybatis类似。需要为每个数据源分别配置SqlSessionFactory、SqlSessionTemplate以及Mapper接口的扫描路径。 4. 多数据...
SpringBoot3 整合JavaFx + MyBatisPlus
09-10
接着，需要集成MyBatisPlus，配置数据源、整合MyBatisPlus到Spring Boot应用中，通过配置文件或者Java配置类设置相应的数据访问层组件。最后，开发者需要根据业务需求，编写JavaFx前端界面代码和MyBatisPlus后端业务...
SpringBoot多数据源配置（方式一：配置多个mapper扫描不同的包路径实现多数据源配置）.docx
05-21
在这个配置类中，我们创建了一个`DynamicRoutingDataSource` Bean来动态切换数据源。此外，还配置了`SqlSessionFactory`和一些其他的MyBatis Plus配置项。 ##### 4. Mapper配置 为了区分不同的Mapper，可以使用...
springboot之多数据源配置
qq_39940489的博客
08-21 4973
应用直接操作的是abstractRoutingDataSource的实现类，告诉AbstractRoutingDataSource访问哪个数据库，然后由AbstractRoutingDataSource从事先配置好的数据源 （ds1，ds2）选择哪一个 ，来访问对应的数据库。
springboot项目整合sqlite+hive
zhangxl123liang的博客
03-01 492
1.引入pom文件 <!-- sqlite --> <dependency> <groupId>org.xerial</groupId> <artifactId>sqlite-jdbc</artifactId> <version>3.36.0.3</version> </dependency>
springboot配置多个数据源
weixin_42704604的博客
08-02 1312
如果使用type类型 com.alibaba.druid.pool.DruidDataSource，需要进行DruidDBConfig 连接池相关配置，如下所示，如果时候type是其他类型，例如spring.datasource.type=com.zaxxer.hikari.HikariDataSource，就可以不配置下面的内容。在一个项目里面读取多个数据库的数据来进行展示，例如读取mysql，pgsql，oracle的不同数据库，springboto对同时配置多个数据源是支持的。
springboot之数据源配置
星星都没我亮的博客
10-29 825
文章目录1、JDBC2、自定义数据源DruidDataSource3、springboot配置多数据源并动态切换4、springboot整合mybatis ​ Spring Framework 为 SQL 数据库提供了广泛的支持。从直接使用 JdbcTemplate 进行 JDBC 访问到完全的对象关系映射（object relational mapping）技术，比如 Hibernate。Spring Data 提供了更多级别的功能，直接从接口创建的 Repository 实现，并使用了约定从方法名生成
Spring Boot 实现多数据源配置
qq_33807380的博客
03-15 4956
在application.properties或application.yml中配置多个数据源的连接信息。在 Spring Boot 中实现多数据源配置通常用于需要连接多个数据库的场景。首先，在pom.xml中添加MyBatis、数据库驱动和Spring Boot的JDBC依赖。在Spring Boot中，通过@Configuration类来配置多个数据源的Bean。将Mapper接口和XML文件分别放在不同的包中，以区分不同的数据源。主数据源Mapper XML文件。次数据源Mapper XML文件。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值