事务传播机制总结

在 Java 中，事务传播机制是指在嵌套事务（即一个事务方法调用另一个事务方法）时，如何处理多个事务之间的关系。这一机制主要由 Spring 框架提供支持，通过 @Transactional 注解的 propagation 属性配置。以下是事务传播机制的核心概念、类型及应用场景：

一、事务传播机制的核心概念

1. 事务上下文
   当前正在执行的事务环境，包含事务的隔离级别、超时时间等属性。
2. 嵌套事务
   一个事务方法内部调用另一个事务方法时，形成的事务嵌套结构。
3. 传播行为
   定义了嵌套事务中，内层事务如何与外层事务交互（如创建新事务、加入现有事务等）。

二、Spring 支持的七种传播行为

1. PROPAGATION_REQUIRED（默认）

• 行为：如果当前存在事务，则加入该事务；否则创建新事务。
• 示例：

  @Transactional(propagation = Propagation.REQUIRED)
  public void methodA() {
      // 外层事务
      methodB(); // 内层事务加入 methodA 的事务
  }
  
  @Transactional(propagation = Propagation.REQUIRED)
  public void methodB() {
      // 操作数据库
  }
  

• 场景：大多数业务场景，保证所有操作在同一个事务中。

2. PROPAGATION_SUPPORTS

• 行为：如果当前存在事务，则加入该事务；否则以非事务方式执行。
• 示例：

  @Transactional(propagation = Propagation.REQUIRED)
  public void methodA() {
      methodB(); // 内层事务加入 methodA 的事务
  }
  
  @Transactional(propagation = Propagation.SUPPORTS)
  public void methodB() {
      // 操作数据库
  }
  

• 场景：查询操作，无需事务时可提高性能。

3. PROPAGATION_MANDATORY

• 行为：必须存在当前事务，否则抛出异常。
• 示例：

  @Transactional(propagation = Propagation.MANDATORY)
  public void methodB() {
      // 必须在已存在的事务中执行
  }
  

• 场景：强制要求在事务中执行的操作（如财务转账）。

4. PROPAGATION_REQUIRES_NEW

• 行为：无论当前是否存在事务，都创建新事务，并挂起当前事务（如果存在）。
• 示例：

  @Transactional(propagation = Propagation.REQUIRED)
  public void methodA() {
      try {
          methodB(); // methodB 创建新事务，与 methodA 隔离
      } catch (Exception e) {
          // methodB 回滚不影响 methodA
      }
  }
  
  @Transactional(propagation = Propagation.REQUIRES_NEW)
  public void methodB() {
      // 操作数据库
  }
  

• 场景：需要独立提交/回滚的操作（如日志记录、审计）。

5. PROPAGATION_NOT_SUPPORTED

• 行为：以非事务方式执行，如果当前存在事务，则挂起该事务。
• 示例：

  @Transactional(propagation = Propagation.REQUIRED)
  public void methodA() {
      methodB(); // methodB 以非事务方式执行
  }
  
  @Transactional(propagation = Propagation.NOT_SUPPORTED)
  public void methodB() {
      // 操作数据库
  }
  

• 场景：耗时操作（如文件上传），避免占用事务资源。

6. PROPAGATION_NEVER

• 行为：以非事务方式执行，如果当前存在事务，则抛出异常。
• 示例：

  @Transactional(propagation = Propagation.NEVER)
  public void methodB() {
      // 禁止在事务中执行
  }
  

• 场景：明确禁止事务的操作（如批量数据导入）。

7. PROPAGATION_NESTED

• 行为：如果当前存在事务，则在嵌套事务中执行（依赖数据库保存点机制）；否则等同于 REQUIRED。
• 示例：

  @Transactional(propagation = Propagation.REQUIRED)
  public void methodA() {
      try {
          methodB(); // methodB 是 methodA 的嵌套事务
      } catch (Exception e) {
          // methodB 回滚，但 methodA 可选择继续执行
      }
  }
  
  @Transactional(propagation = Propagation.NESTED)
  public void methodB() {
      // 操作数据库
  }
  

• 场景：子操作需要独立回滚，但整体事务仍可提交（如批量导入中的单行失败处理）。

三、嵌套事务与保存点（Savepoint）

PROPAGATION_NESTED 依赖数据库的保存点机制实现：

• 保存点：事务中的一个标记点，可单独回滚到该点而不影响之前的操作。
• 示例：

  Connection conn = dataSource.getConnection();
  conn.setAutoCommit(false);
  
  try {
      // 执行操作1
      conn.setSavepoint("SP1"); // 设置保存点
      
      try {
          // 执行操作2（嵌套事务）
          conn.rollback("SP1"); // 回滚到保存点
      } catch (Exception e) {
          // 处理异常
      }
      
      conn.commit(); // 整体事务提交
  } catch (Exception e) {
      conn.rollback(); // 整体回滚
  }
  

四、传播机制的选择原则

1. 原子性要求：如果多个操作必须全部成功或失败，使用 REQUIRED。
2. 隔离需求：需要独立提交/回滚的操作，使用 REQUIRES_NEW。
3. 性能优化：查询类操作可使用 SUPPORTS 减少事务开销。
4. 复杂业务：子操作需要部分回滚时，使用 NESTED（需数据库支持保存点）。

五、注意事项

1. 事务边界：确保事务方法由 Spring AOP 代理调用（如通过接口或 @Transactional 注解）。
2. 异常处理：REQUIRES_NEW 和 NESTED 的异常需单独捕获，避免影响外层事务。
3. 数据库支持：NESTED 依赖数据库保存点（如 MySQL、Oracle 支持，H2 内存数据库默认不支持）。
4. 传播行为与隔离级别：传播行为与隔离级别（如 @Transactional(isolation = Isolation.READ_COMMITTED)）共同影响事务特性。

六、常见应用场景

1. 转账业务：

   @Transactional(propagation = Propagation.REQUIRED)
   public void transfer(String from, String to, BigDecimal amount) {
       accountDao.debit(from, amount);
       accountDao.credit(to, amount);
   }
   

2. 日志记录：

   @Transactional(propagation = Propagation.REQUIRED)
   public void processOrder(Order order) {
       orderDao.save(order);
       logService.record("Order processed", Propagation.REQUIRES_NEW); // 独立事务
   }
   

3. 批量导入：

   @Transactional(propagation = Propagation.REQUIRED)
   public void batchImport(List<Data> dataList) {
       for (Data data : dataList) {
           try {
               importData(data); // 使用 NESTED 允许单行失败
           } catch (Exception e) {
               log.error("Import failed: {}", data, e);
           }
       }
   }
   

总结

事务传播机制是 Spring 框架中处理嵌套事务的核心能力，通过合理配置传播行为（如 REQUIRED、REQUIRES_NEW、NESTED），可灵活控制多个事务方法之间的关系，满足复杂业务场景的原子性、隔离性需求。在实际开发中，需结合业务逻辑和数据库特性选择合适的传播行为，并注意事务边界和异常处理，以确保数据一致性和系统稳定性。