// 核心源碼解析
public abstract class TransactionSynchronizationManager {
    // 線程局部變量存儲(chǔ)事務(wù)狀態(tài)
    private static final ThreadLocal<Map<Object, Object>> resources = 
        new NamedThreadLocal<>("Transactional resources");
    private static final ThreadLocal<Set<TransactionSynchronization>> synchronizations = 
        new NamedThreadLocal<>("Transaction synchronizations");
    private static final ThreadLocal<String> currentTransactionName = 
        new NamedThreadLocal<>("Current transaction name");
    private static final ThreadLocal<Boolean> currentTransactionReadOnly = 
        new NamedThreadLocal<>("Current transaction read-only status");
    private static final ThreadLocal<Integer> currentTransactionIsolationLevel = 
        new NamedThreadLocal<>("Current transaction isolation level");
    private static final ThreadLocal<Boolean> actualTransactionActive = 
        new NamedThreadLocal<>("Actual transaction active");
}

// 簡化的事務(wù)傳播決策邏輯
public class PropagationDecisionEngine {
    public TransactionStatus handlePropagation(
            TransactionDefinition definition, 
            PlatformTransactionManager tm) {
        boolean existingTransaction = tm.hasExistingTransaction();
        switch (definition.getPropagationBehavior()) {
            case PROPAGATION_REQUIRED:
                if (existingTransaction) {
                    // 加入現(xiàn)有事務(wù)
                    return handleExistingTransaction(definition, tm, existingTransaction);
                } else {
                    // 創(chuàng)建新事務(wù)
                    return createNewTransaction(definition, tm);
                }
            case PROPAGATION_REQUIRES_NEW:
                // 總是掛起現(xiàn)有事務(wù)并創(chuàng)建新事務(wù)
                if (existingTransaction) {
                    SuspendedResourcesHolder suspendedResources = suspend(existingTransaction);
                    try {
                        return createNewTransaction(definition, tm);
                    } catch (Throwable ex) {
                        resume(suspendedResources);
                        throw ex;
                    }
                } else {
                    return createNewTransaction(definition, tm);
                }
            // ... 其他傳播行為的處理邏輯
        }
    }
}

@Service
public class OrderProcessingService {
    @Transactional(propagation = Propagation.REQUIRED)
    public void processCompleteOrder(Order order) {
        // 場景1：從無事務(wù)方法調(diào)用
        // 此時(shí)會(huì)創(chuàng)建新事務(wù)
        // 更新訂單狀態(tài)
        order.setStatus("PROCESSING");
        orderRepository.save(order);
        // 調(diào)用庫存服務(wù)（同一事務(wù)）
        inventoryService.deductStock(order.getProductId(), order.getQuantity());
        // 如果庫存服務(wù)使用REQUIRED，會(huì)加入此事務(wù)
        // 調(diào)用支付服務(wù)（同一事務(wù)）
        paymentService.createPayment(order);
        // 如果支付服務(wù)失敗，訂單和庫存操作都會(huì)回滾
    }
}
// 調(diào)用方示例
public void externalCall() {
    // 無事務(wù)上下文
    orderProcessingService.processCompleteOrder(order);
    // 整個(gè)過程在一個(gè)事務(wù)中執(zhí)行
}
@Transactional
public void transactionalCall() {
    // 已有事務(wù)上下文
    orderProcessingService.processCompleteOrder(order);
    // 加入調(diào)用方的事務(wù)
}

@Service
public class ProductQueryService {
    @Transactional(propagation = Propagation.SUPPORTS)
    public ProductStatistics getProductStatistics(Long productId) {
        // 場景分析：
        // 情況1：從@Transactional方法調(diào)用 -> 在事務(wù)中執(zhí)行
        // 情況2：從普通方法調(diào)用 -> 無事務(wù)執(zhí)行
        // 查詢1：獲取產(chǎn)品基本信息
        Product product = productRepository.findById(productId);
        // 由于可能無事務(wù)，這里存在時(shí)間差問題
        // 在兩個(gè)查詢之間，數(shù)據(jù)可能被其他事務(wù)修改
        // 查詢2：獲取產(chǎn)品統(tǒng)計(jì)信息
        ProductStats stats = statsRepository.findByProductId(productId);
        // 組合結(jié)果
        return new ProductStatistics(product, stats);
    }
    // 改進(jìn)方案：使用數(shù)據(jù)庫一致性視圖或添加同步鎖
    @Transactional(propagation = Propagation.SUPPORTS)
    @Lock(LockModeType.PESSIMISTIC_READ)
    public ProductStatistics getConsistentStatistics(Long productId) {
        // 通過鎖機(jī)制保證一致性
    }
}

@Service
public class FinancialService {
    @Transactional(propagation = Propagation.MANDATORY)
    public void transferFunds(TransferRequest request) {
        // 此方法必須被事務(wù)性方法調(diào)用
        // 確保資金轉(zhuǎn)移的原子性
        // 扣減轉(zhuǎn)出賬戶
        accountService.deduct(request.getFromAccount(), request.getAmount());
        // 增加轉(zhuǎn)入賬戶
        accountService.add(request.getToAccount(), request.getAmount());
        // 記錄交易流水
        transactionService.recordTransaction(request);
        // 三個(gè)操作必須同時(shí)成功或同時(shí)失敗
    }
}
// 正確用法
@Service
public class BankingService {
    @Transactional(propagation = Propagation.REQUIRED)
    public TransferResult executeTransfer(TransferRequest request) {
        // 驗(yàn)證業(yè)務(wù)規(guī)則
        validateTransfer(request);
        // 執(zhí)行資金轉(zhuǎn)移（在事務(wù)中）
        financialService.transferFunds(request);
        // 發(fā)送通知（可能使用REQUIRES_NEW）
        notificationService.sendTransferNotification(request);
        return new TransferResult("SUCCESS");
    }
}
// 錯(cuò)誤用法
@Service
public class InvalidBankingService {
    public TransferResult invalidTransfer(TransferRequest request) {
        // 錯(cuò)誤：直接調(diào)用MANDATORY方法
        // 將拋出：No existing transaction found for transaction marked with propagation 'mandatory'
        financialService.transferFunds(request);
        return new TransferResult("SUCCESS");
    }
}

@Service
public class AuditLogService {
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void logCriticalOperation(CriticalOperation operation) {
        // 場景1：從無事務(wù)方法調(diào)用 -> 創(chuàng)建新事務(wù)
        // 場景2：從事務(wù)方法調(diào)用 -> 掛起原事務(wù)，創(chuàng)建新事務(wù)
        // 記錄操作日志
        auditLogRepository.save(operation);
        // 寫入操作軌跡
        operationTraceRepository.saveTrace(operation);
        // 新事務(wù)獨(dú)立提交
        // 即使外部事務(wù)回滾，審計(jì)日志仍然保留
    }
}
// 復(fù)雜場景：嵌套的REQUIRES_NEW
@Service  
public class ComplexBusinessService {
    @Transactional(propagation = Propagation.REQUIRED)
    public void complexBusinessProcess() {
        // 主事務(wù)開始
        // 步驟1：核心業(yè)務(wù)（主事務(wù)）
        coreBusinessService.execute();
        try {
            // 步驟2：審計(jì)日志（獨(dú)立事務(wù)）
            // 掛起主事務(wù)，開啟新事務(wù)
            auditLogService.logCriticalOperation(operation);
            // 新事務(wù)提交，恢復(fù)主事務(wù)
        } catch (AuditException e) {
            // 審計(jì)失敗不影響主業(yè)務(wù)
            log.error("審計(jì)記錄失敗", e);
        }
        try {
            // 步驟3：發(fā)送通知（另一個(gè)獨(dú)立事務(wù)）
            // 再次掛起主事務(wù)，開啟另一個(gè)新事務(wù)
            notificationService.sendAsyncNotification(notification);
        } catch (NotificationException e) {
            // 通知失敗也不影響主業(yè)務(wù)
            log.error("通知發(fā)送失敗", e);
        }
        // 步驟4：繼續(xù)主事務(wù)邏輯
        additionalBusinessService.process();
        // 主事務(wù)提交
    }
}

@Service
public class DataExportService {
    @Transactional(propagation = Propagation.NOT_SUPPORTED)
    public ExportFile exportLargeDataset(ExportCriteria criteria) {
        // 大量數(shù)據(jù)查詢，避免事務(wù)鎖定
        // 查詢1：基礎(chǔ)數(shù)據(jù)（無事務(wù)，立即提交）
        List<BaseData> baseData = baseRepository.findByCriteria(criteria);
        // 復(fù)雜計(jì)算過程
        List<ProcessedData> processed = processData(baseData);
        // 查詢2：關(guān)聯(lián)數(shù)據(jù)（仍無事務(wù)）
        List<RelatedData> related = relatedRepository.findByProcessedData(processed);
        // 生成文件
        ExportFile file = generateExportFile(processed, related);
        // 注意：如果在此過程中發(fā)生異常
        // 已經(jīng)執(zhí)行的SQL不會(huì)回滾（因?yàn)闊o事務(wù)）
        return file;
    }
}
// 與SUPPORTS的區(qū)別
@Service
public class ComparisonService {
    // SUPPORTS vs NOT_SUPPORTED 對比演示
    public void comparePropagation() {
        // 在事務(wù)中調(diào)用
        @Transactional
        public void callInTransaction() {
            // 調(diào)用SUPPORTS方法：在事務(wù)中執(zhí)行
            supportsMethod();  // 參與事務(wù)
            // 調(diào)用NOT_SUPPORTED方法：掛起事務(wù)，非事務(wù)執(zhí)行
            notSupportedMethod();  // 不參與事務(wù)，每條SQL獨(dú)立提交
        }
        // 不在事務(wù)中調(diào)用
        public void callWithoutTransaction() {
            // 調(diào)用SUPPORTS方法：非事務(wù)執(zhí)行
            supportsMethod();  // 非事務(wù)執(zhí)行
            // 調(diào)用NOT_SUPPORTED方法：非事務(wù)執(zhí)行
            notSupportedMethod();  // 非事務(wù)執(zhí)行
            // 兩者效果相同
        }
    }
}

@Service
public class CacheManagementService {
    @Transactional(propagation = Propagation.NEVER)
    public void refreshLocalCache(String cacheKey) {
        // 此方法嚴(yán)禁在事務(wù)中調(diào)用
        // 原因：緩存操作應(yīng)該快速完成，避免長時(shí)間占用連接
        // 清除舊緩存
        cacheManager.evict(cacheKey);
        // 查詢最新數(shù)據(jù)
        Object freshData = dataService.getFreshData(cacheKey);
        // 更新緩存
        cacheManager.put(cacheKey, freshData);
        // 整個(gè)過程應(yīng)該快速完成
        // 如果放在事務(wù)中，可能因?yàn)槭聞?wù)等待而阻塞
    }
    // 正確調(diào)用模式
    public void updateDataWithCacheRefresh(Data newData) {
        // 第一步：更新數(shù)據(jù)庫（在事務(wù)中）
        dataService.updateInTransaction(newData);
        // 第二步：提交事務(wù)后刷新緩存（確保數(shù)據(jù)已持久化）
        // 這里必須在事務(wù)外調(diào)用
        refreshLocalCache("data:" + newData.getId());
    }
    // 錯(cuò)誤調(diào)用模式
    @Transactional
    public void wrongUpdateData(Data newData) {
        dataRepository.save(newData);
        // 錯(cuò)誤：在事務(wù)中調(diào)用NEVER方法
        // 將拋出異常！
        refreshLocalCache("data:" + newData.getId());
    }
}

@Service
public class BatchImportService {
    @Transactional(propagation = Propagation.REQUIRED)
    public ImportResult importProducts(List<Product> products) {
        ImportResult result = new ImportResult();
        for (Product product : products) {
            try {
                // 每個(gè)產(chǎn)品在嵌套事務(wù)中導(dǎo)入
                importSingleProduct(product);
                result.addSuccess(product);
            } catch (DuplicateProductException e) {
                // 重復(fù)產(chǎn)品：記錄但不中斷導(dǎo)入
                result.addSkipped(product, "產(chǎn)品已存在");
                log.warn("跳過重復(fù)產(chǎn)品: {}", product.getCode());
            } catch (InvalidProductException e) {
                // 無效產(chǎn)品：僅回滾當(dāng)前產(chǎn)品
                result.addFailed(product, "產(chǎn)品數(shù)據(jù)無效");
                log.error("產(chǎn)品數(shù)據(jù)無效: {}", product.getCode());
                // 嵌套事務(wù)回滾到保存點(diǎn)
                // 主事務(wù)繼續(xù)執(zhí)行下一個(gè)產(chǎn)品
            }
        }
        return result;
    }
    @Transactional(propagation = Propagation.NESTED)
    public void importSingleProduct(Product product) {
        // 步驟1：驗(yàn)證產(chǎn)品數(shù)據(jù)
        validateProduct(product);
        // 步驟2：檢查重復(fù)
        checkDuplicate(product);
        // 步驟3：保存產(chǎn)品
        productRepository.save(product);
        // 步驟4：保存產(chǎn)品圖片
        saveProductImages(product);
        // 步驟5：更新產(chǎn)品索引
        updateProductIndex(product);
        // 所有步驟在同一個(gè)嵌套事務(wù)中
        // 任何一步失敗都會(huì)回滾整個(gè)嵌套事務(wù)
        // 但不會(huì)影響其他產(chǎn)品的導(dǎo)入
    }
}
// NESTED與REQUIRES_NEW的對比
@Service
public class PropagationComparison {
    public void compareNestedVsRequiresNew() {
        // 場景：處理訂單項(xiàng)列表
        // 使用NESTED
        @Transactional
        public void processWithNested(List<OrderItem> items) {
            for (OrderItem item : items) {
                try {
                    // 嵌套事務(wù)：共享主事務(wù)連接
                    processItemNested(item);
                } catch (Exception e) {
                    // 僅回滾當(dāng)前item
                    continue;
                }
            }
            // 主事務(wù)統(tǒng)一提交
        }
        // 使用REQUIRES_NEW  
        @Transactional
        public void processWithRequiresNew(List<OrderItem> items) {
            for (OrderItem item : items) {
                try {
                    // 獨(dú)立事務(wù)：新建連接
                    processItemRequiresNew(item);
                } catch (Exception e) {
                    // 僅回滾當(dāng)前item的獨(dú)立事務(wù)
                    continue;
                }
            }
            // 主事務(wù)提交
        }
    }
    // 關(guān)鍵區(qū)別：
    // 1. 連接使用：NESTED共享連接，REQUIRES_NEW新建連接
    // 2. 鎖范圍：NESTED可能鎖沖突，REQUIRES_NEW隔離更好
    // 3. 性能：NESTED更高效，REQUIRES_NEW開銷大
}

graph TD
    A[開始選擇傳播行為] --> B{方法是否需要
事務(wù)原子性保證？}
    B -->|必須保證| C[需要事務(wù)保護(hù)路徑]
    B -->|不需要保證| D[不需要事務(wù)保護(hù)路徑]
    C --> E{是否允許獨(dú)立提交？}
    E -->|允許，需要獨(dú)立| F[REQUIRES_NEW]
    E -->|不允許，需一體| G{是否需要部分回滾能力？}
    G -->|需要，部分失敗不影響整體| H{數(shù)據(jù)庫是否支持保存點(diǎn)？}
    H -->|支持| I[NESTED]
    H -->|不支持| J[考慮業(yè)務(wù)重構(gòu)]
    G -->|不需要| K{是否強(qiáng)制要求事務(wù)上下文？}
    K -->|強(qiáng)制，無事務(wù)應(yīng)報(bào)錯(cuò)| L[MANDATORY]
    K -->|不強(qiáng)制| M[REQUIRED]
    D --> N{是否嚴(yán)格禁止事務(wù)？}
    N -->|嚴(yán)格禁止，有事務(wù)應(yīng)報(bào)錯(cuò)| O[NEVER]
    N -->|不嚴(yán)格，可適應(yīng)| P{是否優(yōu)化讀操作？}
    P -->|是，優(yōu)先無事務(wù)查詢| Q[SUPPORTS]
    P -->|否，避免事務(wù)影響| R[NOT_SUPPORTED]

// 電商訂單處理的最佳實(shí)踐
@Service
public class ECommerceBestPractices {
    // 1. 下單主流程 - REQUIRED（默認(rèn)選擇）
    @Transactional(propagation = Propagation.REQUIRED)
    public Order createOrder(OrderRequest request) {
        // 創(chuàng)建訂單（必須與后續(xù)操作原子性）
        Order order = orderRepository.save(new Order(request));
        // 扣減庫存（同一事務(wù)）
        inventoryService.deductStock(request.getItems());
        // 生成支付單（同一事務(wù)）
        Payment payment = paymentService.createPayment(order);
        // 所有操作成功才提交，任何一個(gè)失敗都回滾
        return order;
    }
    // 2. 支付回調(diào)處理 - REQUIRES_NEW
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void handlePaymentSuccess(PaymentCallback callback) {
        // 支付成功必須立即記錄，不受后續(xù)操作影響
        paymentRepository.updatePaymentStatus(callback.getPaymentId(), "SUCCESS");
        // 更新訂單狀態(tài)（可能失敗，但不影響支付狀態(tài)）
        try {
            orderService.updateOrderStatus(callback.getOrderId(), "PAID");
        } catch (OrderException e) {
            log.error("訂單狀態(tài)更新失敗，支付已成功", e);
        }
    }
    // 3. 查詢訂單歷史 - SUPPORTS
    @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
    public Page<Order> queryOrderHistory(Long userId, Pageable pageable) {
        // 查詢操作，有事務(wù)則用，無事務(wù)也可
        // readOnly=true優(yōu)化查詢性能
        return orderRepository.findByUserId(userId, pageable);
    }
    // 4. 批量訂單導(dǎo)出 - NOT_SUPPORTED
    @Transactional(propagation = Propagation.NOT_SUPPORTED)
    public ExportResult exportOrders(Date startDate, Date endDate) {
        // 大數(shù)據(jù)量導(dǎo)出，避免事務(wù)開銷
        List<Order> orders = orderRepository.findByDateRange(startDate, endDate);
        return generateExport(orders); // 可能處理數(shù)十萬條數(shù)據(jù)
    }
    // 5. 訂單數(shù)據(jù)校驗(yàn) - NESTED（如果數(shù)據(jù)庫支持）
    @Transactional(propagation = Propagation.REQUIRED)
    public ValidationResult validateOrders(List<Order> orders) {
        ValidationResult result = new ValidationResult();
        for (Order order : orders) {
            try {
                // 每個(gè)訂單獨(dú)立校驗(yàn)，失敗不影響其他
                validateSingleOrder(order);
                result.addValid(order);
            } catch (ValidationException e) {
                // 僅回滾當(dāng)前訂單的校驗(yàn)操作
                result.addInvalid(order, e.getMessage());
            }
        }
        return result;
    }
    @Transactional(propagation = Propagation.NESTED)
    private void validateSingleOrder(Order order) {
        // 復(fù)雜的校驗(yàn)邏輯
        validateBusinessRules(order);
        validateInventory(order);
        validateCustomerCredit(order);
    }
}

// 金融系統(tǒng)對事務(wù)的嚴(yán)格要求
@Service
public class FinancialTransactionService {
    // 1. 資金轉(zhuǎn)賬 - MANDATORY（強(qiáng)制事務(wù)）
    @Transactional(propagation = Propagation.MANDATORY)
    public void transfer(TransferCommand command) {
        // 必須確保在事務(wù)中執(zhí)行
        // 保證原子性：要么全轉(zhuǎn)，要么全不轉(zhuǎn)
        // 扣減轉(zhuǎn)出賬戶
        accountService.debit(command.getFromAccount(), command.getAmount());
        // 增加轉(zhuǎn)入賬戶
        accountService.credit(command.getToAccount(), command.getAmount());
        // 記錄交易流水
        transactionLogService.logTransfer(command);
    }
    // 2. 日終批量處理 - 復(fù)雜傳播組合
    @Transactional(propagation = Propagation.REQUIRED)
    public BatchResult dailyBatchProcessing() {
        BatchResult result = new BatchResult();
        // 階段1：數(shù)據(jù)準(zhǔn)備（主事務(wù)）
        prepareDailyData();
        // 階段2：利息計(jì)算（每個(gè)賬戶獨(dú)立事務(wù)）
        List<Account> accounts = accountRepository.findAllActive();
        for (Account account : accounts) {
            try {
                calculateInterestForAccount(account);
                result.addSuccess(account);
            } catch (CalculationException e) {
                // 單個(gè)賬戶計(jì)算失敗不影響整體
                result.addFailed(account, e.getMessage());
            }
        }
        // 階段3：審計(jì)日志（獨(dú)立事務(wù)，必須記錄）
        auditDailyBatch(result);
        // 階段4：生成報(bào)告（無事務(wù)，避免鎖）
        generateDailyReport(result);
        return result;
    }
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    private void calculateInterestForAccount(Account account) {
        // 每個(gè)賬戶獨(dú)立計(jì)算和更新
        // 避免長時(shí)間鎖定賬戶表
    }
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    private void auditDailyBatch(BatchResult result) {
        // 審計(jì)記錄必須保存，即使批量處理部分失敗
    }
    @Transactional(propagation = Propagation.NOT_SUPPORTED)
    private void generateDailyReport(BatchResult result) {
        // 復(fù)雜報(bào)表生成，避免事務(wù)開銷
    }
}

// 連接使用對比分析
public class ConnectionUsageAnalysis {
    // REQUIRES_NEW的連接開銷
    @Transactional(propagation = Propagation.REQUIRED)
    public void analyzeRequiresNewCost() {
        // 主事務(wù)獲取連接Connection1
        for (int i = 0; i < 1000; i++) {
            // 每次調(diào)用都需要新連接
            independentOperation(i); // 獲取Connection2, Connection3...
        }
        // 總共：1001個(gè)連接（如果連接池不夠會(huì)阻塞或失?。?
    }
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void independentOperation(int index) {
        // 需要新數(shù)據(jù)庫連接
    }
    // NESTED的優(yōu)化方案
    @Transactional(propagation = Propagation.REQUIRED)
    public void analyzeNestedOptimization() {
        // 主事務(wù)獲取連接Connection1
        for (int i = 0; i < 1000; i++) {
            nestedOperation(i); // 使用同一連接，創(chuàng)建保存點(diǎn)
        }
        // 總共：1個(gè)連接，1000個(gè)保存點(diǎn)
    }
    @Transactional(propagation = Propagation.NESTED)
    public void nestedOperation(int index) {
        // 使用主事務(wù)連接，創(chuàng)建保存點(diǎn)
    }
}

// 傳播行為對鎖的影響
@Service
public class LockingAnalysis {
    // 場景：庫存扣減的鎖競爭
    @Transactional(propagation = Propagation.REQUIRED)
    public void highContentionScenario() {
        // 鎖住商品A的記錄
        inventoryService.deductProductA(10);
        // 嵌套調(diào)用可能增加鎖等待
        processRelatedOperations(); // 內(nèi)部可能鎖其他資源
    }
    // 優(yōu)化：減少鎖持有時(shí)間
    @Transactional(propagation = Propagation.REQUIRED)
    public void optimizedLocking() {
        // 快速操作，盡快釋放鎖
        inventoryService.deductProductA(10);
        // 后續(xù)非關(guān)鍵操作使用獨(dú)立事務(wù)
        asyncLogOperation(); // REQUIRES_NEW，不持有主事務(wù)鎖
    }
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void asyncLogOperation() {
        // 獨(dú)立事務(wù)，不競爭主事務(wù)鎖
    }
}

// 自調(diào)用導(dǎo)致傳播行為失效
@Service
public class SelfInvocationProblem {
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void methodA() {
        // 這個(gè)事務(wù)會(huì)生效
        repository.save(entityA);
        // 自調(diào)用：事務(wù)失效！
        this.methodB(); // 不會(huì)創(chuàng)建新事務(wù)，而是加入當(dāng)前事務(wù)
        // 正確方式：注入自身代理
        self.methodB(); // 通過代理調(diào)用
    }
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void methodB() {
        // 期望獨(dú)立事務(wù)，實(shí)際可能加入methodA的事務(wù)
        repository.save(entityB);
    }
    // 解決方案1：注入自身代理
    @Autowired
    private SelfInvocationProblem self;
    // 解決方案2：使用AspectJ模式
    @Configuration
    @EnableTransactionManagement(mode = AdviceMode.ASPECTJ)
    public class AspectJConfig {
    }
}

// 異常處理對傳播行為的影響
@Service
public class ExceptionPropagation {
    @Transactional(propagation = Propagation.REQUIRED)
    public void parentMethod() {
        try {
            // 調(diào)用REQUIRES_NEW方法
            childMethodWithRequiresNew();
        } catch (ChildException e) {
            // 子方法異常被捕獲
            // 子事務(wù)已回滾，但父事務(wù)繼續(xù)
            log.error("子方法失敗", e);
        }
        // 父事務(wù)繼續(xù)執(zhí)行
        otherOperation(); // 仍然可以執(zhí)行
    }
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void childMethodWithRequiresNew() {
        repository.save(childEntity);
        throw new ChildException("子事務(wù)失敗");
        // 新事務(wù)回滾，異常傳播到父方法
    }
    // 嵌套事務(wù)的異常處理
    @Transactional(propagation = Propagation.REQUIRED)
    public void parentWithNested() {
        try {
            childMethodWithNested();
        } catch (ChildException e) {
            // 嵌套事務(wù)回滾到保存點(diǎn)
            // 父事務(wù)繼續(xù)
            handleError(e);
        }
    }
    @Transactional(propagation = Propagation.NESTED)
    public void childMethodWithNested() {
        repository.save(childEntity);
        throw new ChildException("嵌套事務(wù)失敗");
        // 回滾到保存點(diǎn)，異常傳播
    }
}

# Spring Boot監(jiān)控配置
management:
  endpoints:
    web:
      exposure:
        include: metrics,prometheus,transactions
  metrics:
    export:
      prometheus:
        enabled: true
    distribution:
      percentiles-histogram:
        http.server.requests: true
      sla:
        transaction.duration: 100ms,200ms,500ms,1s,2s
logging:
  level:
    org.springframework.transaction: DEBUG
    org.springframework.jdbc.datasource.DataSourceTransactionManager: TRACE
    org.springframework.orm.jpa.JpaTransactionManager: TRACE

// 傳播行為的單元測試
@SpringBootTest
@Transactional // 測試類默認(rèn)事務(wù)
class TransactionPropagationTest {
    @Autowired
    private TestService testService;
    @Autowired
    private PlatformTransactionManager transactionManager;
    @Test
    void testRequiredPropagation() {
        // 測試1：無事務(wù)時(shí)是否創(chuàng)建新事務(wù)
        TransactionStatus statusBefore = TransactionAspectSupport.currentTransactionStatus();
        assertNull(statusBefore); // 當(dāng)前無事務(wù)
        testService.methodWithRequired();
        // 驗(yàn)證事務(wù)創(chuàng)建
    }
    @Test
    @Transactional // 測試已有事務(wù)
    void testRequiredWithExistingTransaction() {
        TransactionStatus statusBefore = TransactionAspectSupport.currentTransactionStatus();
        assertNotNull(statusBefore); // 當(dāng)前已有事務(wù)
        // 調(diào)用方法應(yīng)加入現(xiàn)有事務(wù)
        testService.methodWithRequired();
        // 驗(yàn)證事務(wù)ID相同
    }
    @Test
    void testRequiresNewCreatesNewTransaction() {
        // 模擬監(jiān)控
        MeterRegistry meterRegistry = new SimpleMeterRegistry();
        // 執(zhí)行REQUIRES_NEW方法
        testService.methodWithRequiresNew();
        // 驗(yàn)證連接使用次數(shù)
        Timer timer = meterRegistry.timer("transaction.requires_new.duration");
        assertTrue(timer.count() > 0);
    }
    @Test
    void testMandatoryThrowsWithoutTransaction() {
        // 驗(yàn)證無事務(wù)時(shí)拋出異常
        assertThrows(IllegalTransactionStateException.class, () -> {
            testService.methodWithMandatory();
        });
    }
}

// 分布式事務(wù)的SAGA模式實(shí)現(xiàn)
@Service
public class DistributedOrderSaga {
    @Transactional(propagation = Propagation.REQUIRED)
    public void createDistributedOrder(OrderRequest request) {
        // 本地事務(wù)開始
        Order order = createLocalOrder(request);
        try {
            // 步驟1：調(diào)用庫存服務(wù)（遠(yuǎn)程）
            inventoryFeignClient.deduct(request.getItems());
            // 步驟2：調(diào)用支付服務(wù)（遠(yuǎn)程）
            paymentFeignClient.create(order);
            // 本地提交
            orderRepository.save(order);
        } catch (RemoteException e) {
            // 分布式事務(wù)失敗，執(zhí)行補(bǔ)償
            compensate(order, request);
            throw new SagaException("分布式事務(wù)失敗", e);
        }
    }
    // 補(bǔ)償操作也需要事務(wù)
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    private void compensate(Order order, OrderRequest request) {
        // 回滾本地訂單
        orderRepository.delete(order);
        // 調(diào)用遠(yuǎn)程補(bǔ)償（可能需要異步）
        compensationService.compensateInventory(request.getItems());
        compensationService.compensatePayment(order.getId());
    }
}