Spring 事务传播机制与 @Transactional 失效的 8 种场景

@Service
public class OrderService {
    @Autowired private InventoryService inventoryService;

    @Transactional  // 默认 REQUIRED
    public void createOrder(Order order) {
        orderDao.insert(order);             // ① 插入订单
        inventoryService.deduct(order);     // ② 扣减库存
    }
}

@Service
public class InventoryService {
    @Transactional  // REQUIRED：加入 createOrder 的事务
    public void deduct(Order order) {
        stockDao.deduct(order.getSkuId());
        if (stock < 0) throw new RuntimeException("库存不足");
        // ★ 抛异常后，createOrder 的 ① 也会回滚！
        // 因为它们在同一个事务中
    }
}

@Service
public class OrderService {
    @Autowired private AuditService auditService;

    @Transactional
    public void createOrder(Order order) {
        orderDao.insert(order);
        auditService.log("创建订单: " + order.getId());  // 记录审计日志
        throw new RuntimeException("业务失败");
        // ★ 外层回滚不影响 auditService.log()
        // REQUIRES_NEW 是独立事务，已提交就提交了
    }
}

@Service
public class AuditService {
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void log(String message) {
        auditDao.insert(new AuditLog(message));
        // ★ 独立事务，外层回滚不影响这里
    }
}

@Service
public class BatchService {
    @Autowired private ItemService itemService;

    @Transactional
    public void batchProcess(List<Item> items) {
        for (Item item : items) {
            try {
                itemService.processItem(item);  // NESTED
            } catch (Exception e) {
                // ★ 只回滚当前 item 的处理
                // 其他已成功的 item 不受影响
                log.warn("item " + item.getId() + " 处理失败，跳过");
            }
        }
    }
}

@Service
public class ItemService {
    @Transactional(propagation = Propagation.NESTED)
    public void processItem(Item item) {
        itemDao.update(item);
        // ★ 在 Savepoint 上执行，失败只回滚到 Savepoint
        // 不回滚外层事务中已成功的操作
    }
}

@Service
public class OrderService {
    public void methodA() {
        // ★ 这里调用 methodB() 等于 this.methodB()
        // 不经过代理，@Transactional 不生效！
        methodB();
    }

    @Transactional
    public void methodB() {
        orderDao.insert(new Order());
        throw new RuntimeException();
        // 不会回滚！因为没有事务
    }
}

// 方案 1：注入自身（推荐）
@Service
public class OrderService {
    @Autowired private OrderService self;  // 注入代理对象
    public void methodA() { self.methodB(); }
}
// 方案 2：从 ApplicationContext 获取代理
OrderService proxy = context.getBean(OrderService.class);
proxy.methodB();
// 方案 3：启用 AspectJ 织入（非代理模式）
@EnableTransactionManagement(mode = AdviceMode.ASPECTJ)

@Transactional
private void insertOrder(Order order) {  // ★ private：事务不生效
    orderDao.insert(order);
}

@Transactional  // 默认 rollbackFor = { RuntimeException, Error }
public void process() throws IOException {
    fileDao.insert(record);
    throw new IOException("文件读写失败");
    // ★ 不回滚！IOException 是 Checked Exception
}

// 正确写法：显式指定 rollbackFor
@Transactional(rollbackFor = Exception.class)
public void process() throws IOException { ... }

@Transactional
public void transfer() {
    try {
        accountDao.deduct(from, amount);
        accountDao.add(to, amount);
        if (balance < 0) throw new RuntimeException("余额不足");
    } catch (Exception e) {
        log.error("转账失败", e);
        // ★ 异常没抛出去！Spring 感知不到，不会回滚
    }
}
// 正确：catch 后重新抛出
catch (Exception e) { log.error(...); throw e; }

// ★ 没有 @Service / @Component，Spring 不管理这个 Bean
public class OrderService {
    @Transactional
    public void createOrder() { ... }
}
// 手动 new 出来的对象也不行
OrderService svc = new OrderService();  // 无代理，事务无效
svc.createOrder();

@Transactional(propagation = Propagation.NOT_SUPPORTED)
public void createOrder() {
    // ★ NOT_SUPPORTED：以非事务方式执行
    // 即使方法里有数据库操作，也不在事务中
    orderDao.insert(order);
    throw new RuntimeException();  // 不回滚
}

@Configuration
@EnableTransactionManagement  // 导入 TransactionManagementConfigurationSelector
public class AppConfig {
    @Bean
    public PlatformTransactionManager transactionManager(DataSource ds) {
        return new DataSourceTransactionManager(ds);
    }
}

public class TransactionInterceptor extends TransactionAspectSupport
        implements MethodInterceptor {
    public Object invoke(MethodInvocation invocation) {
        // 获取目标类和方法
        Class<?> targetClass = getTargetClass(invocation.getThis());
        // 解析 @Transactional 属性（传播行为、隔离级别、超时、rollbackFor...）
        TransactionAttribute txAttr = getTransactionAttributeSource()
                .getTransactionAttribute(method, targetClass);
        // 获取事务管理器
        PlatformTransactionManager tm = determineTransactionManager(txAttr);
        // 创建事务（核心！）
        return invokeWithinTransaction(method, targetClass, invocation::proceed);
    }
}

protected Object invokeWithinTransaction(Method method, Class<?> targetClass,
        InvocationCallback invocation) {
    // 1. 获取事务定义
    TransactionAttribute txAttr = getTransactionAttribute(method, targetClass);
    PlatformTransactionManager tm = determineTransactionManager(txAttr);

    // 2. 创建事务（根据传播行为决定是新建还是加入）
    TransactionInfo txInfo = createTransactionIfNecessary(tm, txAttr, joinpointId);

    Object retVal;
    try {
        // 3. 执行目标方法
        retVal = invocation.proceedWithInvocation();
    } catch (Throwable ex) {
        // 4a. 异常 → 判断是否回滚
        completeTransactionAfterThrowing(txInfo, ex);
        throw ex;
    }
    // 4b. 正常 → 提交事务
    commitTransactionAfterReturning(txInfo);
    return retVal;
}

protected void doBegin(Object transaction, TransactionDefinition def) {
    DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;
    // 从连接池获取新 Connection
    Connection con = obtainDataSource().getConnection();
    // ★ 关闭自动提交 —— 事务的起点
    con.setAutoCommit(false);
    // 绑定到 ThreadLocal
    TransactionSynchronizationManager.bindResource(dataSource,
            new ConnectionHolder(con));
}
protected void doCommit(DefaultTransactionStatus status) {
    Connection con = txObject.getConnectionHolder().getConnection();
    con.commit();  // 提交
}
protected void doRollback(DefaultTransactionStatus status) {
    Connection con = txObject.getConnectionHolder().getConnection();
    con.rollback();  // 回滚
}

@Service
public class PaymentService {
    @Autowired private TransactionTemplate txTemplate;

    public void pay(Order order) {
        // 外层：非事务逻辑
        validateOrder(order);

        // 内层：精确控制事务范围
        String result = txTemplate.execute(status -> {
            try {
                accountDao.deduct(order.getUserId(), order.getAmount());
                paymentDao.insert(new Payment(order));
                return "SUCCESS";
            } catch (Exception e) {
                status.setRollbackOnly();  // 手动标记回滚
                return "FAILED: " + e.getMessage();
            }
        });
        // 事务已结束，继续非事务逻辑
        notifyUser(order, result);
    }
}

@Autowired private PlatformTransactionManager txManager;

public void manualTx() {
    DefaultTransactionDefinition def = new DefaultTransactionDefinition();
    def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
    def.setIsolationLevel(TransactionDefinition.ISOLATION_READ_COMMITTED);

    TransactionStatus status = txManager.getTransaction(def);
    try {
        // 业务 SQL
        orderDao.insert(order);
        txManager.commit(status);
    } catch (Exception e) {
        txManager.rollback(status);
        throw e;
    }
}