资讯专栏INFORMATION COLUMN

上云采购季！| 2核2G4M爆款云服务器低至59元/年，更有多台、长期优惠，快来选购！

立即前往
首页/文章专栏/支付系统设计实现(1)——支付与退款

支付系统设计实现(1)——支付与退款

zhigoo / 2626人阅读

摘要：支付流程以上是微信支付的流程用户进入选择商品进行购买，在内部结算时生成用户本系统订单待支付状态，此时返回订单信息与支付方式列表用户确认金额无误，并选择支付方式。

支付流程

以上是微信app支付的流程：

用户进入app选择商品进行购买，在app内部结算时生成用户本系统订单（待支付状态），此时返回订单信息与支付方式列表

用户确认金额无误，并选择支付方式。此时app将订单id与支付方式传给服务器，服务器根据订单金额与支付方式在外部支付系统下单（预支付订单），并给app返回可以唤起响应支付工具的‘支付数据’

app获取到‘支付数据’调用响应支付sdk，此时用户会看见微信支付或支付宝支付的页面，此时用户需要确认支付金额并输入正确的密码

sdk会检查用户的密码信息是否正确并返回支付结果，此时app收到sdk同步通知的支付结果，并提交到服务器，服务器会记录该笔支付的状态，切记不能使用app上传回来的支付结果作为最终的支付结果，不能信任前端数据

外部支付系统在处理完成该笔支付后会回调服务器设置的回调接口，通知服务器该笔支付的最终支付状态
收到通知时需要注意：

同样的通知可能会多次发送给商户系统。商户系统必须能够正确处理重复的通知。

后台通知交互时，如果微信收到商户的应答不符合规范或超时，微信会判定本次通知失败，重新发送通知，直到成功为止，但微信不保证通知最终一定能成功。

在订单状态不明或者没有收到微信支付结果通知的情况下，建议商户主动调用微信支付【查询订单API】确认订单状态。

商户系统对于支付结果通知的内容一定要做签名验证,并校验返回的订单金额是否与商户侧的订单金额一致，防止数据泄漏导致出现“假通知”，造成资金损失。

当收到通知进行处理时，首先检查对应业务数据的状态，判断该通知是否已经处理过，如果没有处理过再进行处理，如果处理过直接返回结果成功。在对业务数据进行状态检查和处理之前，要采用数据锁进行并发控制，以避免函数重入造成的数据混乱。

线上问题

以上流程时微信与支付宝给出的官方流程，并且也是最标准的流程。但是当外部支付系统并没有微信与支付宝那么优秀的时候，我们的系统就不能按照该流程正常运行下去，下面我说说在使用‘建行支付’时遇到的问题

服务器收不到支付结果的回调

即使主动查询支付状态‘建行支付’依然返回未支付的状态

以上两个问题会引发更复杂的问题

由于没有支付回调，订单状态就不会发送改变用户就会再次支付，造成重复支付的现象

系统没有预料到会出现重复支付也就没有相应的策略去弥补

由于系统并不知道支付已经成功，用户在取消订单的时候就不会收到退款

根据这些线上出现的问题，我们决定进行重构，并深层次的处理整个支付流程！

设计思路

1.确认支付方式

</>复制代码 
  1. 1.微信App支付
  2. 2.支付宝App支付
  3. 3.建行支付App支付

2.如何确保支付成功

</>复制代码 
  1. 1.外部支付系统（支付宝）成功后回调通知
  2. 2.本系统主动查询外部支付系统订单状态

3.如何避免用户重复支付

</>复制代码 
  1. 1.本系统在发起支付的时候检查‘订单号’是否有已经成功的支付记录
  2. 2.本系统在发起支付的时候检查‘订单号’是否有已经提交的支付记录，如果有需要同步查询外部支付系统该订单的支付状态

4.如果用户出现重复支付系统如何处理

</>复制代码 
  1. 1.系统需要定时检查是否有同一个‘订单号’出现多条成功支付的记录，如果有需要保留一笔支付，其余的进行退款处理

5.数据出现异常怎么办（例如：用户说支付完成，但是订单依然是待支付的状态）

</>复制代码 
  1. 1.所有的支付流程都需要进行数据记录，形成支付流水，这样可以直观的看到用户支付的路径，也方便外部支付系统查询
具体逻辑

‘支付’是一次支付的记录，可能包含多个订单的支付金额，因为用户在购买商品生成订单的时候会根据商家拆单

‘支付与订单的隐射’表明该支付中所有的订单信息，每个‘映射’都记录了订单的金额与支付状态，并且重复支付也是发生在该‘映射’上的，因为一个订单智能有一次最终成功支付的记录,最终哪一个映射是有效的由‘是否当前使用’决定，任何时候一个订单只有一个映射有效

‘支付’可能有多条退款记录，退款的总金额不能超过支付金额，并且每一笔退款都需要一个唯一的退款交易号来保证不会重复退款，退款交易号由具体业务系统生成（比如退货，取消订单，重复支付）

所有的退款必须成功

系统需要主动查询支付状态是‘发起支付’，‘app同步通知成功’记录在外部支付系统的支付状态，如果在外部支付系统支付成功，这里需要重新设置支付状态为‘已完成’

支付的外部交易号与退款的退款交易号都是唯一的

为了保证系统的正常工作我们还需要一些定时器来作为最后的防线

接口实现

1. 支付业务逻辑

public interface IPaymentApplicationService {

</>复制代码 
  1. /**
  2.  * 创建支付，待支付状态
  3.  * @param orders 订单JSONArray
  4.  * @param paymentAmount 支付金额
  5.  * @param paymentChannel 支付渠道
  6.  * @param paymentType 支付方式
  7.  * @param accountId 账户
  8.  * @param serviceId 服务
  9.  * @param platformId 平台
  10.  * @param hockParams 回传参数
  11.  * @return
  12.  */
  13. PaymentResultDTO createPayment(List orders, BigDecimal paymentAmount, PaymentChannelEnum paymentChannel, PaymentTypeEnum paymentType, String accountId, String serviceId, String platformId,String hockParams) throws InvalidOperationException;
  14. /**
  15.  * app、小程序、H5收到回调
  16.  * @param paymentId 支付id
  17.  * @param isSuccess 是否支付成功
  18.  */
  19. void synchronizedCallback(String paymentId,boolean isSuccess) throws InvalidOperationException, PaymentQueryException, PaymentNotExistException;
  20. /**
  21.  * app、小程序、H5收到回调
  22.  * @param orderIds 本次支付的所有订单id
  23.  * @param isSuccess 是否成功
  24.  */
  25. void synchronizedCallback(Collection orderIds,boolean isSuccess);
  26. /**
  27.  * 服务器端收到回调
  28.  * @param paymentId 支付id
  29.  * @param isSuccess 是否支付成功
  30.  * @param tradeNo 交易号
  31.  */
  32. void asyncCallback(String paymentId,boolean isSuccess,String tradeNo) throws InvalidOperationException;
  33. /**
  34.  * 服务器端收到回调
  35.  * @param outTradeNo 外部交易号
  36.  * @param isSuccess 是否支付成功
  37.  * @param tradeNo 交易号
  38.  */
  39. void asyncCallbackForOutTradeNo(String outTradeNo,boolean isSuccess,String tradeNo);

}

2.退款业务逻辑

public interface IRefundApplicationService {

</>复制代码 
  1. /**
  2.  * 发起退款
  3.  * @param paymentId 支付id
  4.  * @param sysRefundTradeNo 系统内部退款单号
  5.  * @param refundAmount 退款金额
  6.  * @param refundType 退款类型
  7.  * @param reason 退款理由
  8.  * @return 退款id
  9.  */
  10. void createRefund(String paymentId,String sysRefundTradeNo, BigDecimal refundAmount, RefundTypeEnum refundType, String reason) throws Exception;
  11. /**
  12.  * 针对订单发起退款
  13.  * @param orderId 订单id
  14.  * @param sysRefundTradeNo 系统内部退款单号
  15.  * @param refundAmount 退款金额
  16.  * @param refundType 退款类型
  17.  * @param reason 退款理由
  18.  * @return 退款id
  19.  */
  20. void createRefundByOrder(String orderId,String sysRefundTradeNo, BigDecimal refundAmount, RefundTypeEnum refundType, String reason) throws Exception;
  21. /**
  22.  * 退款
  23.  * @param refund 退款实体
  24.  */
  25. void refund(RefundDO refund) throws InvalidOperationException;

}

附件代码

@Service
@Slf4j
@Transactional(rollbackFor = Exception.class)
public class PaymentApplicationServiceImpl implements IPaymentApplicationService {

</>复制代码 
  1. private final PaymentConfigJpaRepository paymentConfigJpaRepository;
  2. private final PaymentJpaRepository paymentJpaRepository;
  3. private final PaymentOrderJpaRepository paymentOrderJpaRepository;
  4. private final PaymentFlowJpaRepository paymentFlowJpaRepository;
  5. private final OrderRepository orderJpaRepository;
  6. private final PayUtilRepository payUtilRepository;
  7. @Autowired
  8. public PaymentApplicationServiceImpl(PaymentConfigJpaRepository paymentConfigJpaRepository, PaymentJpaRepository paymentJpaRepository, PaymentOrderJpaRepository paymentOrderJpaRepository, PaymentFlowJpaRepository paymentFlowJpaRepository, OrderRepository orderJpaRepository, PayUtilRepository payUtilRepository) {
  9.     this.paymentConfigJpaRepository = paymentConfigJpaRepository;
  10.     this.paymentJpaRepository = paymentJpaRepository;
  11.     this.paymentOrderJpaRepository = paymentOrderJpaRepository;
  12.     this.paymentFlowJpaRepository = paymentFlowJpaRepository;
  13.     this.orderJpaRepository = orderJpaRepository;
  14.     this.payUtilRepository = payUtilRepository;
  15. }
  16. @Override
  17. public PaymentResultDTO createPayment(List orders, BigDecimal paymentAmount, PaymentChannelEnum paymentChannel, PaymentTypeEnum paymentType, String accountId, String serviceId, String platformId, String hockParams,String wechatOpenId) throws Exception {
  18.     Optional paymentConfigOptional = paymentConfigJpaRepository.findByPaymentChannelAndPaymentType(paymentChannel.getValue(),paymentType.getValue());
  19.     if(!paymentConfigOptional.isPresent()){
  20.         throw new InvalidOperationException("支付方式不存在");
  21.     }
  22.     PaymentConfigDO paymentConfig = paymentConfigOptional.get();
  23.     //成功支付的订单不能再次支付
  24.     List orderIds = orders.stream().map(PaymentOrderDTO::getOrderId).collect(Collectors.toList());
  25.     List oldPaymentOrders = paymentOrderJpaRepository.findByOrderIdIn(orderIds);
  26.     for (PaymentOrderDO po : oldPaymentOrders) {
  27.         if(po.getPaymentStatus().equals(PaymentStatusEnum.ASYNC_CALLBACK_SUCCEED.getValue())){
  28.             throw new InvalidOperationException("订单：" + po.getOrderId() + "已成功支付");
  29.         }else if(po.getPaymentStatus().equals(PaymentStatusEnum.SYNCHRONIZE_CALLBACK_SUCCEED.getValue()) ||
  30.                 po.getPaymentStatus().equals(PaymentStatusEnum.LAUNCH_PAY.getValue())){
  31.             //可能是重复支付
  32.             po.fundRepeatPay();
  33.             paymentOrderJpaRepository.save(po);
  34.             //主动查询支付是否成功
  35.             PaymentQueryResult paymentQueryResult;
  36.             paymentQueryResult = getPaymentResult(paymentConfig,po.getOutTradeNo());
  37.             if(paymentQueryResult != null && paymentQueryResult.getTradeStatus().equals(PaymentQueryResult.TradeStatus.SUCCESS)){
  38.                 asyncCallback(po.getPaymentId(),true,paymentQueryResult.getTradeNo());
  39.             }
  40.         }
  41.     }
  42.     PaymentDO payment = new PaymentDO(paymentAmount,paymentChannel,paymentType,paymentConfig.getMerchantId(),accountId,serviceId,platformId);
  43.     paymentJpaRepository.save(payment);
  44.     PaymentFlowDO paymentFlow = new PaymentFlowDO(payment.getId(),payment.getOutTradeNo(), PaymentFlowEnum.REQUEST_SIGNATURE, JSONArray.toJSONString(orders));
  45.     paymentFlowJpaRepository.save(paymentFlow);
  46.     List paymentOrders = new ArrayList<>();
  47.     for (PaymentOrderDTO order : orders) {
  48.         String orderId = order.getOrderId();
  49.         if (StringUtils.isBlank(orderId)) {
  50.             throw new InvalidOperationException("orderId必传");
  51.         }
  52.         PaymentOrderDO paymentOrder = new PaymentOrderDO(payment.getId(), orderId, payment.getOutTradeNo(), order.getOrderAmount(), JSONObject.toJSONString(order));
  53.         paymentOrders.add(paymentOrder);
  54.     }
  55.     paymentOrderJpaRepository.saveAll(paymentOrders);
  56.     String sign = lunchPay(payment,paymentOrders,hockParams,wechatOpenId);
  57.     return new PaymentResultDTO(payment.getId(),sign,hockParams,orderIds);
  58. }
  59. private String lunchPay(PaymentDO payment,List paymentOrders,String hockParams,String wechatOpenId) throws Exception {
  60.     Optional paymentConfigOptional = paymentConfigJpaRepository.findByPaymentChannelAndPaymentType(payment.getPaymentChannel(),payment.getPaymentType());
  61.     if(!paymentConfigOptional.isPresent()){
  62.         throw new InvalidOperationException("支付配置不存在");
  63.     }
  64.     PaymentConfigDO paymentConfig = paymentConfigOptional.get();
  65.     //计算签名字符串
  66.     String signString;
  67.     PaymentChannelEnum paymentChannel = PaymentChannelEnum.getEnumByVal(paymentConfig.getPaymentChannel());
  68.     switch (paymentChannel){
  69.         case ALIPAY:
  70.             AliPayUtil aliPayUtil = payUtilRepository.getAliPay(payment);
  71.             signString = aliPayUtil.getSignStr(paymentConfig.getOrderNamePrefix() + ":" + payment.getId(),payment.getOutTradeNo(),payment.getPaymentAmount(),hockParams);
  72.             break;
  73.         case WECHATPAY:
  74.             WechatPayUtil wechatPayUtil = payUtilRepository.getWechatPay(payment);
  75.             if(StringUtils.isNotBlank(wechatOpenId)) {
  76.                 signString = wechatPayUtil.getJsApiSignStr(paymentConfig.getOrderNamePrefix() + ":" + payment.getId(), payment.getOutTradeNo(), payment.getPaymentAmount(), wechatOpenId, hockParams);
  77.             }else {
  78.                 signString = wechatPayUtil.getSignStr(paymentConfig.getOrderNamePrefix() + ":" + payment.getId(), payment.getOutTradeNo(), payment.getPaymentAmount(), hockParams);
  79.             }
  80.             break;
  81.         default:
  82.             throw new InvalidOperationException("支付方式异常");
  83.     }
  84.     payment.lunchPay(signString);
  85.     for (PaymentOrderDO po : paymentOrders) {
  86.         po.lunchPay(signString);
  87.     }
  88.     PaymentFlowDO paymentFlow = new PaymentFlowDO(payment.getId(),payment.getOutTradeNo(), PaymentFlowEnum.RECEIVE_SIGNATURE,signString);
  89.     paymentJpaRepository.save(payment);
  90.     paymentOrderJpaRepository.saveAll(paymentOrders);
  91.     paymentFlowJpaRepository.save(paymentFlow);
  92.     return signString;
  93. }
  94. @Override
  95. public void synchronizedCallback(String paymentId, boolean isSuccess) throws InvalidOperationException {
  96.     Optional paymentOptional = paymentJpaRepository.findById(paymentId);
  97.     if(!paymentOptional.isPresent()){
  98.         throw new InvalidOperationException("支付不存在");
  99.     }
  100.     PaymentDO payment = paymentOptional.get();
  101.     payment.synchronizedCallback(isSuccess);
  102.     List paymentOrders = paymentOrderJpaRepository.findByPaymentId(paymentId);
  103.     for (PaymentOrderDO po : paymentOrders) {
  104.         po.synchronizedCallback(isSuccess);
  105.     }
  106.     PaymentFlowDO paymentFlow = new PaymentFlowDO(payment.getId(),payment.getOutTradeNo(), PaymentFlowEnum.SYNCHRONIZE_CALLBACK,isSuccess + "");
  107.     //主动查询订单在第三方支付的状态，确保就算没有收到异步回调，支付状态依然正确
  108.     Optional paymentConfigOptional = paymentConfigJpaRepository.findByPaymentChannelAndPaymentType(payment.getPaymentChannel(),payment.getPaymentType());
  109.     if(!paymentConfigOptional.isPresent()){
  110.         throw new InvalidOperationException("支付方式不存在");
  111.     }
  112.     PaymentConfigDO paymentConfig = paymentConfigOptional.get();
  113.     PaymentQueryResult paymentQueryResult = getPaymentResult(paymentConfig,payment.getOutTradeNo());
  114.     if(paymentQueryResult != null && paymentQueryResult.getTradeStatus().equals(PaymentQueryResult.TradeStatus.SUCCESS)){
  115.         asyncCallback(paymentId,true,paymentQueryResult.getTradeNo());
  116.     }
  117.     paymentJpaRepository.save(payment);
  118.     paymentOrderJpaRepository.saveAll(paymentOrders);
  119.     paymentFlowJpaRepository.save(paymentFlow);
  120. }
  121. @Override
  122. public void synchronizedCallback(Collection orderIds, boolean isSuccess) {
  123.     List paymentOrders = paymentOrderJpaRepository.findByOrderIdInAndPaymentStatus(orderIds,PaymentStatusEnum.LAUNCH_PAY.getValue());
  124.     Set paymentIds = paymentOrders.stream().map(PaymentOrderDO::getPaymentId).collect(Collectors.toSet());
  125.     for (String pId : paymentIds) {
  126.         try {
  127.             synchronizedCallback(pId,true);
  128.         } catch (Exception e) {
  129.             e.printStackTrace();
  130.             log.error("支付同步通知异常：" + pId + ":" + e.getMessage());
  131.         }
  132.     }
  133. }
  134. @Override
  135. public void asyncCallback(String paymentId, boolean isSuccess, String tradeNo) throws InvalidOperationException {
  136.     Optional paymentOptional = paymentJpaRepository.findById(paymentId);
  137.     if(!paymentOptional.isPresent()){
  138.         throw new InvalidOperationException("支付不存在");
  139.     }
  140.     PaymentDO payment = paymentOptional.get();
  141.     if(payment.getPaymentStatus().equals(PaymentStatusEnum.ASYNC_CALLBACK_SUCCEED.getValue())){
  142.         return;
  143.     }
  144.     List paymentOrders = paymentOrderJpaRepository.findByPaymentId(paymentId);
  145.     List orderIds = paymentOrders.stream().map(PaymentOrderDO::getOrderId).collect(Collectors.toList());
  146.     //这些订单的其他支付：设置为重复
  147.     List oldOtherPaymentOrders = paymentOrderJpaRepository.
  148.             findByOrderIdIn(orderIds).stream().
  149.             filter(po -> !po.getPaymentId().equalsIgnoreCase(paymentId)).
  150.             collect(Collectors.toList());
  151.     if(!CollectionUtils.isEmpty(oldOtherPaymentOrders)){
  152.         for (PaymentOrderDO opo : oldOtherPaymentOrders) {
  153.             if(opo.getPaymentStatus().equals(PaymentStatusEnum.ASYNC_CALLBACK_SUCCEED.getValue()) ||
  154.                     opo.getPaymentStatus().equals(PaymentStatusEnum.SYNCHRONIZE_CALLBACK_SUCCEED.getValue()) ||
  155.                     opo.getPaymentStatus().equals(PaymentStatusEnum.LAUNCH_PAY.getValue())) {
  156.                 opo.fundRepeatPay();
  157.             }
  158.         }
  159.         paymentOrderJpaRepository.saveAll(oldOtherPaymentOrders);
  160.     }
  161.     payment.asyncCallback(isSuccess,tradeNo);
  162.     for (PaymentOrderDO po : paymentOrders) {
  163.         po.asyncCallback(isSuccess);
  164.         if(isSuccess){
  165.             //todo 需要考虑通知业务系统
  166.             Optional orderOptional = orderJpaRepository.findById(po.getOrderId());
  167.             if(orderOptional.isPresent()) {
  168.                 OrderDO order = orderOptional.get();
  169.                 order.paymentSucceed();
  170.                 orderJpaRepository.save(order);
  171.             }
  172.         }
  173.     }
  174.     PaymentFlowDO paymentFlow = new PaymentFlowDO(payment.getId(),payment.getOutTradeNo(), PaymentFlowEnum.ASYNC_CALLBACK,isSuccess + "");
  175.     paymentJpaRepository.save(payment);
  176.     paymentFlowJpaRepository.save(paymentFlow);
  177. }
  178. @Override
  179. public void asyncCallbackForOutTradeNo(String outTradeNo, boolean isSuccess, String tradeNo) {
  180.     Optional paymentOptional = paymentJpaRepository.findByOutTradeNo(outTradeNo);
  181.     if(paymentOptional.isPresent()){
  182.         PaymentDO payment = paymentOptional.get();
  183.         try{
  184.             asyncCallback(payment.getId(),true,tradeNo);
  185.         }catch (Exception e) {
  186.             e.printStackTrace();
  187.             log.error("支付异步通知异常：" + payment.getId() + ":" + e.getMessage());
  188.         }
  189.     }
  190. }
  191. private PaymentQueryResult getPaymentResult(PaymentConfigDO paymentConfig,String outTradeNo) {
  192.     Optional paymentOptional = paymentJpaRepository.findByOutTradeNo(outTradeNo);
  193.     if(!paymentOptional.isPresent()){
  194.         return null;
  195.     }
  196.     PaymentDO payment = paymentOptional.get();
  197.     PaymentQueryResult paymentQueryResult;
  198.     PaymentChannelEnum paymentChannel = PaymentChannelEnum.getEnumByVal(paymentConfig.getPaymentChannel());
  199.     try{
  200.         switch (paymentChannel){
  201.             case ALIPAY:
  202.                 AliPayUtil aliPayUtil = payUtilRepository.getAliPay(payment);
  203.                 paymentQueryResult = aliPayUtil.paymentQuery(outTradeNo);
  204.                 break;
  205.             case WECHATPAY:
  206.                 WechatPayUtil wechatPayUtil = payUtilRepository.getWechatPay(payment);
  207.                 paymentQueryResult = wechatPayUtil.paymentQuery(outTradeNo);
  208.                 break;
  209.             default:
  210.                 throw new InvalidOperationException("支付方式异常");
  211.         }
  212.         return paymentQueryResult;
  213.     }catch (Exception e){
  214.         log.error(e.getMessage());
  215.         return null;
  216.     }
  217. }

}

@Service
@Transactional(rollbackFor = Exception.class)
@Slf4j
public class RefundApplicationServiceImpl implements IRefundApplicationService {

</>复制代码 
  1. private final RefundJpaRepository refundJpaRepository;
  2. private final RefundFlowJpaRepository refundFlowJpaRepository;
  3. private final PaymentJpaRepository paymentJpaRepository;
  4. private final PaymentOrderJpaRepository paymentOrderJpaRepository;
  5. private final WechatPayUtil wechatPayUtil;
  6. private final AliPayUtil aliPayUtil;
  7. private final CcbPayUtil ccbPayUtil;
  8. @Autowired
  9. public RefundApplicationServiceImpl(RefundJpaRepository refundJpaRepository, RefundFlowJpaRepository refundFlowJpaRepository, PaymentJpaRepository paymentJpaRepository, PaymentOrderJpaRepository paymentOrderJpaRepository, WechatPayUtil wechatPayUtil, AliPayUtil aliPayUtil, CcbPayUtil ccbPayUtil) {
  10.     this.refundJpaRepository = refundJpaRepository;
  11.     this.refundFlowJpaRepository = refundFlowJpaRepository;
  12.     this.paymentJpaRepository = paymentJpaRepository;
  13.     this.paymentOrderJpaRepository = paymentOrderJpaRepository;
  14.     this.wechatPayUtil = wechatPayUtil;
  15.     this.aliPayUtil = aliPayUtil;
  16.     this.ccbPayUtil = ccbPayUtil;
  17. }
  18. @Override
  19. public void createRefund(String paymentId,String sysRefundTradeNo, BigDecimal refundAmount, RefundTypeEnum refundType, String reason) throws Exception {
  20.     Optional paymentOptional = paymentJpaRepository.findById(paymentId);
  21.     if(!paymentOptional.isPresent()){
  22.         throw new InvalidOperationException("支付不存在,不可退款");
  23.     }
  24.     PaymentDO payment = paymentOptional.get();
  25.     //检查支付是否完成，未完成就不可退款
  26.     PaymentChannelEnum paymentChannel = PaymentChannelEnum.getEnumByVal(payment.getPaymentChannel());
  27.     PaymentQueryResult paymentQueryResult = getPaymentResult(paymentChannel,payment.getOutTradeNo());
  28.     log.info("pay query : {}",paymentQueryResult);
  29.     if(paymentQueryResult == null ||
  30.         paymentQueryResult.getTradeStatus().equals(PaymentQueryResult.TradeStatus.FAILED) ||
  31.         paymentQueryResult.getTradeStatus().equals(PaymentQueryResult.TradeStatus.CLOSED) ||
  32.         paymentQueryResult.getTradeStatus().equals(PaymentQueryResult.TradeStatus.PAYING)){
  33.         throw new InvalidOperationException("支付状态异常，不可退款");
  34.     }
  35.     List refundStatus = Arrays.asList(RefundStatusEnum.START.getValue(),RefundStatusEnum.SUCCESS.getValue(),RefundStatusEnum.FAIL.getValue());
  36.     List oldRefunds = refundJpaRepository.findByPaymentIdAndRefundStatusIn(paymentId,refundStatus);
  37.     BigDecimal oldRefundsAmount = oldRefunds.stream().map(RefundDO::getRefundAmount).reduce(BigDecimal.ZERO,BigDecimal::add);
  38.     if(oldRefundsAmount.add(refundAmount).compareTo(payment.getPaymentAmount()) > 0){
  39.         throw new InvalidOperationException("退款总金额不可超过支付金额");
  40.     }
  41.     RefundDO refund;
  42.     Optional refundOptional = refundJpaRepository.findBySysRefundTradeNo(sysRefundTradeNo);
  43.     if(refundOptional.isPresent()){
  44.         RefundDO oldRefund = refundOptional.get();
  45.         if(oldRefund.getRefundStatus().equals(RefundStatusEnum.SUCCESS.getValue())){
  46.             throw new InvalidOperationException("退款已完成");
  47.         }else if(oldRefund.getRefundStatus().equals(RefundStatusEnum.START.getValue())){
  48.             throw new InvalidOperationException("退款处理中");
  49.         }
  50.     }else {
  51.         refund = new RefundDO(paymentId,payment.getOutTradeNo(),sysRefundTradeNo,refundAmount, refundType,reason,payment.getPaymentChannel(), payment.getPaymentType(),payment.getPaymentAmount());
  52.         refundJpaRepository.save(refund);
  53.     }
  54. }
  55. @Override
  56. public void createRefundByOrder(String orderId, String sysRefundTradeNo, BigDecimal refundAmount, RefundTypeEnum refundType, String reason) throws Exception {
  57.     Optional paymentOrderOptional = paymentOrderJpaRepository.findByOrderIdAndIsCurrent(orderId,true);
  58.     if(paymentOrderOptional.isPresent()){
  59.         PaymentOrderDO paymentOrder = paymentOrderOptional.get();
  60.         createRefund(paymentOrder.getPaymentId(),sysRefundTradeNo,refundAmount,refundType,reason);
  61.         paymentOrderJpaRepository.save(paymentOrder);
  62.     }
  63. }
  64. @Override
  65. public void refund(RefundDO refund) throws InvalidOperationException {
  66.     PaymentChannelEnum paymentChannel = PaymentChannelEnum.getEnumByVal(refund.getPaymentChannel());
  67.     RefundTypeEnum refundType = RefundTypeEnum.getEnumByVal(refund.getRefundType());
  68.     String respData;
  69.     try {
  70.         switch (paymentChannel){
  71.             case ALIPAY:
  72.                 respData = aliPayUtil.orderPayRefund(refund.getOutTradeNo(),refund.getOutRefundTradeNo(),refund.getPaymentAmount(),refund.getRefundAmount(),refundType);
  73.                 break;
  74.             case WECHATPAY:
  75.                 respData = wechatPayUtil.orderPayRefund(refund.getOutTradeNo(),refund.getOutRefundTradeNo(),refund.getPaymentAmount(),refund.getRefundAmount(),refundType);
  76.                 break;
  77.             case CCBPAY:
  78.                 respData = ccbPayUtil.orderPayRefund(refund.getOutTradeNo(),refund.getOutRefundTradeNo(),refund.getPaymentAmount(),refund.getRefundAmount(),refundType);
  79.                 break;
  80.             default:
  81.                 throw new InvalidOperationException("支付方式异常");
  82.         }
  83.         refundSuccess(refund,respData);
  84.     }catch (Exception e){
  85.         refundFail(refund,e.getMessage());
  86.     }
  87. }
  88. private void refundSuccess(RefundDO refund,String respData) throws InvalidOperationException {
  89.     refund.asyncCallback(true);
  90.     refundJpaRepository.save(refund);
  91.     RefundFlowDO refundSyncFlow = new RefundFlowDO(refund.getId(), RefundFlowEnum.SYNCHRONIZE_CALLBACK_SUCCESS,respData);
  92.     refundFlowJpaRepository.save(refundSyncFlow);
  93. }
  94. private void refundFail(RefundDO refund,String errorMessage) throws InvalidOperationException{
  95.     refund.asyncCallback(false);
  96.     refundJpaRepository.save(refund);
  97.     RefundFlowDO refundSyncFlow = new RefundFlowDO(refund.getId(), RefundFlowEnum.SYNCHRONIZE_CALLBACK_FAIL,errorMessage);
  98.     refundFlowJpaRepository.save(refundSyncFlow);
  99. }
  100. private PaymentQueryResult getPaymentResult(PaymentChannelEnum paymentChannel,String outTradeNo) {
  101.     try {
  102.         switch (paymentChannel){
  103.             case ALIPAY:
  104.                 return aliPayUtil.paymentQuery(outTradeNo);
  105.             case WECHATPAY:
  106.                 return wechatPayUtil.paymentQuery(outTradeNo);
  107.             case CCBPAY:
  108.                 return ccbPayUtil.paymentQuery(outTradeNo);
  109.             default:
  110.                 return null;
  111.         }
  112.     }catch (Exception e){
  113.         log.error(e.getMessage());
  114.         return null;
  115.     }
  116. }

}

@Component
@Slf4j
@DisallowConcurrentExecution
public class CheckPaymentCloseSchedule extends QuartzJobBean {

</>复制代码 
  1. @Autowired
  2. private PaymentJpaRepository paymentJpaRepository;
  3. @Autowired
  4. private IPaymentQueryService paymentQueryService;
  5. @Override
  6. public void executeInternal(JobExecutionContext context) throws JobExecutionException {
  7.     log.info("检查关闭支付定时器启动");
  8.     List payments = paymentJpaRepository.findByPaymentStatus(PaymentStatusEnum.LAUNCH_PAY.getValue());
  9.     LocalDateTime now = LocalDateTime.now();
  10.     List closePayments = new ArrayList<>();
  11.     for (PaymentDO p : payments) {
  12.         long minutes = 10L;
  13.         if(!now.minusMinutes(minutes).isBefore(p.getLaunchPayTime())){
  14.             //超过十分钟没有支付，就进行关闭
  15.             try {
  16.                 PaymentQueryResult result = paymentQueryService.getPaymentResult(p.getId());
  17.                 if(result == null){
  18.                     p.close();
  19.                     closePayments.add(p);
  20.                     if(closePayments.size() > 100){
  21.                         paymentJpaRepository.saveAll(closePayments);
  22.                         closePayments.clear();
  23.                         p = null;
  24.                     }
  25.                 }
  26.             } catch (Exception e) {
  27.                 log.error("关闭支付异常：" + p.getId() + ":" + e.getMessage());
  28.             }
  29.         }
  30.     }
  31.     paymentJpaRepository.saveAll(closePayments);
  32. }

}

@Component
@Slf4j
@DisallowConcurrentExecution
public class CheckPaymentRepeatSchedule extends QuartzJobBean {

</>复制代码 
  1. @Autowired
  2. private PaymentOrderJpaRepository paymentOrderJpaRepository;
  3. @Autowired
  4. private IRefundApplicationService refundApplicationService;
  5. @Override
  6. public void executeInternal(JobExecutionContext context)throws JobExecutionException {
  7.     log.info("检查重复支付定时器启动");
  8.     //找到尚未处理的重复支付记录
  9.     List paymentOrders = paymentOrderJpaRepository.findByPaymentStatusAndIsCurrentAndRepeatPayProcess(PaymentStatusEnum.ASYNC_CALLBACK_SUCCEED.getValue(),false,false);
  10.     paymentOrders.forEach(po -> {
  11.         try {
  12.             refundApplicationService.createRefund(po.getPaymentId(), ObjectId.get().toString(),po.getPaymentAmount(), RefundTypeEnum.REPEAT_PAY,RefundTypeEnum.REPEAT_PAY.getDescription());
  13.             po.refundRepeatPay();
  14.             paymentOrderJpaRepository.save(po);
  15.         } catch (Exception e) {
  16.             log.error("支付订单：" + po.getId() + "：重复支付退款异常：" + e.getMessage());
  17.         }
  18.     });
  19. }

}

@Component
@Slf4j
@DisallowConcurrentExecution
public class CheckPaymentSuccessSchedule extends QuartzJobBean {

</>复制代码 
  1. @Autowired
  2. private PaymentJpaRepository paymentJpaRepository;
  3. @Autowired
  4. private PaymentFlowJpaRepository paymentFlowJpaRepository;
  5. @Autowired
  6. private IPaymentApplicationService paymentApplicationService;
  7. @Autowired
  8. private IPaymentQueryService paymentQuery;
  9. @Override
  10. public void executeInternal(JobExecutionContext context) throws JobExecutionException {
  11.     log.info("检查支付成功定时器启动");
  12.     List payments = paymentJpaRepository.findByPaymentStatusIn(Arrays.asList(PaymentStatusEnum.LAUNCH_PAY.getValue(),PaymentStatusEnum.SYNCHRONIZE_CALLBACK_SUCCEED.getValue()));
  13.     for (PaymentDO p : payments) {
  14.         PaymentQueryResult result = paymentQuery.getPaymentResult(p.getId());
  15.         PaymentFlowDO paymentFlow;
  16.         if(result != null) {
  17.             paymentFlow = new PaymentFlowDO(p.getId(), p.getOutTradeNo(), PaymentFlowEnum.RECEIVE_PAYMENT_DETAIL, JSONObject.toJSONString(result));
  18.         }else {
  19.             if(p.getPaymentStatus().equals(PaymentStatusEnum.SYNCHRONIZE_CALLBACK_SUCCEED.getValue())) {
  20.                 String error = "支付：" + p.getId() + "app同步通知成功，但是第三方支付查询：未支付！";
  21.                 log.error(error);
  22.                 p.close();
  23.                 paymentJpaRepository.save(p);
  24.                 paymentFlow = new PaymentFlowDO(p.getId(), p.getOutTradeNo(), PaymentFlowEnum.RECEIVE_PAYMENT_DETAIL, error);
  25.             }else {
  26.                 paymentFlow = new PaymentFlowDO(p.getId(), p.getOutTradeNo(), PaymentFlowEnum.RECEIVE_PAYMENT_DETAIL, "未支付");
  27.             }
  28.         }
  29.         paymentFlowJpaRepository.save(paymentFlow);
  30.         if(result != null){
  31.             if(result.getTradeStatus().equals(PaymentQueryResult.TradeStatus.PAYING) ||
  32.                result.getTradeStatus().equals(PaymentQueryResult.TradeStatus.SUCCESS)){
  33.                 //第三方支付成功，直接修改支付状态
  34.                 try {
  35.                     paymentApplicationService.asyncCallback(p.getId(),true,result.getTradeNo());
  36.                     PaymentFlowDO successPaymentFlow = new PaymentFlowDO(p.getId(),p.getOutTradeNo(), PaymentFlowEnum.ASYNC_CALLBACK_SUCCESS, JSONObject.toJSONString(result));
  37.                     paymentFlowJpaRepository.save(successPaymentFlow);
  38.                 } catch (InvalidOperationException e) {
  39.                     log.error("支付：" + p.getId() + "第三方交易成功，本地修改异常：" + e.getMessage());
  40.                 }
  41.             }else if(result.getTradeStatus().equals(PaymentQueryResult.TradeStatus.FAILED)){
  42.                 try {
  43.                     paymentApplicationService.asyncCallback(p.getId(),false,"");
  44.                     PaymentFlowDO failPaymentFlow = new PaymentFlowDO(p.getId(),p.getOutTradeNo(), PaymentFlowEnum.ASYNC_CALLBACK_FAILED, JSONObject.toJSONString(result));
  45.                     paymentFlowJpaRepository.save(failPaymentFlow);
  46.                 } catch (InvalidOperationException e) {
  47.                     log.error("支付：" + p.getId() + "第三方交易失败，本地修改异常：" + e.getMessage());
  48.                 }
  49.             }
  50.         }
  51.     }
  52. }

}

@Component
@Slf4j
@DisallowConcurrentExecution
public class CheckRefundSuccessSchedule extends QuartzJobBean {

</>复制代码 
  1. @Autowired
  2. private RefundJpaRepository refundJpaRepository;
  3. @Autowired
  4. private IRefundApplicationService refundApplicationService;
  5. @Override
  6. public void executeInternal(JobExecutionContext context) {
  7.     log.info("检查退款成功定时器启动");
  8.     List refunds = refundJpaRepository.findByRefundStatusIn(Arrays.asList(RefundStatusEnum.FAIL.getValue(),RefundStatusEnum.START.getValue()));
  9.     for (RefundDO r : refunds) {
  10.         try {
  11.             refundApplicationService.refund(r);
  12.         } catch (InvalidOperationException e) {
  13.             log.error("退款失败：" + r.getId() + ":" + e.getMessage());
  14.         }
  15.     }
  16. }

}

GPU云服务器 云服务器 支付宝退款 微信支付退款? 微信支付退款 支付退款js代码

文章版权归作者所有，未经允许请勿转载,若此文章存在违规行为，您可以联系管理员删除。

转载请注明本文地址：https://www.ucloud.cn/yun/74326.html

相关文章

  • 资损防控体系介绍

    摘要：建立后台触发熔断操作入口，人工录入熔断配置或资损防控检测出异常新增并生效熔断配置，应急情况生效熔断，日常支付链路不会过熔断判断。确认无误或故障处理完成后，触发解熔断操作，业务继续处理或驳回。 1. 资损盲区 随着有赞支付体量的增大，资产部门承担的资金管理，风险把控的责任也越大。我们一方面要小步快跑，快速支撑业务，又要稳住底盘，守好底线。支付业务底线就是守护用户的每一分钱，不能有资金损失...

    shixinzhang 评论0 收藏0

  • 马蜂窝火车票系统服务化改造初探

    摘要：为了帮助用户更好地完成消费决策闭环，马蜂窝上线了大交通业务。现在，用户在马蜂窝也可以完成购买机票火车票等操作。第二阶段架构转变及服务化初探从年开始，整个大交通业务开始从架构向服务化演变。 交通方式是用户旅行前要考虑的核心要素之一。为了帮助用户更好地完成消费决策闭环，马蜂窝上线了大交通业务。现在，用户在马蜂窝也可以完成购买机票、火车票等操作。 与大多数业务系统相同，我们一样经历着从无到有...

    Raaabbit 评论0 收藏0

发表评论

登陆后可评论

0条评论

zhigoo

男|高级讲师
我要私信

TA的文章

阅读更多
最新活动
阅读需要支付1元查看
<