fix(pay): cancel trade orders close related payment orders

YunaiV
1 parent 3ed98e15
Showing 14 changed files with 466 additions and 4 deletions
yudao-module-mall/yudao-module-trade/src/main/java/cn/iocoder/yudao/module/trade/service/order/TradeOrderUpdateServiceImpl.java
yudao-module-pay/src/main/java/cn/iocoder/yudao/module/pay/api/order/PayOrderApi.java
yudao-module-pay/src/main/java/cn/iocoder/yudao/module/pay/api/order/PayOrderApiImpl.java
yudao-module-pay/src/main/java/cn/iocoder/yudao/module/pay/framework/pay/core/client/PayClient.java
yudao-module-pay/src/main/java/cn/iocoder/yudao/module/pay/framework/pay/core/client/impl/AbstractPayClient.java
yudao-module-pay/src/main/java/cn/iocoder/yudao/module/pay/framework/pay/core/client/impl/alipay/AbstractAlipayPayClient.java
yudao-module-pay/src/main/java/cn/iocoder/yudao/module/pay/framework/pay/core/client/impl/alipay/AlipayBarPayClient.java
yudao-module-pay/src/main/java/cn/iocoder/yudao/module/pay/framework/pay/core/client/impl/mock/MockPayClient.java
yudao-module-pay/src/main/java/cn/iocoder/yudao/module/pay/framework/pay/core/client/impl/wallet/WalletPayClient.java
yudao-module-pay/src/main/java/cn/iocoder/yudao/module/pay/framework/pay/core/client/impl/weixin/AbstractWxPayClient.java
yudao-module-pay/src/main/java/cn/iocoder/yudao/module/pay/service/order/PayOrderService.java
yudao-module-pay/src/main/java/cn/iocoder/yudao/module/pay/service/order/PayOrderServiceImpl.java
yudao-module-pay/src/test/java/cn/iocoder/yudao/module/pay/framework/pay/core/client/impl/alipay/AlipayPcPayClientTest.java
yudao-module-pay/src/test/java/cn/iocoder/yudao/module/pay/service/order/PayOrderServiceTest.java
@@ -13,6 +13,7 @@ import cn.hutool.extra.spring.SpringUtil;
 import cn.iocoder.yudao.framework.common.enums.UserTypeEnum;
 import cn.iocoder.yudao.framework.common.util.json.JsonUtils;
 import cn.iocoder.yudao.framework.common.util.number.MoneyUtils;
+import cn.iocoder.yudao.framework.common.util.object.ObjectUtils;
 import cn.iocoder.yudao.module.member.api.address.MemberAddressApi;
 import cn.iocoder.yudao.module.member.api.address.dto.MemberAddressRespDTO;
 import cn.iocoder.yudao.module.pay.api.order.PayOrderApi;
@@ -68,6 +69,8 @@ import lombok.extern.slf4j.Slf4j;
 import org.springframework.scheduling.annotation.Async;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
+import org.springframework.transaction.support.TransactionSynchronization;
+import org.springframework.transaction.support.TransactionSynchronizationManager;
 import java.time.LocalDateTime;
 import java.util.ArrayList;
@@ -639,6 +642,49 @@ public class TradeOrderUpdateServiceImpl implements TradeOrderUpdateService {
         // 3. 增加订单日志
         TradeOrderLogUtils.setOrderInfo(order.getId(), order.getStatus(), TradeOrderStatusEnum.CANCELED.getStatus());
+
+        // 4. 关闭支付单
+        closePayOrder(order.getId(), order.getPayOrderId(), cancelType);
+    }
+
+    /**
+     * 注册事务提交后的支付单关闭任务
+     *
+     * @param orderId    交易订单编号
+     * @param payOrderId 支付订单编号
+     * @param cancelType 订单取消类型
+     */
+    private void closePayOrder(Long orderId, Long payOrderId, TradeOrderCancelTypeEnum cancelType) {
+        if (!ObjectUtils.equalsAny(cancelType, TradeOrderCancelTypeEnum.MEMBER_CANCEL,
+                TradeOrderCancelTypeEnum.PAY_TIMEOUT)
+                || payOrderId == null || !TransactionSynchronizationManager.isSynchronizationActive()) {
+            return;
+        }
+        // 必须在事务提交后，再关闭支付单，避免交易事务回滚后支付单已经关闭
+        TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
+
+            @Override
+            public void afterCommit() {
+                // 异步的原因：避免阻塞当前事务，无需等待结果
+                getSelf().closePayOrderAsync(orderId, payOrderId);
+            }
+
+        });
+    }
+
+    /**
+     * 异步关闭订单关联的支付单
+     *
+     * @param orderId    交易订单编号
+     * @param payOrderId 支付订单编号
+     */
+    @Async
+    public void closePayOrderAsync(Long orderId, Long payOrderId) {
+        try {
+            payOrderApi.closeOrder(payOrderId);
+        } catch (Throwable e) {
+            log.error("[closePayOrderAsync][order({}) payOrder({}) 异步关闭支付单失败]", orderId, payOrderId, e);
+        }
     }
     /**
@@ -30,6 +30,13 @@ public interface PayOrderApi {
     PayOrderRespDTO getOrder(Long id);
     /**
+     * 关闭支付单
+     *
+     * @param id 支付单编号
+     */
+    void closeOrder(Long id);
+
+    /**
      * 更新支付订单价格
      *
      * @param id 支付单编号
@@ -32,6 +32,11 @@ public class PayOrderApiImpl implements PayOrderApi {
     }
     @Override
+    public void closeOrder(Long id) {
+        payOrderService.closeOrder(id);
+    }
+
+    @Override
     public void updatePayOrderPrice(Long id, Integer payPrice) {
         payOrderService.updatePayOrderPrice(id, payPrice);
     }
@@ -58,6 +58,14 @@ public interface PayClient&lt;Config&gt; {
      */
     PayOrderRespDTO getOrder(String outTradeNo);
+    /**
+     * 关闭支付订单
+     *
+     * @param outTradeNo 外部订单号
+     * @return 关闭结果
+     */
+    PayOrderRespDTO closeOrder(String outTradeNo);
+
     // ============ 退款相关 ==========
     /**
@@ -134,6 +134,23 @@ public abstract class AbstractPayClient&lt;Config extends PayClientConfig&gt; implemen
     protected abstract PayOrderRespDTO doGetOrder(String outTradeNo)
             throws Throwable;
+    @Override
+    public final PayOrderRespDTO closeOrder(String outTradeNo) {
+        try {
+            return doCloseOrder(outTradeNo);
+        } catch (ServiceException ex) { // 业务异常，都是实现类已经翻译，所以直接抛出即可
+            throw ex;
+        } catch (Throwable ex) {
+            // 系统异常，则包装成 PayException 异常抛出
+            log.error("[closeOrder][客户端({}) outTradeNo({}) 关闭支付单异常]",
+                    getId(), outTradeNo, ex);
+            throw buildPayException(ex);
+        }
+    }
+
+    protected abstract PayOrderRespDTO doCloseOrder(String outTradeNo)
+            throws Throwable;
+
     // ============ 退款相关 ==========
     @Override
@@ -51,6 +51,11 @@ import static cn.iocoder.yudao.module.pay.framework.pay.core.client.impl.alipay.
 @Slf4j
 public abstract class AbstractAlipayPayClient extends AbstractPayClient<AlipayPayClientConfig> {
+    /**
+     * 支付宝接口调用成功的响应码
+     */
+    protected static final String ALIPAY_SUCCESS_CODE = "10000";
+
     @Getter // 仅用于单测场景
     protected DefaultAlipayClient client;
@@ -117,9 +122,13 @@ public abstract class AbstractAlipayPayClient extends AbstractPayClient&lt;AlipayPa
         } else {
             response = client.execute(request);
         }
-        if (!response.isSuccess()) { // 不成功，例如说订单不存在
-            return PayOrderRespDTO.closedOf(response.getSubCode(), response.getSubMsg(),
-                    outTradeNo, response);
+        if (!isSuccessResponse(response)) {
+            // 只有明确不存在时才关闭，系统异常等情况需要继续等待后续查询
+            if (ObjectUtils.equalsAny(response.getSubCode(), "TRADE_NOT_EXIST", "ACQ.TRADE_NOT_EXIST")) {
+                return PayOrderRespDTO.closedOf(response.getSubCode(), response.getSubMsg(),
+                        outTradeNo, response);
+            }
+            return PayOrderRespDTO.waitingOf(null, null, outTradeNo, response);
         }
         // 2.2 解析订单的状态
         Integer status = parseStatus(response.getTradeStatus());
@@ -130,6 +139,30 @@ public abstract class AbstractAlipayPayClient extends AbstractPayClient&lt;AlipayPa
                 outTradeNo, response);
     }
+    @Override
+    protected PayOrderRespDTO doCloseOrder(String outTradeNo) throws Throwable {
+        // 1.1 构建 AlipayTradeCloseModel 请求
+        AlipayTradeCloseModel model = new AlipayTradeCloseModel();
+        model.setOutTradeNo(outTradeNo);
+        // 1.2 构建 AlipayTradeCloseRequest 请求
+        AlipayTradeCloseRequest request = new AlipayTradeCloseRequest();
+        request.setBizModel(model);
+
+        // 2.1 执行请求
+        AlipayTradeCloseResponse response;
+        if (Objects.equals(config.getMode(), MODE_CERTIFICATE)) {
+            response = client.certificateExecute(request);
+        } else {
+            response = client.execute(request);
+        }
+        if (!isSuccessResponse(response)) {
+            // 关闭失败可能是订单已支付，重新查询保留真实支付事实
+            return doGetOrder(outTradeNo);
+        }
+        // 2.2 创建返回结果
+        return PayOrderRespDTO.closedOf(null, null, outTradeNo, response);
+    }
+
     private static Integer parseStatus(String tradeStatus) {
         return Objects.equals("WAIT_BUYER_PAY", tradeStatus) ? PayOrderStatusEnum.WAITING.getStatus()
                 : ObjectUtils.equalsAny(tradeStatus, "TRADE_FINISHED", "TRADE_SUCCESS") ? PayOrderStatusEnum.SUCCESS.getStatus()
@@ -372,6 +405,16 @@ public abstract class AbstractAlipayPayClient extends AbstractPayClient&lt;AlipayPa
     // ========== 各种工具方法 ==========
+    /**
+     * 判断支付宝接口是否调用成功
+     *
+     * @param response 响应
+     * @return 是否调用成功
+     */
+    protected static boolean isSuccessResponse(AlipayResponse response) {
+        return ALIPAY_SUCCESS_CODE.equals(response.getCode());
+    }
+
     protected String formatAmount(Integer amount) {
         return String.valueOf(amount / 100.0);
     }
@@ -72,7 +72,7 @@ public class AlipayBarPayClient extends AbstractAlipayPayClient {
         if (!response.isSuccess()) {
             return buildClosedPayOrderRespDTO(reqDTO, response);
         }
-        if ("10000".equals(response.getCode())) { // 免密支付
+        if (isSuccessResponse(response)) { // 免密支付
             LocalDateTime successTime = LocalDateTimeUtil.of(response.getGmtPayment());
             return PayOrderRespDTO.successOf(response.getTradeNo(), response.getBuyerUserId(), successTime,
                             response.getOutTradeNo(), response)
@@ -45,6 +45,11 @@ public class MockPayClient extends AbstractPayClient&lt;NonePayClientConfig&gt; {
     }
     @Override
+    protected PayOrderRespDTO doCloseOrder(String outTradeNo) {
+        return PayOrderRespDTO.closedOf(null, null, outTradeNo, MOCK_RESP_SUCCESS_DATA);
+    }
+
+    @Override
     protected PayRefundRespDTO doUnifiedRefund(PayRefundUnifiedReqDTO reqDTO) {
         return PayRefundRespDTO.successOf("MOCK-R-" + reqDTO.getOutRefundNo(), LocalDateTime.now(),
                 reqDTO.getOutRefundNo(), MOCK_RESP_SUCCESS_DATA);
@@ -125,6 +125,27 @@ public class WalletPayClient extends AbstractPayClient&lt;NonePayClientConfig&gt; {
     }
     @Override
+    protected PayOrderRespDTO doCloseOrder(String outTradeNo) {
+        if (orderService == null) {
+            orderService = SpringUtil.getBean(PayOrderService.class);
+        }
+        // 待支付状态：钱包支付为同步扣款，没有渠道侧的待支付单，所以以钱包流水判断是否已扣款
+        // 补充说明：存在扣款成功，但是 notifyOrder 更新支付拓展单失败的情况，此时不能直接关闭
+        PayOrderExtensionDO orderExtension = orderService.getOrderExtensionByNo(outTradeNo);
+        if (orderExtension != null && PayOrderStatusEnum.isWaiting(orderExtension.getStatus())) {
+            PayWalletTransactionDO walletTransaction = walletTransactionService.getWalletTransaction(
+                    String.valueOf(orderExtension.getOrderId()), PayWalletBizTypeEnum.PAYMENT);
+            if (walletTransaction == null) {
+                return PayOrderRespDTO.closedOf(null, null, outTradeNo, "");
+            }
+            return PayOrderRespDTO.successOf(walletTransaction.getNo(), walletTransaction.getCreator(),
+                    walletTransaction.getCreateTime(), outTradeNo, walletTransaction);
+        }
+        // 其它状态：以本地支付状态为准
+        return doGetOrder(outTradeNo);
+    }
+
+    @Override
     @SuppressWarnings("PatternVariableCanBeUsed")
     protected PayRefundRespDTO doUnifiedRefund(PayRefundUnifiedReqDTO reqDTO) {
         try {
@@ -216,6 +216,27 @@ public abstract class AbstractWxPayClient extends AbstractPayClient&lt;WxPayClientC
         }
     }
+    @Override
+    protected PayOrderRespDTO doCloseOrder(String outTradeNo) throws Throwable {
+        try {
+            switch (config.getApiVersion()) {
+                case API_VERSION_V2:
+                    client.closeOrder(WxPayOrderCloseRequest.newBuilder().outTradeNo(outTradeNo).build());
+                    break;
+                case API_VERSION_V3:
+                    client.closeOrderV3(new WxPayOrderCloseV3Request()
+                            .setMchid(config.getMchId()).setOutTradeNo(outTradeNo));
+                    break;
+                default:
+                    throw new IllegalArgumentException(String.format("未知的 API 版本(%s)", config.getApiVersion()));
+            }
+            return PayOrderRespDTO.closedOf(null, null, outTradeNo, null);
+        } catch (WxPayException e) {
+            // 关闭失败时查询真实支付状态，避免遗漏已支付事实
+            return doGetOrder(outTradeNo);
+        }
+    }
+
     private PayOrderRespDTO doGetOrderV2(String outTradeNo) throws WxPayException {
         // 构建 WxPayUnifiedOrderRequest 对象
         WxPayOrderQueryRequest request = WxPayOrderQueryRequest.newBuilder()
@@ -164,4 +164,11 @@ public interface PayOrderService {
      */
     int expireOrder();
+    /**
+     * 关闭支付订单
+     *
+     * @param id 支付单编号
+     */
+    void closeOrder(Long id);
+
 }
@@ -598,6 +598,72 @@ public class PayOrderServiceImpl implements PayOrderService {
         }
     }
+    @Override
+    public void closeOrder(Long id) {
+        PayOrderDO order = orderMapper.selectById(id);
+        if (order == null || PayOrderStatusEnum.isClosed(order.getStatus())
+                || PayOrderStatusEnum.isRefund(order.getStatus())) {
+            return;
+        }
+        if (PayOrderStatusEnum.isSuccess(order.getStatus())) {
+            log.error("[closeOrder][order({}) 已支付，订单业务可能已取消，需要人工退款]", id);
+            return;
+        }
+        try {
+            // 1. 逐个关闭支付拓展单，避免遗漏重复支付尝试
+            List<PayOrderExtensionDO> extensions = orderExtensionMapper.selectListByOrderId(id);
+            for (PayOrderExtensionDO extension : extensions) {
+                if (PayOrderStatusEnum.isClosed(extension.getStatus())) {
+                    continue;
+                }
+                if (PayOrderStatusEnum.isSuccess(extension.getStatus())) {
+                    log.error("[closeOrder][order({}) extension({}) 已支付，订单业务可能已取消，需要人工退款]",
+                            id, extension.getId());
+                    return;
+                }
+                if (!PayOrderStatusEnum.isWaiting(extension.getStatus())) {
+                    continue;
+                }
+                PayClient<?> client = channelService.getPayClient(extension.getChannelId());
+                if (client == null) {
+                    log.error("[closeOrder][order({}) extension({}) 渠道({})不存在]",
+                            id, extension.getId(), extension.getChannelId());
+                    return;
+                }
+                // 1.1 调用渠道关单，已支付结果由渠道客户端转换并保留
+                PayOrderRespDTO respDTO = client.closeOrder(extension.getNo());
+                if (PayOrderStatusEnum.isSuccess(respDTO.getStatus())) {
+                    notifyOrder(extension.getChannelId(), respDTO);
+                    log.error("[closeOrder][order({}) extension({}) 查询发现已支付]", id, extension.getId());
+                    return;
+                }
+                if (!PayOrderStatusEnum.isClosed(respDTO.getStatus())) {
+                    log.warn("[closeOrder][order({}) extension({}) 渠道状态({})，暂不关闭本地支付单]",
+                            id, extension.getId(), respDTO.getStatus());
+                    return;
+                }
+                // 1.2 更新 PayOrderExtensionDO 状态
+                PayOrderExtensionDO updateObj = new PayOrderExtensionDO()
+                        .setStatus(PayOrderStatusEnum.CLOSED.getStatus())
+                        .setChannelErrorCode(respDTO.getChannelErrorCode())
+                        .setChannelErrorMsg(respDTO.getChannelErrorMsg())
+                        .setChannelNotifyData(toJsonString(respDTO));
+                if (orderExtensionMapper.updateByIdAndStatus(extension.getId(),
+                        PayOrderStatusEnum.WAITING.getStatus(), updateObj) == 0) {
+                    log.error("[closeOrder][order({}) extension({}) 更新为支付关闭失败]", id, extension.getId());
+                    return;
+                }
+            }
+            // 2. 所有支付拓展单都关闭后，再关闭支付主单
+            if (orderMapper.updateByIdAndStatus(id, PayOrderStatusEnum.WAITING.getStatus(),
+                    new PayOrderDO().setStatus(PayOrderStatusEnum.CLOSED.getStatus())) == 0) {
+                log.error("[closeOrder][order({}) 更新为支付关闭失败]", id);
+            }
+        } catch (Throwable e) {
+            log.error("[closeOrder][order({}) 关闭支付单异常]", id, e);
+        }
+    }
+
     /**
      * 获得自身的代理对象，解决 AOP 生效问题
      *
@@ -5,8 +5,12 @@ import cn.iocoder.yudao.module.pay.framework.pay.core.client.dto.order.PayOrderR
 import cn.iocoder.yudao.module.pay.framework.pay.core.client.dto.order.PayOrderUnifiedReqDTO;
 import cn.iocoder.yudao.module.pay.framework.pay.core.enums.PayOrderDisplayModeEnum;
 import com.alipay.api.AlipayApiException;
+import com.alipay.api.request.AlipayTradeCloseRequest;
 import com.alipay.api.request.AlipayTradePagePayRequest;
+import com.alipay.api.request.AlipayTradeQueryRequest;
+import com.alipay.api.response.AlipayTradeCloseResponse;
 import com.alipay.api.response.AlipayTradePagePayResponse;
+import com.alipay.api.response.AlipayTradeQueryResponse;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
@@ -18,6 +22,7 @@ import static cn.iocoder.yudao.module.pay.enums.order.PayOrderStatusEnum.WAITING
 import static cn.iocoder.yudao.framework.test.core.util.RandomUtils.*;
 import static org.junit.jupiter.api.Assertions.*;
 import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.argThat;
 import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.when;
@@ -128,4 +133,78 @@ public class AlipayPcPayClientTest extends AbstractAlipayClientTest {
         assertEquals(subMsg, resp.getChannelErrorMsg());
     }
+    @Test
+    @DisplayName("支付宝 PC 网站支付：关单成功")
+    public void testCloseOrder_success() throws AlipayApiException {
+        // mock 方法
+        AlipayTradeCloseResponse response = randomPojo(AlipayTradeCloseResponse.class, o -> {
+            o.setCode(AbstractAlipayPayClient.ALIPAY_SUCCESS_CODE);
+            o.setSubCode("");
+        });
+        when(defaultAlipayClient.execute(any(AlipayTradeCloseRequest.class))).thenReturn(response);
+        // 准备请求参数
+        String outTradeNo = randomString();
+
+        // 调用
+        PayOrderRespDTO resp = client.closeOrder(outTradeNo);
+        // 断言
+        assertEquals(CLOSED.getStatus(), resp.getStatus());
+        assertEquals(outTradeNo, resp.getOutTradeNo());
+        assertSame(response, resp.getRawData());
+    }
+
+    @Test
+    @DisplayName("支付宝 PC 网站支付：关单时交易不存在，查询后关闭")
+    public void testCloseOrder_tradeNotExist() throws AlipayApiException {
+        // mock 方法（关单）
+        AlipayTradeCloseResponse closeResponse = randomPojo(AlipayTradeCloseResponse.class, o -> {
+            o.setCode("40004");
+            o.setSubCode("ACQ.TRADE_NOT_EXIST");
+        });
+        when(defaultAlipayClient.execute(any(AlipayTradeCloseRequest.class))).thenReturn(closeResponse);
+        // mock 方法（查询）
+        AlipayTradeQueryResponse queryResponse = randomPojo(AlipayTradeQueryResponse.class, o -> {
+            o.setCode("40004");
+            o.setSubCode("ACQ.TRADE_NOT_EXIST");
+        });
+        when(defaultAlipayClient.execute(any(AlipayTradeQueryRequest.class))).thenReturn(queryResponse);
+        // 准备请求参数
+        String outTradeNo = randomString();
+
+        // 调用
+        PayOrderRespDTO resp = client.closeOrder(outTradeNo);
+        // 断言
+        assertEquals(CLOSED.getStatus(), resp.getStatus());
+        assertEquals(outTradeNo, resp.getOutTradeNo());
+        assertSame(queryResponse, resp.getRawData());
+        assertEquals(queryResponse.getSubCode(), resp.getChannelErrorCode());
+        assertEquals(queryResponse.getSubMsg(), resp.getChannelErrorMsg());
+    }
+
+    @Test
+    @DisplayName("支付宝 PC 网站支付：关单系统异常，保持待支付")
+    public void testCloseOrder_systemError() throws AlipayApiException {
+        // mock 方法（关单）
+        AlipayTradeCloseResponse closeResponse = randomPojo(AlipayTradeCloseResponse.class, o -> {
+            o.setCode("40004");
+            o.setSubCode("ACQ.SYSTEM_ERROR");
+        });
+        when(defaultAlipayClient.execute(any(AlipayTradeCloseRequest.class))).thenReturn(closeResponse);
+        // mock 方法（查询）
+        AlipayTradeQueryResponse queryResponse = randomPojo(AlipayTradeQueryResponse.class, o -> {
+            o.setCode("40004");
+            o.setSubCode("ACQ.SYSTEM_ERROR");
+        });
+        when(defaultAlipayClient.execute(any(AlipayTradeQueryRequest.class))).thenReturn(queryResponse);
+        // 准备请求参数
+        String outTradeNo = randomString();
+
+        // 调用
+        PayOrderRespDTO resp = client.closeOrder(outTradeNo);
+        // 断言：系统异常时，不能误关闭支付单
+        assertEquals(WAITING.getStatus(), resp.getStatus());
+        assertEquals(outTradeNo, resp.getOutTradeNo());
+        assertSame(queryResponse, resp.getRawData());
+    }
+
 }
@@ -1105,4 +1105,141 @@ public class PayOrderServiceTest extends BaseDbAndRedisUnitTest {
                 "updateTime", "updater");
     }
+    @Test
+    public void testCloseOrder_orderExtension_isSuccess() {
+        // mock 数据（PayOrderDO）
+        PayOrderDO order = randomPojo(PayOrderDO.class,
+                o -> o.setStatus(PayOrderStatusEnum.WAITING.getStatus()));
+        orderMapper.insert(order);
+        // mock 数据（PayOrderExtensionDO 已支付）
+        PayOrderExtensionDO orderExtension = randomPojo(PayOrderExtensionDO.class,
+                o -> o.setStatus(PayOrderStatusEnum.SUCCESS.getStatus())
+                        .setOrderId(order.getId()));
+        orderExtensionMapper.insert(orderExtension);
+
+        // 调用
+        orderService.closeOrder(order.getId());
+        // 断言 order 没有变化，因为没更新
+        assertPojoEquals(order, orderMapper.selectOne(null));
+    }
+
+    @Test
+    public void testCloseOrder_payClient_notFound() {
+        // mock 数据（PayOrderDO）
+        PayOrderDO order = randomPojo(PayOrderDO.class,
+                o -> o.setStatus(PayOrderStatusEnum.WAITING.getStatus()));
+        orderMapper.insert(order);
+        // mock 数据（PayOrderExtensionDO 等待中）
+        PayOrderExtensionDO orderExtension = randomPojo(PayOrderExtensionDO.class,
+                o -> o.setStatus(PayOrderStatusEnum.WAITING.getStatus())
+                        .setOrderId(order.getId())
+                        .setChannelId(10L));
+        orderExtensionMapper.insert(orderExtension);
+
+        // 调用
+        orderService.closeOrder(order.getId());
+        // 断言 order、extension 没有变化，因为没更新
+        assertPojoEquals(order, orderMapper.selectOne(null));
+        assertPojoEquals(orderExtension, orderExtensionMapper.selectOne(null));
+    }
+
+    @Test
+    public void testCloseOrder_closeOrder_isWaiting() {
+        // mock 数据（PayOrderDO）
+        PayOrderDO order = randomPojo(PayOrderDO.class,
+                o -> o.setStatus(PayOrderStatusEnum.WAITING.getStatus()));
+        orderMapper.insert(order);
+        // mock 数据（PayOrderExtensionDO 等待中）
+        PayOrderExtensionDO orderExtension = randomPojo(PayOrderExtensionDO.class,
+                o -> o.setStatus(PayOrderStatusEnum.WAITING.getStatus())
+                        .setOrderId(order.getId()).setNo("P110")
+                        .setChannelId(10L));
+        orderExtensionMapper.insert(orderExtension);
+        // mock 方法（PayClient）
+        PayClient<?> client = mock(PayClient.class);
+        when(channelService.getPayClient(eq(10L))).thenReturn(client);
+        // mock 方法（PayClient 等待返回，例如说渠道系统异常）
+        PayOrderRespDTO respDTO = randomPojo(PayOrderRespDTO.class,
+                o -> o.setStatus(PayOrderStatusEnum.WAITING.getStatus()));
+        when(client.closeOrder(eq("P110"))).thenReturn(respDTO);
+
+        // 调用
+        orderService.closeOrder(order.getId());
+        // 断言 order、extension 没有变化，因为没更新
+        assertPojoEquals(order, orderMapper.selectOne(null));
+        assertPojoEquals(orderExtension, orderExtensionMapper.selectOne(null));
+    }
+
+    @Test
+    public void testCloseOrder_closeOrder_isSuccess() {
+        PayOrderServiceImpl payOrderServiceImpl = mock(PayOrderServiceImpl.class);
+        try (MockedStatic<SpringUtil> springUtilMockedStatic = mockStatic(SpringUtil.class)) {
+            springUtilMockedStatic.when(() -> SpringUtil.getBean(eq(PayOrderServiceImpl.class)))
+                    .thenReturn(payOrderServiceImpl);
+
+            // mock 数据（PayOrderDO）
+            PayOrderDO order = randomPojo(PayOrderDO.class,
+                    o -> o.setStatus(PayOrderStatusEnum.WAITING.getStatus()));
+            orderMapper.insert(order);
+            // mock 数据（PayOrderExtensionDO 等待中）
+            PayOrderExtensionDO orderExtension = randomPojo(PayOrderExtensionDO.class,
+                    o -> o.setStatus(PayOrderStatusEnum.WAITING.getStatus())
+                            .setOrderId(order.getId()).setNo("P110")
+                            .setChannelId(10L));
+            orderExtensionMapper.insert(orderExtension);
+            // mock 方法（PayClient）
+            PayClient<?> client = mock(PayClient.class);
+            when(channelService.getPayClient(eq(10L))).thenReturn(client);
+            // mock 方法（PayClient 成功返回）
+            PayOrderRespDTO respDTO = randomPojo(PayOrderRespDTO.class,
+                    o -> o.setStatus(PayOrderStatusEnum.SUCCESS.getStatus()));
+            when(client.closeOrder(eq("P110"))).thenReturn(respDTO);
+            // mock 方法（PayChannelDO）
+            PayChannelDO channel = randomPojo(PayChannelDO.class, o -> o.setId(10L));
+            when(channelService.validPayChannel(eq(10L))).thenReturn(channel);
+
+            // 调用
+            orderService.closeOrder(order.getId());
+            // 断言 order、extension 没有变化，因为没更新
+            assertPojoEquals(order, orderMapper.selectOne(null));
+            assertPojoEquals(orderExtension, orderExtensionMapper.selectOne(null));
+            verify(payOrderServiceImpl).notifyOrder(same(channel), same(respDTO));
+        }
+    }
+
+    @Test
+    public void testCloseOrder_success() {
+        // mock 数据（PayOrderDO）
+        PayOrderDO order = randomPojo(PayOrderDO.class,
+                o -> o.setStatus(PayOrderStatusEnum.WAITING.getStatus()));
+        orderMapper.insert(order);
+        // mock 数据（PayOrderExtensionDO 等待中）
+        PayOrderExtensionDO orderExtension = randomPojo(PayOrderExtensionDO.class,
+                o -> o.setStatus(PayOrderStatusEnum.WAITING.getStatus())
+                        .setOrderId(order.getId()).setNo("P110")
+                        .setChannelId(10L));
+        orderExtensionMapper.insert(orderExtension);
+        // mock 方法（PayClient）
+        PayClient<?> client = mock(PayClient.class);
+        when(channelService.getPayClient(eq(10L))).thenReturn(client);
+        // mock 方法（PayClient 关闭返回）
+        PayOrderRespDTO respDTO = randomPojo(PayOrderRespDTO.class,
+                o -> o.setStatus(PayOrderStatusEnum.CLOSED.getStatus()));
+        when(client.closeOrder(eq("P110"))).thenReturn(respDTO);
+
+        // 调用
+        orderService.closeOrder(order.getId());
+        // 断言 extension 变化
+        orderExtension.setStatus(PayOrderStatusEnum.CLOSED.getStatus())
+                .setChannelErrorCode(respDTO.getChannelErrorCode())
+                .setChannelErrorMsg(respDTO.getChannelErrorMsg())
+                .setChannelNotifyData(toJsonString(respDTO));
+        assertPojoEquals(orderExtension, orderExtensionMapper.selectOne(null),
+                "updateTime", "updater");
+        // 断言 order 变化
+        order.setStatus(PayOrderStatusEnum.CLOSED.getStatus());
+        assertPojoEquals(order, orderMapper.selectOne(null),
+                "updateTime", "updater");
+    }
+
 }