public enum Propagation {
    /**
     * 支持當(dāng)前事務(wù)，如果不存在則新建一個（默認(rèn)值）
     * 這是最常用的傳播行為
     */
    REQUIRED(TransactionDefinition.PROPAGATION_REQUIRED),
    /**
     * 支持當(dāng)前事務(wù)，如果不存在則以非事務(wù)方式執(zhí)行
     * 適用于不需要事務(wù)支持但可以參與現(xiàn)有事務(wù)的方法
     */
    SUPPORTS(TransactionDefinition.PROPAGATION_SUPPORTS),
    /**
     * 支持當(dāng)前事務(wù)，如果不存在則拋出異常
     * 強(qiáng)制要求必須在事務(wù)中調(diào)用
     */
    MANDATORY(TransactionDefinition.PROPAGATION_MANDATORY),
    /**
     * 新建事務(wù)，如果當(dāng)前存在事務(wù)則將其掛起
     * 適用于需要獨(dú)立事務(wù)的子操作
     */
    REQUIRES_NEW(TransactionDefinition.PROPAGATION_REQUIRES_NEW),
    /**
     * 以非事務(wù)方式執(zhí)行，如果當(dāng)前存在事務(wù)則將其掛起
     * 適用于不需要事務(wù)的只讀操作
     */
    NOT_SUPPORTED(TransactionDefinition.PROPAGATION_NOT_SUPPORTED),
    /**
     * 以非事務(wù)方式執(zhí)行，如果當(dāng)前存在事務(wù)則拋出異常
     * 強(qiáng)制要求不能在事務(wù)中調(diào)用
     */
    NEVER(TransactionDefinition.PROPAGATION_NEVER),
    /**
     * 如果當(dāng)前存在事務(wù)，則在嵌套事務(wù)中執(zhí)行
     * 嵌套事務(wù)是外部事務(wù)的子事務(wù)，可以獨(dú)立提交或回滾
     * 注意：并非所有數(shù)據(jù)源都支持嵌套事務(wù)
     */
    NESTED(TransactionDefinition.PROPAGATION_NESTED)
}

@Service
public class OrderService {
    @Autowired
    private InventoryService inventoryService;
    @Autowired
    private PaymentService paymentService;
    @Transactional(propagation = Propagation.REQUIRED)
    public void createOrder(OrderDTO order) {
        // 創(chuàng)建訂單記錄
        orderRepository.save(order);
        try {
            // 扣減庫存 - 需要獨(dú)立事務(wù)，失敗不影響訂單創(chuàng)建
            inventoryService.deductInventory(order.getProductId(), order.getQuantity());
        } catch (Exception e) {
            // 庫存操作失敗，但訂單已創(chuàng)建，需要人工介入處理
            log.error("庫存扣減失敗，訂單號: {}", order.getOrderNo(), e);
        }
        // 支付處理 - 必須與訂單創(chuàng)建在同一個事務(wù)中
        paymentService.processPayment(order);
    }
}
@Service
class InventoryService {
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void deductInventory(Long productId, Integer quantity) {
        // 獨(dú)立事務(wù)執(zhí)行庫存扣減
        inventoryRepository.reduceStock(productId, quantity);
        // 記錄庫存變更日志
        inventoryLogRepository.save(new InventoryLog(productId, quantity));
    }
}

public enum Isolation {
    /**
     * 使用底層數(shù)據(jù)源的默認(rèn)隔離級別
     * MySQL默認(rèn)是REPEATABLE_READ，Oracle默認(rèn)是READ_COMMITTED
     */
    DEFAULT(TransactionDefinition.ISOLATION_DEFAULT),
    /**
     * 讀未提交 - 允許讀取未提交的數(shù)據(jù)變更
     * 可能出現(xiàn)臟讀、不可重復(fù)讀和幻讀
     * 性能最高，但數(shù)據(jù)一致性最差
     */
    READ_UNCOMMITTED(TransactionDefinition.ISOLATION_READ_UNCOMMITTED),
    /**
     * 讀已提交 - 只能讀取已提交的數(shù)據(jù)
     * 可以避免臟讀，但可能出現(xiàn)不可重復(fù)讀和幻讀
     * 大多數(shù)數(shù)據(jù)庫的默認(rèn)級別
     */
    READ_COMMITTED(TransactionDefinition.ISOLATION_READ_COMMITTED),
    /**
     * 可重復(fù)讀 - 同一事務(wù)中多次讀取結(jié)果一致
     * 可以避免臟讀和不可重復(fù)讀，但可能出現(xiàn)幻讀
     * MySQL的默認(rèn)級別（InnoDB通過MVCC避免了幻讀）
     */
    REPEATABLE_READ(TransactionDefinition.ISOLATION_REPEATABLE_READ),
    /**
     * 串行化 - 完全串行執(zhí)行事務(wù)
     * 可以避免所有并發(fā)問題，但性能最低
     * 適用于對數(shù)據(jù)一致性要求極高的場景
     */
    SERIALIZABLE(TransactionDefinition.ISOLATION_SERIALIZABLE)
}

@Service
public class AccountService {
    // 場景：銀行轉(zhuǎn)賬，需要最高級別的數(shù)據(jù)一致性
    @Transactional(
        isolation = Isolation.SERIALIZABLE,
        timeout = 30
    )
    public void transfer(TransferRequest request) {
        // 檢查賬戶余額（這里需要避免不可重復(fù)讀）
        BigDecimal balance = accountRepository.getBalance(request.getFromAccount());
        if (balance.compareTo(request.getAmount()) < 0) {
            throw new InsufficientBalanceException("余額不足");
        }
        // 扣減轉(zhuǎn)出賬戶金額
        accountRepository.deduct(request.getFromAccount(), request.getAmount());
        // 增加轉(zhuǎn)入賬戶金額
        accountRepository.add(request.getToAccount(), request.getAmount());
        // 記錄交易流水（需要避免幻讀）
        transactionRepository.save(createTransactionRecord(request));
    }
    // 場景：報表統(tǒng)計，對實(shí)時性要求不高但需要一致性視圖
    @Transactional(
        isolation = Isolation.REPEATABLE_READ,
        readOnly = true
    )
    public FinancialReport generateDailyReport(LocalDate date) {
        // 多次查詢需要保持?jǐn)?shù)據(jù)一致性
        BigDecimal totalIncome = orderRepository.sumIncomeByDate(date);
        BigDecimal totalExpense = expenseRepository.sumExpenseByDate(date);
        List<Transaction> transactions = transactionRepository.findByDate(date);
        return FinancialReport.builder()
                .date(date)
                .totalIncome(totalIncome)
                .totalExpense(totalExpense)
                .transactions(transactions)
                .build();
    }
}

@Service
public class BatchProcessingService {
    // 批量數(shù)據(jù)處理，設(shè)置較長的超時時間
    @Transactional(
        timeout = 300,  // 5分鐘超時
        propagation = Propagation.REQUIRES_NEW
    )
    public void processLargeBatch(List<Data> dataList) {
        // 大數(shù)據(jù)量處理操作
        dataList.forEach(data -> {
            processItem(data);
            // 每處理100條記錄提交一次，避免長時間占用連接
            if (counter.get() % 100 == 0) {
                EntityManagerHelper.flushAndClear();
            }
        });
    }
    // 快速查詢操作，設(shè)置較短的超時時間
    @Transactional(
        timeout = 5,  // 5秒超時
        readOnly = true
    )
    public QuickResult quickSearch(SearchCriteria criteria) {
        return searchRepository.quickSearch(criteria);
    }
}

@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    @Transactional(readOnly = true)
    @Query("SELECT u FROM User u WHERE u.status = 'ACTIVE'")
    List<User> findAllActiveUsers();
    @Transactional(readOnly = true)
    @Query("SELECT new com.example.UserDTO(u.id, u.username, u.email) " +
           "FROM User u WHERE u.department = :dept")
    List<UserDTO> findUsersByDepartment(@Param("dept") String department);
}
@Service
public class ReportService {
    @Transactional(readOnly = true)
    public ComplexReport generateComplexReport(ReportRequest request) {
        // 多個查詢操作，使用只讀事務(wù)優(yōu)化
        List<Data> dataSet1 = repository1.findByCriteria(request);
        List<Data> dataSet2 = repository2.findByCriteria(request);
        Statistics stats = repository3.calculateStatistics(request);
        return assembleReport(dataSet1, dataSet2, stats);
    }
}

@Service
public class OrderProcessingService {
    // 業(yè)務(wù)異常不回滾，系統(tǒng)異?；貪L
    @Transactional(
        rollbackFor = {SystemException.class, DataAccessException.class},
        noRollbackFor = {BusinessException.class, ValidationException.class}
    )
    public OrderResult processOrder(OrderRequest request) {
        // 參數(shù)驗證失敗不觸發(fā)事務(wù)回滾
        validateOrder(request);
        try {
            // 業(yè)務(wù)處理
            Order order = createOrder(request);
            processPayment(order);
            updateInventory(order);
            // 發(fā)送通知（即使失敗也不應(yīng)該回滾整個事務(wù)）
            try {
                notificationService.sendOrderConfirmation(order);
            } catch (NotificationException e) {
                log.warn("訂單通知發(fā)送失敗，訂單號: {}", order.getOrderNo(), e);
                // 記錄通知失敗，但不回滾事務(wù)
                notificationLogRepository.saveFailureLog(order, e);
            }
            return OrderResult.success(order);
        } catch (InsufficientStockException e) {
            // 庫存不足是業(yè)務(wù)異常，需要特殊處理但不一定回滾
            log.error("庫存不足，訂單處理失敗", e);
            throw new BusinessException("庫存不足，請調(diào)整商品數(shù)量", e);
        }
    }
    // 自定義回滾邏輯
    @Transactional
    public void processWithCustomRollback(ProcessRequest request) {
        try {
            step1(request);
            step2(request);
            step3(request);
        } catch (Exception e) {
            // 記錄錯誤信息
            errorLogRepository.save(createErrorLog(request, e));
            // 根據(jù)異常類型決定是否回滾
            if (shouldRollback(e)) {
                // 重新拋出異常觸發(fā)Spring事務(wù)回滾
                throw e;
            } else {
                // 執(zhí)行補(bǔ)償操作但不回滾
                executeCompensation(request);
            }
        }
    }
}

@Configuration
public class DataSourceConfig {
    @Primary
    @Bean(name = "primaryTransactionManager")
    public PlatformTransactionManager primaryTransactionManager(
            @Qualifier("primaryDataSource") DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }
    @Bean(name = "secondaryTransactionManager")
    public PlatformTransactionManager secondaryTransactionManager(
            @Qualifier("secondaryDataSource") DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }
}
@Service
public class MultiDataSourceService {
    // 使用主數(shù)據(jù)源的事務(wù)
    @Transactional("primaryTransactionManager")
    public void processWithPrimaryDataSource() {
        primaryRepository.save(new PrimaryEntity());
        // 主數(shù)據(jù)源操作
    }
    // 使用次要數(shù)據(jù)源的事務(wù)
    @Transactional("secondaryTransactionManager")
    public void processWithSecondaryDataSource() {
        secondaryRepository.save(new SecondaryEntity());
        // 次要數(shù)據(jù)源操作
    }
    // 分布式事務(wù)場景（需要XA事務(wù)管理器）
    @Transactional("xaTransactionManager")
    public void processDistributedTransaction() {
        // 操作多個資源管理器
        resource1Repository.update();
        resource2Repository.update();
        jmsTemplate.send(destination, messageCreator);
    }
}

// 基礎(chǔ)服務(wù)類定義通用事務(wù)配置
@Service
@Transactional(
    readOnly = true,
    timeout = 30,
    propagation = Propagation.SUPPORTS
)
public abstract class BaseService {
    protected void commonOperation() {
        // 通用操作
    }
}
// 具體服務(wù)類可以覆蓋事務(wù)配置
@Service
public class UserService extends BaseService {
    // 覆蓋為讀寫事務(wù)
    @Transactional(
        readOnly = false,
        propagation = Propagation.REQUIRED,
        rollbackFor = Exception.class
    )
    public User createUser(UserCreateRequest request) {
        // 創(chuàng)建用戶操作
        return userRepository.save(convertToEntity(request));
    }
    // 繼承基類的只讀事務(wù)配置
    public User getUserById(Long id) {
        return userRepository.findById(id).orElse(null);
    }
}

@Service
public class ComplexBusinessService {
    @Autowired
    private AccountService accountService;
    @Autowired
    private AuditService auditService;
    // 外層事務(wù)方法
    @Transactional(propagation = Propagation.REQUIRED)
    public void complexBusinessProcess(BusinessRequest request) {
        // 步驟1：數(shù)據(jù)準(zhǔn)備（在同一個事務(wù)中）
        prepareData(request);
        // 步驟2：調(diào)用內(nèi)層事務(wù)方法
        try {
            // 內(nèi)層方法使用REQUIRES_NEW，創(chuàng)建獨(dú)立事務(wù)
            accountService.processPayment(request.getPayment());
        } catch (PaymentException e) {
            // 支付失敗，但外層事務(wù)繼續(xù)執(zhí)行
            handlePaymentFailure(request, e);
        }
        // 步驟3：記錄審計日志（使用NOT_SUPPORTED，掛起當(dāng)前事務(wù)）
        auditService.logOperation(request);
        // 步驟4：最終提交（如果前面的REQUIRES_NEW事務(wù)失敗，這里仍可提交）
        completeProcess(request);
    }
    private void prepareData(BusinessRequest request) {
        // 準(zhǔn)備業(yè)務(wù)數(shù)據(jù)
    }
    private void handlePaymentFailure(BusinessRequest request, PaymentException e) {
        // 處理支付失敗
    }
    private void completeProcess(BusinessRequest request) {
        // 完成處理
    }
}

@Service
public class TransactionTrapService {
    // 陷阱1：自調(diào)用導(dǎo)致事務(wù)失效
    public void selfInvocationTrap() {
        // 直接調(diào)用內(nèi)部方法，事務(wù)注解不會生效
        internalTransactionMethod();
        // 解決方案：通過AopContext獲取代理對象
        // ((TransactionTrapService) AopContext.currentProxy()).internalTransactionMethod();
    }
    @Transactional
    public void internalTransactionMethod() {
        // 這個方法的事務(wù)不會生效
    }
    // 陷阱2：異常被捕獲未拋出
    @Transactional
    public void exceptionHandlingTrap() {
        try {
            riskyOperation();
        } catch (Exception e) {
            // 異常被捕獲，事務(wù)不會回滾
            log.error("操作失敗", e);
            // 解決方案1：重新拋出異常
            // throw e;
            // 解決方案2：手動回滾
            // TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        }
    }
    // 陷阱3：非public方法
    @Transactional
    protected void nonPublicMethod() {
        // Spring基于代理的事務(wù)只對public方法生效
    }
}

@Aspect
@Component
@Slf4j
public class TransactionMonitoringAspect {
    @Around("@annotation(transactional)")
    public Object monitorTransaction(ProceedingJoinPoint joinPoint, 
                                     Transactional transactional) throws Throwable {
        String methodName = joinPoint.getSignature().toShortString();
        log.info("事務(wù)開始 - 方法: {}, 傳播行為: {}, 隔離級別: {}", 
                 methodName, 
                 transactional.propagation(),
                 transactional.isolation());
        long startTime = System.currentTimeMillis();
        try {
            Object result = joinPoint.proceed();
            long duration = System.currentTimeMillis() - startTime;
            log.info("事務(wù)提交成功 - 方法: {}, 耗時: {}ms", 
                     methodName, duration);
            return result;
        } catch (Exception e) {
            long duration = System.currentTimeMillis() - startTime;
            log.error("事務(wù)回滾 - 方法: {}, 耗時: {}ms, 異常: {}", 
                      methodName, duration, e.getClass().getSimpleName());
            throw e;
        }
    }
}