@Override
public Object invoke(MethodInvocation invocation) throws Throwable {
  try {
    DynamicDataSourceContextHolder.push(determineDatasource(invocation));
    return invocation.proceed();
  } finally {
    DynamicDataSourceContextHolder.poll();
  }
}

public final class DynamicDataSourceContextHolder {
 
  /**
   * 為什么要用鏈表存儲(chǔ)(準(zhǔn)確的是棧)
   * <pre>
   * 為了支持嵌套切換，如ABC三個(gè)service都是不同的數(shù)據(jù)源
   * 其中A的某個(gè)業(yè)務(wù)要調(diào)B的方法，B的方法需要調(diào)用C的方法。一級(jí)一級(jí)調(diào)用切換，形成了鏈。
   * 傳統(tǒng)的只設(shè)置當(dāng)前線程的方式不能滿足此業(yè)務(wù)需求，必須模擬棧，后進(jìn)先出。
   * </pre>
   */
  @SuppressWarnings("unchecked")
  private static final ThreadLocal<Deque<String>> LOOKUP_KEY_HOLDER = new ThreadLocal() {
    @Override
    protected Object initialValue() {
      return new ArrayDeque();
    }
  };
 
  private DynamicDataSourceContextHolder() {
  }
 
  /**
   * 獲得當(dāng)前線程數(shù)據(jù)源
   *
   * @return 數(shù)據(jù)源名稱
   */
  public static String peek() {
    return LOOKUP_KEY_HOLDER.get().peek();
  }
 
  /**
   * 設(shè)置當(dāng)前線程數(shù)據(jù)源
   * <p>
   * 如非必要不要手動(dòng)調(diào)用，調(diào)用后確保最終清除
   * </p>
   *
   * @param ds 數(shù)據(jù)源名稱
   */
  public static void push(String ds) {
    LOOKUP_KEY_HOLDER.get().push(StringUtils.isEmpty(ds) ? "" : ds);
  }
 
  /**
   * 清空當(dāng)前線程數(shù)據(jù)源
   * <p>
   * 如果當(dāng)前線程是連續(xù)切換數(shù)據(jù)源 只會(huì)移除掉當(dāng)前線程的數(shù)據(jù)源名稱
   * </p>
   */
  public static void poll() {
    Deque<String> deque = LOOKUP_KEY_HOLDER.get();
    deque.poll();
    if (deque.isEmpty()) {
      LOOKUP_KEY_HOLDER.remove();
    }
  }
 
  /**
   * 強(qiáng)制清空本地線程
   * <p>
   * 防止內(nèi)存泄漏，如手動(dòng)調(diào)用了push可調(diào)用此方法確保清除
   * </p>
   */
  public static void clear() {
    LOOKUP_KEY_HOLDER.remove();
  }

dynamic:
  primary: master
  strict: false
  datasource:
    master:
      driver-class-name: com.mysql.cj.jdbc.Driver
      url: jdbc:mysql://***/phorcys-centre?useSSL=false
      username: root
      password: *****
    interface:
      url: jdbc:mysql://***/phorcys-interface?useSSL=false
      username: root
      password: *****
      driver-class-name: com.mysql.cj.jdbc.Driver

@Autowired
UserService userService;
@Autowired
RedisClient redisClient;
@GetMapping("/demo")
@Transactional
public GeneralResponse demo(@RequestBody(required = false) GeneralRequest request){
    SysUser sysUser = new SysUser();
    sysUser.setCode("wonder");
    sysUser.setName("王吉坤");
    sysUser.insert();
    redisClient.set("token",sysUser);
    List<SysUser> sysUsers = new SysUser().selectAll();
    String item01 = userService.getUserInfo("ITEM01");
    return GeneralResponse.success();
}

@Service
public class UserServiceImpl implements UserService {
    @Override
    @DS("interface")
    @Transactional
//    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public String getUserInfo(String name) {
        SapItemRecord sr = new SapItemRecord();
        sr.setBatchId(1L);
        sr.setItemCode("ITEM01");
        sr.setDescription("物料1號(hào)");
        if(sr.insert()){
            LambdaQueryWrapper<SapItemRecord> item01 = new QueryWrapper<SapItemRecord>().lambda().eq(SapItemRecord::getItemCode, name);
            SapItemRecord sapItemRecord = new SapItemRecord().selectOne(item01);
            ExceptionUtils.seed("內(nèi)層事務(wù)異常");
//            return sapItemRecord.getDescription();
        }
 
        return "response : wonder";
    }
}

if (txAttr == null || !(ptm instanceof CallbackPreferringPlatformTransactionManager)) {
   // Standard transaction demarcation with getTransaction and commit/rollback calls.
   TransactionInfo txInfo = createTransactionIfNecessary(ptm, txAttr, joinpointIdentification);
 
   Object retVal;
   try {
      // This is an around advice: Invoke the next interceptor in the chain.
      // This will normally result in a target object being invoked.
      retVal = invocation.proceedWithInvocation();
   }
   catch (Throwable ex) {
      // target invocation exception
      completeTransactionAfterThrowing(txInfo, ex);
      throw ex;
   }
   finally {
      cleanupTransactionInfo(txInfo);
   }
   ....
   }
protected TransactionInfo createTransactionIfNecessary(@Nullable PlatformTransactionManager tm,
      @Nullable TransactionAttribute txAttr, final String joinpointIdentification) {
 
   // If no name specified, apply method identification as transaction name.
   if (txAttr != null && txAttr.getName() == null) {
      txAttr = new DelegatingTransactionAttribute(txAttr) {
         @Override
         public String getName() {
            return joinpointIdentification;
         }
      };
   }
 
   TransactionStatus status = null;
   if (txAttr != null) {
      if (tm != null) {
          // 重點(diǎn)是這里，獲取事務(wù)
         status = tm.getTransaction(txAttr);
      }
      else {
         if (logger.isDebugEnabled()) {
            logger.debug("Skipping transactional joinpoint [" + joinpointIdentification +
                  "] because no transaction manager has been configured");
         }
      }
   }
   return prepareTransactionInfo(tm, txAttr, joinpointIdentification, status);
}

public final TransactionStatus getTransaction(@Nullable TransactionDefinition definition)
      throws TransactionException {
 
   // Use defaults if no transaction definition given.
   TransactionDefinition def = (definition != null ? definition : TransactionDefinition.withDefaults());
 
   Object transaction = doGetTransaction();
   boolean debugEnabled = logger.isDebugEnabled();
 
   if (isExistingTransaction(transaction)) {
      // Existing transaction found -> check propagation behavior to find out how to behave.
      return handleExistingTransaction(def, transaction, debugEnabled);
   }
 
   // Check definition settings for new transaction.
   if (def.getTimeout() < TransactionDefinition.TIMEOUT_DEFAULT) {
      throw new InvalidTimeoutException("Invalid transaction timeout", def.getTimeout());
   }
 
   // No existing transaction found -> check propagation behavior to find out how to proceed.
   if (def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_MANDATORY) {
      throw new IllegalTransactionStateException(
            "No existing transaction found for transaction marked with propagation 'mandatory'");
   }
   else if (def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRED ||
         def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW ||
         def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) {
      SuspendedResourcesHolder suspendedResources = suspend(null);
      if (debugEnabled) {
         logger.debug("Creating new transaction with name [" + def.getName() + "]: " + def);
      }
      try {
         return startTransaction(def, transaction, debugEnabled, suspendedResources);
      }
      catch (RuntimeException | Error ex) {
         resume(null, suspendedResources);
         throw ex;
      }
   }
   else {
      // Create "empty" transaction: no actual transaction, but potentially synchronization.
      if (def.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT && logger.isWarnEnabled()) {
         logger.warn("Custom isolation level specified but no actual transaction initiated; " +
               "isolation level will effectively be ignored: " + def);
      }
      boolean newSynchronization = (getTransactionSynchronization() == SYNCHRONIZATION_ALWAYS);
      return prepareTransactionStatus(def, null, true, newSynchronization, debugEnabled, null);
   }
}

private TransactionStatus startTransaction(TransactionDefinition definition, Object transaction,
      boolean debugEnabled, @Nullable SuspendedResourcesHolder suspendedResources) {
 
   boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
   DefaultTransactionStatus status = newTransactionStatus(
         definition, transaction, true, newSynchronization, debugEnabled, suspendedResources);
   doBegin(transaction, definition);  //dobegin里面關(guān)乎數(shù)據(jù)源和數(shù)據(jù)庫(kù)連接
   prepareSynchronization(status, definition);
   return status;
}

if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW) {
   if (debugEnabled) {
      logger.debug("Suspending current transaction, creating new transaction with name [" +
            definition.getName() + "]");
   }
   SuspendedResourcesHolder suspendedResources = suspend(transaction);
   try {
      return startTransaction(definition, transaction, debugEnabled, suspendedResources);
   }
   catch (RuntimeException | Error beginEx) {
      resumeAfterBeginException(transaction, suspendedResources, beginEx);
      throw beginEx;
   }
}