springboot + Mybatis 动态(多)数据源配置方法

立即下载用AI写一个

发布时间：2020-06-02

1人 | 浏览：3357次 | 收藏 |

技术：springboot2.1.x + mybatis + MySQL/SQL Server

运行环境：windows10 x64

概述

本案例实现了springboot + mybatis + MySQL/SQL Server 进行动态(多)数据源的使用

详细

##文章目的
######本文是作者在开发过程中遇到了需要多数据源或者动态数据源的情况下,研究并实现多数据源配置过程中,遇到的问题和详细过程,希望可以帮到有需要的朋友.

##文章正文
###一、什么是动态(多)数据源?(What?)
动态配置多数据源，即在大型应用中对数据进行切分，并且采用多个数据库实例进行管理，这样可以有效提高系统的水平伸缩性。而这样的方案就会不同于常见的单一数据实例的方案，这就要程序在运行时根据当时的请求及系统状态来动态的决定将数据存储在哪个数据库实例中，以及从哪个数据库提取数据。

###二、为什么要使用动态(多)数据源?什么情况下会使用动态(多)数据源?(Why?)
使用动态(多)数据源的最常见的几种情况是:

使用数据库时,需要做备份的时候,就会用到主从数据库,即一个主数据库,一个副数据库.
	使用数据库时,需要获取/修改的数据来源于不同的数据库.

在这些情况下,我们都会需要配置,使用多数据源开发模式.

###三、怎样使用/配置动态(多)数据源?(How?)
首先,我们需要看一下我完成后的项目结构:
![](/contentImages/image/20200601/VkMvFqJS2PRYuWNLZ5P.png)
####首先我们看配置文件:

application.yml
```yaml
spring:

datasource:
  ##SQL server
     driverClassName: com.microsoft.sqlserver.jdbc.SQLServerDriver
     url: jdbc:sqlserver://0.0.0.0:1433;databasename=CustomerManagement2020
     username: sa
     password: 123456

## MYSQL
     driverClassName_workplatform : com.mysql.cj.jdbc.Driver
     url_workplatform: jdbc:mysql://1.1.1.1:3306/authplatform?serverTimezone=GMT%2B8
     username_workplatform: admin
     password_workplatform: 123456
```

这里我使用的是两个不同的数据库,一个SQL Server 一个MySQL,如果需要更多的数据源,继续加即可.此处讲述两个,更多的同理.

####接下来是动态数据源的配置文件: DatabaseType,DatabaseContextHolder和DynamicDataSource

DatabaseType.java

```java
public enum DatabaseType {

DATASOURCE_SQLSERVEER("sqlServer", "1"),
    DATASOURCE_MySQL("MySQL", "2");

DatabaseType(String name, String value){
        this.name = name;
        this.value = value;
    }

private String name;
    private String value;

public String getName(){
        return name;
    }

public String getValue(){
        return value;
    }
```
DatabaseType.java 是一个枚举类,做一个全局统一的数据源标识,用于区分系统使用的每一个数据源.

DatabaseContextHolder.java

```java
public class DatabaseContextHolder {

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

public static void setDatabaseType(DatabaseType type){
        contextHolder.set(type);
    }

public static DatabaseType getDatabaseType(){
        return contextHolder.get();
    }
}
```
DatabaseContextHolder.java 类的目的是创建一个线程安全的存储DatabaseType的容器,用于在使用数据源的时候,将DatabaseType作为数据源的键.

DynamicDataSource.java

```java
public class DynamicDataSource extends AbstractRoutingDataSource {

protected Object determineCurrentLookupKey() {
        return DatabaseContextHolder.getDatabaseType();
    }
}
```

DynamicDataSource.java,继承AbstractRoutingDataSource抽象类.重写determineCurrentLookupKey()方法.该方法的作用是返回一个lookUpKey,这个lookUpKey是数据源的一个标识.可以通过looUpKey在resolvedDataSources这个map里取出对应的DataSource，如果找不到，则用默认的resolvedDefaultDataSource.此处重写determineCurrentLookupKey()方法的目的,是将我们定义的DatabaseType作为lookUpKey使用.

####接下来是Mybatis的相关配置: MybatisConfig.java

MybatisConfig.java

```java
package com.example.sqlserver.common.config.mybatis;

import javax.sql.DataSource;

import com.alibaba.druid.pool.DruidDataSource;
import com.example.sqlserver.common.config.database.DatabaseContextHolder;
import com.example.sqlserver.common.config.database.DatabaseType;
import com.example.sqlserver.common.config.database.DynamicDataSource;
import java.util.HashMap;
import java.util.Map;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.core.env.Environment;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;

/**
 * Created by Hanlex.Liu on 2020/6/1 09:36.
 * 功能描述 :
 */

@Configuration
@MapperScan(basePackages="com.example.sqlserver.dao", sqlSessionFactoryRef="sessionFactory")
public class MybatisConfig {

@Autowired
    Environment environment;

//读取配置文件中配置的数据源信息,将其映射到本实体类的对应属性.

//SQL Server
    @Value("${spring.datasource.driverClassName}")
    private String dbDriver;

@Value("${spring.datasource.url}")
    private String dbUrl;

@Value("${spring.datasource.username}")
    private String dbUsername;

@Value("${spring.datasource.password}")
    private String dbPassword;

// MySQL
    @Value("${spring.datasource.driverClassName_workplatform}")
    private String dbDriver_workplatform;

@Value("${spring.datasource.url_workplatform}")
    private String dbUrl_workplatform;

@Value("${spring.datasource.username_workplatform}")
    private String dbUsername_workplatform;

@Value("${spring.datasource.password_workplatform}")
    private String dbPassword_workplatform;

/**
     * 创建 SQL Server 环境 dataSource
     * @throws Exception
     */
    @Bean(name="dataSourceSqlServer")
    public DataSource dataSourceSqlServer() throws Exception{
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName(dbDriver);
        dataSource.setUrl(dbUrl);
        dataSource.setUsername(dbUsername);
        dataSource.setPassword(dbPassword);
        return dataSource;
    }

/**
     * 创建 MySQL 环境 dataSource
     * @throws Exception
     */
    @Bean(name="dataSourceMySQL")
    public DataSource dataSourceMySQL() throws Exception{
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName(dbDriver_workplatform);
        dataSource.setUrl(dbUrl_workplatform);
        dataSource.setUsername(dbUsername_workplatform);
        dataSource.setPassword(dbPassword_workplatform);
        return dataSource;
    }

/**
     * 1、创建动态数据源
     * @throws Exception
     * @Primary 该注解表示在同一个接口有多个类可以注入的时候，默认选择哪个，而不是让@Autowired报错
     */
    @Bean(name="dynamicDataSource")
    @Primary
    public DynamicDataSource DataSource(@Qualifier("dataSourceSqlServer") DataSource dataSourceSqlServer,
                                        @Qualifier("dataSourceMySQL") DataSource dataSourceMySQL){
        //将已知的所有数据源信息放进 AbstractRoutingDataSource 类的 targetDataSource 属性中.
        Map<Object, Object> targetDataSource = new HashMap<>();
        targetDataSource.put(DatabaseType.DATASOURCE_SQLSERVEER, dataSourceSqlServer);
        targetDataSource.put(DatabaseType.DATASOURCE_MySQL, dataSourceMySQL);
        DynamicDataSource dataSource = new DynamicDataSource();
        dataSource.setTargetDataSources(targetDataSource);
        //设置默认数据源为 SQL Server 数据源
        dataSource.setDefaultTargetDataSource(dataSourceSqlServer);
        return dataSource;
    }

/**
     * 根据当前数据源创建SqlSessionFactory
     * @throws Exception
     */
    @Bean(name="sessionFactory")
    public SqlSessionFactory sessionFactory(@Qualifier("dynamicDataSource")DynamicDataSource dataSource) throws Exception{
        SqlSessionFactoryBean sessionFactoryBean = new SqlSessionFactoryBean();
        sessionFactoryBean.setDataSource(dataSource);
        PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
        sessionFactoryBean.setMapperLocations(resolver.getResources(environment.getProperty("mybatis.mapper-locations")));    //*Mapper.xml位置
        return sessionFactoryBean.getObject();
    }

/**
     * 手动修改数据源
     * @param environment
     */
    public static void setDataSourceByEnvironment(DatabaseType environment){
        DatabaseContextHolder.setDatabaseType(environment);
    }
}
```

MybatisConfig.java 此类为Mybatis的核心配置文件.包括:设置默认数据源,根据数据源生成SqlSessionFactory,修改数据源的方法.

####剩下的就是Service.java,Mapper.java,Mapper.xml和entity.java的编写/生成,demo中提供了Mybatis的逆向工具 Mybatis-generator的使用,配置方法.具体见demo,此处不做赘述.

entity.java,mapper.xml,mapper.java文件编写方法和正常编写/生成方法一致.可以使用demo中提供的逆向工具自动生成.
	Service.java中可以主动选择当前使用的数据源.

CompanyMapper.java

```java
@Mapper
public interface CompanyMapper {
   
    List<String> selectAll();

}
```

UserMapper.java
```java
@Mapper
public interface UserMapper {

List<User> selectAll();

}
```

CompanyService.java
```java
@Service
public class CompanyService {

@Resource
    private CompanyMapper companyMapper;

public void doTestDyncDatasource(){
        MybatisConfig.setDataSourceByEnvironment(DatabaseType.DATASOURCE_SQLSERVEER);
        List<String> names = companyMapper.selectAll();
        names.forEach(System.out::println);
    }
}
```

UserService.java
```java
@Service
public class UserService {

@Resource
    private UserMapper userMapper;

public void doTestDyncDatasource(){
        MybatisConfig.setDataSourceByEnvironment(DatabaseType.DATASOURCE_MySQL);
        List<User> users = userMapper.selectAll();
        users.stream().map(User::getUserName).forEach(System.out::println);
    }

}
```

然后即可直接使用:
springboot 测试类:

SqlserverApplicationTests.java
```java
@SpringBootTest
class SqlserverApplicationTests {

@Autowired
    private CompanyService companyService;
    @Autowired
    private UserService userService;

@Test
    void test1() {
        companyService.doTestDyncDatasource();
        userService.doTestDyncDatasource();
    }
}
```
### 四、遇到的问题
##### 1.在使用多数据源时,一定要在springboot启动类上的@SpringBootApplication注解中加入exclude属性,用于屏蔽springboot对数据源的自动装配类DataSourceAutoConfiguration:
```java
@SpringBootApplication(exclude = DataSourceAutoConfiguration.class)
@MapperScan("com.example.sqlserver.dao")
public class SqlserverApplication {

public static void main(String[] args) {
        SpringApplication.run(SqlserverApplication.class, args);
    }

}
```
##### 否则会在启动项目时报循环引用的错误 : 
```java
Caused by: org.springframework.beans.factory.BeanCurrentlyInCreationException: Error creating bean with name 'dynamicDataSource': Requested bean is currently in creation: Is there an unresolvable circular reference?
	at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.beforeSingletonCreation(DefaultSingletonBeanRegistry.java:347)
	at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.getSingleton(DefaultSingletonBeanRegistry.java:219)
	at org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory.java:321)
	at org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:202)
	at org.springframework.beans.factory.config.DependencyDescriptor.resolveCandidate(DependencyDescriptor.java:276)
	at org.springframework.beans.factory.support.DefaultListableBeanFactory.doResolveDependency(DefaultListableBeanFactory.java:1306)
	at org.springframework.beans.factory.support.DefaultListableBeanFactory$DependencyObjectProvider.getIfUnique(DefaultListableBeanFactory.java:1963)
	at org.springframework.boot.autoconfigure.jdbc.DataSourceInitializerInvoker.getDataSourceInitializer(DataSourceInitializerInvoker.java:98)
	at org.springframework.boot.autoconfigure.jdbc.DataSourceInitializerInvoker.afterPropertiesSet(DataSourceInitializerInvoker.java:61)
	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.invokeInitMethods(AbstractAutowireCapableBeanFactory.java:1855)
	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.initializeBean(AbstractAutowireCapableBeanFactory.java:1792)
	... 181 more
```

##### 2.在使用多数据源时,如果在Java中需要使用事务管理,务必要注意,不能再同一个 java事务空间(方法) 中动态切换数据源.否则会导致数据源切换失效.解决方法如下:
	1.尽量避免在java事务空间中切换数据源,或者手动提交事务后再切换数据源,再开启事务(未测试是否可行,理论可行).
	2.在需要动态切换数据源的地方尽量不使用事务.

本实例支付的费用只是购买源码的费用，如有疑问欢迎在文末留言交流，如需作者在线代码指导、定制等，在作者开启付费服务后，可以点击“购买服务”进行实时联系，请知悉，谢谢

感谢

手机上随时阅读、收藏该文章？请扫下方二维码

springboot + Mybatis 动态(多)数据源配置方法

概述

详细

相似例子推荐

评论

作者

评分详细

作者例子

springboot + Mybatis 动态(多)数据源 配置方法

概述

详细

相似例子推荐

评论

作者

评分详细

作者例子

springboot + Mybatis 动态(多)数据源配置方法