public class OrderService {
    private Set<String> processedOrderIds = new HashSet<>();
    
    public void createOrder(String orderId, Order order) {
        // 检查订单是否已经处理过
        if (processedOrderIds.contains(orderId)) {
            // 如果已经处理过，直接返回
            return;
        }
        
        // 执行创建订单的逻辑
        doCreateOrder(order);
        
        // 记录已处理的订单ID
        processedOrderIds.add(orderId);
    }
}

2. 数据库唯一约束

利用数据库的唯一约束特性实现幂等性：

-- 创建唯一索引确保订单号不重复
CREATE UNIQUE INDEX idx_order_number ON orders(order_number);

-- 插入订单时，如果订单号已存在会抛出异常
INSERT INTO orders (order_number, customer_id, amount) 
VALUES ('ORD001', 123, 100.00);

3. 状态机设计

通过状态机控制操作的执行流程，确保操作只在特定状态下执行：

public enum OrderStatus {
    PENDING, PROCESSING, COMPLETED, CANCELLED
}

public class OrderService {
    public void processOrder(String orderId) {
        Order order = getOrder(orderId);
        
        // 只有在PENDING状态下才能处理订单
        if (order.getStatus() == OrderStatus.PENDING) {
            // 更新状态为PROCESSING
            updateOrderStatus(orderId, OrderStatus.PROCESSING);
            
            // 执行处理逻辑
            doProcessOrder(order);
            
            // 更新状态为COMPLETED
            updateOrderStatus(orderId, OrderStatus.COMPLETED);
        }
        // 其他状态下直接返回，实现幂等性
    }
}

4. 版本控制

通过版本号或时间戳控制操作的执行：

public class Account {
    private long balance;
    private long version;
    
    public boolean withdraw(long amount, long expectedVersion) {
        // 检查版本号是否匹配
        if (this.version != expectedVersion) {
            return false; // 版本不匹配，操作失败
        }
        
        // 执行扣款操作
        this.balance -= amount;
        this.version++; // 更新版本号
        
        return true;
    }
}

补偿事务（Compensation Transactions）

补偿事务是一种处理分布式事务失败的机制，通过执行逆向操作来撤销已执行的操作，恢复系统到一致状态。

补偿事务的基本原理

在分布式事务中，当某个步骤执行失败时，需要撤销之前已经成功执行的步骤。补偿事务就是这些撤销操作的集合。

正向操作与补偿操作

每个正向操作都需要有一个对应的补偿操作：

正向操作：执行业务逻辑，如创建订单、扣减库存
补偿操作：撤销正向操作的影响，如取消订单、恢复库存

Saga模式

Saga模式是实现长事务的一种常见方式，它将一个长事务分解为多个短事务，每个短事务都有对应的补偿操作。

协调器模式（Choreography）

在协调器模式中，每个服务都监听其他服务的事件，并根据事件决定是否执行补偿操作。

// 订单服务
public class OrderService {
    public void createOrder(Order order) {
        // 创建订单
        orderRepository.save(order);
        
        // 发布订单创建事件
        eventPublisher.publish(new OrderCreatedEvent(order));
    }
    
    @EventListener
    public void handlePaymentFailed(PaymentFailedEvent event) {
        // 如果收到支付失败事件，取消订单
        cancelOrder(event.getOrderId());
        
        // 发布订单取消事件
        eventPublisher.publish(new OrderCancelledEvent(event.getOrderId()));
    }
}

编排模式（Orchestration）

在编排模式中，有一个专门的协调器负责控制整个Saga的执行流程。

public class OrderSagaOrchestrator {
    public void processOrder(Order order) {
        try {
            // 步骤1：创建订单
            orderService.createOrder(order);
            
            // 步骤2：扣减库存
            inventoryService.reserveInventory(order.getItems());
            
            // 步骤3：处理支付
            paymentService.processPayment(order.getPaymentInfo());
            
            // 步骤4：发送通知
            notificationService.sendConfirmation(order.getCustomerId());
            
        } catch (Exception e) {
            // 如果任何步骤失败，执行补偿操作
            compensate(order);
        }
    }
    
    private void compensate(Order order) {
        // 逆序执行补偿操作
        notificationService.cancelConfirmation(order.getCustomerId());
        paymentService.refundPayment(order.getPaymentInfo());
        inventoryService.releaseInventory(order.getItems());
        orderService.cancelOrder(order.getId());
    }
}

补偿事务的设计原则

1. 幂等性

补偿操作本身也应该是幂等的，可以重复执行而不会产生副作用。

2. 可交换性

补偿操作的执行顺序不应该影响最终结果，即补偿操作应该是可交换的。

3. 最终一致性

补偿事务不要求强一致性，但需要保证最终一致性。

4. 可监控性

补偿事务的执行过程应该是可监控的，便于故障诊断和问题排查。

实际应用场景

1. 电商订单处理

在电商系统中，创建订单通常涉及多个步骤：

创建订单记录
扣减商品库存
处理支付
发送确认通知

任何一个步骤失败都需要执行补偿操作：

取消订单
恢复库存
退款
取消通知

2. 银行转账

银行转账涉及两个账户的操作：

从源账户扣款
向目标账户加款

如果源账户扣款成功但目标账户加款失败，需要执行补偿操作：

向源账户退款

3. 酒店预订系统

酒店预订可能涉及多个服务：

检查房间可用性
预订房间
处理支付
发送确认邮件

补偿操作包括：

取消房间预订
退款
取消邮件发送

技术实现方案

1. 基于事件驱动的补偿

使用消息队列实现事件驱动的补偿机制：

@Component
public class CompensationEventHandler {
    
    @RabbitListener(queues = "compensation.queue")
    public void handleCompensationEvent(CompensationEvent event) {
        switch (event.getOperationType()) {
            case "ORDER_CREATION":
                orderService.cancelOrder(event.getEntityId());
                break;
            case "INVENTORY_RESERVATION":
                inventoryService.releaseInventory(event.getEntityId());
                break;
            case "PAYMENT_PROCESSING":
                paymentService.refundPayment(event.getEntityId());
                break;
        }
    }
}

2. 基于状态机的补偿

使用状态机管理事务状态和补偿逻辑：

public enum TransactionState {
    STARTED, ORDER_CREATED, INVENTORY_RESERVED, PAYMENT_PROCESSED, COMPLETED,
    ORDER_CANCELLED, INVENTORY_RELEASED, PAYMENT_REFUNDED, COMPENSATED
}

@Component
public class TransactionStateMachine {
    
    public void executeTransaction(Order order) {
        try {
            // 执行正向操作
            orderService.createOrder(order);
            updateState(TransactionState.ORDER_CREATED);
            
            inventoryService.reserveInventory(order.getItems());
            updateState(TransactionState.INVENTORY_RESERVED);
            
            paymentService.processPayment(order.getPaymentInfo());
            updateState(TransactionState.PAYMENT_PROCESSED);
            
            updateState(TransactionState.COMPLETED);
            
        } catch (Exception e) {
            // 执行补偿操作
            compensate();
        }
    }
    
    private void compensate() {
        if (currentState == TransactionState.PAYMENT_PROCESSED) {
            paymentService.refundPayment(order.getPaymentInfo());
            updateState(TransactionState.PAYMENT_REFUNDED);
        }
        
        if (currentState == TransactionState.INVENTORY_RESERVED) {
            inventoryService.releaseInventory(order.getItems());
            updateState(TransactionState.INVENTORY_RELEASED);
        }
        
        if (currentState == TransactionState.ORDER_CREATED) {
            orderService.cancelOrder(order.getId());
            updateState(TransactionState.ORDER_CANCELLED);
        }
        
        updateState(TransactionState.COMPENSATED);
    }
}

3. 基于数据库的补偿

使用数据库记录事务状态和补偿信息：

CREATE TABLE transaction_log (
    id BIGINT PRIMARY KEY,
    transaction_id VARCHAR(50),
    operation_type VARCHAR(50),
    entity_id VARCHAR(50),
    status VARCHAR(20),
    created_time TIMESTAMP,
    updated_time TIMESTAMP
);

-- 记录正向操作
INSERT INTO transaction_log (transaction_id, operation_type, entity_id, status, created_time)
VALUES ('TXN001', 'ORDER_CREATION', 'ORD001', 'SUCCESS', NOW());

-- 记录补偿操作
INSERT INTO transaction_log (transaction_id, operation_type, entity_id, status, created_time)
VALUES ('TXN001', 'ORDER_CANCELLATION', 'ORD001', 'PENDING', NOW());

最佳实践

1. 设计幂等性友好的API

使用PUT而不是POST进行更新操作
为每个重要操作分配唯一标识符
在API文档中明确标注操作的幂等性特性

2. 实现健壮的补偿机制

为每个正向操作设计对应的补偿操作
确保补偿操作的幂等性和可交换性
记录补偿操作的执行状态

3. 建立完善的监控体系

监控幂等性检查的触发情况
监控补偿事务的执行情况
设置告警机制，及时发现异常

4. 定期测试和演练

定期测试幂等性实现的正确性
演练补偿事务的执行流程
根据测试结果优化实现方案

总结

幂等性与补偿事务是构建可靠分布式系统的重要技术手段。幂等性设计能够有效应对网络重试和消息重复等问题，而补偿事务则为分布式事务的失败处理提供了有效机制。通过合理设计和实现这两种机制，我们可以显著提高系统的容错能力和数据一致性。

在实际应用中，需要根据具体业务场景选择合适的实现方案，并建立完善的监控和测试体系，确保这些机制能够真正发挥作用。下一章我们将探讨自愈系统，了解如何通过自动化技术提高系统的容错能力。