SpringBoot--实现Mybatis的多数据源切换和动态数据源切换
环境依赖：
Spring Boot：1.5.9
JDK：1.8.0
MySQL：5.7.17
Mybatis：3.3.0
本文主要就mybatis的多数据源切换和动态数据源加载的实现原理做分享；对于mybatis的基础可自行百度。由于在开始学习的时候，发现网上有很多人把多数据源切换和动态数据源加载混为一谈，导致在实现动态加载的时候，所很苦恼。所以有必要在这里做以简要说明：
多数据源切换：指项目所需要不止一个数据库的连接信息，eg：同一数据库地址下的不同库或者压根连地址都不同。
动态切换：指所需要的数据所在的数据库信息在项目启动前并不知道，只有在项目运行后根据业务逻辑获取到对应的数据库信息，并在代码的运行过程中，向Spring Boot中添加一个或多个mybatis实例。
单一数据源的连接
顾名思义，在项目中，在项目中只需要配置一个数据库的信息即可，业务所需要的所有数据均在这一个数据库下；这种场景通常能够适用于绝大部分的实际需求，因此这种实现的原理再次不做赘述，如有需求可自行百度。具体实现可参考源码spring-boot-mybatis-demo。
多数据源切换
业务场景：需要分别获取所有的用户信息和学生信息；但是已知用户信息在mybatis_demo数据库中，学生信息在mybatis_demo2 数据库中。如下图所示：
数据库mybatis_demo内有个用户表：user_info，表结构如下：
数据库mybatis_demo2内有一个学生表：student_info，表结构如下：
配置文件信息如下：
在这里介绍一种最为简单的实现方案：多数据源 - 多实例。
在熟悉了单实例数据源的实现后，不难看出，在Spring Boot中，通过为该数据源DataSource初始化一个与之对应的SessionFactory，从而实现连接。因此在面对多数据源的时候，可以分别为每个数据源写一个mybatis的config类，使其每个DataSource都拥有一个只属于自己的SessionFactory，这样就可以根据各自的mapper映射目录找到对应的mybaits实例；
这种实现方法要求不同的mybatis实例的mapper映射目录不能相同
把一个配置类作下的Bean命名统一，并注入相应的Bean，从而可以保证每一个SessionFactory所对应的配置信息唯一；具体配置如下：
第一个数据源的配置：
@Configuration @MapperScan(basePackages = "com.yhyr.mybatis.mapper.UserMapper", sqlSessionTemplateRef = "oneSqlSessionTemplate") public class MybatisConfig { @Bean(name = "oneDataSource") @ConfigurationProperties(prefix = "spring.datasource.one") @Primary public DataSource customDataSource() { return DataSourceBuilder.create().build(); } @Bean(name = "oneSqlSessionFactory") @Primary public SqlSessionFactory customSqlSessionFactory(@Qualifier("oneDataSource") DataSource dataSource) throws Exception { SqlSessionFactoryBean bean = new SqlSessionFactoryBean(); bean.setDataSource(dataSource); bean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath*:mapper/*.xml")); return bean.getObject(); } @Bean(name = "oneTransactionManager") @Primary public DataSourceTransactionManager customTransactionManager(@Qualifier("oneDataSource") DataSource dataSource) { return new DataSourceTransactionManager(dataSource); } @Bean(name = "oneSqlSessionTemplate") @Primary public SqlSessionTemplate customSqlSessionTemplate(@Qualifier("oneSqlSessionFactory") SqlSessionFactory sqlSessionFactory) throws Exception { return new SqlSessionTemplate(sqlSessionFactory); } }
第二个数据源的配置：
@Configuration @MapperScan(basePackages = "com.yhyr.mybatis.mapper.StudentMapper", sqlSessionTemplateRef = "anotherSqlSessionTemplate") public class MybatisConfig2 { @Bean(name = "anotherDataSource") @ConfigurationProperties(prefix = "spring.datasource.another") public DataSource customDataSource() { return DataSourceBuilder.create().build(); } @Bean(name = "anotherSqlSessionFactory") public SqlSessionFactory customSqlSessionFactory(@Qualifier("anotherDataSource") DataSource dataSource) throws Exception { SqlSessionFactoryBean bean = new SqlSessionFactoryBean(); bean.setDataSource(dataSource); bean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath*:mapper/*.xml")); return bean.getObject(); } @Bean(name = "anotherTransactionManager") public DataSourceTransactionManager customTransactionManager(@Qualifier("anotherDataSource") DataSource dataSource) { return new DataSourceTransactionManager(dataSource); } @Bean(name = "anotherSqlSessionTemplate") public SqlSessionTemplate customSqlSessionTemplate(@Qualifier("anotherSqlSessionFactory") SqlSessionFactory sqlSessionFactory) throws Exception { return new SqlSessionTemplate(sqlSessionFactory); } }
完成配置文件的配置后，可在工程目录的mapper包下新建两个目录：UserMapper和StudentMapper，分别对应两个数据源。这两个目录只能同级，或者不同目录，不能互为子父目录。
通过mapper接口和注解方式实现对数据的获取，代码如下：
@Select("SELECT * FROM user_info")
public interface UserInfoMapper {
List<UserInfo> getUserInfo();
}
@Select("SELECT * FROM student_info")
public interface StudentInfoMapper {
List<StudentInfo> getStudentInfo();
}
Service层的逻辑：分别注入UserInfoMapper 和 StudentInfoMapper，获取用户和学生信息；
@SpringBootApplication public class MybatisApplication implements CommandLineRunner { @Autowired UserService userService; @Autowired StudentService studentService; public static void main(String[] args) { SpringApplication.run(MybatisApplication.class, args); } @Override public void run(String... strings) { List<UserInfo> userInfoList = userService.getUserInfo(); userInfoList.stream().forEach(userInfo -> System.out.println("name is : " + userInfo.getName() + "; sex is : " + userInfo.getSex() + "; age is : " + userInfo.getAge())); List<StudentInfo> studentInfoList = studentService.getStudentInfo(); studentInfoList.stream().forEach(studentInfo -> System.out.println("studentName is : " + studentInfo.getStudentName() + "; className is : " + studentInfo.getClassName())); } }
最后贴上入口函数的逻辑和运行结果：
动态数据源切换
业务场景：
现有已知的两个数据源：default和master；
default：用户常规的业务逻辑，（eg：单数据源的业务需求）
master：该数据源内只有一个db_info表，该表内维护这数据库的基本信息(dbName, dbIp, dbPort, dbUser, dbPasswd)
现在需要根据业务需求，获取master中相应的数据库基本信息，然后根据从获取到的数据库基本信息中获取所需要的业务数据。(可类比Hadoop中的NameNode和DataNode的关系)
在这种业务场景下，上述那种在程序执行前就一次性初始化所有mybatis实例的方法就行不通了。所以可以借助如下思路来思考：
基于这种方式，不仅可是实现真正意义上的多数据源的切换（第二种实现多数据源切换的思路），还可以实现在程序的运行过程中，实现动态添加一个或多个新的数据源。这里重点关注的是配置文件之间的关系，对象模型如下：
首先分析一下AbstractRoutingDataSource抽象类的源码：
public abstract class AbstractRoutingDataSource extends AbstractDataSource implements InitializingBean { private Map<Object, Object> targetDataSources; private Object defaultTargetDataSource; private boolean lenientFallback = true; private DataSourceLookup dataSourceLookup = new JndiDataSourceLookup(); private Map<Object, DataSource> resolvedDataSources; private DataSource resolvedDefaultDataSource; public AbstractRoutingDataSource() { } public void setTargetDataSources(Map<Object, Object> targetDataSources) { this.targetDataSources = targetDataSources; } public void setDefaultTargetDataSource(Object defaultTargetDataSource) { this.defaultTargetDataSource = defaultTargetDataSource; } public void setLenientFallback(boolean lenientFallback) { this.lenientFallback = lenientFallback; } public void setDataSourceLookup(DataSourceLookup dataSourceLookup) { this.dataSourceLookup = (DataSourceLookup)(dataSourceLookup != null ? dataSourceLookup : new JndiDataSourceLookup()); } public void afterPropertiesSet() { if (this.targetDataSources == null) { throw new IllegalArgumentException("Property 'targetDataSources' is required"); } else { this.resolvedDataSources = new HashMap(this.targetDataSources.size()); Iterator var1 = this.targetDataSources.entrySet().iterator(); while(var1.hasNext()) { Entry<Object, Object> entry = (Entry)var1.next(); Object lookupKey = this.resolveSpecifiedLookupKey(entry.getKey()); DataSource dataSource = this.resolveSpecifiedDataSource(entry.getValue()); this.resolvedDataSources.put(lookupKey, dataSource); } if (this.defaultTargetDataSource != null) { this.resolvedDefaultDataSource = this.resolveSpecifiedDataSource(this.defaultTargetDataSource); } } } protected Object resolveSpecifiedLookupKey(Object lookupKey) { return lookupKey; } protected DataSource resolveSpecifiedDataSource(Object dataSource) throws IllegalArgumentException { if (dataSource instanceof DataSource) { return (DataSource)dataSource; } else if (dataSource instanceof String) { return this.dataSourceLookup.getDataSource((String)dataSource); } else { throw new IllegalArgumentException("Illegal data source value - only [javax.sql.DataSource] and String supported: " + dataSource); } } public Connection getConnection() throws SQLException { return this.determineTargetDataSource().getConnection(); } public Connection getConnection(String username, String password) throws SQLException { return this.determineTargetDataSource().getConnection(username, password); } public <T> T unwrap(Class<T> iface) throws SQLException { return iface.isInstance(this) ? this : this.determineTargetDataSource().unwrap(iface); } public boolean isWrapperFor(Class<?> iface) throws SQLException { return iface.isInstance(this) || this.determineTargetDataSource().isWrapperFor(iface); } protected DataSource determineTargetDataSource() { Assert.notNull(this.resolvedDataSources, "DataSource router not initialized"); Object lookupKey = this.determineCurrentLookupKey(); DataSource dataSource = (DataSource)this.resolvedDataSources.get(lookupKey); if (dataSource == null && (this.lenientFallback || lookupKey == null)) { dataSource = this.resolvedDefaultDataSource; } if (dataSource == null) { throw new IllegalStateException("Cannot determine target DataSource for lookup key [" + lookupKey + "]"); } else { return dataSource; } } protected abstract Object determineCurrentLookupKey(); }
对于该抽象类，关注两组变量：Map<Object, Object> targetDataSources和Object defaultTargetDataSource、Map<Object, DataSource> resolvedDataSources和DataSource resolvedDefaultDataSource；这两组变量是相互对应的；在熟悉多实例数据源切换代码的不难发现，当有多个数据源的时候，一定要指定一个作为默认的数据源，在这里也同理，当同时初始化多个数据源的时候，需要显示的调用setDefaultTargetDataSource方法指定一个作为默认数据源；
我们需要关注的是Map<Object, Object> targetDataSources和Map<Object, DataSource> resolvedDataSources，targetDataSources是暴露给外部程序用来赋值的，而resolvedDataSources是程序内部执行时的依据，因此会有一个赋值的操作，如下图所示：
根据这段源码可以看出，每次执行时，都会遍历targetDataSources内的所有元素并赋值给resolvedDataSources；这样如果我们在外部程序新增一个新的数据源，都会添加到内部使用，从而实现数据源的动态加载。
继承该抽象类的时候，必须实现一个抽象方法：protected abstract Object determineCurrentLookupKey()，该方法用于指定到底需要使用哪一个数据源。
到此基本上清楚了该抽象类的使用方法，接下来贴下具体的实现代码：
自定义数据源DataSource类：
public class DynamicDataSource extends AbstractRoutingDataSource { private static DynamicDataSource instance; private static byte[] lock=new byte[0]; private static Map<Object,Object> dataSourceMap=new HashMap<Object, Object>(); @Override public void setTargetDataSources(Map<Object, Object> targetDataSources) { super.setTargetDataSources(targetDataSources); dataSourceMap.putAll(targetDataSources); super.afterPropertiesSet();// 必须添加该句，否则新添加数据源无法识别到 } public Map<Object, Object> getDataSourceMap() { return dataSourceMap; } public static synchronized DynamicDataSource getInstance(){ if(instance==null){ synchronized (lock){ if(instance==null){ instance=new DynamicDataSource(); } } } return instance; } //必须实现其方法 protected Object determineCurrentLookupKey() { return DataSourceContextHolder.getDBType(); } }
通过ThreadLocal维护一个全局唯一的map来实现数据源的动态切换
public class DataSourceContextHolder { private static final ThreadLocal<String> contextHolder = new ThreadLocal<String>(); public static synchronized void setDBType(String dbType){ contextHolder.set(dbType); } public static String getDBType(){ return contextHolder.get(); } public static void clearDBType(){ contextHolder.remove(); } }
Mybatis配置文件：
@Configuration public class DataSourceConfig { @Value("${spring.datasource.default.url}") private String defaultDBUrl; @Value("${spring.datasource.default.username}") private String defaultDBUser; @Value("${spring.datasource.default.password}") private String defaultDBPassword; @Value("${spring.datasource.default.driver-class-name}") private String defaultDBDreiverName; @Value("${spring.datasource.master.url}") private String masterDBUrl; @Value("${spring.datasource.master.username}") private String masterDBUser; @Value("${spring.datasource.master.password}") private String masterDBPassword; @Value("${spring.datasource.default.driver-class-name}") private String masterDBDreiverName; @Bean public DynamicDataSource dynamicDataSource() { DynamicDataSource dynamicDataSource = DynamicDataSource.getInstance(); DruidDataSource defaultDataSource = new DruidDataSource(); defaultDataSource.setUrl(defaultDBUrl); defaultDataSource.setUsername(defaultDBUser); defaultDataSource.setPassword(defaultDBPassword); defaultDataSource.setDriverClassName(defaultDBDreiverName); DruidDataSource masterDataSource = new DruidDataSource(); masterDataSource.setDriverClassName(masterDBDreiverName); masterDataSource.setUrl(masterDBUrl); masterDataSource.setUsername(masterDBUser); masterDataSource.setPassword(masterDBPassword); Map<Object,Object> map = new HashMap<>(); map.put("default", defaultDataSource); map.put("master", masterDataSource); dynamicDataSource.setTargetDataSources(map); dynamicDataSource.setDefaultTargetDataSource(defaultDataSource); return dynamicDataSource; } @Bean public SqlSessionFactory sqlSessionFactory( @Qualifier("dynamicDataSource") DataSource dynamicDataSource) throws Exception { SqlSessionFactoryBean bean = new SqlSessionFactoryBean(); bean.setDataSource(dynamicDataSource); bean.setMapperLocations(new PathMatchingResourcePatternResolver() .getResources("classpath*:mapper/*.xml")); return bean.getObject(); } @Bean(name = "sqlSessionTemplate") public SqlSessionTemplate sqlSessionTemplate( @Qualifier("sqlSessionFactory") SqlSessionFactory sqlSessionFactory) throws Exception { return new SqlSessionTemplate(sqlSessionFactory); } }
其他业务逻辑同多数据源切换，下面贴上如何切换数据源：
@SpringBootApplication public class DynamicApplication implements CommandLineRunner { @Autowired UserService userService; @Autowired DBService dbService; @Autowired StudentService studentService; public static void main(String[] args) { SpringApplication.run(DynamicApplication.class, args); } @Override public void run(String... strings) throws Exception { /** * 获取maste数据库信息 */ DataSourceContextHolder.setDBType("default"); List<UserInfo> userInfoList = userService.getUserInfo(); userInfoList.stream().forEach(userInfo -> System.out.println("name is : " + userInfo.getName() + "; sex is : " + userInfo.getSex() + "; age is : " + userInfo.getAge())); /** * 根据slave数据源获取目标数据库信息 */ DataSourceContextHolder.setDBType("master"); int primayrId = 1; DBInfo dbInfo = dbService.getDBInfoByprimayrId(primayrId); System.out.println("dbName is -> " + dbInfo.getDbName() + "; dbIP is -> " + dbInfo.getDbIp() + "; dbUser is -> " + dbInfo.getDbUser() + "; dbPasswd is -> " + dbInfo.getDbPasswd()); DruidDataSource dynamicDataSource = new DruidDataSource(); dynamicDataSource.setDriverClassName("com.mysql.jdbc.Driver"); dynamicDataSource.setUrl("jdbc:mysql://" + dbInfo.getDbIp() + ":" + dbInfo.getDbPort() + "/" + dbInfo.getDbName() + "?characterEncoding=utf-8&zeroDateTimeBehavior=convertToNull"); dynamicDataSource.setUsername(dbInfo.getDbUser()); dynamicDataSource.setPassword(dbInfo.getDbPasswd()); /** * 创建动态数据源 */ Map<Object, Object> dataSourceMap = DynamicDataSource.getInstance().getDataSourceMap(); dataSourceMap.put("dynamic-slave", dynamicDataSource); DynamicDataSource.getInstance().setTargetDataSources(dataSourceMap); /** * 切换为动态数据源实例，打印学生信息 */ DataSourceContextHolder.setDBType("dynamic-slave"); List<StudentInfo> studentInfoList = studentService.getStudentInfo(); studentInfoList.stream().forEach(studentInfo -> System.out.println("studentName is : " + studentInfo.getStudentName() + "; className is : " + studentInfo.getClassName() + "; gradeName is : " + studentInfo.getGradeName())); } }
这种是在业务中使用代码设置数据源的方式，也可以使用AOP+注解的方式实现控制，还可以前端头部设置后端通过拦截器统一设置！
