Spring 事务管理：传播行为、隔离级别与失效场景

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface Transactional {
    // 事务管理器名称
    String value() default "";
    
    // 传播行为
    Propagation propagation() default Propagation.REQUIRED;
    
    // 隔离级别
    Isolation isolation() default Isolation.DEFAULT;
    
    // 超时时间（秒）
    int timeout() default -1;
    
    // 只读事务
    boolean readOnly() default false;
    
    // 回滚异常类型
    Class<? extends Throwable>[] rollbackFor() default {};
    
    // 不回滚异常类型
    Class<? extends Throwable>[] noRollbackFor() default {};
}

public interface PlatformTransactionManager {
    // 获取事务
    TransactionStatus getTransaction(TransactionDefinition definition);
    
    // 提交事务
    void commit(TransactionStatus status);
    
    // 回滚事务
    void rollback(TransactionStatus status);
}

@Service
public class OrderService {
    
    @Transactional
    public void createOrder(Order order) {
        orderDao.save(order);
        // 调用库存服务
        inventoryService.deductStock(order.getItemId(), order.getQuantity());
    }
}

@Service
public class InventoryService {
    
    // 与外层方法共用同一个事务
    @Transactional(propagation = Propagation.REQUIRED)
    public void deductStock(Long itemId, Integer quantity) {
        inventoryDao.deduct(itemId, quantity);
    }
    
    // 独立事务，外层事务失败不影响此操作
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void deductStockIndependent(Long itemId, Integer quantity) {
        inventoryDao.deduct(itemId, quantity);
    }
}

@Transactional(propagation = Propagation.NESTED)
public void nestedOperation() {
    try {
        // 部分操作失败可独立回滚
        riskyOperation();
    } catch (Exception e) {
        // 仅回滚到 savepoint，外层事务继续
        log.error("子操作失败", e);
    }
}

// 事务 A
@Transactional(isolation = Isolation.READ_UNCOMMITTED)
public void readUncommitted() {
    // 可能读到事务 B 未提交的数据
    Order order = orderDao.findById(1L);
}

@Transactional(isolation = Isolation.READ_COMMITTED)
public void nonRepeatableRead() {
    Order order1 = orderDao.findById(1L); // 余额: 1000
    // 其他事务修改并提交
    Order order2 = orderDao.findById(1L); // 余额: 900（不一致！）
}

@Transactional(isolation = Isolation.REPEATABLE_READ)
public void phantomRead() {
    List<Order> orders1 = orderDao.findByStatus("PENDING"); // 10 条
    // 其他事务插入新订单并提交
    List<Order> orders2 = orderDao.findByStatus("PENDING"); // 11 条（幻读）
}

@Service
public class AccountService {
    
    // 转账操作需要强一致性
    @Transactional(isolation = Isolation.REPEATABLE_READ)
    public void transfer(Long fromId, Long toId, BigDecimal amount) {
        Account from = accountDao.findById(fromId);
        Account to = accountDao.findById(toId);
        
        from.deduct(amount);
        to.add(amount);
        
        accountDao.update(from);
        accountDao.update(to);
    }
    
    // 统计查询可接受不可重复读
    @Transactional(isolation = Isolation.READ_COMMITTED, readOnly = true)
    public BigDecimal getTotalBalance() {
        return accountDao.sumBalance();
    }
}

@Service
public class UserService {
    
    @Transactional
    public void methodA() {
        // 调用同类方法 B，事务失效！
        // 因为这里调用的是目标对象本身，而非代理对象
        methodB();
    }
    
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void methodB() {
        // 期望的新事务不会生效
        userDao.update();
    }
}

@Service
public class UserService {
    
    @Autowired
    private ApplicationContext context;
    
    @Transactional
    public void methodA() {
        // 通过代理对象调用
        UserService proxy = context.getBean(UserService.class);
        proxy.methodB();
    }
    
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void methodB() {
        userDao.update();
    }
}

@Transactional
public void createUser(User user) {
    try {
        userDao.save(user);
        sendEmail(user.getEmail()); // 可能抛出异常
    } catch (Exception e) {
        // 异常被捕获，事务不会回滚！
        log.error("发送邮件失败", e);
    }
}

@Transactional
public void createUser(User user) {
    userDao.save(user);
    try {
        sendEmail(user.getEmail());
    } catch (Exception e) {
        log.error("发送邮件失败", e);
        // 可选：标记用户需要手动发送邮件
    }
}

@Transactional
public void updateUser(User user) throws SQLException {
    // 抛出 checked exception，事务不会回滚！
    throw new SQLException("数据库错误");
}

@Transactional(rollbackFor = Exception.class)
public void updateUser(User user) throws Exception {
    userDao.update(user);
}

@Service
public class ProductService {
    
    // 事务不会生效，因为方法不是 public
    @Transactional
    void updateStock(Long productId, Integer quantity) {
        productDao.updateStock(productId, quantity);
    }
}

-- MyISAM 引擎不支持事务
CREATE TABLE user (
    id BIGINT PRIMARY KEY,
    name VARCHAR(50)
) ENGINE=MyISAM;

-- 应使用 InnoDB
CREATE TABLE user (
    id BIGINT PRIMARY KEY,
    name VARCHAR(50)
) ENGINE=InnoDB;

@Service
public class OrderApplicationService {
    
    @Autowired
    private OrderService orderService;
    
    @Autowired
    private PaymentService paymentService;
    
    @Autowired
    private InventoryService inventoryService;
    
    // 事务边界放在应用服务层
    @Transactional(rollbackFor = Exception.class)
    public OrderResult placeOrder(OrderCommand command) {
        // 1. 创建订单
        Order order = orderService.createOrder(command);
        
        // 2. 扣减库存
        inventoryService.deductStock(command.getItemId(), command.getQuantity());
        
        // 3. 发起支付
        PaymentResult payment = paymentService.pay(order);
        
        return OrderResult.of(order, payment);
    }
}

@Service
public class ReportService {
    
    // 标记为只读，Spring 会进行一些优化
    @Transactional(readOnly = true)
    public List<OrderReport> generateDailyReport(LocalDate date) {
        return orderDao.findByDate(date);
    }
}

@Service
public class BatchService {
    
    // 防止长时间运行的事务占用连接
    @Transactional(timeout = 30)
    public void batchProcess(List<Long> ids) {
        for (Long id : ids) {
            process(id);
        }
    }
}