问题引入：
公司云平台项目每个商户一个数据库，所以在写java领域层REST Server端的时候需要，根据应用层传递过来的商户id，进行动态切换数据；
一．普及知识
- 一个数据源，也就代表一个数据库，
源=数据的源头 - 数据源实例：一个数据库连接，就代表一个数据源实例对象；
- 多数据源实例：多个数据库连接对象；
二．寻找解决办法
- 我们的项目使用SpringBoot＋Mybatis开发的领域层，默认只连接一个数据库；
- 网上查询大部分的做法都是多数据源之间动态切换，也就是说在配置文件中提前配置好
几个数据库连接信息，自己获取配置文件中的这些配置，然后在springBoot启动的使用想办法自动创建这几个数据源实例； - 在后续需要切换数据库的时候，只需要指定对应的数据源key，进行动态切换即可；
- 可是我们的需求并不是这样的，我们需要根据外部的
变量进行动态创建数据源实例，然后在切换到该数据源上 - 对于多数据源的切换和加载，以下这篇文件讲的非常到位：
基于Spring Boot实现Mybatis的多数据源切换和动态数据源加载 - 所以我的项目主要需要解决的是多数据源动态加载，当然有了动态加载，动态切换就很简单了；
pom.xml需要添加
<!-- 引入aop -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-aop</artifactId>
</dependency>
<!-- druid数据源 -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid-spring-boot-starter</artifactId>
<version>1.1.6</version>
</dependency>
三．在 application.yml 中配置多个数据库连接信息如下：
db:
default:
#url: jdbc:mysql://localhost:3306/product_master?useSSL=false&useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&autoReconnect=true
driver-class-name: com.mysql.jdbc.Driver
url-base: jdbc:mysql://
host: localhost
port: 3306
dbname: ljyun_share
url-other: ?useSSL=false&useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&autoReconnect=true
username: common
password: common
#蓝景商城数据库
dbMall:
driver-class-name: com.mysql.jdbc.Driver
url-base: jdbc:mysql://
host: localhost
port: 3306
dbname: db_mall
url-other: ?useSSL=false&useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&autoReconnect=true
username: common
password: common
#云平台私有库
privateDB:
driver-class-name: com.mysql.jdbc.Driver
url-base: jdbc:mysql://
host: localhost
port: 3306
dbname: ljyun_{id}_merchant
url-other: ?useSSL=false&useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&autoReconnect=true
username: common
password: common
四．项目目录
多数据源-1.jpg
五．动态数据设置以及获取，本类属于单例；
-
DynamicDataSource需要继承AbstractRoutingDataSource
package domain.dbs;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;
import org.springframework.stereotype.Component;
import java.util.HashMap;
import java.util.Map;
/**
* 动态数据设置以及获取，本类属于单例
* @author lxf 2018-09-29
*/
@Component
public class DynamicDataSource extends AbstractRoutingDataSource {
private final Logger logger = LoggerFactory.getLogger(getClass());
//单例句柄
private static DynamicDataSource instance;
private static byte[] lock=new byte[0];
//用于存储已实例的数据源map
private static Map<Object,Object> dataSourceMap=new HashMap<Object, Object>();
/**
* 获取当前数据源
* @return
*/
@Override
protected Object determineCurrentLookupKey() {
logger.info("Current DataSource is [{}]", DynamicDataSourceContextHolder.getDataSourceKey());
return DynamicDataSourceContextHolder.getDataSourceKey();
}
/**
* 设置数据源
* @param targetDataSources
*/
@Override
public void setTargetDataSources(Map<Object, Object> targetDataSources) {
super.setTargetDataSources(targetDataSources);
dataSourceMap.putAll(targetDataSources);
super.afterPropertiesSet();// 必须添加该句，否则新添加数据源无法识别到
}
/**
* 获取存储已实例的数据源map
* @return
*/
public Map<Object, Object> getDataSourceMap() {
return dataSourceMap;
}
/**
* 单例方法
* @return
*/
public static synchronized DynamicDataSource getInstance(){
if(instance==null){
synchronized (lock){
if(instance==null){
instance=new DynamicDataSource();
}
}
}
return instance;
}
/**
* 是否存在当前key的 DataSource
* @param key
* @return 存在返回 true, 不存在返回 false
*/
public static boolean isExistDataSource(String key) {
return dataSourceMap.containsKey(key);
}
}
六．数据源配置类
-
DataSourceConfigurer在tomcat启动时触发，在该类中生成多个数据源实例并将其注入到 ApplicationContext 中； - 该类通过使用
@Configuration和@Bean注解，将创建好的多数据源实例自动注入到ApplicationContext上下中，供后期切换数据库用；
package domain.dbs;
import com.alibaba.druid.pool.DruidDataSource;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.SqlSessionTemplate;
import org.mybatis.spring.boot.autoconfigure.MybatisProperties;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.env.Environment;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;
import javax.sql.DataSource;
import java.util.HashMap;
import java.util.Map;
/**
* 数据源配置类,在tomcat启动时触发，在该类中生成多个数据源实例并将其注入到 ApplicationContext 中
* @author lxf 2018-09-27
*/
@Configuration
@EnableConfigurationProperties(MybatisProperties.class)
public class DataSourceConfigurer {
//日志logger句柄
private final Logger logger = LoggerFactory.getLogger(getClass());
//自动注入环境类，用于获取配置文件的属性值
@Autowired
private Environment evn;
private MybatisProperties mybatisProperties;
public DataSourceConfigurer(MybatisProperties properties) {
this.mybatisProperties = properties;
}
/**
* 创建数据源对象
* @param dbType 数据库类型
* @return data source
*/
private DruidDataSource createDataSource(String dbType) {
//如果不指定数据库类型，则使用默认数据库连接
String dbName = dbType.trim().isEmpty() ? "default" : dbType.trim();
DruidDataSource dataSource = new DruidDataSource();
String prefix = "db." + dbName +".";
String dbUrl = evn.getProperty( prefix + "url-base")
+ evn.getProperty( prefix + "host") + ":"
+ evn.getProperty( prefix + "port") + "/"
+ evn.getProperty( prefix + "dbname") + evn.getProperty( prefix + "url-other");
logger.info("+++default默认数据库连接url = " + dbUrl);
dataSource.setUrl(dbUrl);
dataSource.setUsername(evn.getProperty( prefix + "username"));
dataSource.setPassword(evn.getProperty( prefix + "password"));
dataSource.setDriverClassName(evn.getProperty( prefix + "driver-class-name"));
return dataSource;
}
/**
* spring boot 启动后将自定义创建好的数据源对象放到TargetDataSources中用于后续的切换数据源用
* (比如：DynamicDataSourceContextHolder.setDataSourceKey("dbMall")，手动切换到dbMall数据源
* 同时指定默认数据源连接
* @return 动态数据源对象
*/
@Bean
public DynamicDataSource dynamicDataSource() {
//获取动态数据库的实例（单例方式）
DynamicDataSource dynamicDataSource = DynamicDataSource.getInstance();
//创建默认数据库连接对象
DruidDataSource defaultDataSource = createDataSource("default");
//创建db_mall数据库连接对象
DruidDataSource mallDataSource = createDataSource("dbMall");
Map<Object,Object> map = new HashMap<>();
//自定义数据源key值，将创建好的数据源对象，赋值到targetDataSources中,用于切换数据源时指定对应key即可切换
map.put("default", defaultDataSource);
map.put("dbMall", mallDataSource);
dynamicDataSource.setTargetDataSources(map);
//设置默认数据源
dynamicDataSource.setDefaultTargetDataSource(defaultDataSource);
return dynamicDataSource;
}
/**
* 配置mybatis的sqlSession连接动态数据源
* @param dynamicDataSource
* @return
* @throws Exception
*/
@Bean
public SqlSessionFactory sqlSessionFactory(
@Qualifier("dynamicDataSource") DataSource dynamicDataSource)
throws Exception {
SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
bean.setDataSource(dynamicDataSource);
bean.setMapperLocations(mybatisProperties.resolveMapperLocations());
bean.setTypeAliasesPackage(mybatisProperties.getTypeAliasesPackage());
bean.setConfiguration(mybatisProperties.getConfiguration());
return bean.getObject();
}
@Bean(name = "sqlSessionTemplate")
public SqlSessionTemplate sqlSessionTemplate(
@Qualifier("sqlSessionFactory") SqlSessionFactory sqlSessionFactory)
throws Exception {
return new SqlSessionTemplate(sqlSessionFactory);
}
/**
* 将动态数据源添加到事务管理器中，并生成新的bean
* @return the platform transaction manager
*/
@Bean
public PlatformTransactionManager transactionManager() {
return new DataSourceTransactionManager(dynamicDataSource());
}
}
七．通过 ThreadLocal 获取和设置线程安全的数据源 key
-
DynamicDataSourceContextHolder类的实现
package domain.dbs;
/**
* 通过 ThreadLocal 获取和设置线程安全的数据源 key
*/
public class DynamicDataSourceContextHolder {
/**
* Maintain variable for every thread, to avoid effect other thread
*/
private static final ThreadLocal<String> contextHolder = new ThreadLocal<String>() {
/**
* 将 default 数据源的 key 作为默认数据源的 key
*/
// @Override
// protected String initialValue() {
// return "default";
// }
};
/**
* To switch DataSource
*
* @param key the key
*/
public static synchronized void setDataSourceKey(String key) {
contextHolder.set(key);
}
/**
* Get current DataSource
*
* @return data source key
*/
public static String getDataSourceKey() {
return contextHolder.get();
}
/**
* To set DataSource as default
*/
public static void clearDataSourceKey() {
contextHolder.remove();
}
}
八．AOP实现在DAO层做动态数据源切换（本项目没有用到）
package domain.dbs;
/**
* 动态数据源切换的切面，切 DAO 层，通过 DAO 层方法名判断使用哪个数据源，实现数据源切换
* 关于切面的 Order 可以可以不设，因为 @Transactional 是最低的，取决于其他切面的设置，
* 并且在 org.springframework.core.annotation.AnnotationAwareOrderComparator 会重新排序
*
* 注意：本项目因为是外部传递进来的云编号，根据动态创建数据源实例，并且进行切换，而这种只用dao层切面的方式，
* 适用于进行多个master/slave读写分类用的场景，所以我们的项目用不到这种方式（我们如果使用这种方式，
* 就需要修改daoAai入参方式，在前置处理器获取dao的方法参数，根据参数切换数据库，这样就需要修改dao接口，
* 以及对应mapper.xml，需要了解动态代理的知识，所以目前我们没有使用该方式，目前我们使用的是
* 在service或controller层手动切库）
*/
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
//@Aspect
//@Component
public class DynamicDataSourceAspect {
private static final Logger logger = LoggerFactory.getLogger(DynamicDataSourceAspect.class);
private final String[] QUERY_PREFIX = {"select"};
@Pointcut("execution( * domain.dao.impl.*.*(..))")
public void daoAspect() {
}
@Before("daoAspect()")
public void switchDataSource(JoinPoint point) {
Object[] params = point.getArgs();
System.out.println(params.toString());
String param = (String) params[0];
for (Object string:params
) {
System.out.println(string.toString());
}
System.out.println("###################################################");
System.out.println(point.getSignature().getName());
Boolean isQueryMethod = isQueryMethod(point.getSignature().getName());
//DynamicDataSourceContextHolder.setDataSourceKey("slave");
if (isQueryMethod) {
DynamicDataSourceContextHolder.setDataSourceKey("slave");
logger.info("Switch DataSource to [{}] in Method [{}]",
DynamicDataSourceContextHolder.getDataSourceKey(), point.getSignature());
}
}
@After("daoAspect())")
public void restoreDataSource(JoinPoint point) {
DynamicDataSourceContextHolder.clearDataSourceKey();
logger.info("Restore DataSource to [{}] in Method [{}]",
DynamicDataSourceContextHolder.getDataSourceKey(), point.getSignature());
}
private Boolean isQueryMethod(String methodName) {
for (String prefix : QUERY_PREFIX) {
if (methodName.startsWith(prefix)) {
return true;
}
}
return false;
}
}
九．SwitchDB手动切换数据库类
- 在
Controller和Service需要切换数据库的使用，需要使用SwitchDB.change()方法．
package domain.dbs;
import com.alibaba.druid.pool.DruidDataSource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.env.Environment;
import org.springframework.transaction.PlatformTransactionManager;
import java.util.HashMap;
import java.util.Map;
/**
* 切换数据库类
* @author lxf 2018-09-28
*/
@Configuration
@Slf4j
public class SwitchDB {
@Autowired
private Environment evn;
//私有库数据源key
private static String ljyunDataSourceKey = "ljyun_" ;
@Autowired
DynamicDataSource dynamicDataSource;
@Autowired
private PlatformTransactionManager transactionManager;
/**
* 切换数据库对外方法,如果私有库id参数非0,则首先连接私有库，否则连接其他已存在的数据源
* @param dbName 已存在的数据库源对象
* @param ljyunId 私有库主键
* @return 返回当前数据库连接对象对应的key
*/
public String change(String dbName,int ljyunId)
{
if( ljyunId == 0){
toDB(dbName);
}else {
toYunDB(ljyunId);
}
//获取当前连接的数据源对象的key
String currentKey = DynamicDataSourceContextHolder.getDataSourceKey();
log.info("＝＝＝＝＝当前连接的数据库是:" + currentKey);
return currentKey;
}
/**
* 切换已存在的数据源
* @param dbName
*/
private void toDB(String dbName)
{
//如果不指定数据库，则直接连接默认数据库
String dbSourceKey = dbName.trim().isEmpty() ? "default" : dbName.trim();
//获取当前连接的数据源对象的key
String currentKey = DynamicDataSourceContextHolder.getDataSourceKey();
//如果当前数据库连接已经是想要的连接，则直接返回
if(currentKey == dbSourceKey) return;
//判断储存动态数据源实例的map中key值是否存在
if( DynamicDataSource.isExistDataSource(dbSourceKey) ){
DynamicDataSourceContextHolder.setDataSourceKey(dbSourceKey);
log.info("＝＝＝＝＝普通库: "+dbName+",切换完毕");
}else {
log.info("切换普通数据库时，数据源key=" + dbName + "不存在");
}
}
/**
* 创建新的私有库数据源
* @param ljyunId
*/
private void toYunDB(int ljyunId){
//组合私有库数据源对象key
String dbSourceKey = ljyunDataSourceKey+String.valueOf(ljyunId);
//获取当前连接的数据源对象的key
String currentKey = DynamicDataSourceContextHolder.getDataSourceKey();
if(dbSourceKey == currentKey) return;
//创建私有库数据源
createLjyunDataSource(ljyunId);
//切换到当前数据源
DynamicDataSourceContextHolder.setDataSourceKey(dbSourceKey);
log.info("＝＝＝＝＝私有库: "+ljyunId+",切换完毕");
}
/**
* 创建私有库数据源，并将数据源赋值到targetDataSources中，供后切库用
* @param ljyunId
* @return
*/
private DruidDataSource createLjyunDataSource(int ljyunId){
//创建新的数据源
if(ljyunId == 0)
{
log.info("动态创建私有库数据时，私有库主键丢失");
}
String yunId = String.valueOf(ljyunId);
DruidDataSource dataSource = new DruidDataSource();
String prefix = "db.privateDB.";
String dbUrl = evn.getProperty( prefix + "url-base")
+ evn.getProperty( prefix + "host") + ":"
+ evn.getProperty( prefix + "port") + "/"
+ evn.getProperty( prefix + "dbname").replace("{id}",yunId) + evn.getProperty( prefix + "url-other");
log.info("+++创建云平台私有库连接url = " + dbUrl);
dataSource.setUrl(dbUrl);
dataSource.setUsername(evn.getProperty( prefix + "username"));
dataSource.setPassword(evn.getProperty( prefix + "password"));
dataSource.setDriverClassName(evn.getProperty( prefix + "driver-class-name"));
//将创建的数据源，新增到targetDataSources中
Map<Object,Object> map = new HashMap<>();
map.put(ljyunDataSourceKey+yunId, dataSource);
DynamicDataSource.getInstance().setTargetDataSources(map);
return dataSource;
}
}
十．Service中根据外部变量手动切换数据库，使用SwitchDB.change()
-
TestTransaction实现
package domain.service.impl.exhibition;
import domain.dao.impl.ExhibitionDao;
import domain.dbs.DynamicDataSource;
import domain.dbs.DynamicDataSourceContextHolder;
import domain.dbs.SwitchDB;
import domain.domain.DomainResponse;
import domain.domain.Exhibition;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport;
import java.util.HashMap;
import java.util.Map;
/**
* 测试切库后的事务类
* @author lxf 2018-09-28
*/
@Service
@Slf4j
public class TestTransaction {
@Autowired
private ExhibitionDao dao;
@Autowired
private SwitchDB switchDB;
@Autowired
DynamicDataSource dynamicDataSource;
public DomainResponse testProcess(int kaiguan, int ljyunId, String dbName){
switchDB.change(dbName,ljyunId);
//获取当前已有的数据源实例
System.out.println("%%%%%%%%"+dynamicDataSource.getDataSourceMap());
return process(kaiguan,ljyunId,dbName);
}
/**
* 事务测试
* 注意：(1)有@Transactional注解的方法，方法内部不可以做切换数据库操作
* (2)在同一个service其他方法调用带@Transactional的方法，事务不起作用，（比如：在本类中使用testProcess调用process()）
* 可以用其他service中调用带@Transactional注解的方法，或在controller中调用.
* @param kaiguan
* @param ljyunId
* @param dbName
* @return
*/
//propagation 传播行为 isolation 隔离级别 rollbackFor 回滚规则
@Transactional(propagation = Propagation.REQUIRED,isolation = Isolation.DEFAULT,timeout=36000,rollbackFor=Exception.class)
public DomainResponse process(int kaiguan, int ljyunId, String dbName ) {
String currentKey = DynamicDataSourceContextHolder.getDataSourceKey();
log.info("＝＝＝＝＝service当前连接的数据库是:" + currentKey);
Exhibition exhibition = new Exhibition();
exhibition.setExhibitionName("A-001-003");
//return new DomainResponse<String>(1, "新增成功", "");
int addRes = dao.insert(exhibition);
if(addRes>0 && kaiguan==1){
exhibition.setExhibitionName("B-001-002");
int addRes2 = dao.insert(exhibition);
return new DomainResponse<String>(1, "新增成功", "");
}else
{
Map<String,String> map = new HashMap<>();
String a = map.get("hello");
//log.info("-----a="+a.replace("a","b"));
//手动回滚事务
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
return new DomainResponse<String>(0, "新增错误，事务已回滚", "");
}
}
}
十一．切库与事务
-
需要在
DataSourceConfigurer类中添加如下配置，让事务管理器与动态数据源对应起来；/** * 将动态数据源添加到事务管理器中，并生成新的bean * @return the platform transaction manager */ @Bean public PlatformTransactionManager transactionManager() { return new DataSourceTransactionManager(dynamicDataSource()); } ``` 有
@Transactional注解的方法，方法内部不可以做切换数据库 操作在
同一个service其他方法调用带@Transactional的方法，事务不起作用，（比如：在本类中使用testProcess调用process()），参考这篇文章：https://blog.csdn.net/qq_33696896/article/details/82013095，知道的；可以用
其他service中调用带@Transactional注解的方法，或在controller中调用.
关于多数据源的参考文章：
spring 动态切换、添加数据源实现以及源码浅析
Spring Boot 中使用 MyBatis 下实现多数据源动态切换，读写分离
关于事务的参考文章：
透彻的掌握 Spring 中@transactional 的使用
