Propagation.REQUIRED

@Transactional(propagation = Propagation.REQUIRED)
public void methodA() {
    // 數(shù)據(jù)庫操作
    methodB();
    // 更多數(shù)據(jù)庫操作
}
@Transactional(propagation = Propagation.REQUIRED)
public void methodB() {
    // 數(shù)據(jù)庫操作
}

Propagation.SUPPORTS

@Transactional
public void methodA() {
    // 數(shù)據(jù)庫操作
    methodB(); // B方法會(huì)在A的事務(wù)中執(zhí)行
}
// 非事務(wù)方法調(diào)用
public void methodC() {
    methodB(); // B方法會(huì)以非事務(wù)方式執(zhí)行
}
@Transactional(propagation = Propagation.SUPPORTS)
public void methodB() {
    // 數(shù)據(jù)庫操作
}

Propagation.MANDATORY

@Transactional
public void methodA() {
    // 數(shù)據(jù)庫操作
    methodB(); // 正常執(zhí)行，B方法加入A的事務(wù)
}
// 非事務(wù)方法調(diào)用
public void methodC() {
    methodB(); // 拋出異常，因?yàn)闆]有事務(wù)環(huán)境
}
@Transactional(propagation = Propagation.MANDATORY)
public void methodB() {
    // 數(shù)據(jù)庫操作
}

Propagation.REQUIRES_NEW

@Transactional
public void methodA() {
    // 數(shù)據(jù)庫操作 - 事務(wù)A
    try {
        methodB(); // 執(zhí)行新事務(wù)B，事務(wù)A被掛起
    } catch (Exception e) {
        // 即使B事務(wù)回滾，A事務(wù)不受影響
    }
    // 繼續(xù)事務(wù)A的操作
}
@Transactional(propagation = Propagation.REQUIRES_NEW)
public void methodB() {
    // 數(shù)據(jù)庫操作 - 在新的事務(wù)B中
    // 如果這里拋出異常，只有事務(wù)B回滾，事務(wù)A不受影響
}

Propagation.NOT_SUPPORTED

@Transactional
public void methodA() {
    // 數(shù)據(jù)庫操作 - 事務(wù)A
    methodB(); // 調(diào)用B方法，事務(wù)A被掛起
    // 繼續(xù)事務(wù)A的操作
}
@Transactional(propagation = Propagation.NOT_SUPPORTED)
public void methodB() {
    // 數(shù)據(jù)庫操作 - 非事務(wù)執(zhí)行
    // 這里的操作不會(huì)影響事務(wù)A
}

Propagation.NEVER

// 非事務(wù)方法調(diào)用
public void methodC() {
    methodB(); // 正常執(zhí)行，因?yàn)闆]有事務(wù)環(huán)境
}
@Transactional
public void methodA() {
    // 數(shù)據(jù)庫操作
    methodB(); // 拋出異常，因?yàn)榇嬖谑聞?wù)環(huán)境
}
@Transactional(propagation = Propagation.NEVER)
public void methodB() {
    // 數(shù)據(jù)庫操作 - 要求非事務(wù)環(huán)境
}

Propagation.NESTED

@Transactional
public void methodA() {
    // 數(shù)據(jù)庫操作 - 事務(wù)A
    try {
        methodB(); // 執(zhí)行嵌套事務(wù)B
    } catch (Exception e) {
        // 捕獲異常，事務(wù)B回滾，事務(wù)A可以繼續(xù)
    }
    // 繼續(xù)事務(wù)A的操作
}
@Transactional(propagation = Propagation.NESTED)
public void methodB() {
    // 數(shù)據(jù)庫操作 - 在嵌套事務(wù)B中
    // 如果這里拋出異常，只有事務(wù)B回滾到保存點(diǎn)，事務(wù)A可以繼續(xù)
}

?? 開始調(diào)用方法
    ↓
?? 檢查當(dāng)前是否存在事務(wù)？
    ↓               ↓
   是 ?            否 ?
    ↓               ↓
?? 根據(jù)傳播行為決定：    ?? 根據(jù)傳播行為決定：
- ?? REQUIRED: 加入     - ?? REQUIRED: 創(chuàng)建新事務(wù)
- ?? SUPPORTS: 加入     - ?? SUPPORTS: 非事務(wù)執(zhí)行
- ?? MANDATORY: 加入    - ?? MANDATORY: 拋異常
- ?? REQUIRES_NEW: 新建 - ?? REQUIRES_NEW: 創(chuàng)建新事務(wù)
- ?? NOT_SUPPORTED: 掛起- ?? NOT_SUPPORTED: 非事務(wù)執(zhí)行
- ?? NEVER: 拋異常      - ?? NEVER: 非事務(wù)執(zhí)行
- ?? NESTED: 嵌套事務(wù)   - ?? NESTED: 創(chuàng)建新事務(wù)

@Transactional
public void createOrder(Order order) {
    // 創(chuàng)建訂單
    orderRepository.save(order);
    // 記錄操作日志（使用獨(dú)立事務(wù)）
    logService.recordLog("創(chuàng)建訂單: " + order.getId());
    // 如果這里發(fā)生異常，訂單創(chuàng)建會(huì)回滾，但日志記錄不會(huì)回滾
    updateInventory(order.getItems());
}
@Service
public class LogService {
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void recordLog(String message) {
        logRepository.save(new Log(message));
    }
}

@Transactional
public void processBatch(List<Item> items) {
    for (Item item : items) {
        try {
            processItem(item);
        } catch (Exception e) {
            // 記錄錯(cuò)誤，繼續(xù)處理下一個(gè)
            logError(item, e);
        }
    }
}
@Transactional(propagation = Propagation.NESTED)
private void processItem(Item item) {
    // 處理單個(gè)項(xiàng)目
    // 如果這里拋出異常，只會(huì)回滾這個(gè)項(xiàng)目的處理
}

@Transactional(
    propagation = Propagation.REQUIRED,
    isolation = Isolation.READ_COMMITTED
)
public void someMethod() {
    // 方法體
}

@Service
public class UserService {
    @Transactional
    public void createUser(User user) {
        // 保存用戶
        saveUser(user);
        // 問題：這里直接調(diào)用同類中的方法，updateUserStats的事務(wù)設(shè)置不會(huì)生效
        updateUserStats();
    }
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void updateUserStats() {
        // 更新統(tǒng)計(jì)信息
    }
}

@Service
public class UserService {
    @Autowired
    private UserService self;
    @Transactional
    public void createUser(User user) {
        // 保存用戶
        saveUser(user);
        // 通過自注入的代理對象調(diào)用，事務(wù)設(shè)置會(huì)生效
        self.updateUserStats();
    }
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void updateUserStats() {
        // 更新統(tǒng)計(jì)信息
    }
}

@Service
public class UserService {
    @Autowired
    private StatsService statsService;
    @Transactional
    public void createUser(User user) {
        // 保存用戶
        saveUser(user);
        // 通過另一個(gè)服務(wù)調(diào)用，事務(wù)設(shè)置會(huì)生效
        statsService.updateUserStats();
    }
}
@Service
public class StatsService {
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void updateUserStats() {
        // 更新統(tǒng)計(jì)信息
    }
}

@Transactional(timeout = 30) // 30秒超時(shí)
public void methodA() {
    // 長時(shí)間操作
    methodB();
}
@Transactional(propagation = Propagation.REQUIRES_NEW, timeout = 5) // 5秒超時(shí)
public void methodB() {
    // 短時(shí)間操作
}

@Transactional(readOnly = true)
public List<User> getAllUsers() {
    return userRepository.findAll();
}

@Bean
public PlatformTransactionManager transactionManager(DataSource dataSource) {
    return new DataSourceTransactionManager(dataSource);
}

// 優(yōu)化前：所有方法都使用REQUIRED
@Transactional(propagation = Propagation.REQUIRED)
public List<User> queryUsers() {
    return userRepository.findAll(); // 只讀操作不需要事務(wù)
}
// 優(yōu)化后：只讀操作使用SUPPORTS或設(shè)置readOnly
@Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
public List<User> queryUsers() {
    return userRepository.findAll();
}

// 避免：長時(shí)間的事務(wù)
@Transactional
public void processLargeDataSet() {
    List<Data> dataList = dataRepository.findAll(); // 可能很大的數(shù)據(jù)集
    for (Data data : dataList) {
        // 復(fù)雜的業(yè)務(wù)邏輯處理
        complexBusinessLogic(data);
        dataRepository.save(data);
    }
}
// 推薦：分批處理
@Transactional
public void processLargeDataSetInBatches() {
    int pageSize = 100;
    int pageNumber = 0;
    Page<Data> dataPage;
    do {
        dataPage = dataRepository.findAll(PageRequest.of(pageNumber, pageSize));
        processBatch(dataPage.getContent());
        pageNumber++;
    } while (dataPage.hasNext());
}
@Transactional(propagation = Propagation.REQUIRES_NEW)
private void processBatch(List<Data> batch) {
    for (Data data : batch) {
        complexBusinessLogic(data);
        dataRepository.save(data);
    }
}

// 優(yōu)化前：事務(wù)邊界過大
@Transactional
public void createUserWithNotification(User user) {
    userRepository.save(user);
    // 發(fā)送郵件通知（耗時(shí)操作）
    emailService.sendWelcomeEmail(user.getEmail());
    // 記錄日志
    logService.recordUserCreation(user.getId());
}
// 優(yōu)化后：縮小事務(wù)邊界
@Transactional
public void createUser(User user) {
    userRepository.save(user);
}
public void createUserWithNotification(User user) {
    createUser(user); // 核心業(yè)務(wù)在事務(wù)中
    // 異步發(fā)送郵件
    asyncEmailService.sendWelcomeEmail(user.getEmail());
    // 獨(dú)立事務(wù)記錄日志
    logService.recordUserCreation(user.getId());
}

// 錯(cuò)誤：private方法上的@Transactional不會(huì)生效
@Transactional
private void saveUser(User user) {
    userRepository.save(user);
}
// 正確：使用public方法
@Transactional
public void saveUser(User user) {
    userRepository.save(user);
}

// 問題代碼
@Service
public class UserService {
    @Transactional
    public void createUser(User user) {
        saveUser(user);
        updateUserStats(); // 這里的事務(wù)設(shè)置不會(huì)生效
    }
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void updateUserStats() {
        // 統(tǒng)計(jì)更新
    }
}

// 錯(cuò)誤：捕獲了異常，事務(wù)不會(huì)回滾
@Transactional
public void riskyOperation() {
    try {
        // 可能拋出異常的操作
        dangerousMethod();
    } catch (Exception e) {
        // 異常被捕獲，事務(wù)不會(huì)回滾
        log.error("操作失敗", e);
    }
}
// 正確：重新拋出異常或手動(dòng)回滾
@Transactional
public void riskyOperation() {
    try {
        dangerousMethod();
    } catch (Exception e) {
        log.error("操作失敗", e);
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        throw e; // 重新拋出異常
    }
}

@Component
@Aspect
public class TransactionMonitorAspect {
    private static final Logger logger = LoggerFactory.getLogger(TransactionMonitorAspect.class);
    @Around("@annotation(org.springframework.transaction.annotation.Transactional)")
    public Object monitorTransaction(ProceedingJoinPoint joinPoint) throws Throwable {
        long startTime = System.currentTimeMillis();
        String methodName = joinPoint.getSignature().getName();
        try {
            Object result = joinPoint.proceed();
            long executionTime = System.currentTimeMillis() - startTime;
            if (executionTime > 1000) { // 超過1秒的事務(wù)記錄警告
                logger.warn("長事務(wù)檢測: 方法 {} 執(zhí)行時(shí)間: {}ms", methodName, executionTime);
            }
            return result;
        } catch (Exception e) {
            long executionTime = System.currentTimeMillis() - startTime;
            logger.error("事務(wù)執(zhí)行失敗: 方法 {} 執(zhí)行時(shí)間: {}ms", methodName, executionTime, e);
            throw e;
        }
    }
}

// 容易產(chǎn)生死鎖的代碼
@Transactional
public void transferMoney(Long fromAccountId, Long toAccountId, BigDecimal amount) {
    Account fromAccount = accountRepository.findById(fromAccountId);
    Account toAccount = accountRepository.findById(toAccountId);
    fromAccount.withdraw(amount);
    toAccount.deposit(amount);
    accountRepository.save(fromAccount);
    accountRepository.save(toAccount);
}
// 避免死鎖的改進(jìn)版本
@Transactional
public void transferMoney(Long fromAccountId, Long toAccountId, BigDecimal amount) {
    // 按ID排序獲取鎖，避免死鎖
    Long firstId = Math.min(fromAccountId, toAccountId);
    Long secondId = Math.max(fromAccountId, toAccountId);
    Account firstAccount = accountRepository.findByIdForUpdate(firstId);
    Account secondAccount = accountRepository.findByIdForUpdate(secondId);
    Account fromAccount = fromAccountId.equals(firstId) ? firstAccount : secondAccount;
    Account toAccount = toAccountId.equals(firstId) ? firstAccount : secondAccount;
    fromAccount.withdraw(amount);
    toAccount.deposit(amount);
    accountRepository.save(fromAccount);
    accountRepository.save(toAccount);
}

// 推薦：在Service層使用事務(wù)
@Service
@Transactional(readOnly = true) // 類級別設(shè)置默認(rèn)只讀
public class UserService {
    @Transactional // 寫操作覆蓋類級別設(shè)置
    public void createUser(User user) {
        userRepository.save(user);
    }
    // 繼承類級別的只讀事務(wù)
    public List<User> findAllUsers() {
        return userRepository.findAll();
    }
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void auditLog(String operation, String details) {
        auditRepository.save(new AuditLog(operation, details));
    }
}

@Service
public class OrderService {
    @Transactional(rollbackFor = Exception.class) // 所有異常都回滾
    public void createOrder(Order order) throws OrderException {
        try {
            validateOrder(order);
            orderRepository.save(order);
            updateInventory(order.getItems());
        } catch (ValidationException e) {
            // 業(yè)務(wù)異常，記錄日志但不回滾
            logService.recordValidationError(order.getId(), e.getMessage());
            throw new OrderException("訂單驗(yàn)證失敗", e);
        } catch (InventoryException e) {
            // 庫存異常，需要回滾
            throw new OrderException("庫存不足", e);
        }
    }
    @Transactional(noRollbackFor = ValidationException.class)
    public void processOrderWithPartialFailure(Order order) {
        // 某些業(yè)務(wù)異常不需要回滾
    }
}

@Configuration
@EnableTransactionManagement
public class TransactionConfig {
    @Bean
    public PlatformTransactionManager transactionManager(DataSource dataSource) {
        DataSourceTransactionManager manager = new DataSourceTransactionManager(dataSource);
        // 設(shè)置默認(rèn)超時(shí)時(shí)間
        manager.setDefaultTimeout(30);
        // 設(shè)置事務(wù)同步
        manager.setTransactionSynchronization(AbstractPlatformTransactionManager.SYNCHRONIZATION_ON_ACTUAL_TRANSACTION);
        return manager;
    }
    // 自定義事務(wù)屬性
    @Bean
    public TransactionTemplate transactionTemplate(PlatformTransactionManager transactionManager) {
        TransactionTemplate template = new TransactionTemplate(transactionManager);
        template.setTimeout(30);
        template.setIsolationLevel(TransactionDefinition.ISOLATION_READ_COMMITTED);
        return template;
    }
}

@Service
public class ComplexBusinessService {
    @Autowired
    private TransactionTemplate transactionTemplate;
    public void complexBusinessLogic() {
        // 需要精確控制事務(wù)邊界的場景
        String result = transactionTemplate.execute(status -> {
            try {
                // 事務(wù)內(nèi)的操作
                performDatabaseOperations();
                return "success";
            } catch (Exception e) {
                // 手動(dòng)回滾
                status.setRollbackOnly();
                return "failed";
            }
        });
        // 事務(wù)外的操作
        sendNotification(result);
    }
}