共计 16482 个字符，预计需要花费 42 分钟才能阅读完成。
前段时间在做会员中心和中间件零碎开发时，屡次碰到多数据源配置问题，次要用到分包形式、参数化切换、注解 +AOP、动静增加 这四种形式。这里做一下总结，分享下应用心得以及踩过的坑。
分包形式
数据源配置文件
在 yml 中，配置两个数据源，id 别离为 master 和 s1。
spring:
datasource:
master:
jdbcUrl: jdbc:mysql://192.168.xxx.xxx:xxxx/db1?.........
username: xxx
password: xxx
driverClassName: com.mysql.cj.jdbc.Driver
s1:
jdbcUrl: jdbc:mysql://192.168.xxx.xxx:xxxx/db2?........
username: xxx
password: xxx
driverClassName: com.mysql.cj.jdbc.Driver数据源配置类
master 数据源配置类
留神点：
须要用 @Primary 注解指定默认数据源，否则 spring 不晓得哪个是主数据源；
@Configuration
@MapperScan(basePackages = "com.hosjoy.xxx.xxx.xxx.xxx.mapper.master", sqlSessionFactoryRef = "masterSqlSessionFactory")
public class MasterDataSourceConfig { // 默认数据源
@Bean(name = "masterDataSource")
@Primary @ConfigurationProperties(prefix = "spring.datasource.master")
public HikariDataSource masterDataSource() { return DataSourceBuilder.create().type(HikariDataSource.class).build();} @Bean(name = "masterSqlSessionFactory")
@Primary public SqlSessionFactory masterSqlSessionFactory(@Qualifier("masterDataSource") DataSource datasource, PaginationInterceptor paginationInterceptor)
throws Exception {MybatisSqlSessionFactoryBean bean = new MybatisSqlSessionFactoryBean(); bean.setDataSource(datasource); bean.setMapperLocations( // 设置 mybatis 的 xml 所在位置
new PathMatchingResourcePatternResolver().getResources("classpath*:mapper/master/**/**.xml"));
bean.setPlugins(new Interceptor[]{paginationInterceptor});
return bean.getObject();} @Bean(name = "masterSqlSessionTemplate")
@Primary public SqlSessionTemplate masterSqlSessionTemplate(@Qualifier("masterSqlSessionFactory") SqlSessionFactory sessionfactory) {return new SqlSessionTemplate(sessionfactory);
}}s1 数据源配置类
@Configuration
@MapperScan(basePackages = "com.hosjoy.xxx.xxx.xxx.xxx.mapper.s1", sqlSessionFactoryRef = "s1SqlSessionFactory")
public class S1DataSourceConfig {@Bean(name = "s1DataSource")
@ConfigurationProperties(prefix = "spring.datasource.s1")
public HikariDataSource s1DataSource() {return DataSourceBuilder.create().type(HikariDataSource.class).build();} @Bean(name = "s1SqlSessionFactory")
public SqlSessionFactory s1SqlSessionFactory(@Qualifier("s1DataSource") DataSource datasource
, PaginationInterceptor paginationInterceptor) throws Exception {MybatisSqlSessionFactoryBean bean = new MybatisSqlSessionFactoryBean(); bean.setDataSource(datasource); bean.setMapperLocations( // 设置 mybatis 的 xml 所在位置
new PathMatchingResourcePatternResolver().getResources("classpath*:mapper/s1/**/**.xml"));
bean.setPlugins(new Interceptor[]{paginationInterceptor});
return bean.getObject();}
@Bean(name = "s1SqlSessionTemplate")
public SqlSessionTemplate s1SqlSessionTemplate(@Qualifier("s1SqlSessionFactory") SqlSessionFactory sessionfactory) {return new SqlSessionTemplate(sessionfactory);
}
}应用
能够看出，mapper 接口、xml 文件，须要依照不同的数据源分包。在操作数据库时，依据须要在 service 类中注入 dao 层。
特点剖析
长处
实现起来简略，只须要编写数据源配置文件和配置类，mapper 接口和 xml 文件留神分包即可。
毛病
很显著，如果前面要减少或删除数据源，不仅要批改数据源配置文件，还须要批改配置类。
例如减少一个数据源，同时还须要新写一个该数据源的配置类，同时还要思考新建 mapper 接口包、xml 包等，没有实现“热插拔”成果。
参数化切换形式
思维
参数化切换数据源，意思是，业务侧须要依据以后业务参数，动静的切换到不同的数据源。
这与分包思维不同。分包的前提是在编写代码的时候，就曾经晓得以后须要用哪个数据源，而参数化切换数据源须要依据业务参数决定用哪个数据源。
例如，申请参数 userType 值为 1 时，须要切换到数据源 slave1；申请参数 userType 值为 2 时，须要切换到数据源 slave2。
/** 伪代码 **/
int userType = reqUser.getType();
if (userType == 1){
// 切换到数据源 slave1
// 数据库操作
} else if(userType == 2){
// 切换到数据源 slave2
// 数据库操作
}设计思路
数据源注册
数据源配置类创立 datasource 时，从 yml 配置文件中读取所有数据源配置，主动创立每个数据源，并注册至 bean 工厂和 AbstractRoutingDatasource(前面聊聊这个)，同时返回默认的数据源 master。
数据源切换
（1）通过线程池解决申请，每个申请独占一个线程，这样每个线程切换数据源时互不影响。
（2）依据业务参数获取应切换的数据源 ID，依据 ID 从数据源缓存池获取数据源 bean；
（3）生成以后线程数据源 key；
（4）将 key 设置到 threadLocal;
（5）将 key 和数据源 bean 放入数据源缓存池；
（6）在执行 mapper 办法前，spring 会调用 determineCurrentLookupKey 办法获取 key，而后依据 key 去数据源缓存池取出数据源，而后 getConnection 获取该数据源连贯；
（7）应用该数据源执行数据库操作；
（8）开释以后线程数据源。
AbstractRoutingDataSource 源码剖析
spring 为咱们提供了 AbstractRoutingDataSource 抽象类，该类就是实现动静切换数据源的要害。
咱们看下该类的类图，其实现了 DataSource 接口。
咱们看下它的 getConnection 办法的逻辑，其首先调用 determineTargetDataSource 来获取数据源，再获取数据库连贯。很容易猜想到就是这里来决定具体应用哪个数据源的。
进入到 determineTargetDataSource 办法，咱们能够看到它先是调用 determineCurrentLookupKey 获取到一个 lookupKey，而后依据这个 key 去 resolvedDataSources 里去找相应的数据源。
看下该类定义的几个对象，defaultTargetDataSource 是默认数据源，resolvedDataSources 是一个 map 对象，存储所有主从数据源。
所以，要害就是这个 lookupKey 的获取逻辑，决定了以后获取的是哪个数据源，而后执行 getConnection 等一系列操作。determineCurrentLookupKey 是 AbstractRoutingDataSource 类中的一个形象办法，而它的返回值是你所要用的数据源 dataSource 的 key 值，有了这个 key 值，resolvedDataSource（这是个 map, 由配置文件中设置好后存入的）就从中取出对应的 DataSource，如果找不到，就用配置默认的数据源。
所以，通过扩大 AbstractRoutingDataSource 类，并重写其中的 determineCurrentLookupKey() 办法，能够实现数据源的切换。
代码实现
上面贴出要害代码实现。
数据源配置文件
这里配了 3 个数据源，其中主数据源是 MySQL，两个从数据源是 sqlserver。
spring:
datasource:
master:
jdbcUrl: jdbc:mysql://192.168.xx.xxx:xxx/db1?........
username: xxx
password: xxx
driverClassName: com.mysql.cj.jdbc.Driver
slave1:
jdbcUrl: jdbc:sqlserver://192.168.xx.xxx:xxx;DatabaseName=db2
username: xxx
password: xxx
driverClassName: com.microsoft.sqlserver.jdbc.SQLServerDriver
slave2:
jdbcUrl: jdbc:sqlserver://192.168.xx.xxx:xxx;DatabaseName=db3
username: xxx
password: xxx
driverClassName: com.microsoft.sqlserver.jdbc.SQLServerDriver定义动静数据源
次要是继承 AbstractRoutingDataSource，实现 determineCurrentLookupKey 办法。
public class DynamicDataSource extends AbstractRoutingDataSource {
/* 存储所有数据源 */
private Map<Object, Object> backupTargetDataSources;
public Map<Object, Object> getBackupTargetDataSources() {return backupTargetDataSources;} /*defaultDataSource 为默认数据源 */
public DynamicDataSource(DataSource defaultDataSource, Map<Object, Object> targetDataSource) {backupTargetDataSources = targetDataSource; super.setDefaultTargetDataSource(defaultDataSource);
super.setTargetDataSources(backupTargetDataSources);
super.afterPropertiesSet();} public void addDataSource(String key, DataSource dataSource) {this.backupTargetDataSources.put(key, dataSource);
super.setTargetDataSources(this.backupTargetDataSources);
super.afterPropertiesSet();} /* 返回以后线程的数据源的 key*/
@Override
protected Object determineCurrentLookupKey() {return DynamicDataSourceContextHolder.getContextKey();
}}定义数据源 key 线程变量持有
定义一个 ThreadLocal 动态变量，该变量持有了线程和线程的数据源 key 之间的关系。当咱们要切换数据源时，首先要本人生成一个 key，将这个 key 存入 threadLocal 线程变量中；同时还应该从 DynamicDataSource 对象中的 backupTargetDataSources 属性中获取到数据源对象，而后将 key 和数据源对象再 put 到 backupTargetDataSources 中。这样，spring 就能依据 determineCurrentLookupKey 办法返回的 key，从 backupTargetDataSources 中取出咱们刚刚设置的数据源对象，进行 getConnection 等一系列操作了。
public class DynamicDataSourceContextHolder {
/**
* 存储线程和数据源 key 的映射关系
*/
private static final ThreadLocal<String> DATASOURCE_CONTEXT_KEY_HOLDER = new ThreadLocal<>();
/***
* 设置以后线程数据源 key
*/
public static void setContextKey(String key) {DATASOURCE_CONTEXT_KEY_HOLDER.set(key);
} /***
* 获取以后线程数据源 key
*/
public static String getContextKey() {String key = DATASOURCE_CONTEXT_KEY_HOLDER.get(); return key == null ? DataSourceConstants.DS_KEY_MASTER : key;
} /***
* 删除以后线程数据源 key
*/
public static void removeContextKey() {DynamicDataSource dynamicDataSource = RequestHandleMethodRegistry.getContext().getBean(DynamicDataSource.class); String currentKey = DATASOURCE_CONTEXT_KEY_HOLDER.get(); if (StringUtils.isNotBlank(currentKey) && !"master".equals(currentKey)) {dynamicDataSource.getBackupTargetDataSources().remove(currentKey); } DATASOURCE_CONTEXT_KEY_HOLDER.remove();}}多数据源主动配置类
这里通过读取 yml 配置文件中所有数据源的配置，主动为每个数据源创立 datasource 对象并注册至 bean 工厂。同时将这些数据源对象，设置到 AbstractRoutingDataSource 中。
通过这种形式，前面如果须要增加或批改数据源，都无需新增或批改 java 配置类，只需去配置核心批改 yml 文件即可。
@Configuration
@MapperScan(basePackages = "com.hosjoy.xxx.xxx.modules.xxx.mapper")
public class DynamicDataSourceConfig {
@Autowired
private BeanFactory beanFactory;
@Autowired
private DynamicDataSourceProperty dynamicDataSourceProperty;
/**
* 性能形容: <br>
* 〈动静数据源 bean 主动配置注册所有数据源〉
*
* @param
* @return javax.sql.DataSource
* @Author li.he
* @Date 2020/6/4 16:47
* @Modifier
*/
@Bean
@Primary
public DataSource dynamicDataSource() {DefaultListableBeanFactory listableBeanFactory = (DefaultListableBeanFactory) beanFactory; /* 获取 yml 所有数据源配置 */
Map<String, Object> datasource = dynamicDataSourceProperty.getDatasource(); Map<Object, Object> dataSourceMap = new HashMap<>(5);
Optional.ofNullable(datasource).ifPresent(map -> { for (Map.Entry<String, Object> entry : map.entrySet()) {
// 创立数据源对象
HikariDataSource dataSource = (HikariDataSource) DataSourceBuilder.create().build();
String dataSourceId = entry.getKey();
configeDataSource(entry, dataSource);
/*bean 工厂注册每个数据源 bean*/
listableBeanFactory.registerSingleton(dataSourceId, dataSource);
dataSourceMap.put(dataSourceId, dataSource);
}
});
//AbstractRoutingDataSource 设置主从数据源
return new DynamicDataSource(beanFactory.getBean("master", DataSource.class), dataSourceMap);
}
private void configeDataSource(Map.Entry<String, Object> entry, HikariDataSource dataSource) {Map<String, Object> dataSourceConfig = (Map<String, Object>) entry.getValue();
dataSource.setJdbcUrl(MapUtils.getString(dataSourceConfig, "jdbcUrl"));
dataSource.setDriverClassName(MapUtils.getString(dataSourceConfig, "driverClassName"));
dataSource.setUsername(MapUtils.getString(dataSourceConfig, "username"));
dataSource.setPassword(MapUtils.getString(dataSourceConfig, "password"));
}
}数据源切换工具类
切换逻辑：
（1）生成以后线程数据源 key
（2）依据业务条件，获取应切换的数据源 ID；
（3）依据 ID 从数据源缓存池中获取数据源对象，并再次增加到 backupTargetDataSources 缓存池中；
（4）threadLocal 设置以后线程对应的数据源 key；
（5）在执行数据库操作前，spring 会调用 determineCurrentLookupKey 办法获取 key，而后依据 key 去数据源缓存池取出数据源，而后 getConnection 获取该数据源连贯；
（6）应用该数据源执行数据库操作；
（7）开释缓存：threadLocal 清理以后线程数据源信息、数据源缓存池清理以后线程数据源 key 和数据源对象，目标是避免内存透露。
@Slf4j
@Component
public class DataSourceUtil {
@Autowired
private DataSourceConfiger dataSourceConfiger; /* 依据业务条件切换数据源 */
public void switchDataSource(String key, Predicate<? super Map<String, Object>> predicate) {
try {
// 生成以后线程数据源 key
String newDsKey = System.currentTimeMillis() + "";
List<Map<String, Object>> configValues = dataSourceConfiger.getConfigValues(key);
Map<String, Object> db = configValues.stream().filter(predicate)
.findFirst().get();
String id = MapUtils.getString(db, "id");
// 依据 ID 从数据源缓存池中获取数据源对象，并再次增加到 backupTargetDataSources
addDataSource(newDsKey, id);
// 设置以后线程对应的数据源 key
DynamicDataSourceContextHolder.setContextKey(newDsKey);
log.info("以后线程数据源切换胜利，以后数据源 ID:{}", id);
}
catch (Exception e) {log.error("切换数据源失败，请查看数据源配置文件。key:{}, 条件:{}", key, predicate.toString());
throw new ClientException("切换数据源失败，请查看数据源配置", e);
}
}
/* 将数据源增加至少数据源缓存池中 */
public static void addDataSource(String key, String dataSourceId) {DynamicDataSource dynamicDataSource = RequestHandleMethodRegistry.getContext().getBean(DynamicDataSource.class);
DataSource dataSource = (DataSource) dynamicDataSource.getBackupTargetDataSources().get(dataSourceId);
dynamicDataSource.addDataSource(key, dataSource);
}
}应用
public void doExecute(ReqTestParams reqTestParams){
// 结构条件
Predicate<? super Map<String, Object>> predicate =.........;
// 切换数据源
dataSourceUtil.switchDataSource("testKey", predicate);
// 数据库操作
mapper.testQuery(); // 清理缓存，防止内存透露
DynamicDataSourceContextHolder.removeContextKey();}每次数据源应用后，都要调用 removeContextKey 办法清理缓存，防止内存透露，这里能够思考用 AOP 拦挡特定办法，利用后置告诉为执行办法代理执行缓存清理工作。
@Aspect
@Component
@Slf4j
public class RequestHandleMethodAspect {@After("xxxxxxxxxxxxxxExecution 表达式 xxxxxxxxxxxxxxxxxx")
public void afterRunning(JoinPoint joinPoint){String name = joinPoint.getSignature().toString(); long id = Thread.currentThread().getId();
log.info("办法执行结束，开始清空以后线程数据源，线程 id:{}, 代理办法:{}",id,name);
DynamicDataSourceContextHolder.removeContextKey(); log.info("以后线程数据源清空结束, 已返回至默认数据源:{}",id);
}}特点剖析
（1）参数化切换数据源形式，出发点和分包形式不一样，适宜于在运行时能力确定用哪个数据源。
（2）须要手动执行切换数据源操作；
（3）无需分包，mapper 和 xml 门路自在定义；
（4）减少数据源，无需批改 java 配置类，只需批改数据源配置文件即可。
注解形式
思维
该形式利用注解 +AOP 思维，为须要切换数据源的办法标记自定义注解，注解属性指定数据源 ID，而后利用 AOP 切面拦挡注解标记的办法，在办法执行前，切换至相应数据源；在办法执行完结后，切换至默认数据源。
须要留神的是，自定义切面的优先级须要高于 @Transactional 注解对应切面的优先级。
否则，在自定义注解和 @Transactional 同时应用时，@Transactional 切面会优先执行，切面在调用 getConnection 办法时，会去调用 AbstractRoutingDataSource.determineCurrentLookupKey 办法，此时获取到的是默认数据源 master。这时 @UsingDataSource 对应的切面即便再设置以后线程的数据源 key，前面也不会再去调用 determineCurrentLookupKey 办法来切换数据源了。
设计思路
数据源注册
同上。
数据源切换
利用切面，拦挡所有 @UsingDataSource 注解标记的办法，依据 dataSourceId 属性，在办法执行前，切换至相应数据源；在办法执行完结后，清理缓存并切换至默认数据源。
代码实现
数据源配置文件
同上。
定义动静数据源
同上。
定义数据源 key 线程变量持有
同上。
多数据源主动配置类
同上。
数据源切换工具类
切换逻辑：
（1）生成以后线程数据源 key
（3）依据 ID 从数据源缓存池中获取数据源对象，并再次增加到 backupTargetDataSources 缓存池中；
（4）threadLocal 设置以后线程对应的数据源 key；
（5）在执行数据库操作前，spring 会调用 determineCurrentLookupKey 办法获取 key，而后依据 key 去数据源缓存池取出数据源，而后 getConnection 获取该数据源连贯；
（6）应用该数据源执行数据库操作；
（7）开释缓存：threadLocal 清理以后线程数据源信息、数据源缓存池清理以后线程数据源 key 和数据源对象。
public static void switchDataSource(String dataSourceId) {if (StringUtils.isBlank(dataSourceId)) {throw new ClientException("切换数据源失败，数据源 ID 不能为空");
} try {String threadDataSourceKey = UUID.randomUUID().toString(); DataSourceUtil.addDataSource(threadDataSourceKey, dataSourceId); DynamicDataSourceContextHolder.setContextKey(threadDataSourceKey); } catch (Exception e) {log.error("切换数据源失败，未找到指定的数据源，请确保所指定的数据源 ID 已在配置文件中配置。dataSourceId:{}", dataSourceId);
throw new ClientException("切换数据源失败，未找到指定的数据源，请确保所指定的数据源 ID 已在配置文件中配置。dataSourceId:" + dataSourceId, e);
}}自定义注解
自定义注解标记以后办法所应用的数据源，默认为主数据源。
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface UsingDataSource {String dataSourceId() default "master";
}切面
次要是定义前置告诉和后置告诉，拦挡 UsingDataSource 注解标记的办法，办法执行前切换数据源，办法执行后清理数据源缓存。
须要标记切面的优先级比 @Transaction 注解对应切面的优先级要高。否则，在自定义注解和 @Transactional 同时应用时，@Transactional 切面会优先执行，切面在调用 getConnection 办法时，会去调用 AbstractRoutingDataSource.determineCurrentLookupKey 办法，此时获取到的是默认数据源 master。这时 @UsingDataSource 对应的切面即便再设置以后线程的数据源 key，前面也不会再去调用 determineCurrentLookupKey 办法来切换数据源了。
@Aspect
@Component
@Slf4j
@Order(value = 1)
public class DynamicDataSourceAspect { // 拦挡 UsingDataSource 注解标记的办法，办法执行前切换数据源
@Before(value = "@annotation(usingDataSource)")
public void before(JoinPoint joinPoint, UsingDataSource usingDataSource) {String dataSourceId = usingDataSource.dataSourceId();
log.info("执行指标办法前开始切换数据源，指标办法:{}, dataSourceId:{}", joinPoint.getSignature().toString(), dataSourceId);
try {DataSourceUtil.switchDataSource(dataSourceId);
}
catch (Exception e) {log.error("切换数据源失败！数据源可能未配置或不可用, 数据源 ID:{}", dataSourceId, e);
throw new ClientException("切换数据源失败！数据源可能未配置或不可用, 数据源 ID:" + dataSourceId, e);
}
log.info("指标办法:{} , 已切换至数据源:{}", joinPoint.getSignature().toString(), dataSourceId);
}
// 拦挡 UsingDataSource 注解标记的办法，办法执行后清理数据源，避免内存透露
@After(value = "@annotation(com.hosjoy.hbp.dts.common.annotation.UsingDataSource)")
public void after(JoinPoint joinPoint) {log.info("指标办法执行结束，执行清理，切换至默认数据源，指标办法:{}", joinPoint.getSignature().toString());
try {DynamicDataSourceContextHolder.removeContextKey();
}
catch (Exception e) {log.error("清理数据源失败", e);
throw new ClientException("清理数据源失败", e);
}
log.info("指标办法:{} , 数据源清理结束，已返回默认数据源", joinPoint.getSignature().toString());
}
}应用
@UsingDataSource(dataSourceId = "slave1")
@Transactional
public void test(){AddressPo po = new AddressPo();
po.setMemberCode("asldgjlk");
po.setName("lihe");
po.setPhone("13544986666");
po.setProvince("asdgjwlkgj");
addressMapper.insert(po); int i = 1 / 0;
}动静增加形式（十分用）
业务场景形容
这种业务场景不是很常见，但必定是有人遇到过的。
我的项目外面只配置了 1 个默认的数据源，而具体运行时须要动静的增加新的数据源，非已配置好的动态的多数据源。例如须要去服务器实时读取数据源配置信息（非配置在本地），而后再执行数据库操作。
这种业务场景，以上 3 种形式就都不实用了，因为上述的数据源都是提前在 yml 文件配置好的。
实现思路
除了第 6 步外，利用之前写好的代码就能够实现。
思路是：
（1）创立新数据源；
（2）DynamicDataSource 注册新数据源；
（3）切换：设置以后线程数据源 key；增加长期数据源；
（4）数据库操作（必须在另一个 service 实现，否则无法控制事务）；
（5）清理以后线程数据源 key、清理长期数据源；
（6）清理刚刚注册的数据源；
（7）此时已返回至默认数据源。
代码
代码写的比拟简陋，然而模板大略就是这样子，次要想表白实现的形式。
Service A:
public String testUsingNewDataSource(){DynamicDataSource dynamicDataSource = RequestHandleMethodRegistry.getContext().getBean("dynamicDataSource", DynamicDataSource.class);
try { // 模仿从服务器读取数据源信息
//..........................
//....................
// 创立新数据源
HikariDataSource dataSource = (HikariDataSource) DataSourceBuilder.create().build();
dataSource.setJdbcUrl("jdbc:mysql://192.168.xxx.xxx:xxxx/xxxxx?......");
dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
dataSource.setUsername("xxx");
dataSource.setPassword("xxx");
//DynamicDataSource 注册新数据源
dynamicDataSource.addDataSource("test_ds_id", dataSource);
// 设置以后线程数据源 key、增加长期数据源
DataSourceUtil.switchDataSource("test_ds_id");
// 数据库操作（必须在另一个 service 实现，否则无法控制事务）serviceB.testInsert();}
finally {
// 清理以后线程数据源 key
DynamicDataSourceContextHolder.removeContextKey();
// 清理刚刚注册的数据源
dynamicDataSource.removeDataSource("test_ds_id");
}
return "aa";
}Service B:
@Transactional(rollbackFor = Exception.class)
public void testInsert() {AddressPo po = new AddressPo();
po.setMemberCode("555555555");
po.setName("李郃");
po.setPhone("16651694996");
po.setProvince("江苏省");
po.setCity("南京市");
po.setArea("浦口区");
po.setAddress("南京市浦口区宁六路 219 号");
po.setDef(false);
po.setCreateBy("23958");
addressMapper.insert(po); // 测试事务回滚
int i = 1 / 0;
}DynamicDataSource: 减少 removeDataSource 办法，清理注册的新数据源。
public class DynamicDataSource extends AbstractRoutingDataSource {................. ................. ................. public void removeDataSource(String key){this.backupTargetDataSources.remove(key);
super.setTargetDataSources(this.backupTargetDataSources);
super.afterPropertiesSet();} ................. ................. .................}四种形式比照
事务问题
应用上述数据源配置形式，可实现单个数据源事务管制。
例如在一个 service 办法中，须要操作多个数据源执行 CUD 时，是能够实现单个数据源事务管制的。形式如下，别离将须要事务管制的办法独自抽取到另一个 service，可实现单个事务办法的事务管制。
ServiceA:
public void updateMuilty(){serviceB.updateDb1(); serviceB.updateDb2();}ServiceB:
@UsingDataSource(dataSourceId = "slave1")
@Transactional
public void updateDb1(){// 业务逻辑......}
@UsingDataSource(dataSourceId = "slave2")
@Transactional
public void updateDb2(){// 业务逻辑......}然而在同一个办法里管制多个数据源的事务就不是这么简略了，这就属于分布式事务的范畴，能够思考应用 atomikos 开源我的项目实现 JTA 分布式事务处理或者阿里的 Fescar 框架。
因为波及到分布式事务管制，实现比较复杂，这里只是引出这个问题，前面抽时间把这块补上来。