mybatis多数据源

目录

1，简介

2，具体使用

2.1 手动配置多个数据源

2.1.1 代码示例

2.1.2 注意事项  

2.2 使用mybatis-plus-dynamic

3，总结

---

1，简介

     在实际开发中很容易就遇到需要多数据源的情形，比如说，在新增数据时除了给自己的库保留一份，还需要同步到别人的库；转移程序需要将A库的数据转到B库等等。使用mybatis配置多数据源我接触过的有两种方式，一种是通过java config的方式手动配置两个数据源，另一种方式便是使用mybatis-plus-dynamic。

2，具体使用

2.1 手动配置多个数据源

2.1.1 代码示例

项目基于springboot和mybatis-plus，首先引入相应的依赖：

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.mytest</groupId>
    <artifactId>dynamic-datasource</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>mybatis-plus-test</module>
    </modules>
    <name>dynamic-datasource</name>
    <!-- FIXME change it to the project's website -->
    <url>http://www.example.com</url>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.13.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.1.1</version>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>dynamic-datasource-spring-boot-starter</artifactId>
            <version>3.1.1</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <dependency>
            <groupId>com.microsoft.sqlserver</groupId>
            <artifactId>mssql-jdbc</artifactId>
            <version>6.1.0.jre8</version>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

如上所示，还引入了sqlServer和mysql的驱动用于多数据源测试。

其次，配置application.yml，内容如下：

server:
  port: 12300
spring:
  datasource:
     dynamic:
       datasource:
         master:
           username: root
           password: 123456
           driver-class-name: com.mysql.jdbc.Driver
           jdbc-url: jdbc:mysql://192.168.136.130:8889/mytest?useSSL=false&characterEncoding=utf8
           connectionTimeout: 15000
         slave-1:
           username: sa
           password: 123456
           driver-class-name: com.microsoft.sqlserver.jdbc.SQLServerDriver
           jdbc-url: jdbc:sqlserver://localhost:1433;databaseName=test

如上所示，分别配置了两个数据源的jdbc-url、driver-name、用户名和密码，这些都属于常规操作。

第三步，通过java config的方式编写代码配置数据源：

首先是mysql的：

@Configuration
@MapperScan(basePackages = "com.mytest.mysql.dao", sqlSessionFactoryRef = "mysqlSqlSessionFactory")
public class MysqlConfig {
    @ConfigurationProperties(prefix = "spring.datasource.dynamic.datasource.master")
    @Primary
    @Bean("mysqlDataSource")
    public DataSource mysqlDataSource(){
        return DataSourceBuilder.create().build();
    }

    @Bean("mysqlSqlSessionFactory")
    @Primary
    public SqlSessionFactory sqlSessionFactory(@Qualifier("mysqlDataSource") DataSource dataSource) throws Exception {
        MybatisSqlSessionFactoryBean sqlSessionFactoryBean = new MybatisSqlSessionFactoryBean();
        sqlSessionFactoryBean.setDataSource(dataSource);
        sqlSessionFactoryBean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:mappers/mysql/*Mapper.xml"));
        return sqlSessionFactoryBean.getObject();
    }

    @Bean("mysqlSqlSessionFactory")
    @Primary
    public SqlSessionTemplate sqlSessionTemplate(@Qualifier("mysqlSqlSessionFactory")SqlSessionFactory sqlSessionFactory) throws Exception {
        SqlSessionTemplate sqlSessionTemplate = new SqlSessionTemplate(sqlSessionFactory);
        return sqlSessionTemplate;
    }

    @Bean("mysqlTransactionManager")
    public DataSourceTransactionManager transactionManager(@Qualifier("mysqlDataSource") DataSource dataSource){
        DataSourceTransactionManager transactionManager = new DataSourceTransactionManager(dataSource);
        return transactionManager;
    }
}

其次是，sqlServer的：

@Configuration
@MapperScan(basePackages = "com.mytest.sqlserver.dao", sqlSessionFactoryRef = "sqlServerSessionFactory")
public class SqlServerConfig {
    @ConfigurationProperties(prefix = "spring.datasource.dynamic.datasource.slave-1")
    @Bean("sqlServerDataSource")
    public DataSource mysqlDataSource(){
        return DataSourceBuilder.create().build();
    }

    @Bean("sqlServerSessionFactory")
    public SqlSessionFactory sqlSessionFactory(@Qualifier("sqlServerDataSource") DataSource dataSource) throws Exception {
        MybatisSqlSessionFactoryBean sqlSessionFactoryBean = new MybatisSqlSessionFactoryBean();
        sqlSessionFactoryBean.setDataSource(dataSource);
        sqlSessionFactoryBean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:mappers/sqlServer/*Mapper.xml"));
        return sqlSessionFactoryBean.getObject();
    }

    @Bean("sqlServerSessionFactory")
    public SqlSessionTemplate sqlSessionTemplate(@Qualifier("sqlServerSessionFactory")SqlSessionFactory sqlSessionFactory) throws Exception {
        SqlSessionTemplate sqlSessionTemplate = new SqlSessionTemplate(sqlSessionFactory);
        return sqlSessionTemplate;
    }

    @Bean("sqlServerTransactionManager")
    public DataSourceTransactionManager transactionManager(@Qualifier("sqlServerDataSource") DataSource dataSource){
        DataSourceTransactionManager transactionManager = new DataSourceTransactionManager(dataSource);
        return transactionManager;
    }
}

总体来说，配置主要包括，产生DataSource，然后是mybatis所需要的SqlSessionFactory，以及配置相应的事务管理器。

2.1.2 注意事项  

（1）在生成DataSource时可以使用springboot提供的方法直接绑定配置文件中的数据源信息；

DataSourceBuilder.create().build() 

当然，也可以手动的方式进行

HikariDataSource dataSource = new HikariDataSource();
dataSource.setXXX();
return dataSource;

最上面的方式会显得更简洁一些，缺点就是需要将添加的属性都配置在yaml中，且需要字段名完全一致，而通过new的方式在setter值时会有相应的提示。

（2）@Primary注解的作用就是当你在代码中注入bean时，如下：

@Autowired
private DataSource dataSource;

由于上面的代码配置了两个数据源且都由spring来管理，就会导致spring不知道你到底想要获取谁的，然后就会报错，通过@Primary注解，意思就是同一个接口的实现类有多个，你优先注入标注了该注解的。

顺带说一下，另外一种处理方式就是，在通过@Autowired注入时可以搭配以下注解

@Qualifier 指定bean的名称亦或者使用@Resource注解

（3）在生成sqlSessionFactory时通过下面的代码

sqlSessionFactoryBean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:mappers/mysql/*Mapper.xml"));

指定了mybatis xml文件所在位置，这个方法的好处就是可以直接使用类路径即classpath，需要注意的是如果指定了但是相应的路径下面没有xml文件，就会报错，这就尴尬了，因为在使用mybatis-plus时很多简单查询是可以不用xml的

（4）@MapperScan指定了mybatis dao层的接口所在位置，这些接口会被mybatis扫描然后生成其相应的代理类，这里有个需要注意的地方，一般情况下我们直接扫描dao是没有毛病的，

@MapperScan(basePackages = "com.mytest.mysql.dao", sqlSessionFactoryRef = "mysqlSqlSessionFactory")

但是如果是这种情况，我有多个包需要扫描，如果这样做

@MapperScan(basePackages = "com.mytest.mysql.**.dao"

意思就是扫描mysql路径下的所有dao包，但是发现不好使，没办法扫描到相应的接口，正确的做法是：

@MapperScan(basePackages = {"com.mytest.mysql.a.dao", "com.mytest.mysql.b.dao"}

因为basePackages本来就是个数组，所以可以指定多个包扫描的路径，但是这样做还是有个问题，如果包很多，那我这样写不是太不美观了；刚开始觉得如果我直接指定扫描mysql下的包呢，问题不就迎刃而解，如下：

@MapperScan(basePackages = "com.mytest.mysql"

但是我发现这样写太年轻了，它会出现个问题，那就是把该路径下的所有接口都会被mybatis认为是dao层需要代理实现的了，比如service包下的接口；所以正确的做法是

@MapperScan(basePackages = "com.mytest.mysql", sqlSessionFactoryRef = "mysqlSqlSessionFactory", annotationClass = Mapper.class)

依旧扫描上层包路径，但是通过annotationClass指定扫描的接口需要有@Mapper注解，如下只需要给想要被扫描的dao加上@Mapper注解就行了。

@Mapper
public interface UserDao extends BaseMapper<UserBean> {
}

通过java config配置的要点就是定义两套数据源，给它们取不同的名称，然后分别扫描不同的包路径，如下为我的项目结构

mysql包和sqlserver包下面分别对应不同的数据源操作。

2.2 使用mybatis-plus-dynamic

首先在pom中新增相应的依赖。

<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>dynamic-datasource-spring-boot-starter</artifactId>
    <version>3.1.1</version>
</dependency>

修改yaml配置：

server:
  port: 9090
spring:
  datasource:
     dynamic:
       datasource:
         master:
           username: root
           password: 123456
           driver-class-name: com.mysql.jdbc.Driver
           url: jdbc:mysql://192.168.136.130:8889/mytest?useSSL=false&characterEncoding=utf8
         slave-1:
           username: sa
           password: 123456
           driver-class-name: com.microsoft.sqlserver.jdbc.SQLServerDriver
           url: jdbc:sqlserver://localhost:1433;databaseName=test
# 指定主数据源，默认名就是master
       primary: master
mybatis-plus:
  mapper-locations: classpath:mappers/*Mapper.xml

注意此处与上面手动配置的不同之处在于手动配置时为jdbc-url， 但此处为url， 同时之所以按照这个结构配置是因为dynamic dataSource配置是这样要求的，意思就是手动配置时压根不用前缀这么长的。此处是为了保持一致。

然后项目的结构为：

好处就是之前单数据源时怎么配置，此时就怎么做；那么又是如何知道我想要对哪个数据库操作的呢？

@Service
@DS("slave-1")
public class TbServiceImpl extends ServiceImpl<TbDao, TbBean> implements TbService {
    @Override
    public String save1() {
        TbBean tbBean = new TbBean();
        tbBean.setName("王五");
        tbBean.setSubject("英语");
        tbBean.setScore(113);
        this.save(tbBean);
        return "success";
    }
}

此处是模拟的一个新增操作，注意类上面的@DS注解，该注解可以标注在类或方法上面；也可以标注在Mapper接口上面，但是不建议同时在Mapper和service上同时标注，可能会出现问题。该注解的value属性便是对应于在yaml中配置的数据源名称，如果没有给值，默认就是使用数据源名为master的数据源。

踩坑日记：

如下代码：

@Service
@DS("master")
public class UserServiceImpl extends ServiceImpl<UserDao, UserBean> implements UserService {

    @Autowired
    private TbService tbService;
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void add() {
        UserBean userBean = new UserBean();
        userBean.setId(3);
        userBean.setLoginName("zhangsan");
        userBean.setName("张三");
        userBean.setPassword("123456");
        this.save(userBean);
        tbService.save1();
    }
}

意思就是我想在保存userBean时同时调用一下tbService的save1方法，注意tbService被@DS("slave-1")注解标注，它对应于sqlServer数据库的操作。当直接调用上面的add方法时，会报如下的错误：

反正就是死活找不到tb这张表，实际上tb这张表是确实存在于sqlServer数据库中的，之所以报错是由于加事务的原因@Transactional(rollbackFor = Exception.class)，由于spring事务默认的传播级别是：

Propagation.REQUIRED

这个事务的特性就是如果上级方法调用时已经获取了事务，则该方法内调用的其它事务方法将复用同一个事务，结果就是对userBean的操作是对应于mysql的，由于加了事务，所以tbService.save1()方法还是在该事务内，造成的结果就是会在mysql数据库中找tb这张表，肯定找不到，结果就报错了，解决方式如下：

@Service
@DS("slave-1")
public class TbServiceImpl extends ServiceImpl<TbDao, TbBean> implements TbService {
    @Override
    @Transactional(rollbackFor = Exception.class, propagation = Propagation.REQUIRES_NEW)
    public String save1() {
        TbBean tbBean = new TbBean();
        tbBean.setName("王五");
        tbBean.setSubject("英语");
        tbBean.setScore(113);
        this.save(tbBean);
        return "success";
    }
}

给save1()方法加上  @Transactional(rollbackFor = Exception.class, propagation = Propagation.REQUIRES_NEW) ， 使其在每次获取事务时都是重新产生一个，不再复用上级方法的事务。

3，总结

     配置多数据源的方法无非就是自己手动处理，或者调用其它的一些现成的包，在我使用dynamic-datasource-spring-boot-starter时觉得它很方便，因为需要显式配置的地方少了很多，但是总感觉不够灵活，也踩了很多坑；在一次做数据推送时，业务场景很简单，就是服务收到数据后本地数据库保存一份，再给其它库推送一份，刚开始是使用dynamic-datasource-spring-boot-starter的，但是线上环境遇到个问题，一旦那个需要推送的数据库挂了，导致主库所有的新增操作都会失败，一开始以为是事务的原因，但是本地测试始终无法复现这个问题的，百思不得其解，没办法最后又换回了手动配置的方式。