try{
  // 開啟分布式事務(wù)
  String xid = TM.beginGlobalTransaction();
  // 執(zhí)行業(yè)務(wù)邏輯，包含遠(yuǎn)程rpc調(diào)用
  RM1.execute(xid); -------RPC調(diào)用--------> RM2.execute(xid);
  // 提交分布式事務(wù)
  TM.commitGlobalTransaction(xid);
}catch(Exception e){
  // 回滾分布式事務(wù)
  TM.rollbackGlobalTransaction(xid);
}finally{
  // 恢復(fù)現(xiàn)場
}

@Override
    public Object invoke(final MethodInvocation methodInvocation) throws Throwable {
        // 拿到被攔截的目標(biāo)類
        Class<?> targetClass =
            methodInvocation.getThis() != null ? AopUtils.getTargetClass(methodInvocation.getThis()) : null;
        // 獲取目標(biāo)方法
        Method specificMethod = ClassUtils.getMostSpecificMethod(methodInvocation.getMethod(), targetClass);
        // 判斷這個(gè)方法是不是Object類中的toString()、equals()等方法
        if (specificMethod != null && !specificMethod.getDeclaringClass().equals(Object.class)) {
            // 通過被攔截的方法找出對應(yīng)的注解GlobalTransactional和GlobalLock
            final Method method = BridgeMethodResolver.findBridgedMethod(specificMethod);
            final GlobalTransactional globalTransactionalAnnotation =
                getAnnotation(method, targetClass, GlobalTransactional.class);
            final GlobalLock globalLockAnnotation = getAnnotation(method, targetClass, GlobalLock.class);
            // 判斷是否開啟分布式事務(wù)，或者TM是否被降級處理，默認(rèn)是沒有被降級的
            boolean localDisable = disable || (degradeCheck && degradeNum >= degradeCheckAllowTimes);
            // 分布式事務(wù)可以正常使用
            if (!localDisable) {
                // 如果注解GlobalTransactional存在，那么直接把里面的配置解析成AspectTransactional
                if (globalTransactionalAnnotation != null || this.aspectTransactional != null) {
                    AspectTransactional transactional;
                    if (globalTransactionalAnnotation != null) {
                        transactional = new AspectTransactional(globalTransactionalAnnotation.timeoutMills(),
                            globalTransactionalAnnotation.name(), globalTransactionalAnnotation.rollbackFor(),
                            globalTransactionalAnnotation.rollbackForClassName(),
                            globalTransactionalAnnotation.noRollbackFor(),
                            globalTransactionalAnnotation.noRollbackForClassName(),
                            globalTransactionalAnnotation.propagation(),
                            globalTransactionalAnnotation.lockRetryInterval(),
                            globalTransactionalAnnotation.lockRetryTimes());
                    } else {
                        transactional = this.aspectTransactional;
                    }
                    // 調(diào)用handleGlobalTransaction處理
                    return handleGlobalTransaction(methodInvocation, transactional);
                } else if (globalLockAnnotation != null) {
                    // 調(diào)用handleGlobalLock處理
                    return handleGlobalLock(methodInvocation, globalLockAnnotation);
                }
            }
        }
        // 如果是Object類中的方法的話，直接調(diào)用，不作攔截
        return methodInvocation.proceed();
    }

Object handleGlobalTransaction(final MethodInvocation methodInvocation,
        final AspectTransactional aspectTransactional) throws Throwable {
        // 默認(rèn)succeed=true
        boolean succeed = true;
        try {
            // 執(zhí)行分布式事務(wù)處理邏輯
            // 詳細(xì)內(nèi)容后面介紹
            return transactionalTemplate.execute(new TransactionalExecutor() {
                // 執(zhí)行業(yè)務(wù)邏輯
                @Override
                public Object execute() throws Throwable {
                    return methodInvocation.proceed();
                }
                // 分布式事務(wù)名稱，沒有指定的話，就用【方法名+參數(shù)類型】命名
                public String name() {
                    String name = aspectTransactional.getName();
                    if (!StringUtils.isNullOrEmpty(name)) {
                        return name;
                    }
                    return formatMethod(methodInvocation.getMethod());
                }
                // 分布式事務(wù)信息，其實(shí)就是@GlobalTransactional注解里面拿到的配置
                @Override
                public TransactionInfo getTransactionInfo() {
                    // reset the value of timeout
                    int timeout = aspectTransactional.getTimeoutMills();
                    if (timeout <= 0 || timeout == DEFAULT_GLOBAL_TRANSACTION_TIMEOUT) {
                        timeout = defaultGlobalTransactionTimeout;
                    }
                    TransactionInfo transactionInfo = new TransactionInfo();
                    transactionInfo.setTimeOut(timeout);
                    transactionInfo.setName(name());
                    transactionInfo.setPropagation(aspectTransactional.getPropagation());
                    transactionInfo.setLockRetryInterval(aspectTransactional.getLockRetryInterval());
                    transactionInfo.setLockRetryTimes(aspectTransactional.getLockRetryTimes());
                    Set<RollbackRule> rollbackRules = new LinkedHashSet<>();
                    for (Class<?> rbRule : aspectTransactional.getRollbackFor()) {
                        rollbackRules.add(new RollbackRule(rbRule));
                    }
                    for (String rbRule : aspectTransactional.getRollbackForClassName()) {
                        rollbackRules.add(new RollbackRule(rbRule));
                    }
                    for (Class<?> rbRule : aspectTransactional.getNoRollbackFor()) {
                        rollbackRules.add(new NoRollbackRule(rbRule));
                    }
                    for (String rbRule : aspectTransactional.getNoRollbackForClassName()) {
                        rollbackRules.add(new NoRollbackRule(rbRule));
                    }
                    transactionInfo.setRollbackRules(rollbackRules);
                    return transactionInfo;
                }
            });
        } catch (TransactionalExecutor.ExecutionException e) {
            // 發(fā)生異常
            TransactionalExecutor.Code code = e.getCode();
            switch (code) {
                // 已經(jīng)回滾過了
                case RollbackDone:
                    throw e.getOriginalException();
                // 開啟分布式事務(wù)失敗
                case BeginFailure:
                    // 分布式事務(wù)失敗
                    succeed = false;
                    // 調(diào)用失敗處理邏輯
                    failureHandler.onBeginFailure(e.getTransaction(), e.getCause());
                    throw e.getCause();
                // 分布式事務(wù)提交失敗
                case CommitFailure:
                    // 分布式事務(wù)失敗
                    succeed = false;
                    // 調(diào)用失敗處理邏輯
                    failureHandler.onCommitFailure(e.getTransaction(), e.getCause());
                    throw e.getCause();
                // 回滾失敗
                case RollbackFailure:
                    // 調(diào)用失敗處理邏輯
                    failureHandler.onRollbackFailure(e.getTransaction(), e.getOriginalException());
                    throw e.getOriginalException();
                // 回滾重試
                case RollbackRetrying:
                    // 調(diào)用失敗處理器中的回滾重試回調(diào)邏輯
                    failureHandler.onRollbackRetrying(e.getTransaction(), e.getOriginalException());
                    throw e.getOriginalException();
                // 啥也不是，直接拋異常
                default:
                    throw new ShouldNeverHappenException(String.format("Unknown TransactionalExecutor.Code: %s", code));
            }
        } finally {
            // 如果允許TM降級，那么這次處理完畢后，說明與TC恢復(fù)通信，可以解除降級
            if (degradeCheck) {
                EVENT_BUS.post(new DegradeCheckEvent(succeed));
            }
        }
    }

public Object execute(TransactionalExecutor business) throws Throwable {
        // 1. 拿到整理好的@GlobalTransactional注解里面的配置信息
        TransactionInfo txInfo = business.getTransactionInfo();
        if (txInfo == null) {
            throw new ShouldNeverHappenException("transactionInfo does not exist");
        }
        // 1.1 獲取當(dāng)前的分布式事務(wù)，如果為null的話，說明這是分布式事務(wù)的發(fā)起者；如果不為null，說明這是分布式事務(wù)的參與者
        GlobalTransaction tx = GlobalTransactionContext.getCurrent();
        // 1.2 獲取分布式事務(wù)的傳播級別，其實(shí)就是按照spring的傳播級別來一套，區(qū)別就是spring事務(wù)是本地事務(wù)，這是分布式事務(wù)，原理都一樣
        Propagation propagation = txInfo.getPropagation();
        SuspendedResourcesHolder suspendedResourcesHolder = null;
        try {
            // 這個(gè)switch里面全都是處理分布式事務(wù)傳播級別的
            switch (propagation) {
                // 如果不支持分布式事務(wù)，如果當(dāng)前存在事務(wù)，那么先掛起當(dāng)前的分布式事務(wù)，再執(zhí)行業(yè)務(wù)邏輯
                case NOT_SUPPORTED:
                    // 分布式事務(wù)存在，先掛起
                    if (existingTransaction(tx)) {
                        suspendedResourcesHolder = tx.suspend();
                    }
                    // 執(zhí)行業(yè)務(wù)邏輯
                    return business.execute();
                // 如果是每次都要創(chuàng)建一個(gè)新的分布式事務(wù)，先把當(dāng)前存在的分布式事務(wù)掛起，然后創(chuàng)建一個(gè)新分布式事務(wù)
                case REQUIRES_NEW:
                    // 如果分布式事務(wù)存在，先掛起當(dāng)前分布式事務(wù)，再創(chuàng)建一個(gè)新的分布式事務(wù)
                    if (existingTransaction(tx)) {
                        suspendedResourcesHolder = tx.suspend();
                        tx = GlobalTransactionContext.createNew();
                    }
                    // 之所以用break，是為了后面的代碼和其他的傳播級別一起共用，業(yè)務(wù)邏輯肯定還是要執(zhí)行的
                    break;
                // 如果支持分布式事務(wù)，如果當(dāng)前不存在分布式事務(wù)，那么直接執(zhí)行業(yè)務(wù)邏輯，否則以分布式事務(wù)的方式執(zhí)行業(yè)務(wù)邏輯
                case SUPPORTS:
                    // 如果不存在分布式事務(wù)，直接執(zhí)行業(yè)務(wù)邏輯
                    if (notExistingTransaction(tx)) {
                        return business.execute();
                    }
                    // 否則，以分布式事務(wù)的方式執(zhí)行業(yè)務(wù)邏輯
                    break;
                // 如果有分布式事務(wù)，就在當(dāng)前分布式事務(wù)下執(zhí)行業(yè)務(wù)邏輯，否則創(chuàng)建一個(gè)新的分布式事務(wù)執(zhí)行業(yè)務(wù)邏輯
                case REQUIRED:
                    // If current transaction is existing, execute with current transaction,
                    // else continue and execute with new transaction.
                    break;
                // 如果不允許有分布式事務(wù)，那么一旦發(fā)現(xiàn)存在分布式事務(wù)，直接拋異常；只有不存在分布式事務(wù)的時(shí)候才正常執(zhí)行
                case NEVER:
                    // 存在分布式事務(wù)，拋異常
                    if (existingTransaction(tx)) {
                        throw new TransactionException(
                            String.format("Existing transaction found for transaction marked with propagation 'never', xid = %s"
                                    , tx.getXid()));
                    } else {
                        // 不存在分布式事務(wù)，執(zhí)行業(yè)務(wù)邏輯
                        return business.execute();
                    }
                // 一定要有分布式事務(wù)，分布式事務(wù)不存在的話，拋異常；
                case MANDATORY:
                    // 不存在分布式事務(wù)，拋異常
                    if (notExistingTransaction(tx)) {
                        throw new TransactionException("No existing transaction found for transaction marked with propagation 'mandatory'");
                    }
                    // Continue and execute with current transaction.
                    break;
                default:
                    throw new TransactionException("Not Supported Propagation:" + propagation);
            }
            // 上面的傳播級別的邏輯處理完畢，下面就是公共的處理邏輯
            // 1.3 如果當(dāng)前分布式事務(wù)沒有的話，那么我們就要創(chuàng)建新的分布式事務(wù)，此時(shí)我們就是分布式事務(wù)的發(fā)起者，也就是TM本身，否則不能稱之為`TM`
            if (tx == null) {
                tx = GlobalTransactionContext.createNew();
            }
            // 開始準(zhǔn)備干活的條件
            // 把我們這個(gè)方法的全局鎖配置放進(jìn)當(dāng)前線程中，并且把線程中已有的全局鎖的配置取出來
            // 我們在干完自己的活后，會把這個(gè)取出來的配置放回去的
            GlobalLockConfig previousConfig = replaceGlobalLockConfig(txInfo);
            try {
                // 2. 如果我們是分布式事務(wù)的發(fā)起者的話，那么我們會和TC通信，并且拿到一個(gè)XID；如果我們不是分布式事務(wù)的發(fā)起者的話，那么這一步啥也不干
                // 這個(gè)XID可以從RootContext中獲取
                beginTransaction(txInfo, tx);
                Object rs;
                try {
                    // 執(zhí)行業(yè)務(wù)邏輯
                    rs = business.execute();
                } catch (Throwable ex) {
                    // 3. 發(fā)生任何異常，我們準(zhǔn)備啟動回滾機(jī)制
                    completeTransactionAfterThrowing(txInfo, tx, ex);
                    throw ex;
                }
                // 4. 一切順利，通知提交分布式事務(wù)
                commitTransaction(tx);
                return rs;
            } finally {
                //5. 恢復(fù)現(xiàn)場，把之前的配置放回去
                resumeGlobalLockConfig(previousConfig);
                // 觸發(fā)回調(diào)
                triggerAfterCompletion();
                // 清理工作
                cleanUp();
            }
        } finally {
            // 恢復(fù)之前掛起的事務(wù)
            if (suspendedResourcesHolder != null) {
                tx.resume(suspendedResourcesHolder);
            }
        }
    }

 private void beginTransaction(TransactionInfo txInfo, GlobalTransaction tx) throws TransactionalExecutor.ExecutionException {
        try {
            // 回調(diào)，默認(rèn)是空回調(diào)
            triggerBeforeBegin();
            // 發(fā)起分布式事務(wù)
            tx.begin(txInfo.getTimeOut(), txInfo.getName());
            // 回調(diào)，默認(rèn)是空回調(diào)
            triggerAfterBegin();
        } catch (TransactionException txe) {
            throw new TransactionalExecutor.ExecutionException(tx, txe,
                TransactionalExecutor.Code.BeginFailure);
        }
    }
@Override
    public void begin(int timeout, String name) throws TransactionException {
        // 如果不是分布式事務(wù)發(fā)起者，那么啥也不做
        if (role != GlobalTransactionRole.Launcher) {
            assertXIDNotNull();
            if (LOGGER.isDebugEnabled()) {
                LOGGER.debug("Ignore Begin(): just involved in global transaction [{}]", xid);
            }
            return;
        }
        assertXIDNull();
        // 如果當(dāng)前已經(jīng)處于分布式事務(wù)當(dāng)中，那么拋異常，因?yàn)槭聞?wù)發(fā)起者不可能事先處于別的分布式事務(wù)當(dāng)中
        String currentXid = RootContext.getXID();
        if (currentXid != null) {
            throw new IllegalStateException("Global transaction already exists," +
                " can't begin a new global transaction, currentXid = " + currentXid);
        }
        // 發(fā)起分布式事務(wù)
        xid = transactionManager.begin(null, null, name, timeout);
        status = GlobalStatus.Begin;
        // 把xid綁定到當(dāng)前線程中
        RootContext.bind(xid);
        if (LOGGER.isInfoEnabled()) {
            LOGGER.info("Begin new global transaction [{}]", xid);
        }
    }
@Override
    public String begin(String applicationId, String transactionServiceGroup, String name, int timeout)
        throws TransactionException {
        // 發(fā)起分布式事務(wù)開啟的請求
        GlobalBeginRequest request = new GlobalBeginRequest();
        request.setTransactionName(name);
        request.setTimeout(timeout);
        GlobalBeginResponse response = (GlobalBeginResponse) syncCall(request);
        if (response.getResultCode() == ResultCode.Failed) {
            throw new TmTransactionException(TransactionExceptionCode.BeginFailed, response.getMsg());
        }
        // 獲取拿到的xid，表示分布式事務(wù)開啟成功
        return response.getXid();
    }

private void completeTransactionAfterThrowing(TransactionInfo txInfo, GlobalTransaction tx, Throwable originalException) throws TransactionalExecutor.ExecutionException {
        // 如果異常類型和指定的類型一致，那么發(fā)起回滾；不一致還是要提交分布式事務(wù)
        if (txInfo != null && txInfo.rollbackOn(originalException)) {
            try {
                // 回滾分布式事務(wù)
                rollbackTransaction(tx, originalException);
            } catch (TransactionException txe) {
                // 回滾失敗拋異常
                throw new TransactionalExecutor.ExecutionException(tx, txe,
                        TransactionalExecutor.Code.RollbackFailure, originalException);
            }
        } else {
            // 不是指定的異常類型，還是繼續(xù)提交分布式事務(wù)
            commitTransaction(tx);
        }
    }
private void rollbackTransaction(GlobalTransaction tx, Throwable originalException) throws TransactionException, TransactionalExecutor.ExecutionException {
        // 執(zhí)行回調(diào)，默認(rèn)空回調(diào)
        triggerBeforeRollback();
        // 回滾
        tx.rollback();
        // 執(zhí)行回調(diào)，默認(rèn)空回調(diào)
        triggerAfterRollback();
        // 就算回滾沒問題，照樣拋異常，目的應(yīng)該是告知開發(fā)人員此處產(chǎn)生了回滾
        throw new TransactionalExecutor.ExecutionException(tx, GlobalStatus.RollbackRetrying.equals(tx.getLocalStatus())
            ? TransactionalExecutor.Code.RollbackRetrying : TransactionalExecutor.Code.RollbackDone, originalException);
    }
@Override
    public void rollback() throws TransactionException {
        // 如果是分布式事務(wù)參與者，那么啥也不做，RM的回滾不在這里，這是TM的回滾
        if (role == GlobalTransactionRole.Participant) {
            // Participant has no responsibility of rollback
            if (LOGGER.isDebugEnabled()) {
                LOGGER.debug("Ignore Rollback(): just involved in global transaction [{}]", xid);
            }
            return;
        }
        assertXIDNotNull();
        // 下面就是一個(gè)循環(huán)重試發(fā)起分布式事務(wù)回滾
        int retry = ROLLBACK_RETRY_COUNT <= 0 ? DEFAULT_TM_ROLLBACK_RETRY_COUNT : ROLLBACK_RETRY_COUNT;
        try {
            while (retry > 0) {
                try {
                    retry--;
                    // 發(fā)起回滾的核心代碼
                    status = transactionManager.rollback(xid);
                    // 回滾成功跳出循環(huán)
                    break;
                } catch (Throwable ex) {
                    LOGGER.error("Failed to report global rollback [{}],Retry Countdown: {}, reason: {}", this.getXid(), retry, ex.getMessage());
                    // 重試失敗次數(shù)完成才會跳出循環(huán)
                    if (retry == 0) {
                        throw new TransactionException("Failed to report global rollback", ex);
                    }
                }
            }
        } finally {
            // 如果回滾的分布式事務(wù)就是當(dāng)前的分布式事務(wù)，那么從當(dāng)前線程中解綁XID
            if (xid.equals(RootContext.getXID())) {
                suspend();
            }
        }
        if (LOGGER.isInfoEnabled()) {
            LOGGER.info("[{}] rollback status: {}", xid, status);
        }
    }
@Override
    public GlobalStatus rollback(String xid) throws TransactionException {
        // 準(zhǔn)備發(fā)起請求給TC，回滾指定的分布式事務(wù)
        GlobalRollbackRequest globalRollback = new GlobalRollbackRequest();
        globalRollback.setXid(xid);
        GlobalRollbackResponse response = (GlobalRollbackResponse) syncCall(globalRollback);
        return response.getGlobalStatus();
    }

private void commitTransaction(GlobalTransaction tx) throws TransactionalExecutor.ExecutionException {
        try {
            // 回調(diào)，默認(rèn)空回調(diào)
            triggerBeforeCommit();
            // 分布式事務(wù)提交
            tx.commit();
            // 回調(diào)，默認(rèn)空回調(diào)
            triggerAfterCommit();
        } catch (TransactionException txe) {
            // 4.1 提交出異常，提交失敗
            throw new TransactionalExecutor.ExecutionException(tx, txe,
                TransactionalExecutor.Code.CommitFailure);
        }
    }
@Override
    public void commit() throws TransactionException {
        // 如果只是分布式事務(wù)參與者，那么啥也不干，TM只能有一個(gè)，哈哈
        if (role == GlobalTransactionRole.Participant) {
            // Participant has no responsibility of committing
            if (LOGGER.isDebugEnabled()) {
                LOGGER.debug("Ignore Commit(): just involved in global transaction [{}]", xid);
            }
            return;
        }
        assertXIDNotNull();
        // 分布式事務(wù)提交也是有重試的
        int retry = COMMIT_RETRY_COUNT <= 0 ? DEFAULT_TM_COMMIT_RETRY_COUNT : COMMIT_RETRY_COUNT;
        try {
            while (retry > 0) {
                try {
                    retry--;
                    // 發(fā)起分布式事務(wù)提交
                    status = transactionManager.commit(xid);
                    // 提交成功跳出循環(huán)
                    break;
                } catch (Throwable ex) {
                    LOGGER.error("Failed to report global commit [{}],Retry Countdown: {}, reason: {}", this.getXid(), retry, ex.getMessage());
                    // 重試結(jié)束，依然失敗就拋異常
                    if (retry == 0) {
                        throw new TransactionException("Failed to report global commit", ex);
                    }
                }
            }
        } finally {
            // 如果提交的分布式事務(wù)就是當(dāng)前事務(wù)，那么需要清理當(dāng)前線程中的XID
            if (xid.equals(RootContext.getXID())) {
                suspend();
            }
        }
        if (LOGGER.isInfoEnabled()) {
            LOGGER.info("[{}] commit status: {}", xid, status);
        }
    }
@Override
    public GlobalStatus commit(String xid) throws TransactionException {
        // 發(fā)起分布式事務(wù)提交請求，這是與TC通信
        GlobalCommitRequest globalCommit = new GlobalCommitRequest();
        globalCommit.setXid(xid);
        GlobalCommitResponse response = (GlobalCommitResponse) syncCall(globalCommit);
        return response.getGlobalStatus();
    }

private Object handleGlobalLock(final MethodInvocation methodInvocation, final GlobalLock globalLockAnno) throws Throwable {
        // 模版模式實(shí)現(xiàn)全局鎖
        return globalLockTemplate.execute(new GlobalLockExecutor() {
            // 執(zhí)行業(yè)務(wù)邏輯
            @Override
            public Object execute() throws Throwable {
                return methodInvocation.proceed();
            }
            // 獲取全局鎖配置
            // 一個(gè)是全局鎖重試間隔時(shí)間
            // 一個(gè)是全局鎖重試次數(shù)
            @Override
            public GlobalLockConfig getGlobalLockConfig() {
                GlobalLockConfig config = new GlobalLockConfig();
                config.setLockRetryInterval(globalLockAnno.lockRetryInterval());
                config.setLockRetryTimes(globalLockAnno.lockRetryTimes());
                return config;
            }
        });
    }
public Object execute(GlobalLockExecutor executor) throws Throwable {
        // 判斷當(dāng)前是否有全局鎖
        boolean alreadyInGlobalLock = RootContext.requireGlobalLock();
        // 如果沒有全局鎖，那么在當(dāng)前線程中設(shè)置需要全局鎖標(biāo)識
        if (!alreadyInGlobalLock) {
            RootContext.bindGlobalLockFlag();
        }
        // 把全局鎖的配置設(shè)置進(jìn)當(dāng)前線程，并把線程中已有的全局鎖配置拿出來，后面恢復(fù)現(xiàn)場需要用
        GlobalLockConfig myConfig = executor.getGlobalLockConfig();
        GlobalLockConfig previousConfig = GlobalLockConfigHolder.setAndReturnPrevious(myConfig);
        try {
            // 執(zhí)行業(yè)務(wù)邏輯
            return executor.execute();
        } finally {
            // 清除線程中的全局鎖標(biāo)記
            if (!alreadyInGlobalLock) {
                RootContext.unbindGlobalLockFlag();
            }
            // 恢復(fù)現(xiàn)場
            if (previousConfig != null) {
                GlobalLockConfigHolder.setAndReturnPrevious(previousConfig);
            } else {
                GlobalLockConfigHolder.remove();
            }
        }
    }