为什么是基于Spring的呢，因为实现方案基于Spring的事务以及AbstractRoutingDataSource（spring中的一个基础类，可以在其中放多个数据源，然后根据一些规则来确定当前需要使用哪个数据，既可以进行读写分离，也可以用来做分库分表）

我们只需要实现

determineCurrentLookupKey()

每次生成jdbc connection时，都会先调用该方法来甄选出实际需要使用的datasource，由于这个方法并没有参数，因此，最佳的方式是基于ThreadLocal变量

@Component
@Primary
public class DynamicRoutingDataSource extends AbstractRoutingDataSource {@Resource(name = "masterDs")private DataSource masterDs;@Resource(name = "slaveDs")private DataSource slaveDs;@Overridepublic void afterPropertiesSet() {Map<Object, Object> targetDataSources = new HashMap<>();targetDataSources.put("slaveDs", slaveDs);targetDataSources.put("masterDs", masterDs);this.setTargetDataSources(targetDataSources);this.setDefaultTargetDataSource(masterDs);super.afterPropertiesSet();}@Overrideprotected Object determineCurrentLookupKey() {return DynamicDataSourceHolder.contextHolder.get();}/*** 持有当前线程所有数据源的程序*/public static class DynamicDataSourceHolder {public static final ThreadLocal<String> contextHolder = new ThreadLocal<>();public static void setWrite() {contextHolder.set("masterDs");}public static void setRead() {contextHolder.set("slaveDs");}public static void remove() {contextHolder.remove();}}
}

DynamicRoutingDataSource 仅仅是一个DataSource实现，更高层的类主要用它来创建连接，如getConnection()，getConnection会先寻找实际的datasource,在创建连接

@Overridepublic Connection getConnection() throws SQLException {return determineTargetDataSource().getConnection();}

以上代码，使用了ThreadLocal contextHolder来存取当前需要的datasource的loopkey
contextHolder上的值可能没有被初始化，此时contextHolder.get() 等于 null，此时会使用默认的datasource，我们设置的默认值对应的是主库

  /*** Retrieve the current target DataSource. Determines the* {@link #determineCurrentLookupKey() current lookup key}, performs* a lookup in the {@link #setTargetDataSources targetDataSources} map,* falls back to the specified* {@link #setDefaultTargetDataSource default target DataSource} if necessary.* @see #determineCurrentLookupKey()*/protected DataSource determineTargetDataSource() {Assert.notNull(this.resolvedDataSources, "DataSource router not initialized");Object lookupKey = determineCurrentLookupKey();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 + "]");}return dataSource;}

下一步，是在sql请求前，先对contextHolder赋值，手动赋值工作量很大，并且容易出错，也没有办法规范

实现方案是基于Aop，根据方法名，或者方法注解来区分

• 根据方法名的好处比较明显，只要工程的manager\dao层方法名称规范就行，不用到处添加注解，缺点是不精准
• 根据注解来区分，缺点是需要在很多个类或接口上加注解，优点是精准

如果有特殊的业务，可以两种情况都使用，如以下场景：

• 一个大的service，先后调用多个manager层\dao层sql，先insert、后query，并且想直接查主库，也就是写后立即查，由于mysql主从同步可能会有延迟，写后立即查可能会读到老数据，写后立即查的情况比较复杂，如果不是事务的话，实现其实比较复杂，如何在非事务场景下，让两个顺序执行的请求，保持同一个connection，需单独调研，根据实际情况进行修改

我们将设置contextHolder的地方加在了dao层，出于以下考量：

• 透过manager层，直接调用dao时，无风险
• 当前工程采用的是手动在manager层开启事务，开启事务lookupKey一定为null，采用默认的masterDs,没有问题，事务开启链接后，dao层的每个被调用的方法，会使用事务中的链接（由Spring Transaction控制）
• 如果在manager层开启事务，manager层的方法名可能不规范，dao层是最接近sql请求的地方，规范更容易遵循

当然，这不是最佳实践，如果在manager层做这个事，也是可以的，看具体的情况，要求是，名称或注解表意为query的方法，里面不能做任何更新操作，因为manager层已经确定了它会查从库，以下方法是会执行失败的

public class Manager1{......public List getSome(params){dao1.getRecord1(params);dao2.updateLog(params);}}

因为dao2是一个更新请求，使用从库进行更新，肯定是会失败的
（使用Spring Boot，或Spring时，需确保开启AspectJ，Spring Boot开启方式 @EnableAspectJAutoProxy(proxyTargetClass = true)
）

aop示例

 @Aspect
@Order(-10)
@Component
public class DataSourceAspect {public static final Logger logger = LoggerFactory.getLogger(DataSourceAspect.class);private static final String[] DefaultSlaveMethodStart= new String[]{"query", "find", "get", "select", "count", "list"};/*** 切入点，所有的mapper pcakge下面的类的方法*/@Pointcut(value = "execution(* com.xx.xx.dao.mapper..*.*(..))")@SuppressWarnings("all")public void pointCutTransaction() {}/*** 根据方法名称，判断是读还是写* @param jp*/@Before("pointCutTransaction()")public void doBefore(JoinPoint jp) {String methodName = jp.getSignature().getName();if (isReadReq(methodName)) {DynamicRoutingDataSource.DynamicDataSourceHolder.setRead();} else {DynamicRoutingDataSource.DynamicDataSourceHolder.setWrite();}}/*** 方法结束 finally 时执行* @param jp*/@After("pointCutTransaction()")public void after(JoinPoint jp) {DynamicRoutingDataSource.DynamicDataSourceHolder.remove();}/*** 根据方法名，判断是否为读请求** @param methodName* @return*/private boolean isReadReq(String methodName) {for (String start : DefaultSlaveMethodStart) {if (methodName.startsWith(start)) {return true;}}return false;}
}

上面的代码，根据方法名称前缀，反向判断哪些方法应该使用从库，凡是不匹配的方法，都走主库
方法结束后，必须清空contextHolder，否则他可能发生混乱，如这里是manager层 call dao层，dao层退出执行后，不清空contextHolder，则manager层开启事务时，会直接使用dao的值，如果这个请求是query，分配给从库了，那么manager层开启事务时就用的是从库了，结果可想而知

如此就完成了读写分离

spring 事务

当前使用的是编程声明式事务

    @Overridepublic <T> T execute(TransactionCallback<T> action) throws TransactionException {if (this.transactionManager instanceof CallbackPreferringPlatformTransactionManager) {return ((CallbackPreferringPlatformTransactionManager) this.transactionManager).execute(this, action);}else {TransactionStatus status = this.transactionManager.getTransaction(this);T result;try {result = action.doInTransaction(status);}catch (RuntimeException ex) {// Transactional code threw application exception -> rollbackrollbackOnException(status, ex);throw ex;}catch (Error err) {// Transactional code threw error -> rollbackrollbackOnException(status, err);throw err;}catch (Throwable ex) {// Transactional code threw unexpected exception -> rollbackrollbackOnException(status, ex);throw new UndeclaredThrowableException(ex, "TransactionCallback threw undeclared checked exception");}this.transactionManager.commit(status);return result;}}

来发起事务，execute方法中

    this.transactionManager.getTransaction(this)

将获取事务需要的链接，其内部会读取ThreadLocal变量，判断是否有事务连接，如果已有，或允许嵌套事务，则会重复利用当前事务链接
如果当前请求已经被包含到了事务中，则根据策略，判断是否新开一个事务或不使用事务，它们的方法基本相同：通过创建一个新的连接来处理，并将当前已被打开的事务先挂起，等待当前操作执行结束后，再恢复外部事务，继续执行
TransactionSynchronizationManager类记录了这些ThreadLocal变量，允许将事务bind到其resources中，DatasourceTransactionManager则会触发这些操作

@Overrideprotected Object doSuspend(Object transaction) {DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;txObject.setConnectionHolder(null);return TransactionSynchronizationManager.unbindResource(this.dataSource);  //挂起事务的基本原理：将外部事务放到新建事务(可能是非事务)的suspendedResources上来进行挂起}@Overrideprotected void doResume(Object transaction, Object suspendedResources) {TransactionSynchronizationManager.bindResource(this.dataSource, suspendedResources);  //将suspendedResources重新绑定到threadLocal变量}