public void processFile(String srcPath, String destPath) {
    File backupFile = null;
    File tempFile = null;
    try {
        // 步骤1：创建备份
        backupFile = new File(srcPath + ".bak");
        Files.copy(Path.of(srcPath), backupFile.toPath(),
                   StandardCopyOption.REPLACE_EXISTING);

        // 步骤2：处理并写入临时文件
        tempFile = new File(destPath + ".tmp");
        try (var reader = new BufferedReader(new FileReader(srcPath));
             var writer = new BufferedWriter(new FileWriter(tempFile))) {
            String line;
            while ((line = reader.readLine()) != null) {
                writer.write(transform(line));
                writer.newLine();
            }
        }

        // 步骤3：原子替换目标文件
        Files.move(tempFile.toPath(), Path.of(destPath),
                   StandardCopyOption.REPLACE_EXISTING,
                   StandardCopyOption.ATOMIC_MOVE);

    } catch (Exception e) {
        // 补偿逻辑：清掉所有中间产物
        if (tempFile != null && tempFile.exists()) {
            tempFile.delete();           // 撤销步骤2
        }
        if (backupFile != null && backupFile.exists()) {
            try {
                Files.move(backupFile.toPath(), Path.of(srcPath),
                           StandardCopyOption.REPLACE_EXISTING);  // 撤销步骤1
            } catch (IOException ex) {
                log.error("连备份恢复都失败了，手动处理吧...", ex);
            }
        }
        throw new ProcessingException("文件处理失败，已尽力回滚", e);
    }
}

Lock lock = lockManager.acquireLock("order:12345");
try {
    // 执行业务逻辑
    processOrder(order);
} finally {
    lockManager.releaseLock(lock);  // 补偿：释放锁
}

Connection conn = dataSource.getConnection();
try {
    // 执行 SQL
} finally {
    conn.close();  // 补偿：归还连接
}

@Transactional
public void updateProduct(ProductDTO dto) {
    // 1. 更新数据库
    productMapper.updateById(dto.toEntity());

    // 2. 更新 Redis 缓存
    try {
        redisTemplate.opsForValue().set("product:" + dto.getId(), dto,
                                         Duration.ofMinutes(30));
    } catch (Exception e) {
        log.warn("缓存更新失败，但不影响主流程", e);
        // 这里要不要回滚 DB？
    }
}

public Result deductStock(String productId, int quantity) {
    // 先在 Redis 扣减（关键路径）
    Long remaining = redisTemplate.opsForValue()
            .decrement("stock:" + productId, quantity);

    if (remaining < 0) {
        // 补偿：加回去
        redisTemplate.opsForValue()
                .increment("stock:" + productId, quantity);
        return Result.fail("库存不足");
    }

    // 异步同步到 DB（非关键路径，失败可重试）
    eventBus.publish(new StockDeductedEvent(productId, quantity));
    return Result.ok();
}

@Service
public class OrderService {

    @Autowired
    private InventoryClient inventoryClient;  // RPC 调用库存服务
    @Autowired
    private CouponClient couponClient;        // RPC 调用优惠券服务
    @Autowired
    private OrderMapper orderMapper;

    @Transactional
    public CreateOrderResult createOrder(CreateOrderRequest req) {
        // 步骤1：创建订单（本地 DB）
        Order order = Order.from(req);
        orderMapper.insert(order);

        try {
            // 步骤2：扣减库存（远程 RPC）
            DeductResult deductResult = inventoryClient.deduct(
                req.getProductId(), req.getQuantity());

            if (!deductResult.isSuccess()) {
                throw new BusinessException("库存扣减失败");
            }

        } catch (Exception e) {
            // 库存扣减失败 → 补偿步骤1：订单需要取消
            // 但此时本地事务还没提交，直接抛异常让 @Transactional 回滚即可
            throw e;
        }

        try {
            // 步骤3：核销优惠券（远程 RPC）
            couponClient.use(req.getCouponId(), order.getId());

        } catch (Exception e) {
            // ⚠️ 优惠券核销失败 → 需要补偿步骤1和步骤2
            // 但订单还没提交（本地事务），库存已经扣了（远程已提交）

            // 补偿步骤2：恢复库存
            inventoryClient.restore(req.getProductId(), req.getQuantity());

            // 步骤1 由 @Transactional 回滚
            throw new BusinessException("优惠券核销失败，已恢复库存", e);
        }

        // 所有步骤成功，事务提交
        return CreateOrderResult.success(order.getId());
    }
}

@Service
public class OrderServiceV2 {

    @Autowired
    private CompensationLogMapper compLogMapper;  // 补偿操作记录表

    @Transactional
    public CreateOrderResult createOrder(CreateOrderRequest req) {
        // 步骤1：创建订单
        Order order = Order.from(req);
        orderMapper.insert(order);

        // 步骤2：扣减库存
        String inventoryLogId = UUID.randomUUID().toString();
        compLogMapper.insert(new CompensationLog(
            inventoryLogId, "INVENTORY_DEDUCT",
            order.getId(), "PENDING"
        ));

        try {
            DeductResult result = inventoryClient.deduct(
                req.getProductId(), req.getQuantity());
            compLogMapper.updateStatus(inventoryLogId, "COMMITTED");
        } catch (Exception e) {
            compLogMapper.updateStatus(inventoryLogId, "FAILED");
            throw e;  // 还没提交其他副作用，直接抛
        }

        // 步骤3：核销优惠券
        String couponLogId = UUID.randomUUID().toString();
        compLogMapper.insert(new CompensationLog(
            couponLogId, "COUPON_USE",
            order.getId(), "PENDING"
        ));

        try {
            couponClient.use(req.getCouponId(), order.getId());
            compLogMapper.updateStatus(couponLogId, "COMMITTED");
        } catch (Exception e) {
            // 记录需要补偿
            compLogMapper.updateStatus(couponLogId, "NEED_COMPENSATION");
            throw new NeedCompensationException(
                order.getId(),
                List.of("INVENTORY_DEDUCT")  // 需要补偿的操作
            );
        }

        return CreateOrderResult.success(order.getId());
    }
}

@Component
public class CompensationExecutor {

    @Scheduled(fixedDelay = 10_000)  // 每 10 秒扫一次
    public void executePendingCompensations() {
        List<CompensationLog> pending = compLogMapper
            .selectByStatus("NEED_COMPENSATION");

        for (CompensationLog log : pending) {
            try {
                executeCompensation(log);
                compLogMapper.updateStatus(log.getId(), "COMPENSATED");
            } catch (Exception e) {
                log.error("补偿失败，等待下次重试: {}", log.getId(), e);
                compLogMapper.incrementRetryCount(log.getId());
            }
        }
    }

    private void executeCompensation(CompensationLog log) {
        // 查出这个订单所有 COMMITTED 的操作，按逆序补偿
        List<CompensationLog> committedOps = compLogMapper
            .selectByOrderAndStatus(log.getOrderId(), "COMMITTED");

        // 逆序遍历
        for (int i = committedOps.size() - 1; i >= 0; i--) {
            CompensationLog op = committedOps.get(i);
            switch (op.getOperationType()) {
                case "INVENTORY_DEDUCT" -> inventoryClient.restore(
                    op.getProductId(), op.getQuantity());
                case "COUPON_USE" -> couponClient.release(
                    op.getCouponId(), op.getOrderId());
                // 每种操作都有对应的逆操作
            }
        }
    }
}

@Service
public class InventoryTccService {

    @Autowired
    private InventoryMapper inventoryMapper;
    @Autowired
    private FreezeLogMapper freezeLogMapper;

    // Try：冻结库存（不是扣减！）
    @TwoPhaseBusinessAction(name = "deductInventory", commitMethod = "confirm", rollbackMethod = "cancel")
    public boolean tryDeduct(String productId, int quantity, String xid) {
        // 检查可用库存 >= 冻结库存 + 请求数量
        int available = inventoryMapper.selectAvailable(productId);
        if (available < quantity) {
            return false;
        }

        // 插入冻结记录 + 增加冻结数量（一两条 SQL，原子性）
        freezeLogMapper.insert(xid, productId, quantity, "TRY");
        inventoryMapper.increaseFrozen(productId, quantity);
        return true;
    }

    // Confirm：确认扣减——真正扣库存
    public boolean confirm(String productId, int quantity, String xid) {
        // 真正减少库存 + 扣减冻结数量
        inventoryMapper.decreaseStock(productId, quantity);
        inventoryMapper.decreaseFrozen(productId, quantity);
        freezeLogMapper.updateStatus(xid, "CONFIRMED");
        return true;
    }

    // Cancel：取消——释放冻结
    public boolean cancel(String productId, int quantity, String xid) {
        // 释放冻结，库存不变
        inventoryMapper.decreaseFrozen(productId, quantity);
        freezeLogMapper.updateStatus(xid, "CANCELLED");
        return true;
    }
}

@Component
public class OrderSagaOrchestrator {

    private final List<SagaStep> steps;

    public OrderSagaOrchestrator() {
        // 编排型 Saga：显式定义步骤链
        this.steps = List.of(
            new SagaStep("CREATE_ORDER",     this::createOrder,     this::cancelOrder),
            new SagaStep("DEDUCT_INVENTORY", this::deductInventory, this::restoreInventory),
            new SagaStep("CHARGE_PAYMENT",   this::chargePayment,   this::refundPayment),
            new SagaStep("USE_COUPON",       this::useCoupon,       this::releaseCoupon),
            new SagaStep("SEND_NOTIFY",      this::sendNotify,      this::voidNotify) // void 不是撤销，是"发送一条'您的订单已退款'通知"
        );
    }

    public SagaResult execute(CreateOrderRequest req) {
        SagaContext ctx = new SagaContext();
        int executedIndex = -1;

        try {
            // 正向执行
            for (int i = 0; i < steps.size(); i++) {
                steps.get(i).forward().accept(ctx, req);
                executedIndex = i;
            }
            return SagaResult.success();

        } catch (Exception e) {
            log.error("步骤 {} 失败，开始逆序补偿", steps.get(executedIndex + 1).name(), e);

            // 逆序补偿已执行的步骤
            for (int i = executedIndex; i >= 0; i--) {
                try {
                    steps.get(i).compensate().accept(ctx, req);
                } catch (Exception compEx) {
                    log.error("补偿步骤 {} 也失败了！需要人工介入",
                              steps.get(i).name(), compEx);
                    // 记录到补偿表，异步重试
                    compLogMapper.insert(new CompensationLog(
                        req.getOrderId(), steps.get(i).name(), "COMPENSATE_FAILED"
                    ));
                }
            }
            return SagaResult.failed(e.getMessage());
        }
    }

    // 每一步的正向操作和补偿操作
    private void createOrder(SagaContext ctx, CreateOrderRequest req) {
        Order order = Order.from(req);
        orderMapper.insert(order);
        ctx.setOrderId(order.getId());
    }

    private void cancelOrder(SagaContext ctx, CreateOrderRequest req) {
        orderMapper.updateStatus(ctx.getOrderId(), "CANCELLED");
    }
    // ... 其余步骤类似
}

@Service
public class OrderWithTransactionalMessage {

    @Autowired
    private RocketMQTemplate rocketMQTemplate;

    @Transactional
    public void createOrderAndNotify(CreateOrderRequest req) {
        // 发送半消息（此时消费者不可见）
        String txId = UUID.randomUUID().toString();
        Message<String> msg = MessageBuilder
            .withPayload(JSON.toJSONString(req))
            .setHeader("txId", txId)
            .build();

        // 步骤1：发半消息 + 步骤2：执行本地事务
        rocketMQTemplate.sendMessageInTransaction(
            "order-created-topic", msg, req);

        // TransactionListener.executeLocalTransaction() 中：
        //   - 本地事务（订单入库）成功 → COMMIT，消息对消费者可见
        //   - 本地事务失败 → ROLLBACK，消息丢弃

        // TransactionListener.checkLocalTransaction() 中：
        //   - 回查本地事务状态（处理 COMMIT/ROLLBACK 丢失的情况）
    }
}

@RocketMQMessageListener(
    topic = "order-created-topic",
    consumerGroup = "inventory-deduct-group"
)
@Component
public class InventoryDeductConsumer
        implements RocketMQListener<MessageExt> {

    @Override
    public void onMessage(MessageExt message) {
        try {
            OrderCreatedEvent event = JSON.parseObject(
                message.getBody(), OrderCreatedEvent.class);

            // 执行库存扣减
            inventoryService.deduct(event.getProductId(), event.getQuantity());

        } catch (Exception e) {
            // 抛异常 → MQ 自动重试（默认 16 次，间隔递增）
            // 重试全部失败 → 进入死信队列（DLQ）
            throw new RuntimeException("库存扣减失败，等待重试", e);
        }
    }
}

@RocketMQMessageListener(
    topic = "%DLQ%inventory-deduct-group",  // 死信队列
    consumerGroup = "dlq-handler-group"
)
@Component
public class InventoryDeductDLQHandler
        implements RocketMQListener<MessageExt> {

    @Override
    public void onMessage(MessageExt message) {
        // 进入死信 = 所有重试都已失败
        // 此时需要补偿前置操作
        OrderCreatedEvent event = JSON.parseObject(
            message.getBody(), OrderCreatedEvent.class);

        // 补偿：释放之前可能已经扣除的库存
        // （虽然扣减失败，但如果之前部分成功，需要清理）
        inventoryService.forceReleaseByOrder(event.getOrderId());

        // 通知订单服务：该订单需要取消 / 退款
        orderClient.markAsFailed(event.getOrderId(),
            "库存扣减多次重试均失败");

        // 告警
        alertService.sendAlert("DLQ",
            "订单 %s 库存扣减彻底失败，已触发补偿".formatted(event.getOrderId()));
    }
}

// 场景 A：幂等写入，重试即可，不需要补偿
@Retryable(maxAttempts = 3, backoff = @Backoff(delay = 1000))
public void syncUserToES(Long userId) {
    User user = userMapper.selectById(userId);
    // ES 的 index 操作本身就是幂等的（相同 docId 覆盖写入）
    elasticsearchOperations.save(user.toDocument());
    // 失败？重试。重试还失败？记日志，定时对账补数据。
}

// 场景 B：只读操作，根本没有副作用
public List<Product> searchProducts(String keyword) {
    // 搜索失败了不需要补偿任何东西，因为没有改动任何数据
    return elasticsearchOperations.search(query, Product.class);
}

// 场景 C：调了第三方支付，有外部不可逆副作用
public void processRefund(Order order) {
    // 支付宝的退款接口调用成功后，钱已经退回用户账户
    // 如果后续操作失败，你能"撤回退款"吗？不能。
    // 你只能再发起一笔扣款——这就是补偿
    AlipayRefundResponse response = alipayClient.refund(
        order.getPayOrderNo(), order.getAmount());

    if (response.isSuccess()) {
        // 记录退款成功
        refundLogMapper.insert(response);
    }
    // 退款操作本身失败了？可以重试（支付宝 refund 接口幂等）
    // 退款成功但后续操作失败？需要补偿——再扣一次钱
}

// 场景 D：发了实物的出库指令，无法撤回
public void shipProduct(Order order) {
    // WMS 已经收到出库指令，拣货机器人开始动了
    // 此时无法"撤回"（物理世界没有 Ctrl+Z）
    // 补偿只能走退货退款流程
    wmsClient.createOutboundOrder(order.toOutboundRequest());
    // 如果这个订单稍后被取消 → 补偿是创建退货入库单，而不是"取消出库"
}

/**
 * 补偿友好型操作的四个要素：
 * 1. 正向操作记录唯一标识
 * 2. 逆操作幂等（多次调用效果相同）
 * 3. 逆操作可重试（网络失败不丢）
 * 4. 状态可审计（中间态有迹可循）
 */
public class CompensationFriendlyOperation {

    private CompensationLogMapper logMapper;

    public void executeWithCompensation(String bizId,
                                         Runnable forward,
                                         Runnable compensate) {
        // 1. 记录操作意图
        CompensationLog log = new CompensationLog(bizId, "PENDING");
        logMapper.insert(log);

        try {
            // 2. 执行正向操作
            forward.run();
            logMapper.updateStatus(log.getId(), "COMMITTED");

        } catch (Exception e) {
            // 3. 标记需要补偿
            logMapper.updateStatus(log.getId(), "NEED_COMPENSATION");

            // 4. 尝试补偿（带重试）
            retryCompensate(compensate, 3);
        }
    }

    private void retryCompensate(Runnable compensate, int maxRetries) {
        for (int i = 0; i < maxRetries; i++) {
            try {
                compensate.run();
                return;  // 补偿成功
            } catch (Exception e) {
                if (i == maxRetries - 1) {
                    // 最后一次也失败了 → 持久化，等外部介入
                    log.error("补偿失败，已耗尽重试次数", e);
                    // 注意：此时 NEED_COMPENSATION 状态依然存在
                    // 定时扫描器会继续尝试
                }
            }
        }
    }
}