一个大方法拆分成很多小方法，通常怎么加注解的，不是每个方法都需要加注解-CSDN博客

本文链接：https://blog.csdn.net/C18298182575/article/details/149327480

大方法拆分成小方法后的事务注解策略

当我们将一个大方法拆分成多个小方法时，事务注解（如 @Transactional）的添加需要根据业务逻辑和事务需求来决定，并不是每个小方法都需要加注解。以下是具体的策略和最佳实践：

1. 基本原则

（1）事务的传播行为（Propagation）

默认 REQUIRED：如果当前有事务，则加入；如果没有，则新建事务。
SUPPORTS：当前有事务则加入，没有则以非事务方式运行。
REQUIRES_NEW：无论当前是否有事务，都新建事务（原事务挂起）。
NOT_SUPPORTED：以非事务方式运行，挂起当前事务（如果有）。
NEVER：必须在非事务环境下运行，否则抛异常。

（2）事务的边界

事务应覆盖完整的业务逻辑，而不是随意分散在多个小方法中。
避免过度拆分事务，否则可能导致事务失效或性能问题。

2. 常见场景与注解策略

场景 1：大方法是事务入口

大方法是业务入口，需要事务管理。
小方法是内部实现细节，无需单独事务。

java

@Service
public class OrderService {

    @Transactional  // 事务入口
    public void placeOrder(Order order) {
        validateOrder(order);     // 校验（无需事务）
        deductInventory(order);   // 扣库存（无需单独事务）
        createPayment(order);     // 创建支付（无需单独事务）
        saveOrder(order);         // 保存订单（无需单独事务）
    }

    private void validateOrder(Order order) { ... }      // 无事务
    private void deductInventory(Order order) { ... }    // 无事务
    private void createPayment(Order order) { ... }      // 无事务
    private void saveOrder(Order order) { ... }          // 无事务
}

策略：

只在最外层方法（placeOrder）加 @Transactional。
内部小方法不加注解，默认继承外层事务。

场景 2：某些小方法需要独立事务

部分小方法需要独立事务（如日志记录、异步操作等）。

java

@Service
public class OrderService {

    @Transactional
    public void placeOrder(Order order) {
        validateOrder(order);
        deductInventory(order);
        createPayment(order);
        saveOrder(order);
        logOperation(order);  // 日志记录需要独立事务
    }

    @Transactional(propagation = Propagation.REQUIRES_NEW)  // 独立事务
    public void logOperation(Order order) {
        // 记录日志，即使主事务回滚，日志仍需保存
    }
}

策略：

主方法（placeOrder）加 @Transactional。
需要独立事务的小方法（logOperation）加 @Transactional(propagation = Propagation.REQUIRES_NEW)。

场景 3：部分小方法不需要事务

某些小方法是只读操作或非关键逻辑，无需事务。

java

@Service
public class OrderService {

    @Transactional
    public void placeOrder(Order order) {
        validateOrder(order);     // 校验（无需事务）
        if (isHighValue(order)) { // 检查（无需事务）
            notifyManager(order); // 通知（非关键逻辑，无需事务）
        }
        processOrder(order);      // 核心逻辑（继承事务）
    }

    private void validateOrder(Order order) { ... }   // 无事务
    private boolean isHighValue(Order order) { ... } // 无事务
    private void notifyManager(Order order) { ... }   // 无事务

    @Transactional(propagation = Propagation.MANDATORY)  // 必须在外层事务中调用
    private void processOrder(Order order) { ... }
}

策略：

非关键小方法（如校验、通知）不加事务。
核心小方法（processOrder）可加 MANDATORY，确保被事务方法调用。

3. 关键注意事项

（1）避免自调用导致事务失效

如果通过 this.method() 调用小方法，事务会失效（因为绕过了 Spring AOP 代理）。
解决方案：
- 通过注入的代理对象调用（如 @Autowired private OrderService self;）。
- 将小方法移到另一个 Bean 中。

（2）事务方法的访问权限

@Transactional 默认只对 public 方法生效。
避免在 private/protected 方法上加注解。

（3）异常处理

默认只对 RuntimeException 和 Error 回滚。
如果需要捕获异常后不回滚，需明确指定：

java
```
@Transactional(noRollbackFor = BusinessException.class)
```

（4）只读事务优化

如果小方法是查询操作，可标记为只读事务：

java

@Transactional(readOnly = true)
public Order getOrder(Long id) { ... }

4. 总结：如何选择加注解？

方法类型	是否加 `@Transactional`	说明
最外层业务方法	✅ 必加	定义事务边界，覆盖完整业务逻辑。
核心子方法	⚠️ 按需添加	如果需要独立事务（如 `REQUIRES_NEW`），则加；否则继承外层事务。
非关键子方法	❌ 不加	如校验、日志、通知等，无需事务。
查询方法	✅ 加 `readOnly=true`	优化性能，避免不必要的写事务开销。

5. 最佳实践示例

java

@Service
@RequiredArgsConstructor
public class OrderService {
    private final OrderRepository orderRepository;
    private final InventoryService inventoryService;
    private final PaymentService paymentService;
    private final LogService logService;  // 拆分到其他Bean，避免自调用问题

    @Transactional
    public void placeOrder(Order order) {
        validate(order);                     // 无事务
        inventoryService.deduct(order);       // 其他Bean的事务方法
        paymentService.create(order);         // 其他Bean的事务方法
        orderRepository.save(order);          // 继承当前事务
        logService.audit(order);              // REQUIRES_NEW 独立事务
    }

    private void validate(Order order) { ... } // 无事务
}

@Service
public class LogService {
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void audit(Order order) { ... }
}