springboot基于注解动态配置多数据源以及多数据源的事务统一

springboot基于注解动态配置多数据源以及多数据源的事务统⼀参考⽂档：
⼀、动态注⼊多数据源
1、配置多数据源配置⽂件（application-db.properties）
######多数据源配置⽂件####################
###第⼀个####
=first
spring.datasource.first.url=jdbc:oracle:thin:@127.0.0.1:1521:orcl
ername=sepcore
spring.datasource.first.password=sepcore
spring.datasource.first.driverClassName=oracle.jdbc.driver.OracleDriver
spring.datasource.first.mapperLocations=classpath:mappers/*Mapper.xml
####第⼆个####
=second
spring.datasource.second.url=jdbc:mysql://127.0.0.1:3306/test?serverTimezone=UTC&characterEncoding=utf8&useUnicode=true&useSSL=false
ername=root
spring.datasource.second.password=123456
spring.datasource.second.driverClassName=com.mysql.jdbc.Driver
spring.datasource.second.mapperLocations=classpath:mappers/*Mapper.xml
#####mapper接⼝所在包#######
scanner.mapperInterfacePackage=com.example.demo.mappers
2、读取配置⽂件类（DataSourceConfig）
public class DataSourceConfig {
/**
* 存储dataSource、SqlSessionTemplate、DataSourceTransactionManager
*/
private Map<String,Map<String,Object>>mapMap;
/**
* 获取mybatis扫描的指定接⼝包（所有数据源的接⼝放在同⼀的⽗包下⾯）
*/
private String mapperInterfacePackage;
public DataSourceConfig(){
mapMap = new HashMap<>();
InputStream in = DataSourceConfig.class.getClassLoader().
getResourceAsStream("application-db.properties");
Properties properties = new Properties();
try {
properties.load(in);
} catch (IOException e) {
e.printStackTrace();
}
Set<String> set = properties.stringPropertyNames();
for (String s : set) {
//判断是否是mapper接⼝指定包路径
if (s.contains("mapperInterfacePackage")){
mapperInterfacePackage = properties.get(s).toString();
continue;
}
String key = s.substring(0, stIndexOf("."));
if (mapMap.containsKey(key)){
Map<String, Object> map = mapMap.get(key);
map.put(s,properties.get(s));
}else{
Map<String,Object>map = new HashMap<>();
map.put(s,properties.get(s));
mapMap.put(key,map);
}
}
}
public String getMapperInterfacePackage() {
return mapperInterfacePackage;
}
/**
* 获取SqlSessionTemplate
* @return
* @throws Exception
*/
public Map<String,Object>getSqlSessionTemplateAndDataSource() throws Exception {
Set<Map.Entry<String, Map<String, Object>>> entries = this.mapMap.entrySet();
Map<String,Object>result = new HashMap<>(entries.size());
for (Map.Entry<String, Map<String, Object>> entry : entries) {
String key = entry.getKey();
Map<String, Object> map = entry.getValue();
DataSource dataSource = DataSourceBuilder.create().url(map.get(key+".url").toString()).
username(map.get(key+".username").toString()).password(map.get(key+".password").toString()).
driverClassName(map.get(key+".driverClassName").toString()).
build();
//为每个数据源设置事务
DataSourceTransactionManager dataSourceTransactionManager = new DataSourceTransactionManager();
dataSourceTransactionManager.setDataSource(dataSource);
SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
//设置dataSource数据源
sqlSessionFactoryBean.setDataSource(dataSource);
//设置*mapper.xml路径
sqlSessionFactoryBean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources(map.get(key+".mapperLocations").toString())); String s = map.get(key + ".name").toString();
result.put(s+"SqlSessionTemplate",new SqlSessionTemplate(sqlSessionFactoryBean.getObject()));
result.put(s+"DataSource",dataSource);
result.put(s+"DataSourceTransactionManager",dataSourceTransactionManager);
}
return result;
}
}
3、使⽤注解（DataSourceRoute），确定每个mapper接⼝使⽤哪个数据源
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface DataSourceRoute {
String name() default "first";
}
@DataSourceRoute
public interface SepUserMapper {
List<Map<String,Object>> findByUserLevel(Long userLevel);
void insert(Map<String,Object>map);
}
@DataSourceRoute(name = "second")
public interface IDiDataItemMapper {
@Select("SELECT dataitem_id,name FROM di_dataitem WHERE dataitem_id=#{dataItemId}")
Map<String,Object>selectOne(Long dataItemId);
void insert(Map<String, Object> map);
}
4、扫描指定包下⾯的mapper接⼝
public class ClassScanner {
public static Map<String,Class<?>>getMapperInterface(String mapperInterfacePackage) throws Exception {
Map<String,Class<?>>classMap = new HashMap<>();
ClassLoader loader = Thread.currentThread().getContextClassLoader();
//将"."替换成"/"
String packagePath = mapperInterfacePackage.replace(".", "/");
URL url = loader.getResource(packagePath);
List<String> fileNames = null;
if (url != null) {
String type = url.getProtocol();
if ("file".equals(type)) {
fileNames = getClassNameByFile(url.getPath(), null, true);
}
}
for (String classPath : fileNames) {
classMap.putAll(getClassByPath(classPath));
}
return classMap;
}
/**
* 读取package下的所有类⽂件
* @param filePath
* @param className
* @param childPackage
* @return
*/
private static List<String> getClassNameByFile(String filePath, List<String> className, boolean childPackage) {
List<String> myClassName = new ArrayList<>();
File file = new File(filePath);
File[] childFiles = file.listFiles();
for (File childFile : childFiles) {
if (childFile.isDirectory()) {
if (childPackage) {
myClassName.addAll(getClassNameByFile(childFile.getPath(), myClassName, childPackage));
}
} else {
String childFilePath = childFile.getPath();
if (childFilePath.endsWith(".class")) {
childFilePath = childFilePath.substring(childFilePath.indexOf("\\classes") + 9,
stIndexOf("."));
childFilePath = childFilePath.replace("\\", ".");
myClassName.add(childFilePath);
}
}
}
return myClassName;
}
/**
* 将Mapper的标准⽂件，转成 Mapper Class
* @param classPath
* @return
* @throws Exception
*/
private static Map<String, Class<?>> getClassByPath(String classPath)
throws Exception{
ClassLoader loader = Thread.currentThread().getContextClassLoader();
Map<String, Class<?>> classMap = new HashMap<>();
classMap.put(getClassAlias(classPath),loader.loadClass(getFullClassName(classPath)));
return classMap;
}
/**
* 将Mapper的标准⽂件，转成java标准的类名称
* @param classPath
* @return
* @throws Exception
*/
private static String getFullClassName(String classPath)
throws Exception{
int comIndex = classPath.indexOf("com");
classPath = classPath.substring(comIndex);
classPath = classPath.replaceAll("\\/", ".");
return classPath;
}
/**
* 根据类地址，获取类的Alais，即根据名称，按照驼峰规则，⽣成可作为变量的名称
* @param classPath
* @return
* @throws Exception
*/
private static String getClassAlias(String classPath)
throws Exception{
String split = "\\/";
String[] classTmp = classPath.split(split);
String className = classTmp[classTmp.length-1];
return toLowerFisrtChar(className);
}
/**
* 将字符串的第⼀个字母转⼩写
* @param className
* @return
*/
private static String toLowerFisrtChar(String className){
String fisrtChar = className.substring(0,1);
fisrtChar = fisrtChar.toLowerCase();
return fisrtChar+className.substring(1);
}
5、使⽤BeanFactoryPostProcessor动态插⼊数据源
@Component
public class DataSourceBean implements BeanFactoryPostProcessor{
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
System.out.println("在spring处理bean前，将⾃定义的bean注册到容器中======================");
DataSourceConfig dataSourceConfig = new DataSourceConfig();
try {
Map<String, Object> sqlSessionTemplateAndDataSource = dataSourceConfig.getSqlSessionTemplateAndDataSource();
Map<String, Class<?>> mapperInterface = ClassScanner.getMapperInterface(dataSourceConfig.getMapperInterfacePackage());
Set<Map.Entry<String, Class<?>>> entries = mapperInterface.entrySet();
for (Map.Entry<String, Class<?>> entry : entries) {
MapperFactoryBean mapperFactoryBean = new MapperFactoryBean();
Class<?> value = entry.getValue();
DataSourceRoute dataSourceRoute = value.getAnnotation(DataSourceRoute.class);
if (null==dataSourceConfig){
continue;
}
String name = ();
SqlSessionTemplate template = (SqlSessionTemplate) sqlSessionTemplateAndDataSource.get(name + "SqlSessionTemplate");
mapperFactoryBean.setMapperInterface(value);
mapperFactoryBean.setSqlSessionTemplate(template);
mapperFactoryBean.afterPropertiesSet();
configurableListableBeanFactory.registerSingleton(name+"MapperFactory",mapperFactoryBean.getObject());
configurableListableBeanFactory.registerSingleton(name+"DataSource",sqlSessionTemplateAndDataSource.get(name + "DataSource"));
configurableListableBeanFactory.registerSingleton(name+"SqlSessionTemplate",template);
configurableListableBeanFactory.registerSingleton(name+"DataSourceTransactionManager",sqlSessionTemplateAndDataSource.get(name+"DataSourceTransactionManager")); }
} catch (Exception e) {
System.err.println(e.getMessage());
}
}
}
⾄此多数据源动态加载就完成了。

⼆、多数据源统⼀事务控制
当使⽤多数据源时，单⼀的事务会出现问题（当在service层同时操作两个数据源时，当发⽣异常，只会回滚离抛出异常最近的数据源的数据）1、⾃定义事务注解
@Target({ElementType.METHOD,ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
public @interface CustomTransaction {
String[] name() default {"firstDataSourceTransactionManager"};
}
2、创建aop切⾯进⾏事务控制
@Component
@Aspect
public class TransactionAop {
@Pointcut(value = "@annotation(com.example.demo.annon.CustomTransaction)")
public void pointCut(){}
@Around(value = "pointCut()&&@annotation(annotation)")
public Object twiceAsOld(ProceedingJoinPoint point, CustomTransaction annotation) throws Throwable {
Stack<DataSourceTransactionManager> dataSourceTransactionManagerStack = new Stack<DataSourceTransactionManager>();
Stack<TransactionStatus> transactionStatuStack = new Stack<TransactionStatus>();
try {
if (!openTransaction(dataSourceTransactionManagerStack, transactionStatuStack, annotation)) {
return null;
}
Object ret = point.proceed();
commit(dataSourceTransactionManagerStack, transactionStatuStack);
return ret;
} catch (Throwable e) {
rollback(dataSourceTransactionManagerStack, transactionStatuStack);
throw e;
}
}
/**
* 开启事务处理⽅法
*
* @param dataSourceTransactionManagerStack
* @param transactionStatuStack
* @param multiTransactional
* @return
*/
private boolean openTransaction(Stack<DataSourceTransactionManager> dataSourceTransactionManagerStack,
Stack<TransactionStatus> transactionStatuStack, CustomTransaction multiTransactional) {
String[] transactionMangerNames = ();
if (ArrayUtils.isEmpty(())) {
return false;
}
for (String beanName : transactionMangerNames) {
//根据事务名称获取具体的事务
DataSourceTransactionManager dataSourceTransactionManager = (DataSourceTransactionManager) SpringContextUtil
.getBean(beanName);
TransactionStatus transactionStatus = dataSourceTransactionManager
.getTransaction(new DefaultTransactionDefinition());
transactionStatuStack.push(transactionStatus);
dataSourceTransactionManagerStack.push(dataSourceTransactionManager);
}
return true;
}
/**
* 提交处理⽅法
*
* @param dataSourceTransactionManagerStack
* @param transactionStatuStack
*/
private void commit(Stack<DataSourceTransactionManager> dataSourceTransactionManagerStack,
Stack<TransactionStatus> transactionStatuStack) {
while (!dataSourceTransactionManagerStack.isEmpty()) {
dataSourceTransactionManagerStack.pop().commit(transactionStatuStack.pop());
}
}
/**
* 回滚处理⽅法
*
* @param dataSourceTransactionManagerStack
* @param transactionStatuStack
*/
private void rollback(Stack<DataSourceTransactionManager> dataSourceTransactionManagerStack,
Stack<TransactionStatus> transactionStatuStack) {
while (!dataSourceTransactionManagerStack.isEmpty()) {
dataSourceTransactionManagerStack.pop().rollback(transactionStatuStack.pop());
}
}
}
3、在service层指定使⽤哪个事务
//注意事务的命名规则
@CustomTransaction(name = {"firstDataSourceTransactionManager","secondDataSourceTransactionManager"}) public void setSepUserMapper(){
//操作数据源2
Map<String,Object>mm = new HashMap<>(2);
mm.put("dataitemId",1L);
mm.put("name","测试");
diDataItemMapper.insert(mm);
//操作数据源1
Map<String,Object>map = new HashMap<>(3);
map.put("userId",1L);
map.put("userName","张三");
map.put("name","平台管理员");
sepUserMapper.insert(map);
throw new RuntimeException("sfsa");
}
辅助类：SpringContextUtil
@Component
public class SpringContextUtil implements ApplicationContextAware{
private static ApplicationContext applicationContext;
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
SpringContextUtil.applicationContext = applicationContext;
}
/**
* @Description: 获取spring容器中的bean,通过bean名称获取
* @param beanName bean名称
* @return: Object 返回Object,需要做强制类型转换
* @author: zongf
* @time: 2018-12-26 10:45:07
*/
public static Object getBean(String beanName){
return applicationContext.getBean(beanName);
}
/**
* @Description: 获取spring容器中的bean, 通过bean类型获取
* @param beanClass bean 类型
* @return: T 返回指定类型的bean实例
* @author: zongf
* @time: 2018-12-26 10:46:31
*/
public static <T> T getBean(Class<T> beanClass) {
return applicationContext.getBean(beanClass);
}
/**
* @Description: 获取spring容器中的bean, 通过bean名称和bean类型精确获取
* @param beanName bean 名称
* @param beanClass bean 类型
* @return: T 返回指定类型的bean实例
* @author: zongf
* @time: 2018-12-26 10:47:45
*/
public static <T> T getBean(String beanName, Class<T> beanClass){
return applicationContext.getBean(beanName,beanClass);
}。