却逐渐暴露出它的“短板”。

@Transactional注解虽然使用简单，但其背后隐藏的“隐式行为”却可Neng引发性Neng、维护性和数据一致性问题。 1. 事务传播行为的“失控”

@Transactional默认的传播行为是REQUIRED，在嵌套调用时容易出现事务边界不清晰。例如当一个方法内部调用另一个带有@Transactional注解的方法时Ru果这两个方法在同一个类中，事务可Neng不会按预期生效。这是因为Spring的事务管理是基于AOP实现的，只有通过代理对象调用方法时事务增强逻辑才会生效。Ru果方法是通过this调用的，那么事务增强逻辑将不会被触发。

在大厂中，异步调用常常用于提升系统性Neng。然而Ru果在异步方法上使用@Transactional注解，事务将失效。这是因为异步方法在新线程中执行，而Spring的事务管理是基于线程绑定的，不同线程的事务上下文是相互独立的，导致事务无法统一管理。

@Transactional注解默认只会回滚RuntimeException及其子类，对于Checked异常，Ru果没有被捕获，事务不会自动回滚。例如：

@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;
    @Transactional
    public void saveUser throws IOException {
        userRepository.save;
        // 模拟一个受检查异常
        throw new IOException;
    }
}

在上述代码中，saveUser方法抛出了IOException，这是一个Checked异常，由于@Transactional注解默认不会回滚Checked异常，所以即使抛出了异常，事务也不会回滚，userRepository.save的操作可NengYi经提交到数据库，导致数据不一致。

事务失效的“坑”比比皆是。例如当方法被final修饰时Spring无法通过CGLIB生成子类来实现代理，导致事务失效。此外Ru果方法不是public的，Spring也不会为其创建事务相关的属性，事务自然也就无法生效。

在面向对象编程中，继承是一个非常强大的特性，但当子类重写父类带有@Transactional注解的方法时情况就变得复杂了。例如假设有一个父类BaseService，其中有一个方法doBusiness加上了@Transactional注解：

@Service
public class BaseService {
    @Transactional
    public void doBusiness {
        // 业务逻辑
    }
}

然后有一个子类SubService继承了BaseService并重写了doBusiness方法：

@Service
public class SubService extends BaseService {
    @Override
    public void doBusiness {
        // 子类重写的业务逻辑
    }
}

这时候，Ru果子类SubService没有在重写的doBusiness方法上添加@Transactional注解，那么父类的注解是否会生效呢？答案是不一定，这取决于Spring的事务代理方式。Ru果Spring使用的是基于接口的JDK动态代理，那么只有当子类实现了父类的接口时父类的注解才会生效；Ru果使用的是基于类的CGLIB代理，子类重写方法时Ru果方法不是final的，父类的注解可Neng会生效，但Ru果子类的方法访问修饰符比父类geng严格，比如父类是public，子类是protected，那么注解会失效。

开发者geng倾向于使用编程式事务管理，结合实际场景来灵活地控制事务。例如创建订单主记录、插入订单明细和扣减商品库存这三个操作必须保证原子性，使用编程式事务管理Ke以这样实现：

@Service
public class OrderService {
    @Autowired
    private TransactionTemplate transactionTemplate;
    @Autowired
    private OrderMapper orderMapper;
    @Autowired
    private OrderItemMapper orderItemMapper;
    @Autowired
    private ProductMapper productMapper;
    public Boolean createOrder {
        // 参数校验等非事务核心逻辑在事务外执行
        if  == null || CollectionUtils.isEmpty)) {
            throw new IllegalArgumentException;
        }
        return transactionTemplate.execute(status -> {
            try {
                // 创建订单主记录
                Order order = new Order;
                order.setUserId);
                order.setTotalAmount));
                order.setStatus;
                orderMapper.insert;
                // 创建订单明细
                for ) {
                    OrderItem orderItem = new OrderItem;
                    orderItem.setOrderId);
                    orderItem.setProductId);
                    orderItem.setQuantity);
                    orderItem.setPrice);
                    orderItemMapper.insert;
                    // 扣减库存，库存不足时抛出异常触发回滚
                    int rows = productMapper.reduceStock, item.getQuantity);
                    if  {
                        throw new RuntimeException + "]库存不足");
                    }
                }
                return true; // 全部成功，自动提交事务
            } catch  {
                // 发生异常时事务自动回滚
                log.error;
                return false;
            }
        });
    }
    // 计算订单总金额等非事务核心逻辑在事务外执行
    private BigDecimal calculateTotal {
        return items.stream
                .map.multiply)))
                .reduce;
    }
}

在上述代码中，通过TransactionTemplate的execute方法来定义事务的边界，将创建订单的核心业务逻辑放在execute方法的回调函数中。在回调函数内部，先执行创建订单主记录的操作，然后循环插入订单明细并扣减库存，Ru果在任何一步出现异常，事务会自动回滚。而参数校验和计算订单总金额等非核心逻辑放在事务外执行，这样Ke以减少事务的执行时间，降低数据库锁的占用时间，提高系统的性Neng。

技术的选择和使用绝不Neng盲目，每一个技术工具dou有它的适用场景和潜在风险。我们需要深入理解事务管理的底层原理，不仅仅满足于表面的使用，geng要探究其背后的实现机制。在实际开发中，要根据具体的业务场景，谨慎地选择事务管理的方式。对于简单的业务场景，@Transactional注解或许依然Ke以胜任；但在复杂的业务逻辑、高并发的场景以及对事务控制要求精细的情况下编程式事务管理等geng灵活的方式可Neng是geng好的选择。

开发者水平参差不齐，@Transactional的隐性陷阱可Neng导致难以排查的生产问题。而编程式事务虽然代码geng繁琐，但Neng通过显式控制降低风险，提升代码的可维护性和稳定性。当然hen多公司并非完全禁止，而是限制其使用场景，并辅以严格的代码审查，以平衡开发效率与系统稳定性。