Springboot2.x集成mybatis配置多数据源

  • A+
所属分类:java

有时候项目处理的数据的时候数据都存在不同的数据库里面,这个时候就需要我们自己配置其他的数据源了,在这里爱编程小编使用的是最新的Spring boot2.1.3的版本,之前在1.x的时候也使用过多数据源,没有记录下来,这次有很多坑都需要注意,所以记录了下来。

1、引入依赖

  1. <dependency>
  2.     <groupId>org.mybatis.spring.boot</groupId>
  3.     <artifactId>mybatis-spring-boot-starter</artifactId>
  4.     <version>2.0.0</version>
  5. </dependency>
  6. <!-- 阿里巴巴连接驱动 -->
  7. <dependency>
  8.     <groupId>com.alibaba</groupId>
  9.     <artifactId>druid-spring-boot-starter</artifactId>
  10.     <version>1.1.13</version>
  11. </dependency>

注意:自从Spring boot2.0开始大量的依赖跟随创建项目的时候更改,还有像上面这种没有包含进项目的第三方集成依赖就需要去官网查看一下最新的的依赖了,如果不知道最合适的版本,就使用最新的版本。后面使用的小版本都在不同程度上面更新了不同的依赖及第三方依赖。不然就会经常出错,这是使用Springboot最需要记住的地方。

1、创建项目包含的集成依赖是自动帮你弄好了版本

2、第三方集成依赖就如上面这个阿里巴巴的连接依赖这种需要版本的


2、配置文件配置数据源

  1. spring:
  2.   #数据源
  3.   datasource:
  4.     #连接池的类型
  5.     type: com.alibaba.druid.pool.DruidDataSource
  6.     #连接驱动
  7.     driver-class-name: com.mysql.cj.jdbc.Driver
  8.     url: jdbc:mysql://ip?serverTimezone=GMT%2B8
  9.     username: username
  10.     password: password
  11.     druid:
  12.       domestic1:  #国外1
  13.         url: jdbc:mysql://ip?serverTimezone=GMT%2B8
  14.         username: username
  15.         password: password
  16.       domestic2:  #国外2
  17.         url: jdbc:mysql://ip?serverTimezone=GMT%2B8
  18.         username: username
  19.         password: password
  20.       #初始大小
  21.       initial-size: 1
  22.       #最大连接数
  23.       max-active: 100
  24.       #最最小空闲连接数
  25.       min-idle: 10
  26.       #配置获取连接等待超时的时间
  27.       max-wait: 60000
  28.       default-auto-commit: true
  29.       #池的准备好的语句
  30. #      pool-prepared-statements: true
  31.       #每个连接大小的MAX池准备语句
  32.       max-pool-prepared-statement-per-connection-size: 20

注意:我的mysql数据库版本是8.x的,因此在url后面需要添加一些参数, mysql5.7及以前的不需要添加某些参数,自动8以后的版本就需要添加一些参数,根据不同的情况添加,有的在数据库里面设置,默认的设置就需要在其他使用的地方添加兼容的参数,不然就各种奇怪的参数,我的另外两篇就记录了8.x版本可能出现的某些错误。


3、查看项目结构

1. java区域结构

Springboot2.x集成mybatis配置多数据源

2. resources区域结构

Springboot2.x集成mybatis配置多数据源


4、配置数据源小告示

多数据源一定需要一个主数据源和其他从数据源下面的是我的数据源结构,然后再看其内容

Springboot2.x集成mybatis配置多数据源


5、配置数据源构造器

  1. import com.alibaba.druid.pool.DruidDataSource;
  2. import java.sql.SQLException;
  3. public class DruidDataSourceBuilder {
  4.     private DruidDataSource dataSource = new DruidDataSource();
  5.     public final static DruidDataSourceBuilder newInstance() {
  6.         return new DruidDataSourceBuilder();
  7.     }
  8.     public DruidDataSourceBuilder appendDriverClassName(String driverClassName) {
  9.         dataSource.setDriverClassName(driverClassName);
  10.         return this;
  11.     }
  12.     public DruidDataSourceBuilder appendUrl(String url) {
  13.         dataSource.setUrl(url);
  14.         return this;
  15.     }
  16.     public DruidDataSourceBuilder appendUsername(String username) {
  17.         dataSource.setUsername(username);
  18.         return this;
  19.     }
  20.     public DruidDataSourceBuilder appendPassword(String password) {
  21.         dataSource.setPassword(password);
  22.         return this;
  23.     }
  24.     public DruidDataSourceBuilder appendInitialSize(int initialSize) {
  25.         dataSource.setInitialSize(initialSize);
  26.         return this;
  27.     }
  28.     public DruidDataSourceBuilder appendMinIdle(int minIdle) {
  29.         dataSource.setMinIdle(minIdle);
  30.         return this;
  31.     }
  32.     public DruidDataSourceBuilder appendMaxActive(int maxActive) {
  33.         dataSource.setMaxActive(maxActive);
  34.         return this;
  35.     }
  36.     public DruidDataSourceBuilder appendMaxWait(long maxWait) {
  37.         dataSource.setMaxWait(maxWait);
  38.         return this;
  39.     }
  40.     public DruidDataSource getDataSource() {
  41.         return dataSource;
  42.     }
  43. }

6、配置主数据源

  1. import org.apache.ibatis.session.SqlSessionFactory;
  2. import org.mybatis.spring.SqlSessionFactoryBean;
  3. import org.mybatis.spring.annotation.MapperScan;
  4. import org.springframework.beans.factory.annotation.Qualifier;
  5. import org.springframework.beans.factory.annotation.Value;
  6. import org.springframework.context.annotation.Bean;
  7. import org.springframework.context.annotation.Configuration;
  8. import org.springframework.context.annotation.Primary;
  9. import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
  10. import org.springframework.jdbc.datasource.DataSourceTransactionManager;
  11. import javax.sql.DataSource;
  12. /**
  13.  * @Author: create_By: 
  14.  * @Data:Created in 2019/2/25 15:17
  15.  * @Version:
  16.  * @Acton:  国外数据源配置
  17.  */
  18. @Configuration
  19. @MapperScan(basePackages = AbroadDataSourceConfig.PACKAGE, sqlSessionFactoryRef = "abroadSqlSessionFactory")
  20. public class AbroadDataSourceConfig {
  21.     static final String PACKAGE = "com.seamax.dailyquery.dao.abroad";
  22.     static final String MAPPER_LOCATION = "classpath:mapper/abroad/*.xml";
  23.     @Value("${spring.datasource.driver-class-name}")
  24.     private String driverClassName;
  25.     @Value("${spring.datasource.url}")
  26.     private String url;
  27.     @Value("${spring.datasource.username}")
  28.     private String username;
  29.     @Value("${spring.datasource.password}")
  30.     private String password;
  31.     @Value("${spring.datasource.druid.initial-size}")
  32.     private int initialSize;
  33.     @Value("${spring.datasource.druid.min-idle}")
  34.     private  int minIdle;
  35.     @Value("${spring.datasource.druid.max-active}")
  36.     private  int maxActive;
  37.     @Value("${spring.datasource.druid.max-wait}")
  38.     private  int maxWait;
  39.     @Bean(name = "abroadDataSource")
  40.     @Primary
  41.     public DataSource abroadDataSource() {
  42.         return DruidDataSourceBuilder.newInstance()
  43.                 .appendDriverClassName(driverClassName)
  44.                 .appendUrl(url)
  45.                 .appendUsername(username)
  46.                 .appendPassword(password)
  47.                 .appendInitialSize(initialSize)
  48.                 .appendMinIdle(minIdle)
  49.                 .appendMaxActive(maxActive)
  50.                 .appendMaxWait(maxWait)
  51.                 .getDataSource();
  52.     }
  53.     @Bean(name = "abroadTransactionManager")
  54.     @Primary
  55.     public DataSourceTransactionManager abroadTransactionManager() {
  56.         return new DataSourceTransactionManager(abroadDataSource());
  57.     }
  58.     @Bean(name = "abroadSqlSessionFactory")
  59.     @Primary
  60.     public SqlSessionFactory abroadSqlSessionFactory(@Qualifier("abroadDataSource") DataSource abroadDataSource)
  61.             throws Exception {
  62.         final SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();
  63.         sessionFactory.setDataSource(abroadDataSource);
  64.         sessionFactory.setMapperLocations(new PathMatchingResourcePatternResolver()
  65.                 .getResources(AbroadDataSourceConfig.MAPPER_LOCATION));
  66.         return sessionFactory.getObject();
  67.     }
  68. }

7、配置从数据源

1.从数据源1

  1. import com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceBuilder;
  2. import org.apache.ibatis.session.SqlSessionFactory;
  3. import org.mybatis.spring.SqlSessionFactoryBean;
  4. import org.mybatis.spring.annotation.MapperScan;
  5. import org.springframework.beans.factory.annotation.Qualifier;
  6. import org.springframework.boot.context.properties.ConfigurationProperties;
  7. import org.springframework.context.annotation.Bean;
  8. import org.springframework.context.annotation.Configuration;
  9. import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
  10. import org.springframework.jdbc.datasource.DataSourceTransactionManager;
  11. import javax.sql.DataSource;
  12. /**
  13.  * @Author: create_By: 
  14.  * @Data:Created in 2019/2/25 15:17
  15.  * @Version:
  16.  * @Acton:  国外数据源配置
  17.  */
  18. @Configuration
  19. @MapperScan(basePackages = Domestic1DataSourceConfig.PACKAGE, sqlSessionFactoryRef = "domestic1SqlSessionFactory")
  20. public class Domestic1DataSourceConfig {
  21.     static final String PACKAGE = "com.seamax.dailyquery.dao.domestic1";
  22.     static final String MAPPER_LOCATION = "classpath:mapper/domestic1/*.xml";
  23.     @Bean(name = "domestic1DataSource")
  24.     @ConfigurationProperties("spring.datasource.druid.domestic1")
  25.     public DataSource domestic1DataSource() {
  26.         return DruidDataSourceBuilder.create().build();
  27.     }
  28.     @Bean(name = "domestic1TransactionManager")
  29.     public DataSourceTransactionManager domestic1TransactionManager() {
  30.         return new DataSourceTransactionManager(domestic1DataSource());
  31.     }
  32.     @Bean(name = "domestic1SqlSessionFactory")
  33.     public SqlSessionFactory abroadSqlSessionFactory(@Qualifier("domestic1DataSource") DataSource domestic1DataSource)
  34.             throws Exception {
  35.         final SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();
  36.         sessionFactory.setDataSource(domestic1DataSource);
  37.         sessionFactory.setMapperLocations(new PathMatchingResourcePatternResolver()
  38.                 .getResources(Domestic1DataSourceConfig.MAPPER_LOCATION));
  39.         return sessionFactory.getObject();
  40.     }

2.从数据源2

  1. import com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceBuilder;
  2. import org.apache.ibatis.session.SqlSessionFactory;
  3. import org.mybatis.spring.SqlSessionFactoryBean;
  4. import org.mybatis.spring.annotation.MapperScan;
  5. import org.springframework.beans.factory.annotation.Qualifier;
  6. import org.springframework.boot.context.properties.ConfigurationProperties;
  7. import org.springframework.context.annotation.Bean;
  8. import org.springframework.context.annotation.Configuration;
  9. import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
  10. import org.springframework.jdbc.datasource.DataSourceTransactionManager;
  11. import javax.sql.DataSource;
  12. /**
  13.  * @Author: create_By: 
  14.  * @Data:Created in 2019/2/25 15:17
  15.  * @Version:
  16.  * @Acton:  国外数据源配置
  17.  */
  18. @Configuration
  19. @MapperScan(basePackages = Domestic2DataSourceConfig.PACKAGE, sqlSessionFactoryRef = "domestic2SqlSessionFactory")
  20. public class Domestic2DataSourceConfig {
  21.     static final String PACKAGE = "com.seamax.dailyquery.dao.domestic2";
  22.     static final String MAPPER_LOCATION = "classpath:mapper/domestic2/*.xml";
  23.     @ConfigurationProperties("spring.datasource.druid.domestic2")
  24.     @Bean(name = "domestic2DataSource")
  25.     public DataSource domestic2DataSource() {
  26.         return DruidDataSourceBuilder.create().build();
  27.     }
  28.     @Bean(name = "domestic2TransactionManager")
  29.     public DataSourceTransactionManager domestic2TransactionManager() {
  30.         return new DataSourceTransactionManager(domestic2DataSource());
  31.     }
  32.     @Bean(name = "domestic2SqlSessionFactory")
  33.     public SqlSessionFactory abroadSqlSessionFactory(@Qualifier("domestic2DataSource") DataSource domestic2DataSource)
  34.             throws Exception {
  35.         final SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();
  36.         sessionFactory.setDataSource(domestic2DataSource);
  37.         sessionFactory.setMapperLocations(new PathMatchingResourcePatternResolver()
  38.                 .getResources(Domestic2DataSourceConfig.MAPPER_LOCATION));
  39.         return sessionFactory.getObject();
  40.     }
  41. }

注意:这两个从数据源里面的DruidDataSourceBuilder.create().build();是druid依赖包里面的,不是前面创建的那个。


8、 测试从不同数据源获取不同数据库里面的数据

先看一下我的三个数据库:

1.主数据库

Springboot2.x集成mybatis配置多数据源

2.从数据库1

Springboot2.x集成mybatis配置多数据源

3.从数据库2

Springboot2.x集成mybatis配置多数据源

测试内容,这里不需要和我一样的,具体的数据库配置数据源已经指定了dao接口,具体的mybatis实现需要自己去写映射sql。
这里分别从3个dao接口查询数据。

  1. @Autowired
  2. private AbroadMapper abroadMapper;
  3. @Autowired
  4. private Domestic1Mapper domestic1Mapper;
  5. @Autowired
  6. private Domestic2Mapper domestic2Mapper;
  7. @Override
  8. public Map<String,Object> getNewlyIncreasedData(Integer day) {
  9.     /* 国外处理 */
  10.     /* 国内处理 */
  11.     List<Map<String, Object>> guowai = abroadMapper.getNewlyIncreasedData();
  12.     List<Map<String, Object>> guonei1 = domestic1Mapper.getNewlyIncreasedData();
  13.     List<Map<String, Object>> guonei2 = domestic2Mapper.getNewlyIncreasedData();
  14.     System.out.println("国外数据:" + guowai);
  15.     System.out.println("国内数据1:" + guonei1);
  16.     System.out.println("国内数据2:" + guonei2);
  17.     Map<String, Object> RS = new HashMap<>();
  18.     return RS;
  19. }

下面是打印结果,看是不是和我的sql脚本查询的一样的。

Springboot2.x集成mybatis配置多数据源

avatar

发表评论

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen: