fix(pay): 收敛退款转账并发与待确认状态

YunaiV
1 parent 8dc18cb4
Showing 16 changed files with 1606 additions and 80 deletions
yudao-module-pay/src/main/java/cn/iocoder/yudao/module/pay/api/refund/PayRefundApi.java
yudao-module-pay/src/main/java/cn/iocoder/yudao/module/pay/api/transfer/PayTransferApi.java
yudao-module-pay/src/main/java/cn/iocoder/yudao/module/pay/dal/mysql/refund/PayRefundMapper.java
yudao-module-pay/src/main/java/cn/iocoder/yudao/module/pay/dal/mysql/transfer/PayTransferMapper.java
yudao-module-pay/src/main/java/cn/iocoder/yudao/module/pay/dal/redis/RedisKeyConstants.java
yudao-module-pay/src/main/java/cn/iocoder/yudao/module/pay/dal/redis/refund/PayRefundLockRedisDAO.java
yudao-module-pay/src/main/java/cn/iocoder/yudao/module/pay/dal/redis/transfer/PayTransferLockRedisDAO.java
yudao-module-pay/src/main/java/cn/iocoder/yudao/module/pay/enums/ErrorCodeConstants.java
yudao-module-pay/src/main/java/cn/iocoder/yudao/module/pay/service/refund/PayRefundServiceImpl.java
yudao-module-pay/src/main/java/cn/iocoder/yudao/module/pay/service/transfer/PayTransferServiceImpl.java
yudao-module-pay/src/main/java/cn/iocoder/yudao/module/pay/service/wallet/PayWalletServiceImpl.java
yudao-module-pay/src/test/java/cn/iocoder/yudao/module/pay/service/refund/PayRefundServiceTest.java
yudao-module-pay/src/test/java/cn/iocoder/yudao/module/pay/service/transfer/PayTransferServiceTest.java
yudao-module-pay/src/test/java/cn/iocoder/yudao/module/pay/service/wallet/PayWalletServiceTest.java
yudao-module-pay/src/test/resources/sql/clean.sql
yudao-module-pay/src/test/resources/sql/create_tables.sql
@@ -15,6 +15,9 @@ public interface PayRefundApi {
     /**
      * 创建退款单
      *
+     * 注意：不加入调用方的事务，退款单、退款结果（包括退款通知）独立提交，调用方的事务回滚时不会回滚。
+     * 调用方需要使用相同的 merchantRefundId 重新发起，并通过退款通知处理最终结果；渠道明确失败时，会抛出渠道错误的业务异常
+     *
      * @param reqDTO 创建请求
      * @return 退款单编号
      */
@@ -15,6 +15,9 @@ public interface PayTransferApi {
     /**
      * 创建转账单
      *
+     * 注意：不加入调用方的事务，转账单、转账结果（包括转账通知）独立提交，调用方的事务回滚时不会回滚。
+     * 调用方需要使用相同的 merchantTransferId 重新发起，并通过转账通知处理最终结果；渠道明确失败时，会抛出渠道错误的业务异常
+     *
      * @param reqDTO 创建请求
      * @return 创建结果
      */
@@ -7,6 +7,7 @@ import cn.iocoder.yudao.module.pay.controller.admin.refund.vo.PayRefundExportReq
 import cn.iocoder.yudao.module.pay.controller.admin.refund.vo.PayRefundPageReqVO;
 import cn.iocoder.yudao.module.pay.dal.dataobject.refund.PayRefundDO;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
 import org.apache.ibatis.annotations.Mapper;
 import java.util.List;
@@ -46,6 +47,24 @@ public interface PayRefundMapper extends BaseMapperX&lt;PayRefundDO&gt; {
                 .eq(PayRefundDO::getId, id).eq(PayRefundDO::getStatus, status));
     }
+    /**
+     * 更新退款单，并清空上一次退款的渠道结果
+     *
+     * 用于退款失败后重新发起退款，避免新的退款结果残留上一次的失败原因、渠道退款单号等
+     *
+     * @param id 退款单编号
+     * @param status 原状态
+     * @param update 更新对象
+     * @return 更新数量
+     */
+    default int updateByIdAndStatusAndClearChannelResult(Long id, Integer status, PayRefundDO update) {
+        return update(update, new LambdaUpdateWrapper<PayRefundDO>()
+                .eq(PayRefundDO::getId, id).eq(PayRefundDO::getStatus, status)
+                .set(PayRefundDO::getChannelRefundNo, null).set(PayRefundDO::getSuccessTime, null)
+                .set(PayRefundDO::getChannelErrorCode, null).set(PayRefundDO::getChannelErrorMsg, null)
+                .set(PayRefundDO::getChannelNotifyData, null));
+    }
+
     default PageResult<PayRefundDO> selectPage(PayRefundPageReqVO reqVO) {
         return selectPage(reqVO, new LambdaQueryWrapperX<PayRefundDO>()
                 .eqIfPresent(PayRefundDO::getAppId, reqVO.getAppId())
@@ -6,6 +6,7 @@ import cn.iocoder.yudao.framework.mybatis.core.query.LambdaQueryWrapperX;
 import cn.iocoder.yudao.module.pay.controller.admin.transfer.vo.PayTransferPageReqVO;
 import cn.iocoder.yudao.module.pay.dal.dataobject.transfer.PayTransferDO;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
 import org.apache.ibatis.annotations.Mapper;
 import java.util.Collection;
@@ -26,6 +27,28 @@ public interface PayTransferMapper extends BaseMapperX&lt;PayTransferDO&gt; {
                 .eq(PayTransferDO::getStatus, whereStatus));
     }
+    /**
+     * 更新转账单，并清空上一次转账的渠道结果
+     *
+     * 用于转账关闭后重新发起转账，避免新的转账残留上一次的失败原因、渠道转账单号、确认收款 package 信息等
+     * 特殊：本次请求没有传递的可选字段（收款人姓名、渠道额外参数、回调地址），也需要清空。原因是：MyBatis Plus 更新时会忽略为 null 的字段
+     *
+     * @param id 转账单编号
+     * @param whereStatus 原状态
+     * @param updateObj 更新对象
+     * @return 更新数量
+     */
+    default int updateByIdAndStatusAndClearChannelResult(Long id, Integer whereStatus, PayTransferDO updateObj) {
+        return update(updateObj, new LambdaUpdateWrapper<PayTransferDO>()
+                .eq(PayTransferDO::getId, id).eq(PayTransferDO::getStatus, whereStatus)
+                .set(PayTransferDO::getChannelTransferNo, null).set(PayTransferDO::getSuccessTime, null)
+                .set(PayTransferDO::getChannelErrorCode, null).set(PayTransferDO::getChannelErrorMsg, null)
+                .set(PayTransferDO::getChannelNotifyData, null).set(PayTransferDO::getChannelPackageInfo, null)
+                .set(updateObj.getUserName() == null, PayTransferDO::getUserName, null)
+                .set(updateObj.getChannelExtras() == null, PayTransferDO::getChannelExtras, null)
+                .set(updateObj.getNotifyUrl() == null, PayTransferDO::getNotifyUrl, null));
+    }
+
     default int updateChannelPackageInfoIfAbsent(Long id, String channelPackageInfo) {
         return update(new PayTransferDO().setChannelPackageInfo(channelPackageInfo),
                 new LambdaQueryWrapper<PayTransferDO>()
@@ -26,6 +26,24 @@ public interface RedisKeyConstants {
     String PAY_WALLET_LOCK = "pay_wallet:lock:%d";
     /**
+     * 退款单创建的分布式锁
+     *
+     * KEY 格式：pay_refund:lock:%d // 参数为支付订单编号
+     * VALUE 数据格式：HASH // RLock.class：Redisson 的 Lock 锁，使用 Hash 数据结构
+     * 过期时间：不固定
+     */
+    String PAY_REFUND_LOCK = "pay_refund:lock:%d";
+
+    /**
+     * 转账单创建的分布式锁
+     *
+     * KEY 格式：pay_transfer:lock:%d:%s // 参数为应用编号、商户转账单编号
+     * VALUE 数据格式：HASH // RLock.class：Redisson 的 Lock 锁，使用 Hash 数据结构
+     * 过期时间：不固定
+     */
+    String PAY_TRANSFER_LOCK = "pay_transfer:lock:%d:%s";
+
+    /**
      * 支付序号的缓存
      *
      * KEY 格式：pay_no:{prefix}
+package cn.iocoder.yudao.module.pay.dal.redis.refund;
+
+import jakarta.annotation.Resource;
+import org.redisson.api.RLock;
+import org.redisson.api.RedissonClient;
+import org.springframework.stereotype.Repository;
+
+import java.util.concurrent.TimeUnit;
+import java.util.function.Supplier;
+
+import static cn.iocoder.yudao.module.pay.dal.redis.RedisKeyConstants.PAY_REFUND_LOCK;
+
+/**
+ * 支付退款的锁 Redis DAO
+ *
+ * @author HUIHUI
+ */
+@Repository
+public class PayRefundLockRedisDAO {
+
+    @Resource
+    private RedissonClient redissonClient;
+
+    public <V> V lock(Long orderId, Long timeoutMillis, Supplier<V> supplier) {
+        String lockKey = formatKey(orderId);
+        RLock lock = redissonClient.getLock(lockKey);
+        try {
+            lock.lock(timeoutMillis, TimeUnit.MILLISECONDS);
+            // 执行逻辑
+            return supplier.get();
+        } finally {
+            lock.unlock();
+        }
+    }
+
+    private static String formatKey(Long orderId) {
+        return String.format(PAY_REFUND_LOCK, orderId);
+    }
+
+}
+package cn.iocoder.yudao.module.pay.dal.redis.transfer;
+
+import jakarta.annotation.Resource;
+import org.redisson.api.RLock;
+import org.redisson.api.RedissonClient;
+import org.springframework.stereotype.Repository;
+
+import java.util.concurrent.TimeUnit;
+import java.util.function.Supplier;
+
+import static cn.iocoder.yudao.module.pay.dal.redis.RedisKeyConstants.PAY_TRANSFER_LOCK;
+
+/**
+ * 支付转账的锁 Redis DAO
+ *
+ * @author HUIHUI
+ */
+@Repository
+public class PayTransferLockRedisDAO {
+
+    @Resource
+    private RedissonClient redissonClient;
+
+    public <V> V lock(Long appId, String merchantTransferId, Long timeoutMillis, Supplier<V> supplier) {
+        String lockKey = formatKey(appId, merchantTransferId);
+        RLock lock = redissonClient.getLock(lockKey);
+        try {
+            lock.lock(timeoutMillis, TimeUnit.MILLISECONDS);
+            // 执行逻辑
+            return supplier.get();
+        } finally {
+            lock.unlock();
+        }
+    }
+
+    private static String formatKey(Long appId, String merchantTransferId) {
+        return String.format(PAY_TRANSFER_LOCK, appId, merchantTransferId);
+    }
+
+}
@@ -40,6 +40,9 @@ public interface ErrorCodeConstants {
     ErrorCode REFUND_EXISTS = new ErrorCode(1_007_006_003, "已经存在退款单");
     ErrorCode REFUND_NOT_FOUND = new ErrorCode(1_007_006_004, "支付退款单不存在");
     ErrorCode REFUND_STATUS_IS_NOT_WAITING = new ErrorCode(1_007_006_005, "支付退款单不处于待退款");
+    ErrorCode REFUND_SUBMIT_CHANNEL_ERROR = new ErrorCode(1_007_006_006, "发起退款报错，错误码：{}，错误提示：{}");
+    ErrorCode REFUND_CREATE_FAIL_ORDER_NOT_MATCH = new ErrorCode(1_007_006_007, "发起退款失败，原因：两次相同退款请求的支付订单不匹配");
+    ErrorCode REFUND_CREATE_FAIL_PRICE_NOT_MATCH = new ErrorCode(1_007_006_008, "发起退款失败，原因：两次相同退款请求的退款金额不匹配");
     // ========== 钱包模块 1-007-007-000 ==========
     ErrorCode WALLET_NOT_FOUND = new ErrorCode(1_007_007_000, "用户钱包不存在");
 package cn.iocoder.yudao.module.pay.service.refund;
 import cn.hutool.core.collection.CollUtil;
+import cn.hutool.core.util.ObjectUtil;
+import cn.hutool.core.util.StrUtil;
 import cn.hutool.extra.spring.SpringUtil;
+import cn.iocoder.yudao.framework.common.exception.ServiceException;
 import cn.iocoder.yudao.framework.common.pojo.PageResult;
+import cn.iocoder.yudao.framework.common.util.date.DateUtils;
 import cn.iocoder.yudao.module.pay.framework.pay.core.client.PayClient;
 import cn.iocoder.yudao.module.pay.framework.pay.core.client.dto.refund.PayRefundRespDTO;
 import cn.iocoder.yudao.module.pay.framework.pay.core.client.dto.refund.PayRefundUnifiedReqDTO;
@@ -17,6 +21,7 @@ import cn.iocoder.yudao.module.pay.dal.dataobject.order.PayOrderDO;
 import cn.iocoder.yudao.module.pay.dal.dataobject.refund.PayRefundDO;
 import cn.iocoder.yudao.module.pay.dal.mysql.refund.PayRefundMapper;
 import cn.iocoder.yudao.module.pay.dal.redis.no.PayNoRedisDAO;
+import cn.iocoder.yudao.module.pay.dal.redis.refund.PayRefundLockRedisDAO;
 import cn.iocoder.yudao.module.pay.enums.notify.PayNotifyTypeEnum;
 import cn.iocoder.yudao.module.pay.enums.order.PayOrderStatusEnum;
 import cn.iocoder.yudao.module.pay.enums.refund.PayRefundStatusEnum;
@@ -28,6 +33,7 @@ import cn.iocoder.yudao.module.pay.service.order.PayOrderService;
 import jakarta.annotation.Resource;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Propagation;
 import org.springframework.transaction.annotation.Transactional;
 import org.springframework.validation.annotation.Validated;
@@ -47,6 +53,11 @@ import static cn.iocoder.yudao.module.pay.enums.ErrorCodeConstants.*;
 @Validated
 public class PayRefundServiceImpl implements PayRefundService {
+    /**
+     * 创建退款单的锁超时时间，单位：毫秒
+     */
+    private static final long CREATE_LOCK_TIMEOUT_MILLIS = 120 * DateUtils.SECOND_MILLIS;
+
     @Resource
     private PayProperties payProperties;
@@ -54,6 +65,8 @@ public class PayRefundServiceImpl implements PayRefundService {
     private PayRefundMapper refundMapper;
     @Resource
     private PayNoRedisDAO noRedisDAO;
+    @Resource
+    private PayRefundLockRedisDAO refundLockRedisDAO;
     @Resource
     private PayOrderService orderService;
@@ -90,6 +103,9 @@ public class PayRefundServiceImpl implements PayRefundService {
     }
     @Override
+    // 注意：不加入调用方的事务，退款单、退款结果（包括退款通知）各自独立提交。
+    // 原因是：调用方的事务回滚（例如说，下面抛出的渠道错误），不能回滚已经向渠道发起的退款单，否则无法使用原退款单号重新发起
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
     public Long createRefund(PayRefundCreateReqDTO reqDTO) {
         // 1.1 校验 App
         PayAppDO app = appService.validPayApp(reqDTO.getAppKey());
@@ -99,31 +115,18 @@ public class PayRefundServiceImpl implements PayRefundService {
         PayChannelDO channel = channelService.validPayChannel(order.getChannelId());
         PayClient<?> client = channelService.getPayClient(channel.getId());
         if (client == null) {
-            log.error("[refund][渠道编号({}) 找不到对应的支付客户端]", channel.getId());
+            log.error("[createRefund][渠道编号({}) 找不到对应的支付客户端]", channel.getId());
             throw exception(CHANNEL_NOT_FOUND);
         }
-        // 1.4 校验退款订单是否已经存在
-        PayRefundDO refund = refundMapper.selectByAppIdAndMerchantRefundId(
-                app.getId(), reqDTO.getMerchantRefundId());
-        if (refund != null) {
-            throw exception(REFUND_EXISTS);
-        }
+        // 2. 加锁，创建退款单、或者重新发起退款失败的退款单
+        // 原因是：同一支付订单串行创建退款单，避免 select 后 insert 时，并发请求重复创建退款单，导致重复退款
+        // 注意：createRefund 不加入调用方的事务，退款单立即提交，所以释放锁后，其它请求可以查询到该退款单
+        PayRefundDO refund = refundLockRedisDAO.lock(order.getId(), CREATE_LOCK_TIMEOUT_MILLIS,
+                () -> createOrRetryRefund(reqDTO, app, order));
-        // 2.1 插入退款单
-        String no = noRedisDAO.generate(payProperties.getRefundNoPrefix());
-        refund = PayRefundConvert.INSTANCE.convert(reqDTO)
-                .setNo(no).setAppId(app.getId()).setOrderId(order.getId()).setOrderNo(order.getNo())
-                .setChannelId(order.getChannelId()).setChannelCode(order.getChannelCode())
-                // 商户相关的字段
-                .setNotifyUrl(app.getRefundNotifyUrl())
-                // 渠道相关字段
-                .setChannelOrderNo(order.getChannelOrderNo())
-                // 退款相关字段
-                .setStatus(PayRefundStatusEnum.WAITING.getStatus())
-                .setPayPrice(order.getPrice()).setRefundPrice(reqDTO.getPrice());
-        refundMapper.insert(refund);
+        // 3.1 调用三方渠道发起退款
+        PayRefundRespDTO refundRespDTO = null;
         try {
-            // 2.2 向渠道发起退款申请
             PayRefundUnifiedReqDTO unifiedReqDTO = new PayRefundUnifiedReqDTO()
                     .setPayPrice(order.getPrice())
                     .setRefundPrice(reqDTO.getPrice())
@@ -131,22 +134,147 @@ public class PayRefundServiceImpl implements PayRefundService {
                     .setOutRefundNo(refund.getNo())
                     .setNotifyUrl(genChannelRefundNotifyUrl(channel))
                     .setReason(reqDTO.getReason());
-            PayRefundRespDTO refundRespDTO = client.unifiedRefund(unifiedReqDTO);
-            // 2.3 处理退款返回
-            getSelf().notifyRefund(channel, refundRespDTO);
+            refundRespDTO = client.unifiedRefund(unifiedReqDTO);
         } catch (Throwable e) {
             // 注意：这里仅打印异常，不进行抛出。
-            // 原因是：虽然调用支付渠道进行退款发生异常（网络请求超时），实际退款成功。这个结果，后续通过退款回调、或者退款轮询补偿可以拿到。
-            // 最终，在异常的情况下，支付中心会异步回调业务的退款回调接口，提供退款结果
-            log.error("[createPayRefund][退款 id({}) requestDTO({}) 发生异常]",
-                    refund.getId(), reqDTO, e);
+            // 原因是：虽然调用支付渠道进行退款发生异常（网络请求超时），实际退款成功。
+            //        所以下面会查询一次渠道退款单，查询不到明确结果时，后续通过退款回调、或者退款轮询补偿可以拿到
+            log.error("[createRefund][退款编号({}) requestDTO({}) 发生异常]", refund.getId(), reqDTO, e);
+        }
+        // 3.2 发起退款没有返回结果、或者返回失败时，查询一次渠道退款单，避免误判
+        // 关联知识星球帖子：https://t.zsxq.com/JRLye、https://t.zsxq.com/gDETH
+        if (refundRespDTO == null || PayRefundStatusEnum.isFailure(refundRespDTO.getStatus())) {
+            refundRespDTO = getRefundAfterUnifiedRefund(client, refund, refundRespDTO);
         }
-        // 返回退款编号
+        // 4. 通知退款结果
+        if (refundRespDTO != null) {
+            if (PayRefundStatusEnum.isFailure(refundRespDTO.getStatus())) {
+                // 4.1 情况一：退款失败
+                PayRefundDO latestRefund = null;
+                try {
+                    getSelf().notifyRefund(channel, refundRespDTO);
+                } catch (ServiceException ex) {
+                    // 由于退款回调、退款轮询可能同时更新退款单，导致存在并发更新问题，此时以最新的退款状态为准
+                    latestRefund = validateRefundNotifyConcurrent(refund.getId(), ex);
+                    log.warn("[createRefund][refund({}) channel({}) 退款结果({}) 通知时发生并发更新，最新状态为({})]",
+                            refund.getId(), channel.getId(), refundRespDTO, latestRefund.getStatus(), ex);
+                }
+                // 如有渠道错误码，则抛出业务异常，提示用户
+                // 特殊：如果已被并发更新为成功，则以最新状态为准，避免旧的失败结果误报
+                if (StrUtil.isNotEmpty(refundRespDTO.getChannelErrorCode())
+                        && (latestRefund == null || PayRefundStatusEnum.isFailure(latestRefund.getStatus()))) {
+                    throw exception(REFUND_SUBMIT_CHANNEL_ERROR, refundRespDTO.getChannelErrorCode(),
+                            refundRespDTO.getChannelErrorMsg());
+                }
+            } else {
+                // 4.2 情况二：退款成功、或者退款中
+                // 注意：这里仅打印异常，不进行抛出。原因是：渠道可能已经退款成功，抛出会导致调用方回滚，后续通过退款回调、或者退款轮询补偿
+                try {
+                    getSelf().notifyRefund(channel, refundRespDTO);
+                } catch (Throwable e) {
+                    log.error("[createRefund][退款编号({}) 退款结果({}) 通知时发生异常]", refund.getId(), refundRespDTO, e);
+                }
+            }
+        }
         return refund.getId();
     }
     /**
+     * 创建退款单；如果存在退款失败的退款单，则重置为待退款，用于重新发起退款
+     *
+     * @param reqDTO 退款申请信息
+     * @param app 支付应用
+     * @param order 支付订单
+     * @return 退款单
+     */
+    private PayRefundDO createOrRetryRefund(PayRefundCreateReqDTO reqDTO, PayAppDO app, PayOrderDO order) {
+        // 1. 校验退款单是否可以发起：不存在，或者之前退款失败
+        PayRefundDO refund = validateRefundCanCreate(reqDTO, app.getId(), order);
+
+        if (refund == null) {
+            // 2.1 情况一：不存在退款单，则插入退款单
+            String no = noRedisDAO.generate(payProperties.getRefundNoPrefix());
+            refund = PayRefundConvert.INSTANCE.convert(reqDTO)
+                    .setNo(no).setAppId(app.getId()).setOrderId(order.getId()).setOrderNo(order.getNo())
+                    .setChannelId(order.getChannelId()).setChannelCode(order.getChannelCode())
+                    // 商户相关的字段
+                    .setNotifyUrl(app.getRefundNotifyUrl())
+                    // 渠道相关字段
+                    .setChannelOrderNo(order.getChannelOrderNo())
+                    // 退款相关字段
+                    .setStatus(PayRefundStatusEnum.WAITING.getStatus())
+                    .setPayPrice(order.getPrice()).setRefundPrice(reqDTO.getPrice());
+            refundMapper.insert(refund);
+        } else {
+            // 2.2 情况二：存在退款失败的退款单，则复用原退款单（包括原退款单号）重新发起，并清空上一次退款的渠道结果
+            // 原因是：微信、支付宝等渠道要求退款失败后重新提交时，使用原商户退款单号，避免上一次实际受理时重复退款。未校验一致的请求字段，以本次请求为准
+            int updateCount = refundMapper.updateByIdAndStatusAndClearChannelResult(refund.getId(), refund.getStatus(),
+                    new PayRefundDO().setStatus(PayRefundStatusEnum.WAITING.getStatus())
+                            .setReason(reqDTO.getReason()).setUserIp(reqDTO.getUserIp())
+                            .setNotifyUrl(app.getRefundNotifyUrl()));
+            if (updateCount == 0) { // 校验状态，避免并发重新发起退款
+                throw exception(REFUND_HAS_REFUNDING);
+            }
+        }
+        return refund;
+    }
+
+    /**
+     * 发起退款没有返回结果、或者返回失败时，查询一次渠道退款单，确认退款结果
+     *
+     * 注意：只有查询到渠道已受理退款，才以查询结果为准；查询到的退款失败，不作为最终结果。
+     * 原因是：一次查询可能存在渠道退款单尚未生成、或者结果尚未同步的情况，例如说微信、钱包查询不存在的退款单时返回失败
+     *
+     * @param client 支付客户端
+     * @param refund 退款单
+     * @param unifiedRespDTO 发起退款的返回结果；为 null 时，表示发起退款发生异常
+     * @return 退款结果；为 null 时，表示结果未知，保留 WAITING 交给退款回调、或者退款轮询补偿
+     */
+    private PayRefundRespDTO getRefundAfterUnifiedRefund(PayClient<?> client, PayRefundDO refund, PayRefundRespDTO unifiedRespDTO) {
+        PayRefundRespDTO queryRespDTO = null;
+        try {
+            queryRespDTO = client.getRefund(refund.getOrderNo(), refund.getNo());
+        } catch (Throwable e) {
+            log.warn("[getRefundAfterUnifiedRefund][退款编号({}) 查询渠道退款单发生异常]", refund.getId(), e);
+        }
+        // 情况一：查询到退款成功、或者已有渠道退款单号的退款中，说明渠道实际已受理退款，以查询结果为准
+        if (queryRespDTO != null && (PayRefundStatusEnum.isSuccess(queryRespDTO.getStatus())
+                || (PayRefundStatusEnum.WAITING.getStatus().equals(queryRespDTO.getStatus())
+                    && StrUtil.isNotEmpty(queryRespDTO.getChannelRefundNo())))) {
+            return queryRespDTO;
+        }
+        // 情况二：其它情况，以发起退款的结果为准
+        // ① 发起退款发生异常：返回 null，保留 WAITING 交给退款回调、或者退款轮询补偿
+        // ② 发起退款明确返回失败：以渠道明确返回的失败为准。原因是：支付宝查询不存在的退款单时返回 WAITING、钱包查询 WAITING 退款单时抛出异常，退款轮询无法补偿
+        return unifiedRespDTO;
+    }
+
+    /**
+     * 校验退款结果通知时的并发更新
+     *
+     * 只有状态竞争导致的通知失败，并且退款单已被并发更新为成功或失败时，才返回最新的退款单；
+     * 否则，直接抛出原异常，避免掩盖真实的通知失败
+     *
+     * @param id 退款单编号
+     * @param ex 通知退款结果时的业务异常
+     * @return 最新的退款单
+     */
+    private PayRefundDO validateRefundNotifyConcurrent(Long id, ServiceException ex) {
+        // 1. 校验是否为状态竞争
+        if (ObjectUtil.notEqual(ex.getCode(), REFUND_STATUS_IS_NOT_WAITING.getCode())) {
+            throw ex;
+        }
+        // 2. 校验最新状态为成功或失败
+        PayRefundDO latestRefund = refundMapper.selectById(id);
+        if (latestRefund == null || !(PayRefundStatusEnum.isSuccess(latestRefund.getStatus())
+                || PayRefundStatusEnum.isFailure(latestRefund.getStatus()))) {
+            throw ex;
+        }
+        return latestRefund;
+    }
+
+    /**
      * 校验支付订单是否可以退款
      *
      * @param reqDTO 退款申请信息
@@ -166,12 +294,39 @@ public class PayRefundServiceImpl implements PayRefundService {
         if (reqDTO.getPrice() + order.getRefundPrice() > order.getPrice()) {
             throw exception(REFUND_PRICE_EXCEED);
         }
-        // 是否有退款中的订单
+        return order;
+    }
+
+    /**
+     * 校验退款单是否可以发起
+     *
+     * @param reqDTO 退款申请信息
+     * @param appId 应用编号
+     * @param order 支付订单
+     * @return 退款失败、需要重新发起的退款单；为 null 时，表示需要新建退款单
+     */
+    private PayRefundDO validateRefundCanCreate(PayRefundCreateReqDTO reqDTO, Long appId, PayOrderDO order) {
+        // 是否有退款中的订单。注意：需要在锁内校验，避免并发创建退款单
         if (refundMapper.selectCountByAppIdAndOrderId(appId, order.getId(),
                 PayRefundStatusEnum.WAITING.getStatus()) > 0) {
             throw exception(REFUND_HAS_REFUNDING);
         }
-        return order;
+        PayRefundDO refund = refundMapper.selectByAppIdAndMerchantRefundId(appId, reqDTO.getMerchantRefundId());
+        if (refund == null) {
+            return null;
+        }
+        // 只有退款失败的退款单，才能再次发起退款
+        if (!PayRefundStatusEnum.isFailure(refund.getStatus())) {
+            throw exception(REFUND_EXISTS);
+        }
+        // 校验参数是否一致
+        if (ObjectUtil.notEqual(refund.getOrderId(), order.getId())) {
+            throw exception(REFUND_CREATE_FAIL_ORDER_NOT_MATCH);
+        }
+        if (ObjectUtil.notEqual(refund.getRefundPrice(), reqDTO.getPrice())) {
+            throw exception(REFUND_CREATE_FAIL_PRICE_NOT_MATCH);
+        }
+        return refund;
     }
     /**
@@ -209,7 +364,39 @@ public class PayRefundServiceImpl implements PayRefundService {
         // 情况二：退款失败
         if (PayRefundStatusEnum.isFailure(notify.getStatus())) {
             notifyRefundFailure(channel, notify);
+            return;
+        }
+        // 情况三：退款中
+        if (PayRefundStatusEnum.WAITING.getStatus().equals(notify.getStatus())) {
+            notifyRefundWaiting(channel, notify);
+        }
+    }
+
+    private void notifyRefundWaiting(PayChannelDO channel, PayRefundRespDTO notify) {
+        // 没有渠道退款单号，说明渠道未明确受理退款，无需更新。例如说：支付宝查询不到退款单时返回 WAITING
+        if (StrUtil.isEmpty(notify.getChannelRefundNo())) {
+            return;
+        }
+        // 1.1 查询 PayRefundDO
+        PayRefundDO refund = refundMapper.selectByAppIdAndNo(
+                channel.getAppId(), notify.getOutRefundNo());
+        if (refund == null) {
+            throw exception(REFUND_NOT_FOUND);
+        }
+        // 如果不是待退款（例如说，已被退款回调并发更新为最终状态）、或者渠道退款单号已一致，直接返回，不用重复更新
+        if (!PayRefundStatusEnum.WAITING.getStatus().equals(refund.getStatus())
+                || ObjectUtil.equal(refund.getChannelRefundNo(), notify.getChannelRefundNo())) {
+            log.info("[notifyRefundWaiting][退款订单({}) 状态({}) 无需更新渠道退款单号]", refund.getId(), refund.getStatus());
+            return;
+        }
+        // 1.2 更新 PayRefundDO：仍是待退款，补充渠道已受理的退款单号
+        int updateCounts = refundMapper.updateByIdAndStatus(refund.getId(), refund.getStatus(), new PayRefundDO()
+                .setChannelRefundNo(notify.getChannelRefundNo()).setChannelNotifyData(toJsonString(notify)));
+        if (updateCounts == 0) { // 已被并发更新为最终状态，以最新状态为准
+            log.info("[notifyRefundWaiting][退款订单({}) 已被并发更新，无需更新渠道退款单号]", refund.getId());
+            return;
         }
+        log.info("[notifyRefundWaiting][退款订单({}) 更新渠道退款单号({})]", refund.getId(), notify.getChannelRefundNo());
     }
     private void notifyRefundSuccess(PayChannelDO channel, PayRefundRespDTO notify) {
@@ -6,6 +6,7 @@ import cn.hutool.core.util.StrUtil;
 import cn.hutool.extra.spring.SpringUtil;
 import cn.iocoder.yudao.framework.common.exception.ServiceException;
 import cn.iocoder.yudao.framework.common.pojo.PageResult;
+import cn.iocoder.yudao.framework.common.util.date.DateUtils;
 import cn.iocoder.yudao.framework.common.util.json.JsonUtils;
 import cn.iocoder.yudao.framework.common.util.object.BeanUtils;
 import cn.iocoder.yudao.module.pay.framework.pay.core.client.PayClient;
@@ -20,6 +21,7 @@ import cn.iocoder.yudao.module.pay.dal.dataobject.channel.PayChannelDO;
 import cn.iocoder.yudao.module.pay.dal.dataobject.transfer.PayTransferDO;
 import cn.iocoder.yudao.module.pay.dal.mysql.transfer.PayTransferMapper;
 import cn.iocoder.yudao.module.pay.dal.redis.no.PayNoRedisDAO;
+import cn.iocoder.yudao.module.pay.dal.redis.transfer.PayTransferLockRedisDAO;
 import cn.iocoder.yudao.module.pay.enums.notify.PayNotifyTypeEnum;
 import cn.iocoder.yudao.module.pay.enums.transfer.PayTransferStatusEnum;
 import cn.iocoder.yudao.module.pay.framework.pay.config.PayProperties;
@@ -29,6 +31,7 @@ import cn.iocoder.yudao.module.pay.service.notify.PayNotifyService;
 import jakarta.annotation.Resource;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Propagation;
 import org.springframework.transaction.annotation.Transactional;
 import java.util.List;
@@ -47,6 +50,11 @@ public class PayTransferServiceImpl implements PayTransferService {
     private static final String TRANSFER_NO_PREFIX = "T";
+    /**
+     * 创建转账单的锁超时时间，单位：毫秒
+     */
+    private static final long CREATE_LOCK_TIMEOUT_MILLIS = 120 * DateUtils.SECOND_MILLIS;
+
     @Resource
     private PayProperties payProperties;
@@ -60,8 +68,14 @@ public class PayTransferServiceImpl implements PayTransferService {
     private PayNotifyService notifyService;
     @Resource
     private PayNoRedisDAO noRedisDAO;
+    @Resource
+    private PayTransferLockRedisDAO transferLockRedisDAO;
     @Override
+    // 注意：不加入调用方的事务，转账单、转账结果（包括转账通知）各自独立提交。
+    // 原因是：调用方的事务回滚（例如说，下面抛出的渠道错误），不能回滚已经向渠道发起的转账单，否则无法使用原转账单号重新发起
+    // 特殊：钱包渠道查询不到调用方事务未提交的数据，所以钱包创建时独立提交，见 PayWalletServiceImpl#createWalletIfAbsent 方法
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
     public PayTransferCreateRespDTO createTransfer(PayTransferCreateReqDTO reqDTO) {
         // 1.1 校验 App
         PayAppDO payApp = appService.validPayApp(reqDTO.getAppKey());
@@ -72,35 +86,29 @@ public class PayTransferServiceImpl implements PayTransferService {
             log.error("[createTransfer][渠道编号({}) 找不到对应的支付客户端]", channel.getId());
             throw exception(CHANNEL_NOT_FOUND);
         }
-        // 1.3 校验转账单已经发起过转账
-        PayTransferDO transfer = validateTransferCanCreate(reqDTO, payApp.getId());
+        // 2. 加锁，创建转账单、或者重新发起转账关闭的转账单
+        // 原因是：同一商户转账单串行创建转账单，避免 select 后 insert 时，并发请求重复创建转账单，导致重复转账
+        // 注意：createTransfer 不加入调用方的事务，转账单立即提交，所以释放锁后，其它请求可以查询到该转账单
+        PayTransferDO transfer = transferLockRedisDAO.lock(payApp.getId(), reqDTO.getMerchantTransferId(),
+                CREATE_LOCK_TIMEOUT_MILLIS, () -> createOrRetryTransfer(reqDTO, payApp, channel));
-        // 2.1 情况一：不存在创建转账单，则进行创建
-        if (transfer == null) {
-            String no = noRedisDAO.generate(TRANSFER_NO_PREFIX);
-            transfer = BeanUtils.toBean(reqDTO, PayTransferDO.class)
-                    .setAppId(channel.getAppId()).setChannelId(channel.getId())
-                    .setNo(no).setStatus(PayTransferStatusEnum.WAITING.getStatus())
-                    .setNotifyUrl(payApp.getTransferNotifyUrl());
-            transferMapper.insert(transfer);
-        } else {
-            // 2.2 情况二：存在创建转账单，但是状态为关闭，则更新为等待中
-            transferMapper.updateByIdAndStatus(transfer.getId(), transfer.getStatus(),
-                    new PayTransferDO().setStatus(PayTransferStatusEnum.WAITING.getStatus()));
-        }
+        // 3.1 调用三方渠道发起转账
         PayTransferRespDTO unifiedTransferResp = null;
         try {
-            // 3. 调用三方渠道发起转账
             PayTransferUnifiedReqDTO transferUnifiedReq = BeanUtils.toBean(reqDTO, PayTransferUnifiedReqDTO.class)
                     .setOutTransferNo(transfer.getNo())
                     .setNotifyUrl(genChannelTransferNotifyUrl(channel));
             unifiedTransferResp = client.unifiedTransfer(transferUnifiedReq);
         } catch (Throwable e) {
-            // 注意这里仅打印异常，不进行抛出。
-            // 原因是：虽然调用支付渠道进行转账发生异常（网络请求超时），实际转账成功。这个结果，后续转账轮询可以拿到。
-            //       或者，使用相同 no 再次发起转账请求
+            // 注意：这里仅打印异常，不进行抛出。
+            // 原因是：虽然调用支付渠道进行转账发生异常（网络请求超时），实际转账成功。
+            //        所以下面会查询一次渠道转账单，查询不到明确结果时，后续通过转账回调、或者转账轮询补偿可以拿到
             log.error("[createTransfer][转账编号({}) requestDTO({}) 发生异常]", transfer.getId(), reqDTO, e);
         }
+        // 3.2 发起转账没有返回结果、或者返回关闭时，查询一次渠道转账单，避免误判
+        if (unifiedTransferResp == null || PayTransferStatusEnum.isClosed(unifiedTransferResp.getStatus())) {
+            unifiedTransferResp = getTransferAfterUnifiedTransfer(client, transfer, unifiedTransferResp);
+        }
         // 4. 通知转账结果
         if (unifiedTransferResp != null) {
@@ -126,6 +134,74 @@ public class PayTransferServiceImpl implements PayTransferService {
     }
     /**
+     * 创建转账单；如果存在转账关闭的转账单，则重置为待转账，用于重新发起转账
+     *
+     * @param reqDTO 转账申请信息
+     * @param payApp 支付应用
+     * @param channel 支付渠道
+     * @return 转账单
+     */
+    private PayTransferDO createOrRetryTransfer(PayTransferCreateReqDTO reqDTO, PayAppDO payApp, PayChannelDO channel) {
+        // 1. 校验转账单是否可以发起：不存在，或者之前转账关闭
+        PayTransferDO transfer = validateTransferCanCreate(reqDTO, payApp.getId());
+
+        if (transfer == null) {
+            // 2.1 情况一：不存在转账单，则插入转账单
+            String no = noRedisDAO.generate(TRANSFER_NO_PREFIX);
+            transfer = BeanUtils.toBean(reqDTO, PayTransferDO.class)
+                    .setAppId(channel.getAppId()).setChannelId(channel.getId())
+                    .setNo(no).setStatus(PayTransferStatusEnum.WAITING.getStatus())
+                    .setNotifyUrl(payApp.getTransferNotifyUrl());
+            transferMapper.insert(transfer);
+        } else {
+            // 2.2 情况二：存在关闭的转账单，则复用原转账单（包括原转账单号）重新发起，并清空上一次转账的渠道结果
+            // 原因是：渠道通过转账单号保证幂等，避免上一次实际受理时重复转账。未校验一致的请求字段，以本次请求为准
+            // 特殊：渠道编号以本次按渠道编码校验的渠道为准，避免渠道删除重建后，转账轮询、转账回调仍使用旧的渠道编号
+            int updateCount = transferMapper.updateByIdAndStatusAndClearChannelResult(transfer.getId(), transfer.getStatus(),
+                    new PayTransferDO().setStatus(PayTransferStatusEnum.WAITING.getStatus()).setChannelId(channel.getId())
+                            .setSubject(reqDTO.getSubject()).setUserAccount(reqDTO.getUserAccount())
+                            .setUserName(reqDTO.getUserName()).setChannelExtras(reqDTO.getChannelExtras())
+                            .setUserIp(reqDTO.getUserIp()).setNotifyUrl(payApp.getTransferNotifyUrl()));
+            if (updateCount == 0) { // 校验状态，避免并发重新发起转账
+                throw exception(PAY_TRANSFER_CREATE_FAIL_STATUS_NOT_CLOSED);
+            }
+        }
+        return transfer;
+    }
+
+    /**
+     * 发起转账没有返回结果、或者返回关闭时，查询一次渠道转账单，确认转账结果
+     *
+     * 注意：只有查询到渠道已受理转账，才以查询结果为准；查询到的转账关闭，不作为最终结果。
+     * 原因是：一次查询可能存在渠道转账单尚未生成、或者结果尚未同步的情况，例如说钱包查询不存在的转账单时返回关闭
+     *
+     * @param client 支付客户端
+     * @param transfer 转账单
+     * @param unifiedResp 发起转账的返回结果；为 null 时，表示发起转账发生异常
+     * @return 转账结果；为 null 时，表示结果未知，保留 WAITING 交给转账回调、或者转账轮询补偿
+     */
+    private PayTransferRespDTO getTransferAfterUnifiedTransfer(PayClient<?> client, PayTransferDO transfer,
+                                                               PayTransferRespDTO unifiedResp) {
+        PayTransferRespDTO queryResp = null;
+        try {
+            queryResp = client.getTransfer(transfer.getNo());
+        } catch (Throwable e) {
+            log.warn("[getTransferAfterUnifiedTransfer][转账编号({}) 查询渠道转账单发生异常]", transfer.getId(), e);
+        }
+        // 情况一：查询到转账成功、转账中、或者已有渠道转账单号的待转账，说明渠道实际已受理转账，以查询结果为准
+        if (queryResp != null && (PayTransferStatusEnum.isSuccess(queryResp.getStatus())
+                || PayTransferStatusEnum.isProcessing(queryResp.getStatus())
+                || (PayTransferStatusEnum.isWaiting(queryResp.getStatus())
+                    && StrUtil.isNotEmpty(queryResp.getChannelTransferNo())))) {
+            return queryResp;
+        }
+        // 情况二：其它情况，以发起转账的结果为准
+        // ① 发起转账发生异常：返回 null，保留 WAITING 交给转账回调、或者转账轮询补偿
+        // ② 发起转账明确返回关闭：以渠道明确返回的关闭为准。原因是：支付宝查询不存在的转账单时返回 WAITING、微信查询不存在的转账单时抛出异常
+        return unifiedResp;
+    }
+
+    /**
      * 校验转账结果通知时的并发更新
      *
      * 只有状态竞争导致的通知失败，并且转账单已被并发更新为成功或关闭时，才返回最新的转账单；
@@ -159,23 +235,30 @@ public class PayTransferServiceImpl implements PayTransferService {
         return payProperties.getTransferNotifyUrl() + "/" + channel.getId();
     }
+    /**
+     * 校验转账单是否可以发起
+     *
+     * @param reqDTO 转账申请信息
+     * @param appId 应用编号
+     * @return 转账关闭、需要重新发起的转账单；为 null 时，表示需要新建转账单
+     */
     private PayTransferDO validateTransferCanCreate(PayTransferCreateReqDTO reqDTO, Long appId) {
         PayTransferDO transfer = transferMapper.selectByAppIdAndMerchantOrderId(appId, reqDTO.getMerchantTransferId());
-        if (transfer != null) {
-            // 只有转账单状态为关闭，才能再次发起转账
-            if (!PayTransferStatusEnum.isClosed(transfer.getStatus())) {
-                throw exception(PAY_TRANSFER_CREATE_FAIL_STATUS_NOT_CLOSED);
-            }
-            // 校验参数是否一致
-            if (ObjectUtil.notEqual(reqDTO.getPrice(), transfer.getPrice())) {
-                throw exception(PAY_TRANSFER_CREATE_PRICE_NOT_MATCH);
-            }
-            if (ObjectUtil.notEqual(reqDTO.getChannelCode(), transfer.getChannelCode())) {
-                throw exception(PAY_TRANSFER_CREATE_CHANNEL_NOT_MATCH);
-            }
+        if (transfer == null) {
+            return null;
+        }
+        // 只有转账关闭的转账单，才能再次发起转账
+        // 原因是：待转账、转账中时，不知道渠道转账是否已经受理，交给转账回调、或者转账轮询补偿
+        if (!PayTransferStatusEnum.isClosed(transfer.getStatus())) {
+            throw exception(PAY_TRANSFER_CREATE_FAIL_STATUS_NOT_CLOSED);
+        }
+        // 校验参数是否一致
+        if (ObjectUtil.notEqual(reqDTO.getChannelCode(), transfer.getChannelCode())) {
+            throw exception(PAY_TRANSFER_CREATE_CHANNEL_NOT_MATCH);
+        }
+        if (ObjectUtil.notEqual(reqDTO.getPrice(), transfer.getPrice())) {
+            throw exception(PAY_TRANSFER_CREATE_PRICE_NOT_MATCH);
         }
-        // 如果状态为等待状态：不知道渠道转账是否发起成功
-        // 特殊：允许使用相同的 no 再次发起转账，渠道会保证幂等
         return transfer;
     }
@@ -194,7 +277,38 @@ public class PayTransferServiceImpl implements PayTransferService {
         if (PayTransferStatusEnum.isProcessing(notify.getStatus())) {
             notifyTransferProgressing(channel, notify);
         }
-        // WAITING 状态无需处理
+        // 转账等待的回调
+        if (PayTransferStatusEnum.isWaiting(notify.getStatus())) {
+            notifyTransferWaiting(channel, notify);
+        }
+    }
+
+    private void notifyTransferWaiting(PayChannelDO channel, PayTransferRespDTO notify) {
+        // 没有渠道转账单号，说明渠道未明确受理转账，无需更新。例如说：支付宝查询不到转账单时返回 WAITING
+        if (StrUtil.isEmpty(notify.getChannelTransferNo())) {
+            return;
+        }
+        // 1. 校验
+        PayTransferDO transfer = transferMapper.selectByAppIdAndNo(channel.getAppId(), notify.getOutTransferNo());
+        if (transfer == null) {
+            throw exception(PAY_TRANSFER_NOT_FOUND);
+        }
+        // 如果不是待转账（例如说，已被转账回调并发更新）、或者渠道转账单号已一致，直接返回，不用重复更新
+        if (!PayTransferStatusEnum.isWaiting(transfer.getStatus())
+                || ObjectUtil.equal(transfer.getChannelTransferNo(), notify.getChannelTransferNo())) {
+            log.info("[notifyTransferWaiting][transfer({}) 状态({}) 无需更新渠道转账单号]", transfer.getId(), transfer.getStatus());
+            return;
+        }
+
+        // 2. 更新渠道转账单号：仍是待转账，补充渠道已受理的转账单号
+        int updateCounts = transferMapper.updateByIdAndStatus(transfer.getId(), PayTransferStatusEnum.WAITING.getStatus(),
+                new PayTransferDO().setChannelTransferNo(notify.getChannelTransferNo())
+                        .setChannelNotifyData(JsonUtils.toJsonString(notify)));
+        if (updateCounts == 0) { // 已被并发更新，以最新状态为准
+            log.info("[notifyTransferWaiting][transfer({}) 已被并发更新，无需更新渠道转账单号]", transfer.getId());
+            return;
+        }
+        log.info("[notifyTransferWaiting][transfer({}) 更新渠道转账单号({})]", transfer.getId(), notify.getChannelTransferNo());
     }
     private void notifyTransferProgressing(PayChannelDO channel, PayTransferRespDTO notify) {
@@ -216,6 +330,7 @@ public class PayTransferServiceImpl implements PayTransferService {
         int updateCounts = transferMapper.updateByIdAndStatus(transfer.getId(),
                 PayTransferStatusEnum.WAITING.getStatus(),
                 new PayTransferDO().setStatus(PayTransferStatusEnum.PROCESSING.getStatus())
+                        .setChannelTransferNo(notify.getChannelTransferNo())
                         .setChannelPackageInfo(notify.getChannelPackageInfo()));
         if (updateCounts == 0) {
             PayTransferDO latestTransfer = transferMapper.selectById(transfer.getId());
 package cn.iocoder.yudao.module.pay.service.wallet;
 import cn.hutool.core.lang.Assert;
+import cn.hutool.extra.spring.SpringUtil;
 import cn.iocoder.yudao.framework.common.pojo.PageResult;
 import cn.iocoder.yudao.framework.common.util.date.DateUtils;
 import cn.iocoder.yudao.module.pay.controller.admin.wallet.vo.wallet.PayWalletPageReqVO;
@@ -19,6 +20,7 @@ import lombok.SneakyThrows;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.context.annotation.Lazy;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Propagation;
 import org.springframework.transaction.annotation.Transactional;
 import java.time.LocalDateTime;
@@ -64,20 +66,37 @@ public class PayWalletServiceImpl implements PayWalletService {
         if (wallet == null) {
             // 使用双重检查锁，保证钱包创建并发问题
             // https://gitee.com/zhijiantianya/ruoyi-vue-pro/pulls/1475/files
-            wallet = lockRedisDAO.lock(userId, UPDATE_TIMEOUT_MILLIS, () -> {
-                PayWalletDO newWallet = walletMapper.selectByUserIdAndType(userId, userType);
-                if (newWallet == null) {
-                    newWallet = new PayWalletDO().setUserId(userId).setUserType(userType)
-                            .setBalance(0).setTotalExpense(0).setTotalRecharge(0);
-                    newWallet.setCreateTime(LocalDateTime.now());
-                    walletMapper.insert(newWallet);
-                }
-                return newWallet;
-            });
+            wallet = lockRedisDAO.lock(userId, UPDATE_TIMEOUT_MILLIS,
+                    () -> getSelf().createWalletIfAbsent(userId, userType));
         }
         return wallet;
     }
+    /**
+     * 创建钱包，如果不存在的话
+     *
+     * 注意：使用新事务，在释放锁之前提交，不加入调用方的事务。原因是：
+     * 1. 调用方的事务未提交时，其它请求查询不到钱包，会重复创建钱包
+     * 2. 后续不加入调用方事务的操作，也需要查询到钱包。例如说，佣金提现到钱包时，转账 createTransfer 不加入调用方的事务
+     * 另外，钱包是空钱包，即使调用方的事务回滚，保留也没有影响
+     *
+     * @param userId 用户编号
+     * @param userType 用户类型
+     * @return 钱包
+     */
+    @Transactional(rollbackFor = Exception.class, propagation = Propagation.REQUIRES_NEW)
+    public PayWalletDO createWalletIfAbsent(Long userId, Integer userType) {
+        PayWalletDO wallet = walletMapper.selectByUserIdAndType(userId, userType);
+        if (wallet != null) {
+            return wallet;
+        }
+        wallet = new PayWalletDO().setUserId(userId).setUserType(userType)
+                .setBalance(0).setTotalExpense(0).setTotalRecharge(0);
+        wallet.setCreateTime(LocalDateTime.now());
+        walletMapper.insert(wallet);
+        return wallet;
+    }
+
     @Override
     public PayWalletDO getWallet(Long walletId) {
         return walletMapper.selectById(walletId);
@@ -245,4 +264,13 @@ public class PayWalletServiceImpl implements PayWalletService {
         }
     }
+    /**
+     * 获得自身的代理对象，解决 AOP 生效问题
+     *
+     * @return 自己
+     */
+    private PayWalletServiceImpl getSelf() {
+        return SpringUtil.getBean(getClass());
+    }
+
 }
 package cn.iocoder.yudao.module.pay.service.refund;
 import cn.hutool.extra.spring.SpringUtil;
+import cn.iocoder.yudao.framework.common.exception.ServiceException;
 import cn.iocoder.yudao.framework.common.pojo.PageResult;
 import cn.iocoder.yudao.framework.test.core.ut.BaseDbAndRedisUnitTest;
 import cn.iocoder.yudao.module.pay.api.refund.dto.PayRefundCreateReqDTO;
@@ -12,6 +13,7 @@ import cn.iocoder.yudao.module.pay.dal.dataobject.order.PayOrderDO;
 import cn.iocoder.yudao.module.pay.dal.dataobject.refund.PayRefundDO;
 import cn.iocoder.yudao.module.pay.dal.mysql.refund.PayRefundMapper;
 import cn.iocoder.yudao.module.pay.dal.redis.no.PayNoRedisDAO;
+import cn.iocoder.yudao.module.pay.dal.redis.refund.PayRefundLockRedisDAO;
 import cn.iocoder.yudao.module.pay.enums.PayChannelEnum;
 import cn.iocoder.yudao.module.pay.enums.notify.PayNotifyTypeEnum;
 import cn.iocoder.yudao.module.pay.enums.order.PayOrderStatusEnum;
@@ -30,9 +32,17 @@ import org.junit.jupiter.api.Test;
 import org.mockito.MockedStatic;
 import org.springframework.context.annotation.Import;
 import org.springframework.test.context.bean.override.mockito.MockitoBean;
+import org.springframework.test.util.AopTestUtils;
+import org.springframework.test.util.ReflectionTestUtils;
+import org.springframework.transaction.PlatformTransactionManager;
+import org.springframework.transaction.support.TransactionTemplate;
+import java.time.LocalDateTime;
+import java.util.ArrayList;
 import java.util.List;
+import java.util.concurrent.CompletableFuture;
+import static cn.iocoder.yudao.framework.common.exception.util.ServiceExceptionUtil.exception;
 import static cn.iocoder.yudao.framework.common.util.date.LocalDateTimeUtils.buildBetweenTime;
 import static cn.iocoder.yudao.framework.common.util.date.LocalDateTimeUtils.buildTime;
 import static cn.iocoder.yudao.framework.common.util.json.JsonUtils.toJsonString;
@@ -45,6 +55,7 @@ import static cn.iocoder.yudao.module.pay.enums.ErrorCodeConstants.*;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.jupiter.api.Assertions.*;
 import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.AdditionalAnswers.delegatesTo;
 import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.*;
@@ -53,7 +64,7 @@ import static org.mockito.Mockito.*;
  *
  * @author 芋艿
  */
-@Import({PayRefundServiceImpl.class, PayNoRedisDAO.class})
+@Import({PayRefundServiceImpl.class, PayNoRedisDAO.class, PayRefundLockRedisDAO.class})
 public class PayRefundServiceTest extends BaseDbAndRedisUnitTest {
     @Resource
@@ -62,6 +73,9 @@ public class PayRefundServiceTest extends BaseDbAndRedisUnitTest {
     @Resource
     private PayRefundMapper refundMapper;
+    @Resource
+    private PlatformTransactionManager transactionManager;
+
     @MockitoBean
     private PayProperties payProperties;
     @MockitoBean
@@ -332,9 +346,9 @@ public class PayRefundServiceTest extends BaseDbAndRedisUnitTest {
         // mock 方法（client）
         PayClient<?> client = mock(PayClient.class);
         when(channelService.getPayClient(eq(10L))).thenReturn(client);
-        // mock 数据（refund 已存在）
+        // mock 数据（refund 已存在，且不是退款失败）
         PayRefundDO refund = randomPojo(PayRefundDO.class, o ->
-                o.setAppId(1L).setMerchantRefundId("200"));
+                o.setAppId(1L).setMerchantRefundId("200").setStatus(PayRefundStatusEnum.SUCCESS.getStatus()));
         refundMapper.insert(refund);
         // 调用，并断言异常
@@ -379,6 +393,453 @@ public class PayRefundServiceTest extends BaseDbAndRedisUnitTest {
                 .containsExactly(order.getId(), order.getNo(), channel.getId(), channel.getCode(),
                         app.getRefundNotifyUrl(), order.getChannelOrderNo(), PayRefundStatusEnum.WAITING.getStatus(),
                         order.getPrice(), reqDTO.getPrice());
+        // 断言：查询一次渠道退款单，查询不到结果时保留 WAITING
+        verify(client).getRefund(eq(order.getNo()), eq(refundDO.getNo()));
+    }
+
+    @Test // 调用 unifiedRefund 接口发生异常，但查询确认渠道退款成功
+    public void testCreateRefund_invokeException_querySuccess() {
+        // mock 方法（client）
+        PayClient<?> client = mockPayClient();
+        when(client.unifiedRefund(any(PayRefundUnifiedReqDTO.class))).thenThrow(new RuntimeException("模拟网络超时"));
+        when(client.getRefund(any(), any())).thenAnswer(invocation -> PayRefundRespDTO.successOf("CHANNEL_R001",
+                LocalDateTime.now(), invocation.getArgument(1), "success"));
+
+        // 调用
+        Long refundId = refundService.createRefund(buildRefundCreateReqDTO());
+        // 断言：按查询结果更新为退款成功
+        PayRefundDO refund = refundMapper.selectById(refundId);
+        assertEquals(PayRefundStatusEnum.SUCCESS.getStatus(), refund.getStatus());
+        assertEquals("CHANNEL_R001", refund.getChannelRefundNo());
+        verify(notifyService).createPayNotifyTask(eq(PayNotifyTypeEnum.REFUND.getType()), eq(refundId));
+    }
+
+    @Test // 调用 unifiedRefund 接口发生异常，查询返回失败（例如说：微信查询不到退款单）
+    public void testCreateRefund_invokeException_queryFailure() {
+        // mock 方法（client）
+        PayClient<?> client = mockPayClient();
+        when(client.unifiedRefund(any(PayRefundUnifiedReqDTO.class))).thenThrow(new RuntimeException("模拟网络超时"));
+        when(client.getRefund(any(), any())).thenAnswer(invocation -> PayRefundRespDTO.failureOf(
+                "REFUND_NOT_EXISTS", "退款单不存在", invocation.getArgument(1), "failure"));
+
+        // 调用：一次查询的失败（可能是渠道退款单尚未生成），不作为最终结果，保留 WAITING 交给退款轮询
+        Long refundId = refundService.createRefund(buildRefundCreateReqDTO());
+        // 断言
+        PayRefundDO refund = refundMapper.selectById(refundId);
+        assertEquals(PayRefundStatusEnum.WAITING.getStatus(), refund.getStatus());
+        assertNull(refund.getChannelErrorCode());
+        verify(notifyService, never()).createPayNotifyTask(any(), any());
+    }
+
+    @Test // 调用 unifiedRefund 接口发生异常，查询返回 WAITING 且无渠道退款单号（例如说：支付宝查询不到退款单）
+    public void testCreateRefund_invokeException_queryWaitingWithoutChannelRefundNo() {
+        // mock 方法（client）
+        PayClient<?> client = mockPayClient();
+        when(client.unifiedRefund(any(PayRefundUnifiedReqDTO.class))).thenThrow(new RuntimeException("模拟网络超时"));
+        when(client.getRefund(any(), any())).thenAnswer(invocation -> PayRefundRespDTO.waitingOf(
+                null, invocation.getArgument(1), "waiting"));
+
+        // 调用：结果未知，保留 WAITING 交给退款轮询
+        Long refundId = refundService.createRefund(buildRefundCreateReqDTO());
+        // 断言
+        assertEquals(PayRefundStatusEnum.WAITING.getStatus(), refundMapper.selectById(refundId).getStatus());
+        verify(notifyService, never()).createPayNotifyTask(any(), any());
+    }
+
+    @Test // 调用 unifiedRefund 接口发生异常，查询渠道退款单也发生异常
+    public void testCreateRefund_invokeException_queryException() {
+        // mock 方法（client）
+        PayClient<?> client = mockPayClient();
+        when(client.unifiedRefund(any(PayRefundUnifiedReqDTO.class))).thenThrow(new RuntimeException("模拟网络超时"));
+        when(client.getRefund(any(), any())).thenThrow(new RuntimeException("模拟查询超时"));
+
+        // 调用：结果未知，保留 WAITING 交给退款轮询
+        Long refundId = refundService.createRefund(buildRefundCreateReqDTO());
+        // 断言
+        assertEquals(PayRefundStatusEnum.WAITING.getStatus(), refundMapper.selectById(refundId).getStatus());
+        verify(notifyService, never()).createPayNotifyTask(any(), any());
+    }
+
+    @Test // 调用 unifiedRefund 接口返回失败，查询也确认渠道退款失败
+    public void testCreateRefund_invokeFailure_queryFailure() {
+        // mock 方法（client）
+        PayClient<?> client = mockPayClient();
+        mockUnifiedRefundFailure(client);
+        when(client.getRefund(any(), any())).thenAnswer(invocation -> PayRefundRespDTO.failureOf(
+                "REFUND_NOT_EXISTS", "退款单不存在", invocation.getArgument(1), "failure"));
+
+        // 调用，并断言异常：以发起退款的失败原因为准
+        assertServiceException(() -> refundService.createRefund(buildRefundCreateReqDTO()),
+                REFUND_SUBMIT_CHANNEL_ERROR, "BALANCE_NOT_ENOUGH", "余额不足");
+        // 断言：退款单已更新为失败
+        assertRefundFailure("BALANCE_NOT_ENOUGH");
+    }
+
+    @Test // 调用 unifiedRefund 接口返回失败，查询返回 WAITING 且无渠道退款单号（例如说：支付宝查询不到退款单）
+    public void testCreateRefund_invokeFailure_queryWaitingWithoutChannelRefundNo() {
+        // mock 方法（client）
+        PayClient<?> client = mockPayClient();
+        mockUnifiedRefundFailure(client);
+        when(client.getRefund(any(), any())).thenAnswer(invocation -> PayRefundRespDTO.waitingOf(
+                null, invocation.getArgument(1), "waiting"));
+
+        // 调用，并断言异常：以发起退款的失败结果为准，避免一直 WAITING
+        assertServiceException(() -> refundService.createRefund(buildRefundCreateReqDTO()),
+                REFUND_SUBMIT_CHANNEL_ERROR, "BALANCE_NOT_ENOUGH", "余额不足");
+        // 断言：退款单已更新为失败
+        assertRefundFailure("BALANCE_NOT_ENOUGH");
+    }
+
+    @Test // 调用 unifiedRefund 接口返回失败，查询渠道退款单发生异常（例如说：钱包查询 WAITING 退款单）
+    public void testCreateRefund_invokeFailure_queryException() {
+        // mock 方法（client）
+        PayClient<?> client = mockPayClient();
+        mockUnifiedRefundFailure(client);
+        when(client.getRefund(any(), any())).thenThrow(new RuntimeException("模拟查询异常"));
+
+        // 调用，并断言异常：以发起退款的失败结果为准，避免一直 WAITING
+        assertServiceException(() -> refundService.createRefund(buildRefundCreateReqDTO()),
+                REFUND_SUBMIT_CHANNEL_ERROR, "BALANCE_NOT_ENOUGH", "余额不足");
+        // 断言：退款单已更新为失败
+        assertRefundFailure("BALANCE_NOT_ENOUGH");
+    }
+
+    @Test // 调用 unifiedRefund 接口返回失败，但查询到渠道退款单处理中
+    public void testCreateRefund_invokeFailure_queryProcessing() {
+        // mock 方法（client）
+        PayClient<?> client = mockPayClient();
+        mockUnifiedRefundFailure(client);
+        when(client.getRefund(any(), any())).thenAnswer(invocation -> PayRefundRespDTO.waitingOf(
+                "CHANNEL_R001", invocation.getArgument(1), "processing"));
+
+        // 调用：渠道实际已受理退款，保留 WAITING 交给退款回调、或者退款轮询
+        Long refundId = refundService.createRefund(buildRefundCreateReqDTO());
+        // 断言：保留渠道已受理的退款单号
+        PayRefundDO refund = refundMapper.selectById(refundId);
+        assertEquals(PayRefundStatusEnum.WAITING.getStatus(), refund.getStatus());
+        assertEquals("CHANNEL_R001", refund.getChannelRefundNo());
+        assertNull(refund.getChannelErrorCode());
+        verify(notifyService, never()).createPayNotifyTask(any(), any());
+    }
+
+    @Test // 调用 unifiedRefund 接口返回退款中，并返回渠道退款单号（例如说：微信退款受理）
+    public void testCreateRefund_invokeWaitingWithChannelRefundNo() {
+        // mock 方法（client）
+        PayClient<?> client = mockPayClient();
+        when(client.unifiedRefund(any(PayRefundUnifiedReqDTO.class))).thenAnswer(invocation -> PayRefundRespDTO.waitingOf(
+                "CHANNEL_R001", ((PayRefundUnifiedReqDTO) invocation.getArgument(0)).getOutRefundNo(), "processing"));
+
+        // 调用
+        Long refundId = refundService.createRefund(buildRefundCreateReqDTO());
+        // 断言：仍是 WAITING，并保存渠道退款单号、渠道返回数据
+        PayRefundDO refund = refundMapper.selectById(refundId);
+        assertEquals(PayRefundStatusEnum.WAITING.getStatus(), refund.getStatus());
+        assertEquals("CHANNEL_R001", refund.getChannelRefundNo());
+        assertNotNull(refund.getChannelNotifyData());
+        verify(client, never()).getRefund(any(), any());
+        verify(notifyService, never()).createPayNotifyTask(any(), any());
+    }
+
+    @Test // 退款中的通知晚于退款成功到达，不能覆盖已成功的退款单
+    public void testNotifyRefund_waitingWhenSuccess() {
+        // mock 数据（refund 已退款成功）
+        PayRefundDO refund = randomPojo(PayRefundDO.class, o -> o.setAppId(1L).setNo("R001")
+                .setStatus(PayRefundStatusEnum.SUCCESS.getStatus()).setChannelRefundNo("CHANNEL_R001"));
+        refundMapper.insert(refund);
+        // 准备参数
+        PayChannelDO channel = randomPojo(PayChannelDO.class, o -> o.setAppId(1L));
+
+        // 调用
+        refundService.notifyRefund(channel, PayRefundRespDTO.waitingOf("CHANNEL_R002", "R001", "processing"));
+        // 断言：不更新
+        PayRefundDO dbRefund = refundMapper.selectById(refund.getId());
+        assertEquals(PayRefundStatusEnum.SUCCESS.getStatus(), dbRefund.getStatus());
+        assertEquals("CHANNEL_R001", dbRefund.getChannelRefundNo());
+        assertEquals(refund.getChannelNotifyData(), dbRefund.getChannelNotifyData());
+    }
+
+    @Test // 并发使用相同的商户退款编号发起退款，只能创建一个退款单，避免重复退款
+    public void testCreateRefund_concurrentCreate() throws Exception {
+        // mock 方法（client）
+        PayClient<?> client = mockPayClient();
+        when(client.unifiedRefund(any(PayRefundUnifiedReqDTO.class))).thenAnswer(invocation -> PayRefundRespDTO.waitingOf(
+                "CHANNEL_R001", ((PayRefundUnifiedReqDTO) invocation.getArgument(0)).getOutRefundNo(), "processing"));
+        // mock 方法（mapper）：查询后等待一段时间，放大 select 后 insert 的时间窗口
+        PayRefundMapper refundMapperSpy = mock(PayRefundMapper.class, delegatesTo(refundMapper));
+        doAnswer(invocation -> {
+            Long count = refundMapper.selectCountByAppIdAndOrderId(invocation.getArgument(0),
+                    invocation.getArgument(1), invocation.getArgument(2));
+            Thread.sleep(300);
+            return count;
+        }).when(refundMapperSpy).selectCountByAppIdAndOrderId(any(), any(), any());
+        Object target = AopTestUtils.getTargetObject(refundService);
+        ReflectionTestUtils.setField(target, "refundMapper", refundMapperSpy);
+        List<Throwable> exceptions = new ArrayList<>();
+        try {
+            // 调用：两个请求并发发起退款
+            List<CompletableFuture<Long>> futures = List.of(
+                    CompletableFuture.supplyAsync(() -> refundService.createRefund(buildRefundCreateReqDTO())),
+                    CompletableFuture.supplyAsync(() -> refundService.createRefund(buildRefundCreateReqDTO())));
+            for (CompletableFuture<Long> future : futures) {
+                try {
+                    future.get();
+                } catch (Exception ex) {
+                    exceptions.add(ex.getCause());
+                }
+            }
+        } finally {
+            ReflectionTestUtils.setField(target, "refundMapper", refundMapper);
+        }
+        // 断言：只有一个请求创建退款单，另一个请求提示存在退款中的退款单
+        assertEquals(1, exceptions.size());
+        assertEquals(REFUND_HAS_REFUNDING.getCode(), ((ServiceException) exceptions.get(0)).getCode());
+        assertEquals(1, refundMapper.selectList().size());
+        verify(client, times(1)).unifiedRefund(any());
+    }
+
+    @Test // 调用 unifiedRefund 接口返回失败，但查询确认渠道退款成功
+    public void testCreateRefund_invokeFailure_querySuccess() {
+        // mock 方法（client）
+        PayClient<?> client = mockPayClient();
+        mockUnifiedRefundFailure(client);
+        when(client.getRefund(any(), any())).thenAnswer(invocation -> PayRefundRespDTO.successOf("CHANNEL_R001",
+                LocalDateTime.now(), invocation.getArgument(1), "success"));
+
+        // 调用
+        Long refundId = refundService.createRefund(buildRefundCreateReqDTO());
+        // 断言：按查询结果更新为退款成功
+        PayRefundDO refund = refundMapper.selectById(refundId);
+        assertEquals(PayRefundStatusEnum.SUCCESS.getStatus(), refund.getStatus());
+        verify(notifyService).createPayNotifyTask(eq(PayNotifyTypeEnum.REFUND.getType()), eq(refundId));
+    }
+
+    @Test // 调用 unifiedRefund 接口返回成功，但处理退款结果时发生异常
+    public void testCreateRefund_invokeSuccess_notifyException() {
+        // mock 方法（client）：返回不存在的退款单号，使 notifyRefund 抛出异常
+        PayClient<?> client = mockPayClient();
+        when(client.unifiedRefund(any(PayRefundUnifiedReqDTO.class))).thenReturn(PayRefundRespDTO.successOf(
+                "CHANNEL_R001", LocalDateTime.now(), "NOT_EXISTS", "success"));
+
+        // 调用：渠道已退款成功，不向调用方抛出异常，避免调用方回滚退款单
+        Long refundId = refundService.createRefund(buildRefundCreateReqDTO());
+        // 断言
+        assertEquals(PayRefundStatusEnum.WAITING.getStatus(), refundMapper.selectById(refundId).getStatus());
+        verify(client, never()).getRefund(any(), any());
+    }
+
+    @Test // 调用 unifiedRefund 接口返回存在渠道错误，但退款单已被并发更新为成功（例如说：退款回调）
+    public void testCreateRefund_channelErrorWhenConcurrentSuccess() {
+        // mock 方法（client）
+        PayClient<?> client = mockPayClient();
+        mockUnifiedRefundFailure(client);
+        when(client.getRefund(any(), any())).thenAnswer(invocation -> {
+            // 模拟：退款回调并发更新退款单为退款成功
+            PayRefundDO refund = refundMapper.selectByNo(invocation.getArgument(1));
+            refundMapper.updateById(new PayRefundDO().setId(refund.getId())
+                    .setStatus(PayRefundStatusEnum.SUCCESS.getStatus()));
+            return PayRefundRespDTO.failureOf("REFUND_NOT_EXISTS", "退款单不存在", invocation.getArgument(1), "failure");
+        });
+
+        // 调用：以最新的退款成功为准，不向调用方误报失败
+        Long refundId = refundService.createRefund(buildRefundCreateReqDTO());
+        // 断言
+        assertEquals(PayRefundStatusEnum.SUCCESS.getStatus(), refundMapper.selectById(refundId).getStatus());
+        verify(notifyService, never()).createPayNotifyTask(any(), any());
+    }
+
+    @Test // 调用 unifiedRefund 接口返回存在渠道错误，通知时发生状态竞争，但退款单仍是待退款
+    public void testCreateRefund_channelErrorWhenConcurrentWaiting() {
+        PayRefundServiceImpl payRefundServiceImpl = mock(PayRefundServiceImpl.class);
+        try (MockedStatic<SpringUtil> springUtilMockedStatic = mockStatic(SpringUtil.class)) {
+            springUtilMockedStatic.when(() -> SpringUtil.getBean(eq(PayRefundServiceImpl.class)))
+                    .thenReturn(payRefundServiceImpl);
+            doThrow(exception(REFUND_STATUS_IS_NOT_WAITING))
+                    .when(payRefundServiceImpl).notifyRefund(any(PayChannelDO.class), any());
+            // mock 方法（client）
+            PayClient<?> client = mockPayClient();
+            mockUnifiedRefundFailure(client);
+
+            // 调用，并断言异常：无法确认最新状态，抛出原通知异常
+            assertServiceException(() -> refundService.createRefund(buildRefundCreateReqDTO()),
+                    REFUND_STATUS_IS_NOT_WAITING);
+            // 断言
+            PayRefundDO refund = refundMapper.selectByAppIdAndMerchantRefundId(1L, "200");
+            assertEquals(PayRefundStatusEnum.WAITING.getStatus(), refund.getStatus());
+        }
+    }
+
+    @Test // 调用 unifiedRefund 接口返回存在渠道错误，但创建退款通知任务时发生异常
+    public void testCreateRefund_channelErrorAndNotifyTaskException() {
+        // mock 方法（client）
+        PayClient<?> client = mockPayClient();
+        mockUnifiedRefundFailure(client);
+        // mock 方法（notify）
+        RuntimeException notifyTaskException = new RuntimeException("模拟创建通知任务异常");
+        doThrow(notifyTaskException).when(notifyService).createPayNotifyTask(any(), any());
+
+        // 调用，并断言异常：抛出真实的通知异常，而不是渠道错误
+        RuntimeException ex = assertThrows(RuntimeException.class,
+                () -> refundService.createRefund(buildRefundCreateReqDTO()));
+        assertSame(notifyTaskException, ex);
+        // 断言：失败状态随通知事务回滚
+        PayRefundDO refund = refundMapper.selectByAppIdAndMerchantRefundId(1L, "200");
+        assertEquals(PayRefundStatusEnum.WAITING.getStatus(), refund.getStatus());
+        assertNull(refund.getChannelErrorCode());
+    }
+
+    @Test // 调用 unifiedRefund 接口，返回失败，但不存在渠道错误
+    public void testCreateRefund_failureWithoutChannelError() {
+        // mock 方法（client）
+        PayClient<?> client = mockPayClient();
+        when(client.unifiedRefund(any(PayRefundUnifiedReqDTO.class))).thenAnswer(invocation ->
+                PayRefundRespDTO.failureOf(null, null,
+                        ((PayRefundUnifiedReqDTO) invocation.getArgument(0)).getOutRefundNo(), "failure"));
+
+        // 调用：不抛出异常，由退款通知告知调用方
+        Long refundId = refundService.createRefund(buildRefundCreateReqDTO());
+        // 断言
+        assertEquals(PayRefundStatusEnum.FAILURE.getStatus(), refundMapper.selectById(refundId).getStatus());
+        verify(notifyService).createPayNotifyTask(eq(PayNotifyTypeEnum.REFUND.getType()), eq(refundId));
+    }
+
+    @Test // 退款失败（例如说：余额不足）后，使用相同的商户退款编号再次发起，退款成功
+    public void testCreateRefund_retryAfterFailure_success() {
+        // 准备参数：首次发起退款失败
+        PayClient<?> client = mockPayClient();
+        mockUnifiedRefundFailure(client);
+        when(client.getRefund(any(), any())).thenAnswer(invocation -> PayRefundRespDTO.failureOf(
+                "REFUND_NOT_EXISTS", "退款单不存在", invocation.getArgument(1), "failure"));
+        assertServiceException(() -> refundService.createRefund(buildRefundCreateReqDTO()),
+                REFUND_SUBMIT_CHANNEL_ERROR, "BALANCE_NOT_ENOUGH", "余额不足");
+        PayRefundDO failureRefund = refundMapper.selectByAppIdAndMerchantRefundId(1L, "200");
+        // mock 方法（client 再次发起时，退款成功）
+        doAnswer(invocation -> PayRefundRespDTO.successOf("CHANNEL_R001", LocalDateTime.now(),
+                ((PayRefundUnifiedReqDTO) invocation.getArgument(0)).getOutRefundNo(), "success"))
+                .when(client).unifiedRefund(any(PayRefundUnifiedReqDTO.class));
+
+        // 调用
+        Long refundId = refundService.createRefund(buildRefundCreateReqDTO().setReason("再次退款"));
+        // 断言：复用原退款单及原退款单号，并清空上一次的失败原因
+        assertEquals(failureRefund.getId(), refundId);
+        assertEquals(1, refundMapper.selectList().size());
+        PayRefundDO refund = refundMapper.selectById(refundId);
+        assertEquals(failureRefund.getNo(), refund.getNo());
+        assertEquals(PayRefundStatusEnum.SUCCESS.getStatus(), refund.getStatus());
+        assertEquals("CHANNEL_R001", refund.getChannelRefundNo());
+        assertEquals("再次退款", refund.getReason());
+        assertNull(refund.getChannelErrorCode());
+        assertNull(refund.getChannelErrorMsg());
+        // 断言：两次都使用原退款单号向渠道发起退款，并分别通知退款失败、退款成功
+        verify(client, times(2)).unifiedRefund(argThat(unifiedReqDTO ->
+                failureRefund.getNo().equals(unifiedReqDTO.getOutRefundNo())));
+        verify(notifyService, times(2)).createPayNotifyTask(eq(PayNotifyTypeEnum.REFUND.getType()), eq(refundId));
+    }
+
+    @Test // 退款失败后再次发起，渠道结果未知，保留 WAITING 并清空上一次的渠道结果
+    public void testCreateRefund_retryAfterFailure_unknown() {
+        // 准备参数：已存在退款失败的退款单
+        PayClient<?> client = mockPayClient();
+        PayRefundDO failureRefund = insertFailureRefund(9);
+        // mock 方法（client 调用发生异常，查询也发生异常）
+        when(client.unifiedRefund(any(PayRefundUnifiedReqDTO.class))).thenThrow(new RuntimeException("模拟网络超时"));
+        when(client.getRefund(any(), any())).thenThrow(new RuntimeException("模拟查询超时"));
+
+        // 调用
+        Long refundId = refundService.createRefund(buildRefundCreateReqDTO());
+        // 断言：复用原退款单号，状态重置为 WAITING，交给退款回调、或者退款轮询
+        assertEquals(failureRefund.getId(), refundId);
+        PayRefundDO refund = refundMapper.selectById(refundId);
+        assertEquals(PayRefundStatusEnum.WAITING.getStatus(), refund.getStatus());
+        assertNull(refund.getChannelRefundNo());
+        assertNull(refund.getChannelErrorCode());
+        assertNull(refund.getChannelErrorMsg());
+        assertNull(refund.getChannelNotifyData());
+        verify(client).getRefund(eq(failureRefund.getOrderNo()), eq(failureRefund.getNo()));
+    }
+
+    @Test // 退款失败后再次发起，但退款单已被并发重新发起
+    public void testCreateRefund_retryAfterFailure_concurrentRetry() {
+        // 准备参数：已存在退款失败的退款单
+        PayClient<?> client = mockPayClient();
+        PayRefundDO failureRefund = insertFailureRefund(9);
+        // mock 方法（mapper）：校验通过后、更新前，其它请求已将退款单重新发起为 WAITING
+        PayRefundMapper refundMapperSpy = mock(PayRefundMapper.class, delegatesTo(refundMapper));
+        doAnswer(invocation -> {
+            refundMapper.updateById(new PayRefundDO().setId(failureRefund.getId())
+                    .setStatus(PayRefundStatusEnum.WAITING.getStatus()));
+            return refundMapper.updateByIdAndStatusAndClearChannelResult(invocation.getArgument(0),
+                    invocation.getArgument(1), invocation.getArgument(2));
+        }).when(refundMapperSpy).updateByIdAndStatusAndClearChannelResult(any(), any(), any());
+        Object target = AopTestUtils.getTargetObject(refundService);
+        ReflectionTestUtils.setField(target, "refundMapper", refundMapperSpy);
+        try {
+            // 调用，并断言异常
+            assertServiceException(() -> refundService.createRefund(buildRefundCreateReqDTO()),
+                    REFUND_HAS_REFUNDING);
+        } finally {
+            ReflectionTestUtils.setField(target, "refundMapper", refundMapper);
+        }
+        // 断言：不会再次向渠道发起退款
+        verify(client, never()).unifiedRefund(any());
+        assertEquals(PayRefundStatusEnum.WAITING.getStatus(), refundMapper.selectById(failureRefund.getId()).getStatus());
+    }
+
+    @Test // 调用方存在事务，退款失败后调用方事务回滚，退款失败的结果仍需保存，并可使用原退款单号重新发起
+    public void testCreateRefund_outerTransactionRollback() {
+        // mock 方法（client）
+        PayClient<?> client = mockPayClient();
+        mockUnifiedRefundFailure(client);
+        PayRefundDO outerRefund = randomPojo(PayRefundDO.class, o -> o.setAppId(1L).setMerchantRefundId("300"));
+
+        // 调用：调用方事务中，先写入自己的数据，再发起退款，渠道错误导致调用方事务回滚
+        TransactionTemplate transactionTemplate = new TransactionTemplate(transactionManager);
+        assertServiceException(() -> transactionTemplate.executeWithoutResult(status -> {
+            refundMapper.insert(outerRefund);
+            refundService.createRefund(buildRefundCreateReqDTO());
+        }), REFUND_SUBMIT_CHANNEL_ERROR, "BALANCE_NOT_ENOUGH", "余额不足");
+        // 断言：调用方事务已回滚，但退款失败的结果（包括退款通知）已保存
+        assertNull(refundMapper.selectById(outerRefund.getId()));
+        assertRefundFailure("BALANCE_NOT_ENOUGH");
+        PayRefundDO failureRefund = refundMapper.selectByAppIdAndMerchantRefundId(1L, "200");
+
+        // mock 方法（client 再次发起时，退款成功）
+        doAnswer(invocation -> PayRefundRespDTO.successOf("CHANNEL_R001", LocalDateTime.now(),
+                ((PayRefundUnifiedReqDTO) invocation.getArgument(0)).getOutRefundNo(), "success"))
+                .when(client).unifiedRefund(any(PayRefundUnifiedReqDTO.class));
+        // 调用：使用相同的商户退款编号再次发起
+        Long refundId = transactionTemplate.execute(status -> refundService.createRefund(buildRefundCreateReqDTO()));
+        // 断言：复用原退款单号
+        assertEquals(failureRefund.getId(), refundId);
+        PayRefundDO refund = refundMapper.selectById(refundId);
+        assertEquals(failureRefund.getNo(), refund.getNo());
+        assertEquals(PayRefundStatusEnum.SUCCESS.getStatus(), refund.getStatus());
+    }
+
+    @Test // 退款失败后再次发起，但支付订单不一致
+    public void testCreateRefund_retryAfterFailure_orderNotMatch() {
+        // 准备参数：已存在退款失败的退款单，关联其它支付订单
+        PayClient<?> client = mockPayClient();
+        PayRefundDO failureRefund = insertFailureRefund(9);
+        refundMapper.updateById(new PayRefundDO().setId(failureRefund.getId()).setOrderId(-1L));
+
+        // 调用，并断言异常
+        assertServiceException(() -> refundService.createRefund(buildRefundCreateReqDTO()),
+                REFUND_CREATE_FAIL_ORDER_NOT_MATCH);
+        assertEquals(PayRefundStatusEnum.FAILURE.getStatus(), refundMapper.selectById(failureRefund.getId()).getStatus());
+        verify(client, never()).unifiedRefund(any());
+    }
+
+    @Test // 退款失败后再次发起，但退款金额不一致
+    public void testCreateRefund_retryAfterFailure_priceNotMatch() {
+        // 准备参数：已存在退款金额为 5 的退款失败的退款单
+        PayClient<?> client = mockPayClient();
+        PayRefundDO failureRefund = insertFailureRefund(5);
+
+        // 调用，并断言异常
+        assertServiceException(() -> refundService.createRefund(buildRefundCreateReqDTO()),
+                REFUND_CREATE_FAIL_PRICE_NOT_MATCH);
+        assertEquals(PayRefundStatusEnum.FAILURE.getStatus(), refundMapper.selectById(failureRefund.getId()).getStatus());
+        verify(client, never()).unifiedRefund(any());
     }
     @Test
@@ -696,4 +1157,59 @@ public class PayRefundServiceTest extends BaseDbAndRedisUnitTest {
         assertEquals(count, 0);
     }
+    private PayClient<?> mockPayClient() {
+        // mock 方法（app）
+        PayAppDO app = randomPojo(PayAppDO.class, o -> o.setId(1L));
+        when(appService.validPayApp(eq("demo"))).thenReturn(app);
+        // mock 数据（order）
+        PayOrderDO order = randomPojo(PayOrderDO.class, o ->
+                o.setStatus(PayOrderStatusEnum.SUCCESS.getStatus())
+                        .setPrice(10).setRefundPrice(0)
+                        .setChannelId(10L).setChannelCode(PayChannelEnum.ALIPAY_APP.getCode()));
+        when(orderService.getOrder(eq(1L), eq("100"))).thenReturn(order);
+        // mock 方法（channel）
+        PayChannelDO channel = randomPojo(PayChannelDO.class, o -> o.setId(10L).setAppId(1L)
+                .setCode(PayChannelEnum.ALIPAY_APP.getCode()));
+        when(channelService.validPayChannel(eq(10L))).thenReturn(channel);
+        // mock 方法（client）
+        PayClient<?> client = mock(PayClient.class);
+        when(channelService.getPayClient(eq(10L))).thenReturn(client);
+        return client;
+    }
+
+    private static void mockUnifiedRefundFailure(PayClient<?> client) {
+        when(client.unifiedRefund(any(PayRefundUnifiedReqDTO.class))).thenAnswer(invocation -> {
+            PayRefundUnifiedReqDTO unifiedReqDTO = invocation.getArgument(0);
+            return PayRefundRespDTO.failureOf("BALANCE_NOT_ENOUGH", "余额不足",
+                    unifiedReqDTO.getOutRefundNo(), "failure");
+        });
+    }
+
+    private static PayRefundCreateReqDTO buildRefundCreateReqDTO() {
+        return new PayRefundCreateReqDTO().setAppKey("demo").setUserIp("127.0.0.1")
+                .setUserId(1L).setUserType(1)
+                .setMerchantOrderId("100").setMerchantRefundId("200")
+                .setReason("测试退款").setPrice(9);
+    }
+
+    /**
+     * 插入退款失败的退款单，关联 {@link #mockPayClient()} 的支付订单
+     */
+    private PayRefundDO insertFailureRefund(Integer refundPrice) {
+        PayOrderDO order = orderService.getOrder(1L, "100");
+        PayRefundDO refund = randomPojo(PayRefundDO.class, o -> o.setAppId(1L).setMerchantRefundId("200")
+                .setOrderId(order.getId()).setOrderNo(order.getNo()).setRefundPrice(refundPrice)
+                .setStatus(PayRefundStatusEnum.FAILURE.getStatus())
+                .setChannelErrorCode("BALANCE_NOT_ENOUGH").setChannelErrorMsg("余额不足"));
+        refundMapper.insert(refund);
+        return refund;
+    }
+
+    private void assertRefundFailure(String channelErrorCode) {
+        PayRefundDO refund = refundMapper.selectByAppIdAndMerchantRefundId(1L, "200");
+        assertEquals(PayRefundStatusEnum.FAILURE.getStatus(), refund.getStatus());
+        assertEquals(channelErrorCode, refund.getChannelErrorCode());
+        verify(notifyService).createPayNotifyTask(eq(PayNotifyTypeEnum.REFUND.getType()), eq(refund.getId()));
+    }
+
 }
 package cn.iocoder.yudao.module.pay.service.transfer;
 import cn.hutool.extra.spring.SpringUtil;
+import cn.iocoder.yudao.framework.common.exception.ServiceException;
 import cn.iocoder.yudao.framework.test.core.ut.BaseDbAndRedisUnitTest;
 import cn.iocoder.yudao.module.pay.api.transfer.dto.PayTransferCreateReqDTO;
 import cn.iocoder.yudao.module.pay.api.transfer.dto.PayTransferCreateRespDTO;
@@ -9,6 +10,7 @@ import cn.iocoder.yudao.module.pay.dal.dataobject.channel.PayChannelDO;
 import cn.iocoder.yudao.module.pay.dal.dataobject.transfer.PayTransferDO;
 import cn.iocoder.yudao.module.pay.dal.mysql.transfer.PayTransferMapper;
 import cn.iocoder.yudao.module.pay.dal.redis.no.PayNoRedisDAO;
+import cn.iocoder.yudao.module.pay.dal.redis.transfer.PayTransferLockRedisDAO;
 import cn.iocoder.yudao.module.pay.enums.PayChannelEnum;
 import cn.iocoder.yudao.module.pay.enums.notify.PayNotifyTypeEnum;
 import cn.iocoder.yudao.module.pay.enums.transfer.PayTransferStatusEnum;
@@ -24,14 +26,23 @@ import org.junit.jupiter.api.Test;
 import org.mockito.MockedStatic;
 import org.springframework.context.annotation.Import;
 import org.springframework.test.context.bean.override.mockito.MockitoBean;
+import org.springframework.test.util.AopTestUtils;
+import org.springframework.test.util.ReflectionTestUtils;
+import org.springframework.transaction.PlatformTransactionManager;
+import org.springframework.transaction.support.TransactionTemplate;
 import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.CompletableFuture;
 import static cn.iocoder.yudao.framework.test.core.util.AssertUtils.assertServiceException;
 import static cn.iocoder.yudao.framework.test.core.util.RandomUtils.randomPojo;
 import static cn.iocoder.yudao.framework.common.exception.util.ServiceExceptionUtil.exception;
 import static cn.iocoder.yudao.module.pay.enums.ErrorCodeConstants.*;
 import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.AdditionalAnswers.delegatesTo;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.*;
@@ -41,7 +52,7 @@ import static org.mockito.Mockito.*;
  *
  * @author 芋道源码
  */
-@Import({PayTransferServiceImpl.class, PayNoRedisDAO.class})
+@Import({PayTransferServiceImpl.class, PayNoRedisDAO.class, PayTransferLockRedisDAO.class})
 public class PayTransferServiceTest extends BaseDbAndRedisUnitTest {
     @Resource
@@ -50,6 +61,9 @@ public class PayTransferServiceTest extends BaseDbAndRedisUnitTest {
     @Resource
     private PayTransferMapper transferMapper;
+    @Resource
+    private PlatformTransactionManager transactionManager;
+
     @MockitoBean
     private PayProperties payProperties;
     @MockitoBean
@@ -123,6 +137,207 @@ public class PayTransferServiceTest extends BaseDbAndRedisUnitTest {
         verify(notifyService, never()).createPayNotifyTask(any(), any());
     }
+    @Test // 调用 unifiedTransfer 接口发生异常，查询返回关闭（例如说：钱包查询不到转账单）
+    public void testCreateTransfer_unifiedTransferException_queryClosed() {
+        // mock 方法（client）
+        PayClient<?> client = mockPayClient();
+        when(client.unifiedTransfer(any())).thenThrow(new RuntimeException("模拟网络超时"));
+        when(client.getTransfer(any())).thenAnswer(invocation ->
+                PayTransferRespDTO.closedOf("ORDER_NOT_EXIST", "转账单不存在", invocation.getArgument(0), "closed"));
+        // 准备参数
+        PayTransferCreateReqDTO reqDTO = buildTransferCreateReqDTO();
+
+        // 调用：一次查询的关闭（可能是渠道转账单尚未生成），不作为最终结果，保留 WAITING 交给转账轮询
+        PayTransferCreateRespDTO respDTO = transferService.createTransfer(reqDTO);
+        // 断言
+        PayTransferDO dbTransfer = transferMapper.selectById(respDTO.getId());
+        assertEquals(PayTransferStatusEnum.WAITING.getStatus(), dbTransfer.getStatus());
+        assertNull(dbTransfer.getChannelErrorCode());
+        verify(client).getTransfer(any());
+        verify(notifyService, never()).createPayNotifyTask(any(), any());
+    }
+
+    @Test // 调用 unifiedTransfer 接口发生异常，查询返回 WAITING（例如说：支付宝查询不到转账单）
+    public void testCreateTransfer_unifiedTransferException_queryWaiting() {
+        // mock 方法（client）
+        PayClient<?> client = mockPayClient();
+        when(client.unifiedTransfer(any())).thenThrow(new RuntimeException("模拟网络超时"));
+        when(client.getTransfer(any())).thenAnswer(invocation ->
+                PayTransferRespDTO.waitingOf(null, invocation.getArgument(0), "waiting"));
+        // 准备参数
+        PayTransferCreateReqDTO reqDTO = buildTransferCreateReqDTO();
+
+        // 调用：结果未知，保留 WAITING 交给转账轮询
+        PayTransferCreateRespDTO respDTO = transferService.createTransfer(reqDTO);
+        // 断言
+        assertEquals(PayTransferStatusEnum.WAITING.getStatus(), transferMapper.selectById(respDTO.getId()).getStatus());
+        verify(notifyService, never()).createPayNotifyTask(any(), any());
+    }
+
+    @Test // 调用 unifiedTransfer 接口返回关闭，但查询到渠道转账中（例如说：上一次实际已受理）
+    public void testCreateTransfer_closed_queryProcessing() {
+        // mock 方法（client）
+        PayClient<?> client = mockPayClient();
+        when(client.unifiedTransfer(any())).thenAnswer(invocation -> {
+            PayTransferUnifiedReqDTO unifiedReqDTO = invocation.getArgument(0);
+            return PayTransferRespDTO.closedOf("SYSTEM_ERROR", "系统繁忙", unifiedReqDTO.getOutTransferNo(), "closed");
+        });
+        when(client.getTransfer(any())).thenAnswer(invocation ->
+                PayTransferRespDTO.processingOf("CHANNEL_T001", invocation.getArgument(0), "processing"));
+        // 准备参数
+        PayTransferCreateReqDTO reqDTO = buildTransferCreateReqDTO();
+
+        // 调用：渠道实际已受理转账，以查询结果为准，不向调用方误报渠道错误
+        PayTransferCreateRespDTO respDTO = transferService.createTransfer(reqDTO);
+        // 断言
+        PayTransferDO dbTransfer = transferMapper.selectById(respDTO.getId());
+        assertEquals(PayTransferStatusEnum.PROCESSING.getStatus(), dbTransfer.getStatus());
+        assertNull(dbTransfer.getChannelErrorCode());
+        verify(notifyService, never()).createPayNotifyTask(any(), any());
+    }
+
+    @Test // 调用 unifiedTransfer 接口返回关闭，但查询到已有渠道转账单号的待转账（例如说：上一次实际已受理）
+    public void testCreateTransfer_closed_queryWaitingWithChannelTransferNo() {
+        // mock 方法（client）
+        PayClient<?> client = mockPayClient();
+        when(client.unifiedTransfer(any())).thenAnswer(invocation -> {
+            PayTransferUnifiedReqDTO unifiedReqDTO = invocation.getArgument(0);
+            return PayTransferRespDTO.closedOf("SYSTEM_ERROR", "系统繁忙", unifiedReqDTO.getOutTransferNo(), "closed");
+        });
+        when(client.getTransfer(any())).thenAnswer(invocation ->
+                PayTransferRespDTO.waitingOf("CHANNEL_T001", invocation.getArgument(0), "waiting"));
+        // 准备参数
+        PayTransferCreateReqDTO reqDTO = buildTransferCreateReqDTO();
+
+        // 调用：渠道实际已受理转账，以查询结果为准，不向调用方误报渠道错误
+        PayTransferCreateRespDTO respDTO = transferService.createTransfer(reqDTO);
+        // 断言：仍是 WAITING，并保存渠道转账单号、渠道返回数据
+        PayTransferDO dbTransfer = transferMapper.selectById(respDTO.getId());
+        assertEquals(PayTransferStatusEnum.WAITING.getStatus(), dbTransfer.getStatus());
+        assertEquals("CHANNEL_T001", dbTransfer.getChannelTransferNo());
+        assertNotNull(dbTransfer.getChannelNotifyData());
+        assertNull(dbTransfer.getChannelErrorCode());
+        verify(notifyService, never()).createPayNotifyTask(any(), any());
+    }
+
+    @Test // 待转账的通知晚于转账中到达，不能覆盖转账中的转账单
+    public void testNotifyTransferWaiting_whenProcessing() {
+        // mock 数据（PayTransferDO）
+        PayTransferDO transfer = randomPojo(PayTransferDO.class, o -> o.setAppId(10L).setNo("T110")
+                .setStatus(PayTransferStatusEnum.PROCESSING.getStatus()).setChannelTransferNo("WX_TRANSFER_110"));
+        transferMapper.insert(transfer);
+        // 准备参数
+        PayChannelDO channel = randomPojo(PayChannelDO.class, o -> o.setAppId(10L));
+
+        // 调用
+        transferService.notifyTransfer(channel, PayTransferRespDTO.waitingOf("WX_TRANSFER_111", "T110", "waiting"));
+        // 断言：不更新
+        PayTransferDO dbTransfer = transferMapper.selectById(transfer.getId());
+        assertEquals(PayTransferStatusEnum.PROCESSING.getStatus(), dbTransfer.getStatus());
+        assertEquals("WX_TRANSFER_110", dbTransfer.getChannelTransferNo());
+        assertEquals(transfer.getChannelNotifyData(), dbTransfer.getChannelNotifyData());
+    }
+
+    @Test // 并发使用相同的商户转账编号发起转账，只能创建一个转账单，避免重复转账
+    public void testCreateTransfer_concurrentCreate() throws Exception {
+        // mock 方法（client）
+        PayClient<?> client = mockPayClient();
+        when(client.unifiedTransfer(any())).thenAnswer(invocation -> {
+            PayTransferUnifiedReqDTO unifiedReqDTO = invocation.getArgument(0);
+            return PayTransferRespDTO.processingOf("CHANNEL_T001", unifiedReqDTO.getOutTransferNo(), "processing");
+        });
+        // mock 方法（mapper）：查询后等待一段时间，放大 select 后 insert 的时间窗口
+        PayTransferMapper transferMapperSpy = mock(PayTransferMapper.class, delegatesTo(transferMapper));
+        doAnswer(invocation -> {
+            PayTransferDO transfer = transferMapper.selectByAppIdAndMerchantOrderId(invocation.getArgument(0),
+                    invocation.getArgument(1));
+            Thread.sleep(300);
+            return transfer;
+        }).when(transferMapperSpy).selectByAppIdAndMerchantOrderId(any(), any());
+        Object target = AopTestUtils.getTargetObject(transferService);
+        ReflectionTestUtils.setField(target, "transferMapper", transferMapperSpy);
+        List<Throwable> exceptions = new ArrayList<>();
+        try {
+            // 调用：两个请求并发发起转账
+            List<CompletableFuture<PayTransferCreateRespDTO>> futures = List.of(
+                    CompletableFuture.supplyAsync(() -> transferService.createTransfer(buildTransferCreateReqDTO())),
+                    CompletableFuture.supplyAsync(() -> transferService.createTransfer(buildTransferCreateReqDTO())));
+            for (CompletableFuture<PayTransferCreateRespDTO> future : futures) {
+                try {
+                    future.get();
+                } catch (Exception ex) {
+                    exceptions.add(ex.getCause());
+                }
+            }
+        } finally {
+            ReflectionTestUtils.setField(target, "transferMapper", transferMapper);
+        }
+        // 断言：只有一个请求创建转账单，另一个请求提示转账单不是关闭状态
+        assertEquals(1, exceptions.size());
+        assertEquals(PAY_TRANSFER_CREATE_FAIL_STATUS_NOT_CLOSED.getCode(), ((ServiceException) exceptions.get(0)).getCode());
+        assertEquals(1, transferMapper.selectList().size());
+        verify(client, times(1)).unifiedTransfer(any());
+    }
+
+    @Test // 调用 unifiedTransfer 接口返回关闭，查询返回 WAITING（例如说：支付宝查询不到转账单）
+    public void testCreateTransfer_closed_queryWaiting() {
+        // mock 方法（client）
+        PayClient<?> client = mockPayClient();
+        when(client.unifiedTransfer(any())).thenAnswer(invocation -> {
+            PayTransferUnifiedReqDTO unifiedReqDTO = invocation.getArgument(0);
+            return PayTransferRespDTO.closedOf("PAYEE_NOT_EXIST", "收款账号不存在",
+                    unifiedReqDTO.getOutTransferNo(), "closed");
+        });
+        when(client.getTransfer(any())).thenAnswer(invocation ->
+                PayTransferRespDTO.waitingOf(null, invocation.getArgument(0), "waiting"));
+        // 准备参数
+        PayTransferCreateReqDTO reqDTO = buildTransferCreateReqDTO();
+
+        // 调用，并断言异常：以渠道明确返回的关闭为准
+        assertServiceException(() -> transferService.createTransfer(reqDTO),
+                PAY_TRANSFER_SUBMIT_CHANNEL_ERROR, "PAYEE_NOT_EXIST", "收款账号不存在");
+        // 断言
+        PayTransferDO dbTransfer = transferMapper.selectByAppIdAndMerchantOrderId(1L, reqDTO.getMerchantTransferId());
+        assertEquals(PayTransferStatusEnum.CLOSED.getStatus(), dbTransfer.getStatus());
+        assertEquals("PAYEE_NOT_EXIST", dbTransfer.getChannelErrorCode());
+    }
+
+    @Test // 调用 unifiedTransfer 接口发生异常，但查询确认渠道转账成功
+    public void testCreateTransfer_unifiedTransferException_querySuccess() {
+        // mock 方法（client）
+        PayClient<?> client = mockPayClient();
+        when(client.unifiedTransfer(any())).thenThrow(new RuntimeException("模拟网络超时"));
+        when(client.getTransfer(any())).thenAnswer(invocation ->
+                PayTransferRespDTO.successOf("CHANNEL_T001", LocalDateTime.now(),
+                        invocation.getArgument(0), "success"));
+        // 准备参数
+        PayTransferCreateReqDTO reqDTO = buildTransferCreateReqDTO();
+
+        // 调用：查询确认渠道转账成功
+        PayTransferCreateRespDTO respDTO = transferService.createTransfer(reqDTO);
+        // 断言：按查询结果落库为成功
+        PayTransferDO dbTransfer = transferMapper.selectById(respDTO.getId());
+        assertEquals(PayTransferStatusEnum.SUCCESS.getStatus(), dbTransfer.getStatus());
+        verify(notifyService).createPayNotifyTask(eq(PayNotifyTypeEnum.TRANSFER.getType()), eq(dbTransfer.getId()));
+    }
+
+    @Test // 调用 unifiedTransfer 接口发生异常，查询渠道状态也发生异常
+    public void testCreateTransfer_unifiedTransferException_queryException() {
+        // mock 方法（client）
+        PayClient<?> client = mockPayClient();
+        when(client.unifiedTransfer(any())).thenThrow(new RuntimeException("模拟网络超时"));
+        when(client.getTransfer(any())).thenThrow(new RuntimeException("模拟查询超时"));
+        // 准备参数
+        PayTransferCreateReqDTO reqDTO = buildTransferCreateReqDTO();
+
+        // 调用：查询失败时保留 WAITING，交给后续轮询补偿
+        PayTransferCreateRespDTO respDTO = transferService.createTransfer(reqDTO);
+        // 断言
+        PayTransferDO dbTransfer = transferMapper.selectById(respDTO.getId());
+        assertEquals(PayTransferStatusEnum.WAITING.getStatus(), dbTransfer.getStatus());
+        verify(client).getTransfer(any());
+    }
+
     @Test // 调用 unifiedTransfer 接口，返回 null
     public void testCreateTransfer_nullResponse() {
         // mock 方法（client）
@@ -223,6 +438,7 @@ public class PayTransferServiceTest extends BaseDbAndRedisUnitTest {
         PayTransferDO dbTransfer = transferMapper.selectById(respDTO.getId());
         assertEquals(PayTransferStatusEnum.PROCESSING.getStatus(), dbTransfer.getStatus());
         assertEquals("package-info-001", dbTransfer.getChannelPackageInfo());
+        assertEquals("CHANNEL_T001", dbTransfer.getChannelTransferNo());
     }
     @Test // 调用 unifiedTransfer 接口返回成功，但通知转账结果时找不到转账单
@@ -360,6 +576,203 @@ public class PayTransferServiceTest extends BaseDbAndRedisUnitTest {
         }
     }
+    @Test // 已存在相同的转账单，且不是转账关闭
+    public void testCreateTransfer_transferExists() {
+        // mock 方法（client）
+        PayClient<?> client = mockPayClient();
+        // mock 数据：已存在转账成功的转账单
+        PayTransferDO transfer = insertClosedTransfer();
+        transferMapper.updateById(new PayTransferDO().setId(transfer.getId())
+                .setStatus(PayTransferStatusEnum.SUCCESS.getStatus()));
+
+        // 调用，并断言异常
+        assertServiceException(() -> transferService.createTransfer(buildTransferCreateReqDTO()),
+                PAY_TRANSFER_CREATE_FAIL_STATUS_NOT_CLOSED);
+        verify(client, never()).unifiedTransfer(any());
+    }
+
+    @Test // 转账关闭后再次发起，但转账渠道不一致
+    public void testCreateTransfer_retryAfterClosed_channelNotMatch() {
+        // mock 方法（client）
+        PayClient<?> client = mockPayClient();
+        // mock 数据：已存在其它渠道的关闭的转账单
+        PayTransferDO transfer = insertClosedTransfer();
+        transferMapper.updateById(new PayTransferDO().setId(transfer.getId())
+                .setChannelCode(PayChannelEnum.WX_PUB.getCode()));
+
+        // 调用，并断言异常
+        assertServiceException(() -> transferService.createTransfer(buildTransferCreateReqDTO()),
+                PAY_TRANSFER_CREATE_CHANNEL_NOT_MATCH);
+        assertEquals(PayTransferStatusEnum.CLOSED.getStatus(), transferMapper.selectById(transfer.getId()).getStatus());
+        verify(client, never()).unifiedTransfer(any());
+    }
+
+    @Test // 转账关闭后再次发起，但转账金额不一致
+    public void testCreateTransfer_retryAfterClosed_priceNotMatch() {
+        // mock 方法（client）
+        PayClient<?> client = mockPayClient();
+        // mock 数据：已存在金额为 50 的关闭的转账单
+        PayTransferDO transfer = insertClosedTransfer();
+        transferMapper.updateById(new PayTransferDO().setId(transfer.getId()).setPrice(50));
+
+        // 调用，并断言异常
+        assertServiceException(() -> transferService.createTransfer(buildTransferCreateReqDTO()),
+                PAY_TRANSFER_CREATE_PRICE_NOT_MATCH);
+        assertEquals(PayTransferStatusEnum.CLOSED.getStatus(), transferMapper.selectById(transfer.getId()).getStatus());
+        verify(client, never()).unifiedTransfer(any());
+    }
+
+    @Test // 转账关闭后再次发起，渠道结果未知，保留 WAITING 并清空上一次的渠道结果
+    public void testCreateTransfer_retryAfterClosed_unknown() {
+        // mock 方法（client 调用发生异常，查询也发生异常）
+        PayClient<?> client = mockPayClient();
+        when(client.unifiedTransfer(any())).thenThrow(new RuntimeException("模拟网络超时"));
+        when(client.getTransfer(any())).thenThrow(new RuntimeException("模拟查询超时"));
+        // mock 数据：已存在关闭的转账单
+        PayTransferDO closedTransfer = insertClosedTransfer();
+
+        // 调用
+        PayTransferCreateRespDTO respDTO = transferService.createTransfer(buildTransferCreateReqDTO());
+        // 断言：复用原转账单号，状态重置为 WAITING，并清空上一次转账的渠道结果
+        assertEquals(closedTransfer.getId(), respDTO.getId());
+        PayTransferDO dbTransfer = transferMapper.selectById(respDTO.getId());
+        assertEquals(PayTransferStatusEnum.WAITING.getStatus(), dbTransfer.getStatus());
+        assertNull(dbTransfer.getChannelTransferNo());
+        assertNull(dbTransfer.getSuccessTime());
+        assertNull(dbTransfer.getChannelErrorCode());
+        assertNull(dbTransfer.getChannelErrorMsg());
+        assertNull(dbTransfer.getChannelNotifyData());
+        assertNull(dbTransfer.getChannelPackageInfo());
+        assertEquals("佣金提现", dbTransfer.getSubject());
+        assertEquals("test@example.com", dbTransfer.getUserAccount());
+        assertEquals("芋艿", dbTransfer.getUserName());
+        assertEquals(Map.of("sceneId", "1000"), dbTransfer.getChannelExtras());
+        assertEquals("http://127.0.0.1/transfer", dbTransfer.getNotifyUrl());
+        // 断言：渠道编号更新为本次按渠道编码校验的渠道
+        assertEquals(10L, dbTransfer.getChannelId());
+        verify(client).unifiedTransfer(argThat(unifiedReqDTO ->
+                closedTransfer.getNo().equals(unifiedReqDTO.getOutTransferNo())));
+    }
+
+    @Test // 转账关闭后再次发起，本次请求没有传递可选字段，需要清空上一次的值
+    public void testCreateTransfer_retryAfterClosed_clearOptionalFields() {
+        // mock 方法（client 调用发生异常，查询也发生异常）
+        PayClient<?> client = mockPayClient();
+        when(client.unifiedTransfer(any())).thenThrow(new RuntimeException("模拟网络超时"));
+        when(client.getTransfer(any())).thenThrow(new RuntimeException("模拟查询超时"));
+        // mock 方法（app）：没有配置转账回调地址
+        PayAppDO app = randomPojo(PayAppDO.class, o -> o.setId(1L).setTransferNotifyUrl(null));
+        when(appService.validPayApp(eq("demo"))).thenReturn(app);
+        // mock 数据：已存在关闭的转账单
+        PayTransferDO closedTransfer = insertClosedTransfer();
+
+        // 调用：本次请求没有传递收款人姓名、渠道额外参数
+        PayTransferCreateRespDTO respDTO = transferService.createTransfer(buildTransferCreateReqDTO()
+                .setUserName(null).setChannelExtras(null));
+        // 断言：上一次的收款人姓名、渠道额外参数、回调地址已清空
+        assertEquals(closedTransfer.getId(), respDTO.getId());
+        PayTransferDO dbTransfer = transferMapper.selectById(respDTO.getId());
+        assertEquals(PayTransferStatusEnum.WAITING.getStatus(), dbTransfer.getStatus());
+        assertNull(dbTransfer.getUserName());
+        assertNull(dbTransfer.getChannelExtras());
+        assertNull(dbTransfer.getNotifyUrl());
+        assertEquals(10L, dbTransfer.getChannelId());
+    }
+
+    @Test // 转账关闭后再次发起，但转账单已被并发重新发起
+    public void testCreateTransfer_retryAfterClosed_concurrentRetry() {
+        // mock 方法（client）
+        PayClient<?> client = mockPayClient();
+        // mock 数据：已存在关闭的转账单
+        PayTransferDO closedTransfer = insertClosedTransfer();
+        // mock 方法（mapper）：校验通过后、更新前，其它请求已将转账单重新发起为 WAITING
+        PayTransferMapper transferMapperSpy = mock(PayTransferMapper.class, delegatesTo(transferMapper));
+        doAnswer(invocation -> {
+            updateTransferStatus(closedTransfer.getNo(), PayTransferStatusEnum.WAITING.getStatus());
+            return transferMapper.updateByIdAndStatusAndClearChannelResult(invocation.getArgument(0),
+                    invocation.getArgument(1), invocation.getArgument(2));
+        }).when(transferMapperSpy).updateByIdAndStatusAndClearChannelResult(any(), any(), any());
+        Object target = AopTestUtils.getTargetObject(transferService);
+        ReflectionTestUtils.setField(target, "transferMapper", transferMapperSpy);
+        try {
+            // 调用，并断言异常
+            assertServiceException(() -> transferService.createTransfer(buildTransferCreateReqDTO()),
+                    PAY_TRANSFER_CREATE_FAIL_STATUS_NOT_CLOSED);
+        } finally {
+            ReflectionTestUtils.setField(target, "transferMapper", transferMapper);
+        }
+        // 断言：不会再次向渠道发起转账
+        verify(client, never()).unifiedTransfer(any());
+        assertEquals(PayTransferStatusEnum.WAITING.getStatus(), transferMapper.selectById(closedTransfer.getId()).getStatus());
+    }
+
+    @Test // 调用方存在事务，转账关闭后调用方事务回滚，转账关闭的结果仍需保存，并可使用原转账单号重新发起
+    public void testCreateTransfer_outerTransactionRollback() {
+        // mock 方法（client）
+        PayClient<?> client = mockPayClient();
+        when(client.unifiedTransfer(any())).thenAnswer(invocation -> {
+            PayTransferUnifiedReqDTO unifiedReqDTO = invocation.getArgument(0);
+            return PayTransferRespDTO.closedOf("PAYEE_NOT_EXIST", "收款账号不存在",
+                    unifiedReqDTO.getOutTransferNo(), "closed");
+        });
+        PayTransferDO outerTransfer = randomPojo(PayTransferDO.class, o -> o.setAppId(1L).setMerchantTransferId("2002"));
+
+        // 调用：调用方事务中，先写入自己的数据，再发起转账，渠道错误导致调用方事务回滚
+        TransactionTemplate transactionTemplate = new TransactionTemplate(transactionManager);
+        assertServiceException(() -> transactionTemplate.executeWithoutResult(status -> {
+            transferMapper.insert(outerTransfer);
+            transferService.createTransfer(buildTransferCreateReqDTO());
+        }), PAY_TRANSFER_SUBMIT_CHANNEL_ERROR, "PAYEE_NOT_EXIST", "收款账号不存在");
+        // 断言：调用方事务已回滚，但转账关闭的结果（包括转账通知）已保存
+        assertNull(transferMapper.selectById(outerTransfer.getId()));
+        PayTransferDO closedTransfer = transferMapper.selectByAppIdAndMerchantOrderId(1L, "1001");
+        assertEquals(PayTransferStatusEnum.CLOSED.getStatus(), closedTransfer.getStatus());
+        assertEquals("PAYEE_NOT_EXIST", closedTransfer.getChannelErrorCode());
+        verify(notifyService).createPayNotifyTask(eq(PayNotifyTypeEnum.TRANSFER.getType()), eq(closedTransfer.getId()));
+
+        // mock 方法（client 再次发起时，转账成功）
+        doAnswer(invocation -> {
+            PayTransferUnifiedReqDTO unifiedReqDTO = invocation.getArgument(0);
+            return PayTransferRespDTO.successOf("CHANNEL_T001", LocalDateTime.now(),
+                    unifiedReqDTO.getOutTransferNo(), "success");
+        }).when(client).unifiedTransfer(any());
+        // 调用：使用相同的商户转账编号再次发起
+        PayTransferCreateRespDTO respDTO = transactionTemplate.execute(status ->
+                transferService.createTransfer(buildTransferCreateReqDTO()));
+        // 断言：复用原转账单号
+        assertEquals(closedTransfer.getId(), respDTO.getId());
+        PayTransferDO dbTransfer = transferMapper.selectById(respDTO.getId());
+        assertEquals(closedTransfer.getNo(), dbTransfer.getNo());
+        assertEquals(PayTransferStatusEnum.SUCCESS.getStatus(), dbTransfer.getStatus());
+    }
+
+    @Test // 转账关闭后再次发起，返回转账中及新的 package 信息
+    public void testCreateTransfer_retryAfterClosed_processing() {
+        // mock 方法（client）
+        PayClient<?> client = mockPayClient();
+        when(client.unifiedTransfer(any())).thenAnswer(invocation -> {
+            PayTransferUnifiedReqDTO unifiedReqDTO = invocation.getArgument(0);
+            PayTransferRespDTO resp = PayTransferRespDTO.processingOf("CHANNEL_T002",
+                    unifiedReqDTO.getOutTransferNo(), "processing");
+            resp.setChannelPackageInfo("package-info-002");
+            return resp;
+        });
+        // mock 数据：已存在关闭的转账单
+        PayTransferDO closedTransfer = insertClosedTransfer();
+
+        // 调用
+        PayTransferCreateRespDTO respDTO = transferService.createTransfer(buildTransferCreateReqDTO());
+        // 断言：使用新的 package 信息，且不残留上一次的失败原因
+        assertEquals(closedTransfer.getId(), respDTO.getId());
+        assertEquals("package-info-002", respDTO.getChannelPackageInfo());
+        PayTransferDO dbTransfer = transferMapper.selectById(respDTO.getId());
+        assertEquals(PayTransferStatusEnum.PROCESSING.getStatus(), dbTransfer.getStatus());
+        assertEquals("package-info-002", dbTransfer.getChannelPackageInfo());
+        assertNull(dbTransfer.getChannelErrorCode());
+        assertNull(dbTransfer.getChannelErrorMsg());
+        assertEquals("CHANNEL_T002", dbTransfer.getChannelTransferNo());
+    }
+
     private PayClient<?> mockPayClient() {
         // mock 方法（app）
         PayAppDO app = randomPojo(PayAppDO.class, o -> o.setId(1L).setTransferNotifyUrl("http://127.0.0.1/transfer"));
@@ -375,6 +788,22 @@ public class PayTransferServiceTest extends BaseDbAndRedisUnitTest {
         return client;
     }
+    /**
+     * 插入关闭的转账单，与 {@link #buildTransferCreateReqDTO()} 的转账请求一致，并残留上一次转账的渠道结果
+     *
+     * 特殊：渠道编号使用旧的渠道编号，模拟渠道删除重建的情况
+     */
+    private PayTransferDO insertClosedTransfer() {
+        PayTransferDO transfer = randomPojo(PayTransferDO.class, o -> o.setAppId(1L).setChannelId(9L)
+                .setChannelCode(PayChannelEnum.ALIPAY_PC.getCode()).setMerchantTransferId("1001").setPrice(100)
+                .setUserName("旧的收款人").setChannelExtras(Map.of("sceneId", "1005"))
+                .setStatus(PayTransferStatusEnum.CLOSED.getStatus())
+                .setChannelErrorCode("PAYEE_NOT_EXIST").setChannelErrorMsg("收款账号不存在")
+                .setChannelPackageInfo("package-info-001"));
+        transferMapper.insert(transfer);
+        return transfer;
+    }
+
     private void updateTransferStatus(String no, Integer status) {
         PayTransferDO transfer = transferMapper.selectByAppIdAndNo(1L, no);
         transferMapper.updateById(new PayTransferDO().setId(transfer.getId()).setStatus(status));
@@ -384,7 +813,7 @@ public class PayTransferServiceTest extends BaseDbAndRedisUnitTest {
         return new PayTransferCreateReqDTO().setAppKey("demo").setChannelCode(PayChannelEnum.ALIPAY_PC.getCode())
                 .setUserIp("127.0.0.1").setUserId(1L).setUserType(1)
                 .setMerchantTransferId("1001").setSubject("佣金提现").setPrice(100)
-                .setUserAccount("test@example.com").setUserName("芋艿");
+                .setUserAccount("test@example.com").setUserName("芋艿").setChannelExtras(Map.of("sceneId", "1000"));
     }
 }
+package cn.iocoder.yudao.module.pay.service.wallet;
+
+import cn.iocoder.yudao.framework.test.core.ut.BaseDbAndRedisUnitTest;
+import cn.iocoder.yudao.module.pay.dal.dataobject.wallet.PayWalletDO;
+import cn.iocoder.yudao.module.pay.dal.dataobject.wallet.PayWalletTransactionDO;
+import cn.iocoder.yudao.module.pay.dal.mysql.wallet.PayWalletMapper;
+import cn.iocoder.yudao.module.pay.dal.redis.wallet.PayWalletLockRedisDAO;
+import cn.iocoder.yudao.module.pay.enums.wallet.PayWalletBizTypeEnum;
+import cn.iocoder.yudao.module.pay.service.order.PayOrderService;
+import cn.iocoder.yudao.module.pay.service.refund.PayRefundService;
+import jakarta.annotation.Resource;
+import org.junit.jupiter.api.Test;
+import org.springframework.context.annotation.Import;
+import org.springframework.test.context.bean.override.mockito.MockitoBean;
+import org.springframework.transaction.PlatformTransactionManager;
+import org.springframework.transaction.TransactionDefinition;
+import org.springframework.transaction.support.TransactionTemplate;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.when;
+
+/**
+ * {@link PayWalletServiceImpl} 的单元测试类
+ *
+ * @author HUIHUI
+ */
+@Import({PayWalletServiceImpl.class, PayWalletLockRedisDAO.class})
+public class PayWalletServiceTest extends BaseDbAndRedisUnitTest {
+
+    @Resource
+    private PayWalletServiceImpl walletService;
+
+    @Resource
+    private PayWalletMapper walletMapper;
+
+    @Resource
+    private PlatformTransactionManager transactionManager;
+
+    @MockitoBean
+    private PayWalletTransactionService walletTransactionService;
+    @MockitoBean
+    private PayOrderService orderService;
+    @MockitoBean
+    private PayRefundService refundService;
+
+    @Test
+    public void testGetOrCreateWallet_create() {
+        // 调用：首次获取，创建钱包
+        PayWalletDO wallet = walletService.getOrCreateWallet(1L, 2);
+        // 断言
+        assertNotNull(wallet.getId());
+        PayWalletDO dbWallet = walletMapper.selectById(wallet.getId());
+        assertEquals(1L, dbWallet.getUserId());
+        assertEquals(2, dbWallet.getUserType());
+        assertEquals(0, dbWallet.getBalance());
+
+        // 调用：再次获取，不重复创建钱包
+        assertEquals(wallet.getId(), walletService.getOrCreateWallet(1L, 2).getId());
+        assertEquals(1, walletMapper.selectList().size());
+    }
+
+    @Test // 调用方存在事务时，首次创建的钱包需要独立提交（例如说：佣金提现审核时，创建钱包后再转账到钱包）
+    public void testGetOrCreateWallet_outerTransaction() {
+        // mock 方法（钱包流水）
+        when(walletTransactionService.createWalletTransaction(any())).thenReturn(new PayWalletTransactionDO());
+
+        // 调用：调用方事务中，首次创建钱包；随后不加入调用方事务（同 createTransfer），给钱包增加余额；最后调用方事务回滚
+        TransactionTemplate transactionTemplate = new TransactionTemplate(transactionManager);
+        TransactionTemplate notSupportedTemplate = new TransactionTemplate(transactionManager);
+        notSupportedTemplate.setPropagationBehavior(TransactionDefinition.PROPAGATION_NOT_SUPPORTED);
+        Long walletId = transactionTemplate.execute(status -> {
+            PayWalletDO wallet = walletService.getOrCreateWallet(1L, 2);
+            notSupportedTemplate.executeWithoutResult(notSupportedStatus -> walletService.addWalletBalance(
+                    wallet.getId(), "T001", PayWalletBizTypeEnum.TRANSFER, 100));
+            status.setRollbackOnly();
+            return wallet.getId();
+        });
+        // 断言：钱包已独立提交，钱包余额已增加，不受调用方事务回滚影响
+        PayWalletDO dbWallet = walletMapper.selectById(walletId);
+        assertNotNull(dbWallet);
+        assertEquals(100, dbWallet.getBalance());
+    }
+
+}
@@ -4,5 +4,6 @@ DELETE FROM pay_order;
 DELETE FROM pay_order_extension;
 DELETE FROM pay_refund;
 DELETE FROM pay_transfer;
+DELETE FROM pay_wallet;
 DELETE FROM pay_notify_task;
 DELETE FROM pay_notify_log;
@@ -180,3 +180,19 @@ CREATE TABLE IF NOT EXISTS `pay_transfer` (
     `deleted`              bit(1)        NOT NULL DEFAULT FALSE,
     PRIMARY KEY ("id")
 ) COMMENT = '转账单';
+
+CREATE TABLE IF NOT EXISTS `pay_wallet` (
+    "id" number NOT NULL GENERATED BY DEFAULT AS IDENTITY,
+    `user_id`        bigint(20)  NOT NULL,
+    `user_type`      tinyint(4)  NOT NULL,
+    `balance`        int(11)     NOT NULL DEFAULT 0,
+    `freeze_price`   int(11)     NOT NULL DEFAULT 0,
+    `total_expense`  int(11)     NOT NULL DEFAULT 0,
+    `total_recharge` int(11)     NOT NULL DEFAULT 0,
+    `creator`        varchar(64) NULL     DEFAULT '',
+    `create_time`    datetime(0) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    `updater`        varchar(64) NULL     DEFAULT '',
+    `update_time`    datetime(0) NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+    `deleted`        bit(1)      NOT NULL DEFAULT FALSE,
+    PRIMARY KEY ("id")
+) COMMENT = '会员钱包';