#支付系统设计

public void processPayment(PaymentRequest request) {
    // 1. 查询订单
    PaymentOrder order = orderDao.findById(request.getOrderId());

    // 2. 检查状态
    if (order.getStatus() == PaymentStatus.PAID) {
        return; // 已支付
    }

    // 3. 发起支付
    PaymentResult result = paymentGateway.pay(request);

    // 4. 更新状态
    order.setStatus(PaymentStatus.PAID);
    orderDao.update(order);
}

@Service
class PaymentService {
    @Autowired
    private PaymentOrderDao orderDao;
    @Autowired
    private PaymentGatewayRouter router;

    /**
     * 创建支付订单
     */
    public PaymentOrder createOrder(CreatePaymentRequest request) {
        // 1. 幂等检查
        PaymentOrder existing = orderDao.findByMerchantOrderNo(
            request.getMerchantOrderNo()
        );
        if (existing != null) {
            return existing; // 返回已有订单
        }

        // 2. 创建订单
        PaymentOrder order = new PaymentOrder();
        order.setMerchantOrderNo(request.getMerchantOrderNo());
        order.setAmount(request.getAmount());
        order.setStatus(PaymentStatus.PENDING);
        order.setCreateTime(Instant.now());
        orderDao.save(order);

        return order;
    }

    /**
     * 发起支付
     */
    public PaymentResponse initiatePayment(Long orderId, String payChannel) {
        // 1. 获取订单
        PaymentOrder order = orderDao.findById(orderId);

        // 2. 幂等：已支付直接返回
        if (order.getStatus() == PaymentStatus.PAID) {
            return PaymentResponse.alreadyPaid();
        }

        // 3. 状态流转
        order.setStatus(PaymentStatus.PROCESSING);
        order.setPayChannel(payChannel);
        order.setUpdateTime(Instant.now());
        orderDao.update(order);

        // 4. 调用支付渠道
        PaymentGateway gateway = router.getGateway(payChannel);
        PaymentResult result = gateway.pay(order);

        // 5. 保存渠道流水号
        order.setChannelOrderNo(result.getChannelOrderNo());
        order.setUpdateTime(Instant.now());
        orderDao.update(order);

        return PaymentResponse.success(result);
    }
}

@Service
class IdempotentService {
    @Autowired
    private RedisTemplate<String, String> redisTemplate;

    private static final String IDEMPOTENT_PREFIX = "payment:idempotent:";

    /**
     * 幂等检查
     */
    public boolean isProcessed(String idempotentKey) {
        String key = IDEMPOTENT_PREFIX + idempotentKey;
        return Boolean.TRUE.equals(redisTemplate.hasKey(key));
    }

    /**
     * 标记已处理
     */
    public void markProcessed(String idempotentKey, String result) {
        String key = IDEMPOTENT_PREFIX + idempotentKey;
        redisTemplate.opsForValue().set(key, result, Duration.ofHours(24));
    }
}

@Dao
interface PaymentOrderDao {
    @Query("UPDATE payment_order SET status = :newStatus, " +
           "version = version + 1 " +
           "WHERE id = :id AND status = :currentStatus AND version = :version")
    int updateStatusWithOptimisticLock(
        @Param("id") Long id,
        @Param("currentStatus") String currentStatus,
        @Param("newStatus") String newStatus,
        @Param("version") int version
    );
}

@Service
class PaymentService {
    public void updateStatus(Long orderId, String newStatus) {
        PaymentOrder order = orderDao.findById(orderId);
        int affected = orderDao.updateStatusWithOptimisticLock(
            orderId,
            order.getStatus(),
            newStatus,
            order.getVersion()
        );

        if (affected == 0) {
            throw new ConcurrentModificationException("并发更新失败");
        }
    }
}

@RestController
class PaymentCallbackController {
    @Autowired
    private PaymentCallbackService callbackService;

    @PostMapping("/callback/{channel}")
    public String handleCallback(
            @PathVariable String channel,
            @RequestBody String rawBody,
            @RequestParam Map<String, String> params) {

        // 1. 记录原始回调
        callbackService.recordCallback(channel, rawBody, params);

        // 2. 验签
        if (!verifySignature(channel, params)) {
            return "fail";
        }

        // 3. 幂等处理
        String channelOrderNo = params.get("out_trade_no");
        if (callbackService.isProcessed(channelOrderNo)) {
            return "success";
        }

        // 4. 处理回调
        try {
            callbackService.processCallback(channel, params);
            return "success";
        } catch (Exception e) {
            log.error("回调处理失败", e);
            return "fail";
        }
    }
}

@Service
class PaymentCallbackService {
    @Autowired
    private RocketMQTemplate mqTemplate;

    public void recordCallback(String channel, String rawBody, Map<String, String> params) {
        // 记录原始回调
        callbackDao.save(new PaymentCallback(channel, rawBody, params));
    }

    public void processCallback(String channel, Map<String, String> params) {
        // 发送到 MQ，异步处理
        mqTemplate.asyncSend("payment:callback:topic",
            new CallbackMessage(channel, params),
            new SendCallback() {
                @Override
                public void onSuccess(SendResult result) { }

                @Override
                public void onException(Throwable e) {
                    // 发送失败，标记重试
                    markForRetry(channel, params);
                }
            }
        );
    }
}

@RocketMQListener(topic = "payment:callback:topic")
class CallbackConsumer {
    @Transactional
    public void handle(CallbackMessage message) {
        String channelOrderNo = message.getParams().get("out_trade_no");
        String status = message.getParams().get("trade_status");

        PaymentOrder order = orderDao.findByChannelOrderNo(channelOrderNo);

        if ("TRADE_SUCCESS".equals(status)) {
            order.setStatus(PaymentStatus.PAID);
            order.setPaidTime(Instant.now());
        } else if ("TRADE_CLOSED".equals(status)) {
            order.setStatus(PaymentStatus.CLOSED);
        }

        orderDao.update(order);
    }
}

@Service
class ReconciliationService {
    @Autowired
    private PaymentOrderDao orderDao;
    @Autowired
    private ChannelApiService channelApi;

    /**
     * 日终对账：核对订单和渠道流水
     */
    @Scheduled(cron = "0 30 4 * * ?") // 每天凌晨 4:30
    public void dailyReconciliation(String date) {
        // 1. 获取本地订单
        List<PaymentOrder> localOrders = orderDao.findByDate(date);

        // 2. 获取渠道流水
        List<ChannelTransaction> channelTxs = channelApi.fetchDailyTransactions(date);

        // 3. 构建对账文件
        Map<String, PaymentOrder> orderMap = localOrders.stream()
            .collect(Collectors.toMap(PaymentOrder::getChannelOrderNo, o -> o));

        // 4. 比对差异
        List<ReconcileDiff> diffs = new ArrayList<>();

        for (ChannelTransaction tx : channelTxs) {
            PaymentOrder order = orderMap.get(tx.getChannelOrderNo());

            if (order == null) {
                // 本地不存在，渠道存在：长款
                diffs.add(new ReconcileDiff(tx, ReconcileType.LONG));
            } else if (!order.getAmount().equals(tx.getAmount())) {
                // 金额不一致
                diffs.add(new ReconcileDiff(tx, order, ReconcileType.AMOUNT_MISMATCH));
            } else {
                // 匹配成功
                order.setReconciled(true);
                orderDao.update(order);
            }
        }

        // 5. 处理差异
        for (ReconcileDiff diff : diffs) {
            handleDiff(diff);
        }
    }
}

@Service
class DiffHandleService {
    @Autowired
    private PaymentOrderDao orderDao;
    @Autowired
    private RefundService refundService;

    public void handleDiff(ReconcileDiff diff) {
        switch (diff.getType()) {
            case LONG:
                // 长款：渠道有，本地没有
                // 可能是本地创建订单失败，需要补充
                PaymentOrder补充订单 = createMissingOrder(diff.getChannelTransaction());
                refundService.autoRefund(补充订单.getAmount()); // 自动退款
                break;

            case SHORT:
                // 短款：本地有，渠道没有
                // 可能是渠道回调失败，需要主动查询
                PaymentOrder order = orderDao.findById(diff.getOrderId());
                queryChannelStatus(order);
                break;

            case AMOUNT_MISMATCH:
                // 金额不一致
                // 需要人工介入
                sendAlert(diff);
                break;
        }
    }
}