资讯专栏INFORMATION COLUMN

支付系统设计实现(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. }

}

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

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

相关文章

  • 资损防控体系介绍

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

    shixinzhang 评论0 收藏0
  • 马蜂窝火车票系统服务化改造初探

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

    Raaabbit 评论0 收藏0

发表评论

0条评论

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