springboot+Mybatis(MybatisPlus)+HikariCP多数据源动态配置(三个数据源)

最新推荐文章于 2025-06-04 11:20:33 发布
最新推荐文章于 2025-06-04 11:20:33 发布
阅读量1.6k 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： HikariCP多数据源动态配置 文章标签： java
原文链接：https://blog.youkuaiyun.com/dfBeautifulLive/article/details/100541931
本文详细介绍如何在SpringBoot项目中配置和使用Mybatis多数据源，包括使用HikariCP连接池，通过AOP动态切换数据源，以及具体代码实现。

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

springboot+Mybatis(MybatisPlus)+HikariCP多数据源动态配置(三个数据源)

我们新做的系统可能是很多个数据源，所以我闲来无事研究一下Mybatis多数据源的配置，然后连接池只要你不配置默认就是HikariCP，被称为最快速的连接池。所以我们使用HikariCP数据库连接池，需要用到aop动态切换，话不多说，上代码了。 1.pom.xml大概要使用的包，仅供参考，我也需要自动生成代码所以也会有MybatisPlus的包
<!-- ##################### mybatis ###########################-->
  • <!-- mybatis分页插件 -->
  • <dependency>
  • <groupId>com.github.pagehelper</groupId>
  • <artifactId>pagehelper</artifactId>
  • <version>4.1.0</version>
  • </dependency>
  • <!-- mybatis-plus 核心库 -->
  • <dependency>
  • <groupId>com.baomidou</groupId>
  • <artifactId>mybatis-plus</artifactId>
  • <version>2.1.8</version>
  • </dependency>
  • <!-- mybatis-plus-模板引擎自动生成代码用 -->
  • <dependency>
  • <groupId>org.apache.velocity</groupId>
  • <artifactId>velocity-engine-core</artifactId>
  • <version>2.0</version>
  • </dependency>
  • <!-- mybatis-springboot -->
  • <dependency>
  • <groupId>org.mybatis.spring.boot</groupId>
  • <artifactId>mybatis-spring-boot-starter</artifactId>
  • <version>1.3.2</version>
  • </dependency>
  • <!-- ##################### mybatis end ###########################-->
  • <!-- springboot-aop -->
  • <dependency>
  • <groupId>org.springframework.boot</groupId>
  • <artifactId>spring-boot-starter-aop</artifactId>
  • </dependency>
  • <dependency>
  • <groupId>org.assertj</groupId>
  • <artifactId>assertj-core</artifactId>
  • </dependency>

  • 2.然后就是yml的配置。

    1. spring:
    2.   aop:
    3.     proxy-target-class: true
    4.     # proxy-target-class属性值决定是基于接口的还是基于类的代理被创建。
    5.     #如果proxy-target-class 属性值被设置为true，那么基于类的代理将起作用（这时需要cglib库）。如果proxy-target-class属值被设置为false或者这个属性被省略，那么标准的JDK 基于接口的代理将起作用。
    6.     auto: true
    7.   application:
    8.     name: gsa-geographic-system
    9.   datasource:
    10.     ds0:
    11.       jdbc-url: jdbc:mysql://localhost:3306/xdclass?useUnicode=true&characterEncoding=utf-8&useSSL=false
    12.       username: root
    13.       password: root
    14.       driver-class-name: com.mysql.jdbc.Driver
    15.     ds1:
    16.       jdbc-url: jdbc:mysql://localhost:3306/mall_0?useUnicode=true&characterEncoding=utf-8&useSSL=false
    17.       username: root
    18.       password: root
    19.       driver-class-name: com.mysql.jdbc.Driver
    20.     ds2:
    21.       jdbc-url: jdbc:mysql://localhost:3306/babytun?useUnicode=true&characterEncoding=utf-8&useSSL=false
    22.       username: root
    23.       password: root
    24.       driver-class-name: com.mysql.jdbc.Driver
    25.

    3.以上准备好了以后就需要配置注入了，创建类MybatisPlusConfig。

    1. package gsa.geographic.system.config.dataSource;
    2.  
    3. import com.baomidou.mybatisplus.MybatisConfiguration;
    4. import com.baomidou.mybatisplus.entity.GlobalConfiguration;
    5. import com.baomidou.mybatisplus.plugins.PaginationInterceptor;
    6. import com.baomidou.mybatisplus.spring.MybatisSqlSessionFactoryBean;
    7. import com.github.pagehelper.PageHelper;
    8. import gsa.geographic.system.enumclass.DBTypeEnum;
    9. import org.apache.ibatis.plugin.Interceptor;
    10. import org.apache.ibatis.session.SqlSessionFactory;
    11. import org.apache.ibatis.type.JdbcType;
    12. import org.springframework.beans.factory.annotation.Qualifier;
    13. import org.springframework.boot.context.properties.ConfigurationProperties;
    14. import org.springframework.boot.jdbc.DataSourceBuilder;
    15. import org.springframework.context.annotation.Bean;
    16. import org.springframework.context.annotation.Configuration;
    17. import org.springframework.context.annotation.Primary;
    18. import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
    19.  
    20. import javax.sql.DataSource;
    21. import java.util.HashMap;
    22. import java.util.Map;
    23. import java.util.Properties;
    24.  
    25. /**
    26.  * 分页配置
    27.  *
    28.  * @Author df
    29.  * @Date 2019/8/20 10:09
    30.  * @Version 1.0
    31.  */
    32. @Configuration
    33. public class MybatisPlusConfig {
    34.  
    35.     /**
    36.      * mybatis-plus分页插件<br>
    37.      * 文档：http://mp.baomidou.com<br>
    38.      */
    39.     @Bean
    40.     public PaginationInterceptor paginationInterceptor() {
    41.         PaginationInterceptor paginationInterceptor = new PaginationInterceptor();
    42.         paginationInterceptor.setDialectType("mysql");
    43.         // paginationInterceptor.setLimit(你的最大单页限制数量，默认 500 条，小于 0 如 -1 不受限制);
    44.         //return new PerformanceInterceptor();
    45.         return paginationInterceptor;
    46.     }
    47.  
    48.     /**
    49.      * 配置mybatis的分页插件pageHelper
    50.      *
    51.      * @return
    52.      */
    53.     @Bean
    54.     public PageHelper pageHelper() {
    55.         PageHelper pageHelper = new PageHelper();
    56.         Properties properties = new Properties();
    57.         properties.setProperty("offsetAsPageNum", "true");
    58.         properties.setProperty("rowBoundsWithCount", "true");
    59.         properties.setProperty("reasonable", "true");
    60.         properties.setProperty("dialect", "mysql");    //配置mysql数据库的方言        pageHelper.setProperties(properties);        return pageHelper;    }}
    61.         return pageHelper;
    62.     }
    63.  
    64.     /**
    65.      * 创建第一个数据源
    66.      * @return
    67.      */
    68.     @Bean(name = "ds0")
    69.     @ConfigurationProperties(prefix = "spring.datasource.ds0")
    70.     public DataSource dataSource0() {
    71.         return DataSourceBuilder.create().build();
    72.     }
    73.  
    74.     /**
    75.      * 创建第二个数据源
    76.      * @return
    77.      */
    78.     @Bean(name = "ds1")
    79.     @ConfigurationProperties(prefix = "spring.datasource.ds1")
    80.     public DataSource dataSource1() {
    81.         return DataSourceBuilder.create().build();
    82.     }
    83.  
    84.     /**
    85.      * 创建第三个数据源
    86.      * @return
    87.      */
    88.     @Bean(name = "ds2")
    89.     @ConfigurationProperties(prefix = "spring.datasource.ds2")
    90.     public DataSource dataSource2() {
    91.         return DataSourceBuilder.create().build();
    92.     }
    93.  
    94.     /**
    95.      * 动态数据源配置
    96.      *
    97.      * @return
    98.      */
    99.     @Bean
    100.     @Primary
    101.     public DataSource multipleDataSource(@Qualifier("ds0") DataSource ds0,
    102.                                          @Qualifier("ds1") DataSource ds1,
    103.                                          @Qualifier("ds2") DataSource ds2) {
    104.         DynamicDataSource dynamicDataSource = new DynamicDataSource();
    105.         Map<Object, Object> dataSources = new HashMap<>();
    106.         dataSources.put(DBTypeEnum.DS0.getValue(), ds0);
    107.         dataSources.put(DBTypeEnum.DS1.getValue(), ds1);
    108.         dataSources.put(DBTypeEnum.DS2.getValue(), ds2);
    109.         dynamicDataSource.setTargetDataSources(dataSources);
    110.         dynamicDataSource.setDefaultTargetDataSource(ds0);
    111.         return dynamicDataSource;
    112.     }
    113.  
    114.     @Bean("sqlSessionFactory")
    115.     public SqlSessionFactory sqlSessionFactory() throws Exception {
    116.         // 导入mybatissqlsession配置
    117.         MybatisSqlSessionFactoryBean sessionFactory = new MybatisSqlSessionFactoryBean();
    118.         // 指明数据源
    119.         sessionFactory.setDataSource(multipleDataSource(dataSource0(), dataSource1(), dataSource2()));
    120.         // 指明mapper.xml位置(配置文件中指明的xml位置会失效用此方式代替，具体原因未知)
    121.         sessionFactory.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath*:/mapper/**Mapper.xml"));
    122.         // 指明实体扫描(多个package用逗号或者分号分隔)
    123.         sessionFactory.setTypeAliasesPackage("gsa.geographic.system.entity");
    124.         // 导入mybatis配置
    125.         MybatisConfiguration configuration = new MybatisConfiguration();
    126.         configuration.setJdbcTypeForNull(JdbcType.NULL);
    127.         configuration.setMapUnderscoreToCamelCase(true);
    128.         configuration.setCacheEnabled(false);
    129.         sessionFactory.setConfiguration(configuration);
    130.         // 添加分页功能
    131.         sessionFactory.setPlugins(new Interceptor[]{
    132.                 paginationInterceptor()
    133.         });
    134.         // 导入全局配置
    135.         sessionFactory.setGlobalConfig(globalConfiguration());
    136.         return sessionFactory.getObject();
    137.     }
    138.  
    139.     /**
    140.      * 在代码中配置MybatisPlus替换掉application.yml中的配置
    141.      *
    142.      * @return
    143.      */
    144.     @Bean
    145.     public GlobalConfiguration globalConfiguration() {
    146.         GlobalConfiguration configuration = new GlobalConfiguration();
    147.         configuration.setLogicDeleteValue("-1");
    148.         configuration.setLogicNotDeleteValue("1");
    149.         // 主键类型 0:数据库ID自增, 1:用户输入ID,2:全局唯一ID (数字类型唯一ID), 3:全局唯一ID UUID
    150.         configuration.setIdType(0);
    151.         // 驼峰下划线转换
    152.         configuration.setDbColumnUnderline(true);
    153.         // 是否动态刷新mapper
    154.         configuration.setRefresh(true);
    155.         return configuration;
    156.     }
    157.  
    158. }

    4.创建动态数据源的获取类DynamicDataSource继承AbstractRoutingDataSource

    1. package gsa.geographic.system.config.dataSource;
    2. import gsa.geographic.system.config.dataSource.DbContextHolder;
    3. import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;
    4.  
    5. /**
    6.  * @Author df
    7.  * 扩展Spring的AbstractRoutingDataSource抽象类，实现动态数据源（他的作用就是动态切换数据源）
    8.  * AbstractRoutingDataSource中的抽象方法determineCurrentLookupKey是实现数据源的route的核心，
    9.  * 这里对该方法进行Override。【上下文DbContextHolder为一线程安全的ThreadLocal】
    10.  * @Date 2019/9/3 15:39
    11.  * @Version 1.0
    12.  */
    13.  
    14.  
    15. public class DynamicDataSource extends AbstractRoutingDataSource {
    16.     /**
    17.      * 取得当前使用哪个数据源
    18.      *
    19.      * @return
    20.      */
    21.     @Override
    22.     protected Object determineCurrentLookupKey() {
    23.         return DbContextHolder.getDbType();
    24.     }
    25. }

    5.创建获取，设置数据源的类DbContextHolder，为了线程安全使用了ThreadLocal。

    1. package gsa.geographic.system.config.dataSource;
    2. import gsa.geographic.system.enumclass.DBTypeEnum;
    3.  
    4. /**
    5.  * @Author df
    6.  * @Date 2019/9/3 16:14
    7.  * @Version 1.0
    8.  * @description：设置，获取，清空 当前线程内的数据源变量。
    9.  */
    10. public class DbContextHolder {
    11.     private static final ThreadLocal contextHolder = new ThreadLocal();
    12.  
    13.     /**
    14.      * 设置数据源
    15.      *
    16.      * @param dbTypeEnum
    17.      */
    18.     public static void setDbType(DBTypeEnum dbTypeEnum) {
    19.         contextHolder.set(dbTypeEnum.getValue());
    20.     }
    21.  
    22.     /**
    23.      * 取得当前数据源
    24.      *
    25.      * @return
    26.      */
    27.     public static String getDbType() {
    28.         return (String) contextHolder.get();
    29.     }
    30.  
    31.     /**
    32.      * 清除上下文数据
    33.      */
    34.     public static void clearDbType() {
    35.         contextHolder.remove();
    36.     }
    37. }

    6.创建枚举类DBTypeEnum，方便添加查看哪些枚举类

    1. package gsa.geographic.system.enumclass;
    2. /**
    3.  * @Author df
    4.  * @Date 2019/9/3 15:45
    5.  * @Version 1.0
    6.  * 设置数据源
    7.  */
    8. public enum DBTypeEnum {
    9.     DS0("ds0"), DS1("ds1"), DS2("ds2");
    10.     private String value;
    11.  
    12.     DBTypeEnum(String value) {
    13.         this.value = value;
    14.     }
    15.  
    16.     public String getValue() {
    17.         return value;
    18.     }
    19.  
    20. }

    7.再添加一个aop切面类DataSourceSwitchAspect，这样就可以动态切换数据源了

    1. package gsa.geographic.system.config.dataSource;
    2.  
    3. import gsa.geographic.system.enumclass.DBTypeEnum;
    4. import lombok.extern.slf4j.Slf4j;
    5. import org.aspectj.lang.JoinPoint;
    6. import org.aspectj.lang.annotation.Aspect;
    7. import org.aspectj.lang.annotation.Before;
    8. import org.aspectj.lang.annotation.Pointcut;
    9. import org.aspectj.lang.reflect.MethodSignature;
    10. import org.springframework.core.annotation.Order;
    11. import org.springframework.stereotype.Component;
    12.  
    13. import java.util.Objects;
    14.  
    15. /**
    16.  * AOP方式动态切换数据源
    17.  *
    18.  * @Author df
    19.  * @Date 2019/9/3 16:26
    20.  * @Version 1.0
    21.  */
    22.  
    23. @Component
    24. @Aspect
    25. @Order(-100) //这是为了保证AOP在事务注解之前生效,Order的值越小,优先级越高
    26. @Slf4j
    27. public class DataSourceSwitchAspect {
    28.     @Pointcut("execution(* gsa.geographic.system.service..*.*(..))")
    29.     private void dbAspect() {
    30.  
    31.     }
    32.  
    33.     @Before("dbAspect()")
    34.     public void db(JoinPoint joinPoint) {
    35.         MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
    36.         DataSourceSwitch dataSourceSwitch = methodSignature.getMethod().getAnnotation(DataSourceSwitch.class);
    37.         if (Objects.isNull(dataSourceSwitch) || Objects.isNull(dataSourceSwitch.value())) {
    38.             DbContextHolder.setDbType(DBTypeEnum.DS0);
    39.         } else {
    40.             switch (dataSourceSwitch.value().getValue()) {
    41.                 case "ds0":
    42.                     DbContextHolder.setDbType(DBTypeEnum.DS0);
    43.                     break;
    44.                 case "ds1":
    45.                     DbContextHolder.setDbType(DBTypeEnum.DS1);
    46.                     break;
    47.                 case "ds2":
    48.                     DbContextHolder.setDbType(DBTypeEnum.DS2);
    49.                     break;
    50.                 default:
    51.                     DbContextHolder.setDbType(DBTypeEnum.DS0);
    52.             }
    53.         }
    54.     }
    55.  
    56. }

    8.再添加一个可以供我们用注解形式的调用方式的接口。

    1. package gsa.geographic.system.config.dataSource;
    2. import gsa.geographic.system.enumclass.DBTypeEnum;
    3. import java.lang.annotation.ElementType;
    4. import java.lang.annotation.Retention;
    5. import java.lang.annotation.RetentionPolicy;
    6. import java.lang.annotation.Target;
    7.  
    8. /**
    9.  * Service方法调用
    10.  *
    11.  * @Author df
    12.  * @Date 2019/9/3 16:32
    13.  * @Version 1.0
    14.  */
    15. @Retention(RetentionPolicy.RUNTIME)
    16. @Target({ElementType.METHOD})
    17. public @interface DataSourceSwitch {
    18.     DBTypeEnum value() default DBTypeEnum.DS0;
    19. }

    好了配置以上我这边反正是可以启动正常的。

    然后开始在service里边使用不同的数据源把，先给大家我的serviceImpl的示例把！这是使用第一个数据源，其实配置默认的数据源以后默认的那个数据源是可以不用写注解表名的，其他两个数据源需要写上注解。

    1. package gsa.geographic.system.service.impl;
    2.  
    3. import gsa.geographic.system.config.dataSource.DataSourceSwitch;
    4. import gsa.geographic.system.entity.TOrder0;
    5. import gsa.geographic.system.dao.TOrder0Mapper;
    6. import gsa.geographic.system.enumclass.DBTypeEnum;
    7. import gsa.geographic.system.service.TOrder0Service;
    8. import com.baomidou.mybatisplus.service.impl.ServiceImpl;
    9. import org.springframework.beans.factory.annotation.Autowired;
    10. import org.springframework.stereotype.Service;
    11.  
    12. import java.util.List;
    13.  
    14. /**
    15.  * <p>
    16.  * 服务实现类
    17.  * </p>
    18.  *
    19.  * @author df123
    20.  * @since 2019-09-03
    21.  */
    22. @Service
    23. public class TOrder0ServiceImpl extends ServiceImpl<TOrder0Mapper, TOrder0> implements TOrder0Service {
    24.  
    25.     @Autowired
    26.     private TOrder0Mapper mapper;
    27.  
    28.     @DataSourceSwitch(DBTypeEnum.DS1)
    29.     @Override
    30.     public List getAll() {
    31.         return mapper.selectList(null);
    32.     }
    33. }
    1. package gsa.geographic.system.service.impl;
    2.  
    3. import gsa.geographic.system.config.dataSource.DataSourceSwitch;
    4. import gsa.geographic.system.entity.TGoods;
    5. import gsa.geographic.system.dao.TGoodsMapper;
    6. import gsa.geographic.system.enumclass.DBTypeEnum;
    7. import gsa.geographic.system.service.TGoodsService;
    8. import com.baomidou.mybatisplus.service.impl.ServiceImpl;
    9. import org.springframework.beans.factory.annotation.Autowired;
    10. import org.springframework.stereotype.Service;
    11.  
    12. import java.util.List;
    13.  
    14. /**
    15.  * <p>
    16.  * 服务实现类
    17.  * </p>
    18.  *
    19.  * @author df123
    20.  * @since 2019-09-03
    21.  */
    22. @Service
    23. public class TGoodsServiceImpl extends ServiceImpl<TGoodsMapper, TGoods> implements TGoodsService {
    24.  
    25.     @Autowired
    26.     private TGoodsMapper goodsMapper;
    27.  
    28.     @DataSourceSwitch(DBTypeEnum.DS2)
    29.     @Override
    30.     public List getAll() {
    31.         return goodsMapper.selectList(null);
    32.     }
    33. }

    9 然后在写上测试用例。

    1. package gsa.geographic.system.service.impl;
    2.  
    3. import gsa.geographic.system.service.TGoodsService;
    4. import gsa.geographic.system.service.TOrder0Service;
    5. import gsa.geographic.system.service.UserService;
    6. import org.junit.Test;
    7. import org.junit.runner.RunWith;
    8. import org.springframework.beans.factory.annotation.Autowired;
    9. import org.springframework.boot.test.context.SpringBootTest;
    10. import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
    11.  
    12. import java.util.List;
    13.  
    14. import static org.junit.Assert.*;
    15.  
    16. /**
    17.  * @Author df
    18.  * @Date 2019/9/3 16:40
    19.  * @Version 1.0
    20.  */
    21. @SpringBootTest
    22. @RunWith(SpringJUnit4ClassRunner.class)
    23. public class UserServiceImplTest {
    24.  
    25.     @Autowired
    26.     private UserService userService;
    27.  
    28.     @Autowired
    29.     private TOrder0Service tOrder0Service;
    30.     @Autowired
    31.     private TGoodsService goodsService;
    32.  
    33.     @Test
    34.     public void getAll() {
    35.         List list = userService.selectList(null);
    36.         List list1=tOrder0Service.getAll();
    37.         List list2=goodsService.getAll();
    38.         System.out.println(list);
    39.     }
    40.  
    41. }

    10.控制台结果，也能看到确实使用了HikariCP的数据库连接池，这样就大公告成了

     

     

多数据源 - dynamic-datasource | 集成 HikariCP 连接池
甘蓝的专栏
03-20 2599
基于 SpringBoot 的多数据源 dynamic-datasource 与 HikariCP 数据库连接池集成。
springboot集成mybatis-plus多数据源HikariCP
干货分享，希望帮助读者不断提升自己的编程技能，解决工作中实际问题，并激发对技术的无限热爱。
01-11 909
springboot+mybatis-plus+HikariCP
springboot mybatis-plus 多数据源配置(HikariCP)
qiaobing1226的博客
07-22 1863
springboot mybatis-plus 多数据源配置
java springboot+mybatis 配置多数据源（简洁明了）
最新发布
ladack的博客
06-04 459
前言：网上找了很多配置多数据源的，霹雳啪啦一堆不想看，自己写一个简捷版的，因为在实际工作中可能会涉及到多个库或者不同ip地址的数据库，话不多说，直接上代码。
Spring Boot HikariCP 一 ——集成多数据源
热门推荐
坤哥的博客
12-19 2万+
其实这里介绍的东西主要是参考的另外一篇文章，数据库读写分离的。参考文章就把链接贴出来，里面有那位的代码，简单明了https://gitee.com/comven/dynamic-datasource-demo?spm=5176.100239.blogcont188540.13.iARYDh。读写分离的功能我已经使用replication集成好了，因为我们需要单独设置每个数据源的链接属性，而且使用的还
spring boot + mybatis/mybatis-plus + hikari 多数据源配置
Word_Nihao的博客
09-30 4629
1、配置文件 第一数据源 spring.datasource.jdbc-url = jdbc:mysql://***:3306/dbname?useUnicode=true&characterEncoding=utf-8&allowMultiQueries=true spring.datasource.username = *** spring.datasource.passw...
Springboot + HikariCp + MybatisPlus多数据源配置 （1）
weixin_44215595的博客
09-29 6120
概述 以前一直用的druid，最近想换hikari了，因为druid的监控多数情况我用不到，hikari的速度更能让我满意 项目架构 项目依赖 <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <proj...
SpringBoot+Mybatis-Plus整合Sharding-JDBC5.1.1实现单库分表【全网最新】.doc
07-09
- 或者选择使用默认的数据源，如HikariCP，因为Sharding-JDBC本身就推荐使用默认数据源。 - Maven配置示例： ```xml <groupId>com.alibaba</groupId> <artifactId>druid <version>1.2.8 ``` 或者直接使用...
springboot+dubbo+mybatis-plus集成
05-28
5. **配置数据源**：由于MyBatis-Plus需要数据源，我们需要在SpringBoot项目中配置数据源，可以使用Druid或HikariCP等数据源连接池。 6. **配置MyBatis-Plus**：在SpringBoot项目中，我们需要配置MyBatis-Plus的...
springboot+mybatis-plus+hikari多数据源配置
weixin_45658376的博客
10-26 3670
.ymal文件针对mysql举例 # database spring: application: name: dipper-web flyway: enabled: false datasource: portal: driver-class-name: com.mysql.jdbc.Driver type: com.zaxxer.hikari.HikariDataSource jdbc-url: jdbc:mysql:########
SpringBoot集成MybatisPlus, Redis,hikari ,swagger2
11-23
SpringBoot集成MybatisPlus, Redis,hikari ,swagger2 ，完整代码框架，下载即可直接打开运行,此提供学习使用，也可用于实际项目
springboot集成mybatis多数据源HikariCP
干货分享，希望帮助读者不断提升自己的编程技能，解决工作中实际问题，并激发对技术的无限热爱。
01-11 1094
中的一个配置类中增加如下配置即可。
SpringBoot+MyBatisPlus+AOP实现多数据源切换
小学生波波
11-02 1811
SpringBoot+MyBatisPlus+AOP实现多数据源切换
springboot使用mybatisplus的多数据源，连接三个数据库
hqw921054的博客
03-23 786
springboot使用mybatisplus的多数据源，连接三个数据库，进行操作。 看配置数据源文件。 spring: datasource: url: jdbc:mysql://localhost:3306/enterprise_wallet?useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai username: root password: 123456 ds
springBoot2 多数据源配置Hikari + MybatisPlus
weixin_43344648的博客
04-25 2230
环境：springBoot2.4.5 IDEA 数据库：Mysql8.0.21 主要任务：多数据源配置Hikari + MybatisPlus 项目结构 注意要点 两个数据源的mapperScan目录一定要分开，否则就会出现数据源1中的表去数据源2数据库中查询的情况 原因：在mapperScan的过程中会把扫描到的类归属于正在配置的某一个数据源，而不会智那区分 application.yml配置 spring: datasource: user: jdbc-url: jdbc:my
SpringBoot集成MyBatis Plus，使用HikariCP连接池
Crazy_young_man的博客
04-26 6772
我这里用到了lombok中的几个注解 1. 准备一个基础的Spring Boot项目 创建一个简单的SpringBoot项目你应该是没有问题的吧？如果不会请移步https://www.yuanmen.top/pages/view.html?id=33 2. pom.xml添加依赖 <!-- Lombok --> <dependency> <groupId>...
【mybatis-plus】多数据源切换[dynamic-datasource] 手动切换数据源
日拱一卒无有尽，功不唐捐终入海
09-04 1万+
苞米豆团队支持多种数据源切换方案，核心都是基于。本文我们利用filter和拦截器，以及方法中硬编码 这三种方式动态手动切换数据源。在使用 dynamic-datasource 库时，您可以通过过滤器（Filter）来实现在请求处理过程中切换数据源。创建在过滤器的doFilter方法中，获取当前请求的上下文信息，例如请求参数、请求头等。根据上下文信息，判断应该使用哪个数据源，然后调用方法设置数据源标识。@Component@Override// 获取上下文信息，判断应该使用哪个数据源。
SpringBoot 整合MyBatis-Plus 详细教程，配置多数据源并支持事务，附带代码生成器使用教程
ChenJin_2的博客
10-13 5211
SpringBoot 整合MyBatis-Plus 详细教程，配置多数据源并支持事务，附带代码生成器使用教程 一.在pom.xml加入依赖，如下 <!-- MySQL驱动 --> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <scope>runtime</scope>
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值