SpringBoot+MyBatis 配置多数据源 (两种方式实现)

在项目的开发中 , 有时候会涉及到多个数据库的访问 , 也就是多个数据源; 下面记录一下如何使用SpringBoot + MyBatis配置多数据源.

首先使用IDEA搭建一个SpringBoot项目 , 我使用的是JDK1.8 ,SpringBoot版本为1.5.12.RELEASE , 另外添加一些起步依赖

<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-aop</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-jdbc</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
		<dependency>
			<groupId>org.mybatis.spring.boot</groupId>
			<artifactId>mybatis-spring-boot-starter</artifactId>
			<version>1.3.2</version>
		</dependency>

		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<scope>runtime</scope>
		</dependency>
		<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
			<optional>true</optional>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>

		<!-- alibaba的druid数据库连接池 -->
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>druid-spring-boot-starter</artifactId>
			<version>1.1.0</version>
		</dependency>

以下是我的项目结构 

项目搭建起来之后 , 在进行SpringBoot的配置 , 我使用的是properties的方式,而非yml;在我们本地的MYSQL上 , 我新建了两个数据库 VX 和 CRAWLER , 并配置文件中添加上相应的配置

mybatis.configuration.jdbc-type-for-null=null
mybatis.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl
mybatis.configuration.multiple-result-sets-enabled=true
mybatis.mapper-locations=classpath:/mapper/**/*.xml
mybatis.typeAliasesPackage=com.xc.boot.datasource.multi

jdbc.vx.driverClassName=com.mysql.jdbc.Driver
jdbc.vx.url=jdbc:mysql://localhost:3306/vx?autoReconnect=true&useUnicode=true&characterEncoding=utf8
jdbc.vx.username=root
jdbc.vx.password=123456

jdbc.crawler.driverClassName=com.mysql.jdbc.Driver
jdbc.crawler.url=jdbc:mysql://localhost:3306/crawler?autoReconnect=true&useUnicode=true&characterEncoding=utf8
jdbc.crawler.username=root
jdbc.crawler.password=123456

jdbc.driver-class-name=com.mysql.jdbc.Driver
jdbc.filters=stat
jdbc.maxActive=20
jdbc.initialSize=1
jdbc.maxWait=6000
jdbc.timeBetweenEvictionRunsMillis=60000
jdbc.minEvictableIdleTimeMillis=300000
jdbc.validationQuery=select 'x' from dual
jdbc.testWhileIdle=true
jdbc.testOnBorrow=false
jdbc.testOnReturn=false
jdbc.poolPreparedStatements=true
jdbc.maxOpenPreparedStatements=20

logging.level.com.xc.boot.datasource.multi.dao=debug

------------------------------------------- 第一种方式 ------------------------------------------------

在config包下新建一个配置类 ,  相当于是spring的一个配置文件

package com.xc.boot.datasource.multi.config;

import org.springframework.context.annotation.Configuration;

@Configuration
public class MultiDataSourceConfig {
 
}

现在 , 一步一步加入配置 ;

1) 配置数据源

    @Bean
    @Primary
    @ConfigurationProperties(prefix = "jdbc.vx")
    public DataSource vxDataSource(){
        return DataSourceBuilder.create().build();
    }

    @Bean
    @ConfigurationProperties(prefix = "jdbc.crawler")
    public DataSource crawlerDataSource(){
        return DataSourceBuilder.create().build();
    }

@Bean : 将其表示为spring的bean,让spring进行管理

@Primary : 指定同一个接口有多个实现类可以注入的时候 , 默认注入哪一个

@ConfigurationProperties : 绑定配置文件中的属性到bean中

 

2) 配置SqlSessionFactory

    @Bean
    @Primary
    public SqlSessionFactory vxSqlSessionFactory(@Qualifier("vxDataSource")DataSource vxDataSource) throws Exception{
        SqlSessionFactoryBean fb = new SqlSessionFactoryBean();
        fb.setDataSource(vxDataSource);
        fb.setTypeAliasesPackage("com.xc.boot.datasource");
        fb.setMapperLocations(
                new PathMatchingResourcePatternResolver().getResources("classpath:/mapper/vx/**/*.xml")
        );
        return fb.getObject();
    }

    @Bean
    public SqlSessionFactory crawlerSqlSessionFactory(@Qualifier("crawlerDataSource")DataSource crawlerDataSource) throws Exception{
        SqlSessionFactoryBean fb = new SqlSessionFactoryBean();
        fb.setDataSource(crawlerDataSource);
        fb.setTypeAliasesPackage("com.xc.boot.datasource");
        fb.setMapperLocations(
                new PathMatchingResourcePatternResolver().getResources("classpath:/mapper/crawler/**/*.xml")
        );
        return fb.getObject();
    }

每一个SqlSessionFactory都设置了一个DataSource属性 , 所以他们产生的SqlSession就是不同数据库的SqlSession ; 另外TypeAliasesPackage属性表示扫描该属性下的全部java文件作为别名 , 即mapper.xml文件中 select 标签 resultType属性的值 ,如果不设置则要输入对应实体的全限定名称 , 设置之后只需输入对应实体的类名即可; MapperLocations 属性用于扫描指定文件下的哪些文件作为MyBatis的xml映射文件;

 

3)配置MapperScannerConfigurer

    @Bean(name="vxMapperScannerConfigurer")
    public MapperScannerConfigurer vxMapperScannerConfigurer(){
        MapperScannerConfigurer configurer = new MapperScannerConfigurer();
        configurer.setSqlSessionFactoryBeanName("vxSqlSessionFactory");
        configurer.setBasePackage("com.xc.boot.datasource");
        configurer.setAnnotationClass(VXDao.class);
        return configurer;
    }

    @Bean(name="crwalerMapperScannerConfigurer")
    public MapperScannerConfigurer crwalerMapperScannerConfigurer(){
        MapperScannerConfigurer configurer = new MapperScannerConfigurer();
        configurer.setSqlSessionFactoryBeanName("crawlerSqlSessionFactory");
        configurer.setBasePackage("com.xc.boot.datasource");
        configurer.setAnnotationClass(CrawlerDao.class);
        return configurer;
    }

MapperScannerConfigurer用于配置MyBatis Mapper接口的扫描 ; 该对象可以设置BasePackage 和 AnnotationClass属性,分别表示 扫描哪个包下的文件且标识了指定注解的接口 作为MyBatis 的 Mapper , 同时还需设置一个SqlSessionFactory; 

VXDao.class 和 CrawlerDao.class是我自定义的两个运行期且只能注解在类上的注解

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Component
public @interface VXDao {
    String value() default "";
}


@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
@Component
public @interface CrawlerDao {
    String value() default "";
};

 

4)配置 事务管理器

    @Bean(name="vxTransactionManager")
    @Primary
    public DataSourceTransactionManager vxTransactionManager(@Qualifier("vxDataSource")DataSource vxDataSource) throws Exception{
        return new DataSourceTransactionManager(vxDataSource);
    }

    @Bean(name="crawlerTransactionManager")
    public DataSourceTransactionManager crawlerTransactionManager(@Qualifier("crawlerDataSource")DataSource crawlerDataSource) throws Exception{
        return new DataSourceTransactionManager(crawlerDataSource);
    }

事务管理器只需要指定对应的DataSource即可

5)总结

以上步骤配置完成之后 , 只需要在对应的Dao接口上添加上 @VXDao 或 @CrawlerDao 注解 , 即可完成多数据源的访问 , 每一个注解对应一个数据源;

优点 : 通过注解的形式 , 指定了那个接口访问那个数据库 , 相对灵活

缺点 : 每新增一个数据源就要多加一套 DataSource , SqlSessionFactory , MapperScannerConfigurer , DataSourceTransactionManager  , Annotation  的配置 , 改动量较大;

------------------------------------------- 第二种方式 ------------------------------------------------

首先 ,  我们需要舍弃第一种方式的配置类,新增另一个配置类 ; 实现EnvironmentAware接口 , 主要是为了将Environment对象注入进来 , 这样就可以通过 env.getProperty("")方法获取配置文件中的配置信息

package com.xc.boot.datasource.multi.config;


import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.EnvironmentAware;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.env.Environment;


@Configuration
@MapperScan(basePackages = "com.xc.boot.datasource.multi.dao")
public class DynamicDataSourceConfig implements EnvironmentAware{

    @Autowired
    private Environment env;

    @Override
    public void setEnvironment(Environment environment) {
        this.env = environment;
    }

 
}

1) 创建动态的数据源对象

 1.1 先添加一个枚举对象 , 用于当做数据源的ID使用 , 有多少个数据源则添加多少个对应的属性

package com.xc.boot.datasource.multi.enums;

public enum DataSourceType {
    VXDB,CRAWLERDB
}

​

 1.2 构建一个DataSourceType容器

package com.xc.boot.datasource.multi.utils;

import com.xc.boot.datasource.multi.enums.DataSourceType;

public class DataSourceContextHolder {

    public static final ThreadLocal<DataSourceType> holder = new ThreadLocal<>();

    public static void setDataSourceType(DataSourceType type) {
        holder.set(type);
    }

    public static DataSourceType getDataSourceType(){
        return holder.get();
    }
}

 1.3 创建动态的数据源对象

package com.xc.boot.datasource.multi.utils;

import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;

public class DynamicDataSource extends AbstractRoutingDataSource{


    @Override
    protected Object determineCurrentLookupKey() {
        return DataSourceContextHolder.getDataSourceType();
    }
}

AbstractRoutingDataSource类是Spring为方便的在项目中实现动态切换数据源而提供的一个抽象类, 我们只需要实现上面的这个抽象方法 即可 , 该方法用于返回当前需要切换的数据源的key;

2) 配置数据源

在上面的配置类中加入数据源的配置

    @Bean(name="crawlerDataSource")
    public DataSource crawlerDataSource() throws Exception{
        Properties props = new Properties();
        props.put("url",env.getProperty("jdbc.crawler.url"));
        props.put("username",env.getProperty("jdbc.crawler.username"));
        props.put("password",env.getProperty("jdbc.crawler.password"));
        props.put("driver-class-name",env.getProperty("jdbc.driver-class-name"));
        props.put("filters",env.getProperty("jdbc.filters"));
        props.put("maxActive",env.getProperty("jdbc.maxActive"));
        props.put("initialSize",env.getProperty("jdbc.initialSize"));
        props.put("maxWait",env.getProperty("jdbc.maxWait"));
        props.put("validationQuery",env.getProperty("jdbc.validationQuery"));
        props.put("poolPreparedStatements",env.getProperty("jdbc.poolPreparedStatements"));
        props.put("maxOpenPreparedStatements",env.getProperty("jdbc.maxOpenPreparedStatements"));
        return DruidDataSourceFactory.createDataSource(props);
    }

    @Bean(name="vxDataSource")
    public DataSource vxDataSource() throws Exception{
        Properties props = new Properties();
        props.put("url",env.getProperty("jdbc.vx.url"));
        props.put("username",env.getProperty("jdbc.vx.username"));
        props.put("password",env.getProperty("jdbc.vx.password"));
        props.put("driver-class-name",env.getProperty("jdbc.driver-class-name"));
        props.put("filters",env.getProperty("jdbc.filters"));
        props.put("maxActive",env.getProperty("jdbc.maxActive"));
        props.put("initialSize",env.getProperty("jdbc.initialSize"));
        props.put("maxWait",env.getProperty("jdbc.maxWait"));
        props.put("validationQuery",env.getProperty("jdbc.validationQuery"));
        props.put("poolPreparedStatements",env.getProperty("jdbc.poolPreparedStatements"));
        props.put("maxOpenPreparedStatements",env.getProperty("jdbc.maxOpenPreparedStatements"));
        return DruidDataSourceFactory.createDataSource(props);
    }

    @Bean("dynamicDataSource")
    @Primary
    public DynamicDataSource dynamicDataSource(@Qualifier("vxDataSource")DataSource vxDataSource,
                                        @Qualifier("crawlerDataSource")DataSource crawlerDataSource){
        Map<Object,Object> targetDataSource = new HashMap<Object,Object>();
        targetDataSource.put(DataSourceType.VXDB,vxDataSource);
        targetDataSource.put(DataSourceType.CRAWLERDB,crawlerDataSource);
        DynamicDataSource dynamicDataSource = new DynamicDataSource();
        dynamicDataSource.setTargetDataSources(targetDataSource);
        dynamicDataSource.setDefaultTargetDataSource(vxDataSource);
        return dynamicDataSource;
    }

可以看到  , 除了VXDataSource 和 CrawlerDataSource 之外 , 还添加了一个上面新增的 DynamicDataSource , 其属性TartgetDataSources 是一个HashMap , 保存了需要用到的DataSource 和 每个DataSource的Key , 另外还可以设置一个默认的DataSource;

3) 配置SqlSessionFactory和事务管理器

    @Bean
    @Primary
    public SqlSessionFactory sqlSessionFactory(@Qualifier("vxDataSource")DataSource vxDataSource,
                                               @Qualifier("crawlerDataSource")DataSource crawlerDataSource) throws Exception{
        SqlSessionFactoryBean sqlSessionFactoryBean =  new SqlSessionFactoryBean();
        sqlSessionFactoryBean.setDataSource(dynamicDataSource(vxDataSource,crawlerDataSource));
        sqlSessionFactoryBean.setTypeAliasesPackage(env.getProperty("mybatis.typeAliasesPackage"));
        sqlSessionFactoryBean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources(env.getProperty("mybatis.mapper-locations")));
        return sqlSessionFactoryBean.getObject();
    }

    @Bean
    @Primary
    public DataSourceTransactionManager dataSourceTransactionManager(@Qualifier("dynamicDataSource")DynamicDataSource dynamicDataSource){
        return new DataSourceTransactionManager(dynamicDataSource);
    }

这两项的配置和第一种方式没有任何区别; 到此为止就配置完成了;

4) 完成动态数据源的切换

由于没有配置 MapperScannerConfugurer , 所以Spring并不知道应该使用哪一个数据源 , 所以会一直使用默认的数据源 ; 如果在Service层去手动执行其他数据源的切换的话 , 就会造成代码的侵入 , 因此可以编写一个AOP去动态的切换

package com.xc.boot.datasource.multi.aspect;

import com.xc.boot.datasource.multi.anno.CrawlerDao;
import com.xc.boot.datasource.multi.enums.DataSourceType;
import com.xc.boot.datasource.multi.utils.DataSourceContextHolder;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.aop.aspectj.MethodInvocationProceedingJoinPoint;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;

import java.lang.annotation.Annotation;

@Aspect
@Component
public class DynamicSelectedDataSourceAspect {


    @Pointcut("execution(* com.xc.boot.datasource.multi..*Dao.*(..))")
    public void dataSourcePointcut(){}

    @Before("dataSourcePointcut()")
    public void selectDataSource(JoinPoint joinPoint){
        System.out.println("-------------> selected dataSource aspect ");
        Signature signature = joinPoint.getSignature();
        Class mapper = signature.getDeclaringType();
        Annotation annos = mapper.getDeclaredAnnotation(CrawlerDao.class);
        if(null != annos){
            DataSourceContextHolder.setDataSourceType(DataSourceType.CRAWLERDB);
            System.out.println("-------------> selected Crawler dataSource");
        }else if(DataSourceContextHolder.getDataSourceType() != DataSourceType.VXDB){
            DataSourceContextHolder.setDataSourceType(DataSourceType.VXDB);
            System.out.println("-------------> selected VX dataSource");
        }
    }
}

首先编写一个切点表达式 , 该表达式的意思是 , 匹配 在 com.xc.boot.datasource.multi下的包及其子包中任意以Dao结尾的类中的全部方法 (不考虑其返回类型 , 方式名以及方法参数) , 即该任意一个方法被调用的时候都会拦截下来 ; 下面定义了一个前置通知 , 获取被调研的类 , 判断其是否有 @CrawlerDao 注解, 如果有则切换为Crawler数据源 , 否则使用 VX 数据源;

(PS: 没记错的话 Class.getDeclaredAnnotation方法是1.8新加的 ; 这里的切点表达式不可以配合 && @within 或 @annotation 使用 , 因为我们需要拦截的都是接口 , 而这两个指示器只能拦截到具体的类)

5) 总结

第二种方式相较于第一种方式来说 ,更加灵活 , 配置较少; 但是每一次对Dao的调用都会被AOP拦截 , 感觉还是有点不爽的

------------------------------------------- 问题 ------------------------------------------------

其实以上两种方式 , 都已经实现了数据源的动态切换 , 但是还有一个问题没有考虑到 , 那就是事务;

第一种方式中 , 定义了两个事务管理器; 一般在Service层 , 添加@Transactional 注解时 , 都会需要指定一个事务管理器 , 如果不指定那就使用默认的; 若在一个Service的方法中 , 需要对多个数据源进行更新操作 , 那么将只有指定发的哪一个事务会生效 ,其他事务不会生效 ;

第二种方式中 , 只定义了一个事务管理器 ; 同样的 ,在一个Service的方法中添加了@Transactional 注解之后 , 此时动态切换数据源将会失效 ,即此时只能够访问默认的数据源 , 其他的数据源无法进行访问 ;

以上的问题 , 都是本人在测试的时候发现的问题 , 且暂时还未找到完美的解决方法 ; 不知道各位有没有遇到这样的问题 , 以及对应的解决方案是啥?