#同步 vs 异步处理

// 同步支付（用户必须等待结果）
public PaymentResult processPaymentSync(PaymentRequest request) {
    // 1. 校验支付参数
    validatePaymentRequest(request);
    
    // 2. 调用第三方支付
    PaymentResponse response = paymentGateway.pay(request);
    
    // 3. 更新订单状态
    if (response.isSuccess()) {
        orderService.updateStatus(OrderStatus.PAID);
        return PaymentResult.success(response.getTransactionId());
    } else {
        return PaymentResult.failure(response.getErrorMessage());
    }
}

// 异步下单（用户不需要等待完整流程）
public OrderSubmitResponse submitOrderAsync(OrderSubmitRequest request) {
    // 1. 快速校验（参数校验、风控预检）
    validateRequest(request);
    
    // 2. 发送消息到队列，立即返回
    orderMessageProducer.send(new OrderCreatedMessage(request));
    
    // 3. 返回受理成功（不等待后续处理）
    return OrderSubmitResponse.accepted(request.getOrderId());
}

// 后台 Worker 处理
@MessageListener
public void handleOrderCreated(OrderCreatedMessage message) {
    // 扣减库存
    inventoryService.deduct(message.getProductId(), message.getQuantity());
    
    // 创建正式订单
    orderService.createOrder(message);
    
    // 发送通知
    notificationService.notifyOrderCreated(message.getUserId());
}

// 原始同步代码
public void submitOrder(Order order) {
    // 调用库存服务
    inventoryService.decrement(order.getProductId(), order.getQuantity());
    
    // 调用积分服务
    pointService.add(order.getUserId(), order.getPoints());
    
    // 调用通知服务
    notificationService.send(order.getUserId(), "订单创建成功");
    
    // 保存订单
    orderRepository.save(order);
}

// 优化为异步
public void submitOrder(Order order) {
    // 只需要同步保存订单
    orderRepository.save(order);
    
    // 发送事件，后续服务自行处理
    eventPublisher.publish(new OrderCreatedEvent(order));
}

// 轮询模式（浪费资源）
@GetMapping("/task/status")
public TaskStatus pollStatus(@RequestParam String taskId) {
    return taskService.getStatus(taskId);
}

// Webhook 模式（真正的异步）
@PostMapping("/task/webhook")
public void receiveWebhook(TaskResult result) {
    taskService.updateResult(result);
}

// RocketMQ 持久化消息
Message message = new Message(
    "order-topic",
    "create",
    order.toJSON().getBytes()
);
message.setDelayTimeLevel(3); // 持久化保障

producer.send(message);

@RocketMQMessageListener(
    topic = "order-topic",
    consumerGroup = "order-consumer-group",
    maxReconsumeTimes = 3  // 最大重试 3 次
)
public class OrderConsumer implements RocketMQListener<OrderMessage> {
    
    @Override
    public void onMessage(OrderMessage message) {
        try {
            processOrder(message);
            // 成功：自动 ACK
        } catch (Exception e) {
            // 失败：抛出异常，进入重试队列
            throw e;
        }
    }
}

public void handleMessage(OrderMessage message) {
    // 幂等键：使用订单 ID 作为唯一标识
    String idempotentKey = "order:processed:" + message.getOrderId();
    
    // Redis SETNX 实现幂等
    Boolean result = redisTemplate.opsForValue()
        .setIfAbsent(idempotentKey, "1", Duration.ofHours(24));
    
    if (Boolean.FALSE.equals(result)) {
        log.info("订单已处理过，跳过: {}", message.getOrderId());
        return;
    }
    
    // 执行业务逻辑
    processOrder(message);
}