下面案例源码可参考：

  1. springboot-dydamic-datasources分包方式实现多数据源
  2. springboot-dydamic-datasources自定义注解实现多数据源

    1.为什么微服务还要使用多数据源

    :::tips 我们知道面对微服务化的拆分，我们希望一个微服务能做到小而精（做到只干一件事，比如账单服务，库存服务）。但是有些时候拆分不是很测地，需要在一个微服务项目中使用多数据源的情形（eg：如果满足a条件入a库，满足b条件入b库）。基于此，这里简单采用springboot分包方式实现多数据源。仅供参考。 :::

    2.分包方式实现多数据源切换

    2.1 项目目录结构

    我们在进行分包的方式来实现多数据源的动态切换，重点就是分包。项目分包如下：
    1. ├─src
    2. │  ├─main
    3. │  │  ├─java
    4. │  │  │  └─com
    5. │  │  │      └─itmck
    6. │  │  │          ├─config       多数据源配置包
    7. │  │  │          ├─dao
    8. │  │  │          │  ├─master    主数据源mapper
    9. │  │  │          │  └─slave     从数据源mapper
    10. │  │  │          ├─entity       实体
    11. │  │  │          └─service      接口
    12. │  │  └─resources
    13. │  │      └─mapper
    14. │  │          ├─master          主数据源mapper.xml
    15. │  │          └─slave           从数据源mapper.xml
    16. │  └─test

    2.2 数据源配置清单

    ```yaml spring: datasource: master: url: jdbc:mysql://localhost:3306/spring_db?characterEncoding=utf-8&useSSL=false&serverTimezone=GMT%2B8 driver-class-name: com.mysql.cj.jdbc.Driver username: root password: 123456 slave: url: jdbc:mysql://localhost:3306/spring_db2?characterEncoding=utf-8&useSSL=false&serverTimezone=GMT%2B8 driver-class-name: com.mysql.cj.jdbc.Driver username: root password: 123456 type: com.zaxxer.hikari.HikariDataSource hikari: connection-timeout: 30000 idle-timeout: 30000 auto-commit: ‘true’ minimum-idle: 5 maximum-pool-size: 15 pool-name: HikariCP connection-test-query: SELECT 1 FROM DUAL max-lifetime: 1800000

mybatis-plus: mapper-locations: ‘classpath:mapper//*Mapper.xml’ type-aliases-package: com.itmck.entity configuration: log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

  1. <a name="PLVX3"></a>
  2. ## 2.3 master数据源
  3. :::info
  4. @MapperScan(basePackages = "com.itmck.dao.master", sqlSessionTemplateRef = "primarySqlSessionTemplate")<br />basePackages代表要扫描的mapper接口，这是分包切换数据源的关键
  5. :::
  6. ```java
  7. package com.itmck.filterconfig;
  9. import com.baomidou.mybatisplus.core.MybatisConfiguration;
  10. import com.baomidou.mybatisplus.core.config.GlobalConfig;
  11. import com.baomidou.mybatisplus.extension.incrementer.OracleKeyGenerator;
  12. import com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor;
  13. import com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean;
  14. import com.zaxxer.hikari.HikariDataSource;
  15. import lombok.extern.slf4j.Slf4j;
  16. import org.apache.ibatis.session.SqlSessionFactory;
  17. import org.mybatis.spring.SqlSessionTemplate;
  18. import org.mybatis.spring.annotation.MapperScan;
  19. import org.springframework.boot.autoconfigure.jdbc.DataSourceProperties;
  20. import org.springframework.boot.context.properties.ConfigurationProperties;
  21. import org.springframework.context.annotation.Bean;
  22. import org.springframework.context.annotation.Configuration;
  23. import org.springframework.context.annotation.Primary;
  24. import org.springframework.jdbc.datasource.DataSourceTransactionManager;
  26. import javax.sql.DataSource;
  28. /**
  29.  * 太阳当空照,花儿对我笑
  30.  * <p>
  31.  * Create by M ChangKe 2021/11/17 15:07
  32.  **/
  33. @Slf4j
  34. @Configuration
  35. @MapperScan(basePackages = "com.itmck.dao.master", sqlSessionTemplateRef = "primarySqlSessionTemplate")
  36. public class PrimaryDataSourceConfig {
  39.     @Bean
  40.     @ConfigurationProperties(prefix = "spring.datasource.master")
  41.     public DataSourceProperties primaryDataSourceProperties() {
  42.         return new DataSourceProperties();
  43.     }
  45.     @Bean
  46.     @Primary
  47.     public DataSource primaryDateSource() {
  48.         return primaryDataSourceProperties()
  49.                 .initializeDataSourceBuilder()
  50.                 .type(HikariDataSource.class)
  51.                 .build();
  52.     }
  54.     @Bean
  55.     @Primary
  56.     public SqlSessionFactory primarySqlSessionFactory() throws Exception {
  57.         MybatisSqlSessionFactoryBean mybatisSqlSessionFactoryBean = new MybatisSqlSessionFactoryBean();
  58.         mybatisSqlSessionFactoryBean.setPlugins(new PaginationInterceptor());
  59.         mybatisSqlSessionFactoryBean.setDataSource(primaryDateSource());
  60. //        mybatisSqlSessionFactoryBean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath*:mapper/master/*.xml"));
  61. //        mybatisSqlSessionFactoryBean.setConfiguration(this.mybatisConfiguration());//解决oracle下不能使用sequence问题
  62.         return mybatisSqlSessionFactoryBean.getObject();
  63.     }
  65.     private MybatisConfiguration mybatisConfiguration() {
  66.         GlobalConfig globalConfig = new GlobalConfig();
  67.         GlobalConfig.DbConfig dbConfig = new GlobalConfig.DbConfig().setKeyGenerator(new OracleKeyGenerator());
  68.         globalConfig.setDbConfig(dbConfig);
  69.         MybatisConfiguration mybatisConfiguration = new MybatisConfiguration();
  70.         mybatisConfiguration.setGlobalConfig(globalConfig);
  71.         return mybatisConfiguration;
  72.     }
  75.     @Bean
  76.     @Primary
  77.     public DataSourceTransactionManager primaryDataSourceTransactionManager() {
  78.         return new DataSourceTransactionManager(primaryDateSource());
  79.     }
  81.     @Bean
  82.     @Primary
  83.     public SqlSessionTemplate primarySqlSessionTemplate() throws Exception {
  84.         return new SqlSessionTemplate(primarySqlSessionFactory());
  85.     }
  87. }

2.4 slave数据源

:::info @MapperScan(basePackages = “com.itmck.dao.slave”,sqlSessionTemplateRef = “slaveSqlSessionTemplate”)
basePackages代表要扫描的mapper接口，这是分包切换数据源的关键 :::

  1. package com.itmck.filterconfig;
  3. import com.baomidou.mybatisplus.core.MybatisConfiguration;
  4. import com.baomidou.mybatisplus.core.config.GlobalConfig;
  5. import com.baomidou.mybatisplus.extension.incrementer.OracleKeyGenerator;
  6. import com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor;
  7. import com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean;
  8. import com.zaxxer.hikari.HikariDataSource;
  9. import lombok.extern.slf4j.Slf4j;
  10. import org.apache.ibatis.session.SqlSessionFactory;
  11. import org.mybatis.spring.SqlSessionTemplate;
  12. import org.mybatis.spring.annotation.MapperScan;
  13. import org.springframework.boot.autoconfigure.jdbc.DataSourceProperties;
  14. import org.springframework.boot.context.properties.ConfigurationProperties;
  15. import org.springframework.context.annotation.Bean;
  16. import org.springframework.context.annotation.Configuration;
  17. import org.springframework.jdbc.datasource.DataSourceTransactionManager;
  19. import javax.sql.DataSource;
  22. /**
  23.  * 太阳当空照,花儿对我笑
  24.  * <p>
  25.  * Create by M ChangKe 2021/11/17 15:07
  26.  * <p>
  27.  * 从数据源
  28.  **/
  29. @Slf4j
  30. @Configuration
  31. @MapperScan(basePackages = "com.itmck.dao.slave",sqlSessionTemplateRef = "slaveSqlSessionTemplate")
  32. public class SlaveDataSourceConfig {
  35.     @Bean
  36.     @ConfigurationProperties(prefix = "spring.datasource.slave")
  37.     public DataSourceProperties slaveDataSourceProperties() {
  38.         return new DataSourceProperties();
  39.     }
  41.     @Bean
  42.     public DataSource slaveDateSource() {
  43.         return slaveDataSourceProperties()
  44.                 .initializeDataSourceBuilder()
  45.                 .type(HikariDataSource.class)
  46.                 .build();
  47.     }
  49.     @Bean
  50.     public SqlSessionFactory slaveSqlSessionFactory() throws Exception {
  51.         MybatisSqlSessionFactoryBean mybatisSqlSessionFactoryBean = new MybatisSqlSessionFactoryBean();
  52.         mybatisSqlSessionFactoryBean.setPlugins(new PaginationInterceptor());
  53.         mybatisSqlSessionFactoryBean.setDataSource(slaveDateSource());
  54. //        mybatisSqlSessionFactoryBean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath*:mapper/slave/*.xml"));
  55. //        mybatisSqlSessionFactoryBean.setConfiguration(this.mybatisConfiguration());//解决oracle下不能使用sequence问题
  56.         return mybatisSqlSessionFactoryBean.getObject();
  57.     }
  59.     private MybatisConfiguration mybatisConfiguration() {
  60.         GlobalConfig globalConfig = new GlobalConfig();
  61.         GlobalConfig.DbConfig dbConfig = new GlobalConfig.DbConfig().setKeyGenerator(new OracleKeyGenerator());
  62.         globalConfig.setDbConfig(dbConfig);
  63.         MybatisConfiguration mybatisConfiguration = new MybatisConfiguration();
  64.         mybatisConfiguration.setGlobalConfig(globalConfig);
  65.         return mybatisConfiguration;
  66.     }
  68.     @Bean
  69.     public DataSourceTransactionManager slaveDataSourceTransactionManager() {
  70.         return new DataSourceTransactionManager(slaveDateSource());
  71.     }
  73.     @Bean
  74.     public SqlSessionTemplate slaveSqlSessionTemplate() throws Exception {
  75.         return new SqlSessionTemplate(slaveSqlSessionFactory());
  76.     }
  77. }

2.5 启动类 :::tips 启动类上exclude排除默认的数据源自动装配配置类。否则会出现无法确认数据源的错误。 :::

  1. package com.itmck;
  3. import com.baomidou.mybatisplus.autoconfigure.MybatisPlusAutoConfiguration;
  4. import org.springframework.boot.SpringApplication;
  5. import org.springframework.boot.autoconfigure.SpringBootApplication;
  6. import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
  7. import org.springframework.boot.autoconfigure.jdbc.DataSourceTransactionManagerAutoConfiguration;
  8. import org.springframework.transaction.annotation.EnableTransactionManagement;
  10. /**
  11.  * 太阳当空照,花儿对我笑
  12.  * <p>
  13.  * Create by M ChangKe 2021/11/17 15:03
  14.  **/
  15. @SpringBootApplication(
  16.         //排除默认的数据源自动装配配置类
  17.         exclude = {
  18.                 DataSourceAutoConfiguration.class,
  19.                 DataSourceTransactionManagerAutoConfiguration.class,
  20.                 MybatisPlusAutoConfiguration.class
  21.         }
  22. )
  23. @EnableTransactionManagement
  24. public class SpringbootMultipartDataSourcesApplication {
  26.     public static void main(String[] args) {
  27.         SpringApplication.run(SpringbootMultipartDataSourcesApplication.class, args);
  28.     }
  29. }

3.自定义注解方式实现多数据源

:::tips 使用多数据源也可以完成的.这里简单自定义注解实现多数据源切换.
场景：针对动态数据源的切换操作可以扩展成读写分离.举例:如果读写分离可以使用中间件mycat. :::

3.1 项目目录结构

  1. ├─src
  2. │  ├─main
  3. │  │  ├─java
  4. │  │  │  └─com
  5. │  │  │      └─itmck
  6. │  │  │          ├─annotation  自定义数据源切换注解
  7. │  │  │          ├─config      切面以及配置类
  8. │  │  │          ├─dao
  9. │  │  │          ├─entity
  10. │  │  │          ├─enums
  11. │  │  │          ├─handler
  12. │  │  │          └─service
  13. │  │  └─resources
  14. │  └─test
  15. │      └─java
  16. │          └─com
  17. │              └─itmck
  18. │                  └─service

3.2 项目所需依赖

  1. <dependency>
  2.     <groupId>mysql</groupId>
  3.     <artifactId>mysql-connector-java</artifactId>
  4.     <scope>runtime</scope>
  5. </dependency>
  6. <dependency>
  7.     <groupId>com.baomidou</groupId>
  8.     <artifactId>mybatis-plus-boot-starter</artifactId>
  9.     <version>3.2.0</version>
  10. </dependency>
  11. <!--这里引入aop目的自定义注解实现切面-->
  12. <dependency>
  13.     <groupId>org.springframework.boot</groupId>
  14.     <artifactId>spring-boot-starter-aop</artifactId>
  15. </dependency>

3.3 application.yml配置

:::tips 注意: url改成 jdbc-url 否则报错: jdbcUrl is required with driverClassName 原文链接：解决方案 :::

  1. server:
  2.   port: 8080
  4. spring:
  5.   datasource:
  6.     master:
  7.       #这里url必须改为:jdbc-url 用来重写自定义连接池
  8.       jdbc-url: jdbc:mysql://localhost:3306/spring_db?characterEncoding=utf-8&useSSL=false&serverTimezone=GMT%2B8
  9.       driver-class-name: com.mysql.cj.jdbc.Driver
  10.       username: root
  11.       password: 123456
  12.     slave:
  13.       jdbc-url: jdbc:mysql://localhost:3306/spring_db2?characterEncoding=utf-8&useSSL=false&serverTimezone=GMT%2B8
  14.       driver-class-name: com.mysql.cj.jdbc.Driver
  15.       username: root
  16.       password: 123456
  17.     type: com.zaxxer.hikari.HikariDataSource
  18.     hikari:
  19.       connection-timeout: 30000
  20.       idle-timeout: 30000
  21.       auto-commit: 'true'
  22.       minimum-idle: 5
  23.       maximum-pool-size: 15
  24.       pool-name: HikariCP
  25.       connection-test-query: SELECT 1 FROM DUAL
  26.       max-lifetime: 1800000
  28. mybatis-plus:
  29.   mapper-locations: 'classpath*:mapper/*/*Mapper.xml'
  30.   type-aliases-package: com.itmck.entity
  31.   configuration:
  32.     log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

3.4 自定义注解

  1. package com.itmck.annotation;
  2. import com.itmck.enums.DataSourceType;
  3. import java.lang.annotation.*;
  5. /**
  6.  * 自定义多数据源切换注解
  7.  *
  8.  * @author miaochangke
  9.  */
  10. @Target({ElementType.METHOD,ElementType.TYPE})
  11. @Retention(RetentionPolicy.RUNTIME)
  12. @Documented
  13. public @interface Ds
  14. {
  15.     /**
  16.      * 切换数据源名称
  17.      */
  18.     public DataSourceType value() default DataSourceType.MASTER;
  19. }
  1. package com.itmck.enums;
  3. /**
  4.  * 太阳当空照,花儿对我笑
  5.  * <p>
  6.  * Create by M ChangKe 2021/11/22 14:28
  7.  * <p>
  8.  * 定义数据源枚举
  9.  **/
  10. public enum DataSourceType {
  11.     /**
  12.      * 主库
  13.      */
  14.     MASTER,
  16.     /**
  17.      * 从库
  18.      */
  19.     SLAVE
  20. }

3.5 自定义DynamicDataSourceContextHolder

:::tips 用来管理线程变量,根据线程进行数据源切换 :::

  1. package com.itmck.handler;
  3. import lombok.extern.slf4j.Slf4j;
  5. /**
  6.  * 太阳当空照,花儿对我笑
  7.  * <p>
  8.  * Create by M ChangKe 2021/11/22 14:31
  9.  **/
  10. @Slf4j
  11. public class DynamicDataSourceContextHolder {
  13.     /**
  14.      * 使用ThreadLocal维护变量，ThreadLocal为每个使用该变量的线程提供独立的变量副本，
  15.      * 所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。
  16.      */
  17.     private static final ThreadLocal<String> CONTEXT_HOLDER = new ThreadLocal<>();
  19.     /**
  20.      * 设置数据源的变量
  21.      */
  22.     public static void setDateSourceType(String dsType) {
  23.         log.info("切换到{}数据源", dsType);
  24.         CONTEXT_HOLDER.set(dsType);
  25.     }
  27.     /**
  28.      * 获得数据源的变量
  29.      */
  30.     public static String getDateSourceType() {
  31.         return CONTEXT_HOLDER.get();
  32.     }
  34.     /**
  35.      * 清空数据源变量
  36.      */
  37.     public static void clearDateSourceType() {
  38.         CONTEXT_HOLDER.remove();
  39.     }
  40. }

3.6 自定义DynamicDataSource

:::tips 通过自定义DynamicDataSource extends AbstractRoutingDataSource 重写determineCurrentLookupKey()来选择当前线程对应数据源 :::

  1. package com.itmck.handler;
  3. import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;
  5. import javax.sql.DataSource;
  6. import java.util.Map;
  8. /**
  9.  * 太阳当空照,花儿对我笑
  10.  * <p>
  11.  * Create by M ChangKe 2021/11/22 14:37
  12.  * <p>
  13.  * 动态数据源
  14.  **/
  15. public class DynamicDataSource extends AbstractRoutingDataSource {
  18.     public DynamicDataSource(DataSource defaultTargetDataSource, Map<Object, Object> targetDataSources) {
  19.         super.setDefaultTargetDataSource(defaultTargetDataSource);//设置默认数据源
  20.         super.setTargetDataSources(targetDataSources);//设置目标数据源
  21.         super.afterPropertiesSet();
  22.     }
  24.     @Override
  25.     protected Object determineCurrentLookupKey() {
  26.         return DynamicDataSourceContextHolder.getDateSourceType();//选择数据源
  27.     }
  28. }

3.7 创建DynamicDataSourceConfig

:::tips 初始化扫描数据源 :::

  1. package com.itmck.filterconfig;
  3. import com.itmck.enums.DataSourceType;
  4. import com.itmck.handler.DynamicDataSource;
  5. import com.zaxxer.hikari.HikariDataSource;
  6. import org.mybatis.spring.annotation.MapperScan;
  7. import org.springframework.boot.context.properties.ConfigurationProperties;
  8. import org.springframework.boot.jdbc.DataSourceBuilder;
  9. import org.springframework.context.annotation.Bean;
  10. import org.springframework.context.annotation.Configuration;
  11. import org.springframework.context.annotation.Primary;
  13. import javax.sql.DataSource;
  14. import java.util.HashMap;
  15. import java.util.Map;
  17. /**
  18.  * 太阳当空照,花儿对我笑
  19.  * <p>
  20.  * Create by M ChangKe 2021/11/22 14:43
  21.  **/
  22. @Configuration
  23. @MapperScan("com.itmck.dao")
  24. public class DynamicDataSourceConfig {
  26.     @Bean
  27.     @ConfigurationProperties(prefix = "spring.datasource.master")
  28.     public DataSource primaryDateSource() {
  29.         return DataSourceBuilder.create()
  30.                 .type(HikariDataSource.class)
  31.                 .build();
  32.     }
  34.     @Bean
  35.     @ConfigurationProperties(prefix = "spring.datasource.slave")
  36.     public DataSource slaveDateSource() {
  37.         return DataSourceBuilder.create()
  38.                 .type(HikariDataSource.class)
  39.                 .build();
  40.     }
  43.     @Bean(name = "dynamicDataSource")
  44.     @Primary
  45.     public DynamicDataSource dataSource() {
  46.         Map<Object, Object> targetDataSources = new HashMap<>();
  47.         targetDataSources.put(DataSourceType.MASTER.name(), primaryDateSource());
  48.         targetDataSources.put(DataSourceType.SLAVE.name(), slaveDateSource());
  49.         return new DynamicDataSource(primaryDateSource(), targetDataSources);
  50.     }
  51. }

3.8 创建切面

使用切面针对使用了注解@Ds的方法进行数据源的切换

  1. package com.itmck.filterconfig;
  3. import com.itmck.annotation.Ds;
  4. import com.itmck.handler.DynamicDataSourceContextHolder;
  5. import lombok.extern.slf4j.Slf4j;
  6. import org.aspectj.lang.ProceedingJoinPoint;
  7. import org.aspectj.lang.annotation.Around;
  8. import org.aspectj.lang.annotation.Aspect;
  9. import org.aspectj.lang.annotation.Pointcut;
  10. import org.aspectj.lang.reflect.MethodSignature;
  11. import org.springframework.core.annotation.Order;
  12. import org.springframework.stereotype.Component;
  14. import java.lang.reflect.Method;
  16. /**
  17.  * 太阳当空照,花儿对我笑
  18.  * <p>
  19.  * Create by M ChangKe 2021/11/22 14:39
  20.  **/
  21. @Slf4j
  22. @Aspect
  23. @Order(1)
  24. @Component
  25. public class DataSourceAspect {
  28.     @Pointcut("@annotation(com.itmck.annotation.Ds)")
  29.     public void dsPointCut() {
  31.     }
  33.     @Around("dsPointCut()")
  34.     public Object around(ProceedingJoinPoint point) throws Throwable {
  35.         MethodSignature signature = (MethodSignature) point.getSignature();
  36.         Method method = signature.getMethod();
  37.         Ds ds = method.getAnnotation(Ds.class);
  38.         if (null != ds) {
  39.             DynamicDataSourceContextHolder.setDateSourceType(ds.value().name());
  40.         }
  41.         try {
  42.             return point.proceed();
  43.         } finally {
  44.             // 销毁数据源 在执行方法之后
  45.             DynamicDataSourceContextHolder.clearDateSourceType();
  46.         }
  47.     }
  48. }

3.9 注解使用

:::tips 参考DsChangeImpl#getStudentList() 切换数据源: @Ds(value = DataSourceType.SLAVE) :::

  1. package com.itmck.service;
  3. import com.baomidou.mybatisplus.extension.service.additional.query.impl.LambdaQueryChainWrapper;
  4. import com.itmck.annotation.Ds;
  5. import com.itmck.dao.StudentMapper;
  6. import com.itmck.dao.UserMapper;
  7. import com.itmck.entity.Student;
  8. import com.itmck.entity.User;
  9. import com.itmck.enums.DataSourceType;
  10. import org.springframework.stereotype.Service;
  12. import javax.annotation.Resource;
  13. import java.util.List;
  15. /**
  16.  * 太阳当空照,花儿对我笑
  17.  * <p>
  18.  * Create by M ChangKe 2021/11/17 15:49
  19.  **/
  20. @Service
  21. public class DsChangeImpl implements DsChange {
  23.     @Resource
  24.     private UserMapper userMapper;
  26.     @Resource
  27.     private StudentMapper studentMapper;
  29.     //使用默认数据源
  30.     @Override
  31.     public List<User> getUserList() {
  32.         return new LambdaQueryChainWrapper<>(userMapper).list();
  33.     }
  35.     //使用从数据源
  36.     @Override
  37.     @Ds(value = DataSourceType.SLAVE)
  38.     public List<Student> getStudentList() {
  39.         return new LambdaQueryChainWrapper<>(studentMapper).list();
  40.     }
  41. }

3.10 启动类排除数据源自动注册

:::tips @SpringBootApplication(exclude = {DataSourceAutoConfiguration.class}) 排除数据源自动配置类 :::

  1. package com.itmck;
  3. import org.springframework.boot.SpringApplication;
  4. import org.springframework.boot.autoconfigure.SpringBootApplication;
  5. import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
  6. import org.springframework.transaction.annotation.EnableTransactionManagement;
  8. /**
  9.  * 太阳当空照,花儿对我笑
  10.  * <p>
  11.  * Create by M ChangKe 2021/11/17 15:03
  12.  **/
  13. //@Import(DynamicDataSourceConfig.class)
  14. @SpringBootApplication(exclude = {DataSourceAutoConfiguration.class})
  15. @EnableTransactionManagement
  16. public class SpringbootDynamicDataSourcesApplication {
  18.     public static void main(String[] args) {
  19.         SpringApplication.run(SpringbootDynamicDataSourcesApplication.class, args);
  20.     }
  21. }

3.11 测试

  1. package com.itmck.service;
  3. import com.itmck.entity.Student;
  4. import com.itmck.entity.User;
  5. import lombok.extern.slf4j.Slf4j;
  6. import org.junit.Test;
  7. import org.junit.runner.RunWith;
  8. import org.springframework.boot.test.context.SpringBootTest;
  9. import org.springframework.test.context.junit4.SpringRunner;
  11. import javax.annotation.Resource;
  12. import java.util.List;
  14. /**
  15.  * 太阳当空照,花儿对我笑
  16.  * <p>
  17.  * Create by M ChangKe 2021/11/17 15:49
  18.  **/
  19. @Slf4j
  20. @RunWith(SpringRunner.class)
  21. @SpringBootTest
  22. public class DsChangeImplTest {
  24.     @Resource
  25.     private DsChange dsChange;
  27.     @Test
  28.     public void userMapper() {
  29.         List<User> list = dsChange.getUserList();
  30.         log.info("list:{}", list);
  31.     }
  33.     @Test
  34.     public void studentMapper() {
  35.         List<Student> list = dsChange.getStudentList();
  36.         log.info("list:{}", list);
  37.     }
  38. }

分别输出:

==> Preparing: SELECT id,name,email,age FROM user ==> Parameters: <== Columns: id, name, email, age <== Row: 1, mck, 1735580535, 26 <== Total: 1 list:[User(id=1, name=mck, age=26, email=1735580535)]

==> Preparing: SELECT id,name,age FROM student ==> Parameters: <== Columns: id, name, age <== Row: 1, wxp, 25 <== Total: 1 Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@51b01550] list:[Student(id=1, name=wxp, age=25)]