事务管理与失效场景

public User getUserByEmail(String email) {
  return jdbcTemplate.queryForObject(
    "SELECT * FROM users WHERE email = ?",
    (ResultSet rs, int rowNum) -> new User(
      rs.getLong("id"),
      rs.getString("email"),
      rs.getString("password"),
      rs.getString("name")),
    email);
}

public long getUsers() {
  return jdbcTemplate.queryForObject("SELECT COUNT(*) FROM users",
    (ResultSet rs, int rowNum) -> rs.getLong(1));
}

public List<User> getUsers(int pageIndex) {
  int limit = 100;
  int offset = limit * (pageIndex - 1);
  return jdbcTemplate.query("SELECT * FROM users LIMIT ? OFFSET ?",
    new BeanPropertyRowMapper<>(User.class), limit, offset);
}

-- 表列名 office_address，JavaBean 属性 workAddress
SELECT id, email, office_address AS workAddress, name FROM users WHERE email = ?

public void updateUser(User user) {
  if (1 != jdbcTemplate.update("UPDATE users SET name = ? WHERE id = ?",
      user.getName(), user.getId())) {
    throw new RuntimeException("User not found by id");
  }
}

public User register(String email, String password, String name) {
  KeyHolder holder = new GeneratedKeyHolder();
  if (1 != jdbcTemplate.update((conn) -> {
    var ps = conn.prepareStatement(
      "INSERT INTO users(email, password, name) VALUES(?, ?, ?)",
      Statement.RETURN_GENERATED_KEYS); // 必须指定返回自增键
    ps.setObject(1, email);
    ps.setObject(2, password);
    ps.setObject(3, name);
    return ps;
  }, holder)) {
    throw new RuntimeException("Insert failed.");
  }
  return new User(holder.getKey().longValue(), email, password, name);
}

@Repository  // 数据访问层组件
public class UserDao {

  @Autowired
  JdbcTemplate jdbcTemplate;

  public User getById(long id) { /* ... */ }

  public List<User> getUsers(int page) { /* ... */ }

  public User createUser(User user) { /* ... */ }

  public User updateUser(User user) { /* ... */ }

  public void deleteUser(User user) { /* ... */ }
}

@Service
public class OrderService {

    private final TransactionTemplate transactionTemplate;

    // Spring Boot 自动注入 PlatformTransactionManager
    public OrderService(PlatformTransactionManager txManager) {
        this.transactionTemplate = new TransactionTemplate(txManager);
        // 可以配置事务属性
        this.transactionTemplate.setIsolationLevel(TransactionDefinition.ISOLATION_READ_COMMITTED);
        this.transactionTemplate.setTimeout(30);
    }

    public void createOrder(OrderDTO dto) {
        // 编程式事务：精确控制事务边界
        transactionTemplate.execute(status -> {
            orderDao.insert(order);
            inventoryService.deductStock(dto.getProductId(), dto.getCount());
            return null;
        });
    }

    public void createOrderWithResult(OrderDTO dto) {
        // 带返回值的事务
        Order order = transactionTemplate.execute(status -> {
            orderDao.insert(order);
            inventoryService.deductStock(dto.getProductId(), dto.getCount());
            return order;
        });
    }
}

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface Transactional {

    // 事务管理器名称（多事务管理器场景）
    String value() default "";

    // 同 value，推荐用这个
    String transactionManager() default "";

    // 传播行为
    Propagation propagation() default Propagation.REQUIRED;

    // 隔离级别
    Isolation isolation() default Isolation.DEFAULT;

    // 超时时间（秒）
    int timeout() default TransactionDefinition.TIMEOUT_DEFAULT;

    // 是否只读
    boolean readOnly() default false;

    // 指定哪些异常会触发回滚（默认 RuntimeException 和 Error）
    Class<? extends Throwable>[] rollbackFor() default {};

    // 指定哪些异常不触发回滚
    Class<? extends Throwable>[] noRollbackFor() default {};

    // 指定回滚异常的异常名称（字符串形式）
    String[] rollbackForClassName() default {};

    // 指定不回滚异常的异常名称
    String[] noRollbackForClassName() default {};
}

时间 | 事务A                    | 事务B
-----|--------------------------|--------------------------
T1   | 开始事务                  |
T2   | 修改账户余额为 100        |
T3   |                          | 查询余额 = 100（读到了未提交的数据）
T4   | 回滚                     |
T5   |                          | 余额应该是 200，但读到了脏数据 100

时间 | 事务A                    | 事务B
-----|--------------------------|--------------------------
T1   | 开始事务                  |
T2   | 查询余额 = 100           |
T3   |                          | 修改余额为 200
T4   |                          | 提交
T5   | 查询余额 = 200（前后不一致）|

时间 | 事务A                          | 事务B
-----|--------------------------------|--------------------------------
T1   | 开始事务                        |
T2   | 查询年龄>20的用户，共 10 条     |
T3   |                                | 插入一条年龄=25的用户
T4   |                                | 提交
T5   | 查询年龄>20的用户，共 11 条     |

@Service
public class OrderService {

    // 使用数据库默认隔离级别（MySQL 为 REPEATABLE_READ）
    @Transactional(rollbackFor = Exception.class)
    public void createOrder() {}

    // 读操作使用读已提交 + 只读，提高并发性能
    @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED)
    public List<Order> listOrders() {}

    // 写操作使用可重复读，保证一致性
    @Transactional(rollbackFor = Exception.class, isolation = Isolation.REPEATABLE_READ)
    public void updateOrder() {}
}

@Service
public class OrderService {

    @Autowired
    private InventoryService inventoryService;

    @Transactional(rollbackFor = Exception.class)
    public void createOrder() {
        orderDao.insert(order);
        // deductStock() 会加入当前事务
        inventoryService.deductStock(productId, count);
    }
}

@Service
public class InventoryService {

    @Transactional(rollbackFor = Exception.class) // 加入 OrderService 的事务
    public void deductStock(Long productId, int count) {
        inventoryDao.deduct(productId, count);
    }
}

createOrder() 开始事务
  └─ deductStock() 加入同一事务
  └─ 如果 deductStock() 抛异常 → 整个事务回滚
  └─ 如果 createOrder() 抛异常 → 整个事务回滚
createOrder() 提交事务

@Service
public class OrderService {

    @Autowired
    private LogService logService;

    @Transactional(rollbackFor = Exception.class)
    public void createOrder() {
        orderDao.insert(order);
        // 独立事务记录日志
        logService.recordLog("创建订单");
        // 后续操作失败，订单回滚，但日志已提交保留
        throw new RuntimeException("订单创建失败");
    }
}

@Service
public class LogService {

    @Transactional(propagation = Propagation.REQUIRES_NEW, rollbackFor = Exception.class)
    public void recordLog(String message) {
        logDao.insert(new Log(message));
    }
}

createOrder() 开始事务A
  └─ recordLog() 挂起事务A，开始新事务B
  └─ recordLog() 提交事务B（日志已持久化）
  └─ 抛出异常
createOrder() 回滚事务A（日志不受影响）

@Service
public class BatchService {

    @Autowired
    private ItemService itemService;

    @Transactional(rollbackFor = Exception.class)
    public void batchImport(List<Item> items) {
        for (Item item : items) {
            try {
                // 每个项目的导入是嵌套事务
                itemService.importItem(item);
            } catch (Exception e) {
                // 单个项目失败不影响其他项目
                log.error("导入失败: {}", item, e);
            }
        }
    }
}

@Service
public class ItemService {

    @Transactional(propagation = Propagation.NESTED, rollbackFor = Exception.class)
    public void importItem(Item item) {
        itemDao.insert(item);
    }
}

batchImport() 开始事务
  └─ importItem(item1) 创建保存点1，执行，释放保存点1
  └─ importItem(item2) 创建保存点2，执行失败，回滚到保存点2
  └─ importItem(item3) 创建保存点3，执行，释放保存点3
batchImport() 提交事务

@Service
public class QueryService {

    @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
    public List<Order> queryOrders() {
        // 可以在事务中执行，也可以不在事务中执行
        return orderDao.selectAll();
    }
}

@Service
public class PaymentService {

    @Transactional(propagation = Propagation.MANDATORY)
    public void processPayment(Long orderId) {
        paymentDao.insert(payment);
    }
}

// 正确用法：在事务中调用
@Transactional(rollbackFor = Exception.class)
public void createOrder() {
    paymentService.processPayment(orderId); // 在事务中调用
}

// 错误用法：直接调用
public void standalone() {
    paymentService.processPayment(orderId); // 抛异常：No existing transaction found
}

@Service
public class ReportService {

    @Transactional(propagation = Propagation.NOT_SUPPORTED)
    public void generateBigReport() {
        // 耗时操作，不希望长时间占用事务连接
        reportDao.generateBigReport();
    }
}

@Service
public class CacheService {

    @Transactional(propagation = Propagation.NEVER)
    public void clearCache() {
        cacheDao.clearAll();
    }
}

@Service
public class QueryService {

    // 只读事务，提高查询性能
    @Transactional(readOnly = true)
    public List<Order> listOrders() {
        return orderDao.selectAll();
    }

    // 只读事务 + 指定隔离级别
    @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED)
    public Order getOrderById(Long id) {
        return orderDao.selectById(id);
    }
}

@Service
public class BatchService {

    // 设置超时时间为 30 秒
    @Transactional(rollbackFor = Exception.class, timeout = 30)
    public void batchProcess() {
        for (int i = 0; i < 10000; i++) {
            processOne();
        }
    }
}

@Service
public class OrderService {

    public void createOrder() {
        // 直接调用同类方法，不经过代理
        saveOrder();  // × 事务不生效
    }

    @Transactional(rollbackFor = Exception.class)
    public void saveOrder() {
        orderDao.insert(order);
    }
}

// 方案1：注入自己（推荐，最简洁）
@Service
public class OrderService {

    @Autowired
    private OrderService self;  // 注入自己

    public void createOrder() {
        self.saveOrder();  // √ 经过代理，事务生效
    }

    @Transactional(rollbackFor = Exception.class)
    public void saveOrder() {
        orderDao.insert(order);
    }
}

// 方案2：使用 AopContext（需要在启动类配置）
@Service
public class OrderService {

    public void createOrder() {
        OrderService proxy = (OrderService) AopContext.currentProxy();
        proxy.saveOrder();  // √ 经过代理，事务生效
    }

    @Transactional(rollbackFor = Exception.class)
    public void saveOrder() {
        orderDao.insert(order);
    }
}

// 启动类需要配置暴露代理
@EnableAspectJAutoProxy(exposeProxy = true)
@SpringBootApplication
public class Application {}

@Service
public class OrderService {

    @Transactional
    private void saveOrder() {  // × private 方法，事务不生效
        orderDao.insert(order);
    }

    @Transactional
    protected void updateOrder() {  //  protected 方法，不保证生效
        orderDao.update(order);
    }

    @Transactional
    void deleteOrder() {  //  包私有方法，不保证生效
        orderDao.delete(order);
    }
}

@Service
public class OrderService {

    @Transactional(rollbackFor = Exception.class)
    public void saveOrder() {  // √ public 方法，事务生效
        orderDao.insert(order);
    }
}

@Service
public class OrderService {

    @Transactional(rollbackFor = Exception.class)
    public void createOrder() {
        try {
            orderDao.insert(order);
            inventoryService.deductStock();
            throw new RuntimeException("库存不足");
        } catch (Exception ex) {
            log.error("创建订单失败", ex);
            // × 异常被捕获，没有继续抛出，事务正常提交
        }
    }
}

@Service
public class OrderService {

    // 方案1：继续抛出异常（推荐）
    @Transactional(rollbackFor = Exception.class)
    public void createOrder() {
        try {
            orderDao.insert(order);
            inventoryService.deductStock();
        } catch (Exception ex) {
            log.error("创建订单失败", ex);
            throw ex;  // √ 继续抛出异常，触发回滚
        }
    }

    // 方案2：使用手动回滚（适合需要返回错误信息而非抛异常的场景）
    @Transactional(rollbackFor = Exception.class)
    public void createOrder() {
        try {
            orderDao.insert(order);
            inventoryService.deductStock();
        } catch (Exception ex) {
            log.error("创建订单失败", ex);
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();  // √ 手动标记回滚
        }
    }

    // 方案3：不捕获异常，让异常自然传播
    @Transactional(rollbackFor = Exception.class)
    public void createOrder() {
        orderDao.insert(order);
        inventoryService.deductStock();  // √ 异常自然抛出，自动回滚
    }
}

@Service
public class OrderService {

    @Transactional
    public void createOrder() throws IOException {
        orderDao.insert(order);
        writeToFile();  // 抛出 IOException
        // × IOException 是受检异常，默认不回滚
    }

    private void writeToFile() throws IOException {
        throw new IOException("文件写入失败");
    }
}

@Service
public class OrderService {

    // 方案1：统一指定 Exception.class（推荐，最安全）
    @Transactional(rollbackFor = Exception.class)
    public void createOrder() throws IOException {
        orderDao.insert(order);
        writeToFile();
    }

    // 方案2：指定特定异常
    @Transactional(rollbackFor = IOException.class)
    public void createOrder() throws IOException {
        orderDao.insert(order);
        writeToFile();
    }

    // 方案3：包装为运行时异常
    @Transactional
    public void createOrder() {
        orderDao.insert(order);
        try {
            writeToFile();
        } catch (IOException e) {
            throw new RuntimeException("文件写入失败", e);  // √ RuntimeException 会回滚
        }
    }
}

@Service
public class OrderService {

    @Transactional(rollbackFor = Exception.class)
    public void createOrder() {
        orderDao.insert(order);

        // × 异步线程中的操作不在当前事务中
        CompletableFuture.runAsync(() -> {
            inventoryService.deductStock();  // 新线程，新的事务上下文
        });

        // × 新线程中的操作不在当前事务中
        new Thread(() -> {
            logService.recordLog();  // 新线程，新的事务上下文
        }).start();
    }
}

@Service
public class OrderService {

    // 方案1：在主线程完成所有事务操作，再异步执行非事务操作
    @Transactional(rollbackFor = Exception.class)
    public void createOrder() {
        orderDao.insert(order);
        inventoryService.deductStock();  // √ 在事务中完成
    }

    public void createOrderAsync() {
        createOrder();  // 同步执行事务操作

        // 事务提交后再异步执行非事务操作
        CompletableFuture.runAsync(() -> {
            notificationService.sendEmail();  // 非事务操作
        });
    }

    // 方案2：异步方法开启独立事务
    @Transactional(rollbackFor = Exception.class)
    public void createOrder() {
        orderDao.insert(order);
        asyncService.deductStockAsync();  // 异步方法有自己的事务
    }
}

@Service
public class AsyncService {

    @Async
    @Transactional(propagation = Propagation.REQUIRES_NEW, rollbackFor = Exception.class)
    public void deductStockAsync() {
        inventoryService.deductStock();  // √ 独立事务
    }
}

@Service
public class OrderService {

    @Transactional(rollbackFor = Exception.class)
    public void createOrder() {
        orderDao.insert(order);  // MySQL MyISAM 引擎
        // × MyISAM 不支持事务，Spring 层面"开启事务"但数据库无法回滚
    }
}

-- 使用 InnoDB 引擎（MySQL 5.5+ 默认）
CREATE TABLE orders (
    id BIGINT PRIMARY KEY,
    -- ...
) ENGINE=InnoDB;

@Service
public final class OrderService {  // × final 类，CGLIB 无法生成子类

    @Transactional(rollbackFor = Exception.class)
    public void createOrder() {
        orderDao.insert(order);
    }
}

@Service
public class UserService {

    @Transactional(rollbackFor = Exception.class)
    public final void createUser() {  // × final 方法，CGLIB 无法覆盖
        userDao.insert(user);
    }
}

@Service
public class OrderService {  // √ 去掉 final

    @Transactional(rollbackFor = Exception.class)
    public void createOrder() {  // √ 去掉 final
        orderDao.insert(order);
    }
}

// × 没有 @Service 等注解，不被 Spring 管理
public class OrderService {

    @Transactional(rollbackFor = Exception.class)
    public void createOrder() {
        orderDao.insert(order);
    }
}

// × 手动创建对象，不经过 Spring 容器
public class Main {
    public static void main(String[] args) {
        OrderService orderService = new OrderService();
        orderService.createOrder();  // 无代理
    }
}

@Service  // √ 添加 Spring 注解
public class OrderService {

    @Transactional(rollbackFor = Exception.class)
    public void createOrder() {
        orderDao.insert(order);
    }
}

// 通过 Spring 容器获取
public class Main {
    public static void main(String[] args) {
        ApplicationContext ctx = new AnnotationConfigApplicationContext(AppConfig.class);
        OrderService orderService = ctx.getBean(OrderService.class);  // √ 从容器获取代理对象
        orderService.createOrder();
    }
}

@Service
public class OrderService {

    @Transactional(rollbackFor = Exception.class)
    public void createOrder() {
        masterOrderDao.insert(order);  // 操作主库
        slaveLogDao.insert(log);       // 操作从库
        // × 默认事务管理器只管理一个数据源，跨库事务失效
    }
}

// 方案1：指定事务管理器（各自管各自的数据源）
@Service
public class OrderService {

    @Transactional(transactionManager = "masterTransactionManager", rollbackFor = Exception.class)
    public void createOrder() {
        masterOrderDao.insert(order);
    }

    @Transactional(transactionManager = "slaveTransactionManager", rollbackFor = Exception.class)
    public void recordLog() {
        slaveLogDao.insert(log);
    }
}

// 方案2：使用分布式事务框架（如 Seata）
@GlobalTransactional
public void createOrder() {
    masterOrderDao.insert(order);
    slaveLogDao.insert(log);
}

@Service
public class OrderService {

    @Transactional
    public void createOrder(OrderDTO dto) {
        orderDao.insert(order);
        try {
            inventoryService.deductStock(dto.getProductId(), dto.getCount());
        } catch (Exception e) {
            log.error("扣减库存失败", e);
            // × 异常被捕获，没有抛出，事务提交
        }
    }
}

@Service
public class OrderService {

    @Transactional(rollbackFor = Exception.class)  // √ 统一配置 rollbackFor
    public void createOrder(OrderDTO dto) {
        orderDao.insert(order);
        // √ 不捕获异常，让事务回滚
        inventoryService.deductStock(dto.getProductId(), dto.getCount());
    }
}

@Service
public class ImportService {

    @Transactional(rollbackFor = Exception.class)
    public void batchImport(List<Item> items) {
        for (Item item : items) {
            // × REQUIRES_NEW 会开启新事务，独立提交
            itemService.importItem(item);
        }
    }
}

@Service
public class ItemService {

    @Transactional(propagation = Propagation.REQUIRES_NEW, rollbackFor = Exception.class)
    public void importItem(Item item) {
        itemDao.insert(item);
    }
}

// 方案1：使用默认传播行为（REQUIRED），整体回滚
@Service
public class ImportService {

    @Transactional(rollbackFor = Exception.class)
    public void batchImport(List<Item> items) {
        for (Item item : items) {
            itemService.importItem(item);  // √ 加入外层事务
        }
    }
}

@Service
public class ItemService {

    @Transactional(rollbackFor = Exception.class)  // 默认 REQUIRED
    public void importItem(Item item) {
        itemDao.insert(item);
    }
}

// 方案2：使用嵌套事务（部分回滚，单条失败不影响整体）
@Service
public class ImportService {

    @Transactional(rollbackFor = Exception.class)
    public void batchImport(List<Item> items) {
        for (Item item : items) {
            try {
                itemService.importItem(item);  // √ 嵌套事务，可独立回滚
            } catch (Exception e) {
                log.error("导入失败: {}", item, e);
            }
        }
    }
}

@Service
public class ItemService {

    @Transactional(propagation = Propagation.NESTED, rollbackFor = Exception.class)
    public void importItem(Item item) {
        itemDao.insert(item);
    }
}

@Service
public class OrderService {

    @Transactional(rollbackFor = Exception.class)
    public void createOrder(OrderDTO dto) {
        orderDao.insert(order);
        // × 事务未提交就发送消息，如果后续失败回滚，消息已发出
        messageService.sendAsync("order.created", order);
        inventoryService.deductStock(dto.getProductId());
    }
}

// 方案1：使用 TransactionSynchronizationManager 注册回调
@Service
public class OrderService {

    @Transactional(rollbackFor = Exception.class)
    public void createOrder(OrderDTO dto) {
        orderDao.insert(order);
        inventoryService.deductStock(dto.getProductId());

        // 注册事务提交后的回调
        TransactionSynchronizationManager.registerSynchronization(
            new TransactionSynchronization() {
                @Override
                public void afterCommit() {
                    // √ 事务提交后再发送消息
                    messageService.sendAsync("order.created", order);
                }
            }
        );
    }
}

// 方案2：使用 @TransactionalEventListener（推荐，解耦更好）
@Service
public class OrderService {

    @Autowired
    private ApplicationEventPublisher eventPublisher;

    @Transactional(rollbackFor = Exception.class)
    public void createOrder(OrderDTO dto) {
        orderDao.insert(order);
        inventoryService.deductStock(dto.getProductId());
        // 发布领域事件
        eventPublisher.publishEvent(new OrderCreatedEvent(order));
    }
}

@Component
public class OrderEventListener {

    @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)  // √ 事务提交后执行
    public void handleOrderCreated(OrderCreatedEvent event) {
        messageService.sendAsync("order.created", event.getOrder());
    }
}

@Service
public class ReportService {

    @Transactional(rollbackFor = Exception.class)
    public void generateReport() {
        // × 长事务：查询 + 计算 + 写入，时间过长
        List<Data> data = dataDao.queryBigData();  // 查询耗时 10 秒
        Report report = calculateReport(data);      // 计算耗时 20 秒
        reportDao.insert(report);                   // 写入耗时 1 秒
        // 总耗时 31 秒，长时间占用数据库连接和锁
    }
}

@Service
public class ReportService {

    // 拆分事务：查询和计算不需要事务，只有写入需要
    public void generateReport() {
        // 查询（非事务）
        List<Data> data = queryBigData();
        // 计算（非事务）
        Report report = calculateReport(data);
        // 写入（短事务）
        saveReport(report);
    }

    @Transactional(readOnly = true, timeout = 30)
    public List<Data> queryBigData() {
        return dataDao.queryBigData();
    }

    @Transactional(rollbackFor = Exception.class, timeout = 10)  // √ 短事务，只包含写入
    public void saveReport(Report report) {
        reportDao.insert(report);
    }
}

// × 不推荐：事务中夹杂 RPC、消息和复杂循环
@Transactional(rollbackFor = Exception.class)
public void createOrder() {
    orderDao.insert(order);
    inventoryService.remoteDeductStock();  // RPC 调用，耗时不可控
    messageService.sendMessage();          // 发消息，可能失败
    for (int i = 0; i < 10000; i++) {     // 复杂循环
        processOne();
    }
}

// √ 推荐：拆分事务和非事务操作
public void createOrder() {
    createOrderWithTransaction();  // 事务操作
    messageService.sendMessage();  // 非事务操作
}

@Transactional(rollbackFor = Exception.class, timeout = 10)
public void createOrderWithTransaction() {
    orderDao.insert(order);
    inventoryService.deductStock();  // 本地调用
}

# application.yml（Spring Boot 3.x）
logging:
  level:
    org.springframework.transaction: DEBUG
    org.springframework.jdbc.datasource.DataSourceTransactionManager: DEBUG
    org.springframework.orm.jpa.JpaTransactionManager: DEBUG

Creating new transaction with name [com.example.OrderService.createOrder]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT
Participating in existing transaction
Initiating transaction commit
Initiating transaction rollback

@Service
public class OrderService {

    public void checkTransactionStatus() {
        // 检查是否在事务中
        boolean inTransaction = TransactionSynchronizationManager.isActualTransactionActive();
        log.info("是否在事务中: {}", inTransaction);

        // 获取事务名称（通常是方法全限定名）
        String transactionName = TransactionSynchronizationManager.getCurrentTransactionName();
        log.info("事务名称: {}", transactionName);

        // 获取事务隔离级别
        int isolationLevel = TransactionSynchronizationManager.getCurrentTransactionIsolationLevel();
        log.info("隔离级别: {}", isolationLevel);

        // 获取当前事务是否标记为只读
        boolean readOnly = TransactionSynchronizationManager.isCurrentTransactionReadOnly();
        log.info("是否只读: {}", readOnly);
    }
}

# application.yml - 启用事务指标
management:
  endpoints:
    web:
      exposure:
        include: metrics
  metrics:
    export:
      simple:
        enabled: true

// √ 推荐：应用服务层控制事务边界
@Service
public class OrderApplicationService {

    @Transactional(rollbackFor = Exception.class)
    public void createOrder(CreateOrderCommand command) {
        orderService.createOrder(command);
        inventoryService.deductStock(command);
        paymentService.createPayment(command);
    }
}

// √ 推荐：领域服务专注业务逻辑，不关心事务
@Service
public class OrderService {

    public void createOrder(CreateOrderCommand command) {
        orderRepository.save(order);
    }
}

// √ 推荐：项目级统一配置
@Transactional(rollbackFor = Exception.class, propagation = Propagation.REQUIRED)
public void businessMethod() {
    // ...
}

// 自定义长事务监控切面
@Aspect
@Component
@Slf4j
public class LongTransactionMonitor {

    // 超过 3 秒视为长事务
    private static final long WARN_THRESHOLD = 3000;

    @Around("@annotation(transactional)")
    public Object monitorTransaction(ProceedingJoinPoint pjp, Transactional transactional) throws Throwable {
        long start = System.currentTimeMillis();
        try {
            return pjp.proceed();
        } finally {
            long elapsed = System.currentTimeMillis() - start;
            if (elapsed > WARN_THRESHOLD) {
                log.warn("长事务警告: {} 耗时 {}ms", pjp.getSignature(), elapsed);
            }
        }
    }
}

@Service
public class OrderService {

    // √ 写操作：统一配置 rollbackFor
    @Transactional(rollbackFor = Exception.class)
    public void createOrder() {}

    // √ 查询操作：使用只读事务
    @Transactional(readOnly = true)
    public List<Order> listOrders() {}

    // √ 批量操作：设置超时
    @Transactional(rollbackFor = Exception.class, timeout = 30)
    public void batchProcess() {}
}