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

时间 2019-12-13

标签支付系统设计实现退款繁體版

原文原文链接

支付流程

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

用户进入app选择商品进行购买，在app内部结算时生成用户本系统订单（待支付状态），此时返回订单信息与支付方式列表
用户确认金额无误，并选择支付方式。此时app将订单id与支付方式传给服务器，服务器根据订单金额与支付方式在外部支付系统下单（预支付订单），并给app返回能够唤起响应支付工具的‘支付数据’
app获取到‘支付数据’调用响应支付sdk，此时用户会看见微信支付或支付宝支付的页面，此时用户须要确认支付金额并输入正确的密码
sdk会检查用户的密码信息是否正确并返回支付结果，此时app收到sdk同步通知的支付结果，并提交到服务器，服务器会记录该笔支付的状态，切记不能使用app上传回来的支付结果做为最终的支付结果，不能信任前端数据
外部支付系统在处理完成该笔支付后会回调服务器设置的回调接口，通知服务器该笔支付的最终支付状态
收到通知时须要注意：小程序
1. 一样的通知可能会屡次发送给商户系统。商户系统必须可以正确处理重复的通知。
2. 后台通知交互时，若是微信收到商户的应答不符合规范或超时，微信会断定本次通知失败，从新发送通知，直到成功为止，但微信不保证通知最终必定能成功。
3. 在订单状态不明或者没有收到微信支付结果通知的状况下，建议商户主动调用微信支付【查询订单API】确认订单状态。
4. 商户系统对于支付结果通知的内容必定要作签名验证,并校验返回的订单金额是否与商户侧的订单金额一致，防止数据泄漏致使出现“假通知”，形成资金损失。
5. 当收到通知进行处理时，首先检查对应业务数据的状态，判断该通知是否已经处理过，若是没有处理过再进行处理，若是处理过直接返回结果成功。在对业务数据进行状态检查和处理以前，要采用数据锁进行并发控制，以免函数重入形成的数据混乱。

线上问题

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

服务器收不到支付结果的回调
即便主动查询支付状态‘建行支付’依然返回未支付的状态

以上两个问题会引起更复杂的问题微信

因为没有支付回调，订单状态就不会发送改变用户就会再次支付，形成重复支付的现象
系统没有预料到会出现重复支付也就没有相应的策略去弥补
因为系统并不知道支付已经成功，用户在取消订单的时候就不会收到退款

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

设计思路

1.确认支付方式app

1.微信App支付
2.支付宝App支付
3.建行支付App支付

2.如何确保支付成功异步

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

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

1.本系统在发起支付的时候检查‘订单号’是否有已经成功的支付记录
2.本系统在发起支付的时候检查‘订单号’是否有已经提交的支付记录，若是有须要同步查询外部支付系统该订单的支付状态

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

1.系统须要定时检查是否有同一个‘订单号’出现多条成功支付的记录，若是有须要保留一笔支付，其他的进行退款处理

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

1.全部的支付流程都须要进行数据记录，造成支付流水，这样能够直观的看到用户支付的路径，也方便外部支付系统查询

具体逻辑

‘支付’是一次支付的记录，可能包含多个订单的支付金额，由于用户在购买商品生成订单的时候会根据商家拆单
‘支付与订单的隐射’代表该支付中全部的订单信息，每一个‘映射’都记录了订单的金额与支付状态，而且重复支付也是发生在该‘映射’上的，由于一个订单智能有一次最终成功支付的记录,最终哪个映射是有效的由‘是否当前使用’决定，任什么时候候一个订单只有一个映射有效
‘支付’可能有多条退款记录，退款的总金额不能超过支付金额，而且每一笔退款都须要一个惟一的退款交易号来保证不会重复退款，退款交易号由具体业务系统生成（好比退货，取消订单，重复支付）
全部的退款必须成功
系统须要主动查询支付状态是‘发起支付’，‘app同步通知成功’记录在外部支付系统的支付状态，若是在外部支付系统支付成功，这里须要从新设置支付状态为‘已完成’
支付的外部交易号与退款的退款交易号都是惟一的
为了保证系统的正常工做咱们还须要一些定时器来做为最后的防线

接口实现

1. 支付业务逻辑

public interface IPaymentApplicationService {

/**
 * 建立支付，待支付状态
 * @param orders 订单JSONArray
 * @param paymentAmount 支付金额
 * @param paymentChannel 支付渠道
 * @param paymentType 支付方式
 * @param accountId 帐户
 * @param serviceId 服务
 * @param platformId 平台
 * @param hockParams 回传参数
 * @return
 */
PaymentResultDTO createPayment(List<PaymentOrderDTO> orders, BigDecimal paymentAmount, PaymentChannelEnum paymentChannel, PaymentTypeEnum paymentType, String accountId, String serviceId, String platformId,String hockParams) throws InvalidOperationException;

/**
 * app、小程序、H5收到回调
 * @param paymentId 支付id
 * @param isSuccess 是否支付成功
 */
void synchronizedCallback(String paymentId,boolean isSuccess) throws InvalidOperationException, PaymentQueryException, PaymentNotExistException;

/**
 * app、小程序、H5收到回调
 * @param orderIds 本次支付的全部订单id
 * @param isSuccess 是否成功
 */
void synchronizedCallback(Collection<String> orderIds,boolean isSuccess);

/**
 * 服务器端收到回调
 * @param paymentId 支付id
 * @param isSuccess 是否支付成功
 * @param tradeNo 交易号
 */
void asyncCallback(String paymentId,boolean isSuccess,String tradeNo) throws InvalidOperationException;


/**
 * 服务器端收到回调
 * @param outTradeNo 外部交易号
 * @param isSuccess 是否支付成功
 * @param tradeNo 交易号
 */
void asyncCallbackForOutTradeNo(String outTradeNo,boolean isSuccess,String tradeNo);

}

2.退款业务逻辑

public interface IRefundApplicationService {

/**
 * 发起退款
 * @param paymentId 支付id
 * @param sysRefundTradeNo 系统内部退款单号
 * @param refundAmount 退款金额
 * @param refundType 退款类型
 * @param reason 退款理由
 * @return 退款id
 */
void createRefund(String paymentId,String sysRefundTradeNo, BigDecimal refundAmount, RefundTypeEnum refundType, String reason) throws Exception;

/**
 * 针对订单发起退款
 * @param orderId 订单id
 * @param sysRefundTradeNo 系统内部退款单号
 * @param refundAmount 退款金额
 * @param refundType 退款类型
 * @param reason 退款理由
 * @return 退款id
 */
void createRefundByOrder(String orderId,String sysRefundTradeNo, BigDecimal refundAmount, RefundTypeEnum refundType, String reason) throws Exception;

/**
 * 退款
 * @param refund 退款实体
 */
void refund(RefundDO refund) throws InvalidOperationException;

}

附件代码

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

private final PaymentConfigJpaRepository paymentConfigJpaRepository;
private final PaymentJpaRepository paymentJpaRepository;
private final PaymentOrderJpaRepository paymentOrderJpaRepository;
private final PaymentFlowJpaRepository paymentFlowJpaRepository;
private final OrderRepository orderJpaRepository;
private final PayUtilRepository payUtilRepository;

@Autowired
public PaymentApplicationServiceImpl(PaymentConfigJpaRepository paymentConfigJpaRepository, PaymentJpaRepository paymentJpaRepository, PaymentOrderJpaRepository paymentOrderJpaRepository, PaymentFlowJpaRepository paymentFlowJpaRepository, OrderRepository orderJpaRepository, PayUtilRepository payUtilRepository) {
    this.paymentConfigJpaRepository = paymentConfigJpaRepository;
    this.paymentJpaRepository = paymentJpaRepository;
    this.paymentOrderJpaRepository = paymentOrderJpaRepository;
    this.paymentFlowJpaRepository = paymentFlowJpaRepository;
    this.orderJpaRepository = orderJpaRepository;
    this.payUtilRepository = payUtilRepository;
}

@Override
public PaymentResultDTO createPayment(List<PaymentOrderDTO> orders, BigDecimal paymentAmount, PaymentChannelEnum paymentChannel, PaymentTypeEnum paymentType, String accountId, String serviceId, String platformId, String hockParams,String wechatOpenId) throws Exception {
    Optional<PaymentConfigDO> paymentConfigOptional = paymentConfigJpaRepository.findByPaymentChannelAndPaymentType(paymentChannel.getValue(),paymentType.getValue());
    if(!paymentConfigOptional.isPresent()){
        throw new InvalidOperationException("支付方式不存在");
    }
    PaymentConfigDO paymentConfig = paymentConfigOptional.get();
    //成功支付的订单不能再次支付
    List<String> orderIds = orders.stream().map(PaymentOrderDTO::getOrderId).collect(Collectors.toList());
    List<PaymentOrderDO> oldPaymentOrders = paymentOrderJpaRepository.findByOrderIdIn(orderIds);
    for (PaymentOrderDO po : oldPaymentOrders) {
        if(po.getPaymentStatus().equals(PaymentStatusEnum.ASYNC_CALLBACK_SUCCEED.getValue())){
            throw new InvalidOperationException("订单：" + po.getOrderId() + "已成功支付");
        }else if(po.getPaymentStatus().equals(PaymentStatusEnum.SYNCHRONIZE_CALLBACK_SUCCEED.getValue()) ||
                po.getPaymentStatus().equals(PaymentStatusEnum.LAUNCH_PAY.getValue())){
            //多是重复支付
            po.fundRepeatPay();
            paymentOrderJpaRepository.save(po);
            //主动查询支付是否成功
            PaymentQueryResult paymentQueryResult;
            paymentQueryResult = getPaymentResult(paymentConfig,po.getOutTradeNo());
            if(paymentQueryResult != null && paymentQueryResult.getTradeStatus().equals(PaymentQueryResult.TradeStatus.SUCCESS)){
                asyncCallback(po.getPaymentId(),true,paymentQueryResult.getTradeNo());
            }
        }
    }
    PaymentDO payment = new PaymentDO(paymentAmount,paymentChannel,paymentType,paymentConfig.getMerchantId(),accountId,serviceId,platformId);
    paymentJpaRepository.save(payment);
    PaymentFlowDO paymentFlow = new PaymentFlowDO(payment.getId(),payment.getOutTradeNo(), PaymentFlowEnum.REQUEST_SIGNATURE, JSONArray.toJSONString(orders));
    paymentFlowJpaRepository.save(paymentFlow);
    List<PaymentOrderDO> paymentOrders = new ArrayList<>();
    for (PaymentOrderDTO order : orders) {
        String orderId = order.getOrderId();
        if (StringUtils.isBlank(orderId)) {
            throw new InvalidOperationException("orderId必传");
        }
        PaymentOrderDO paymentOrder = new PaymentOrderDO(payment.getId(), orderId, payment.getOutTradeNo(), order.getOrderAmount(), JSONObject.toJSONString(order));
        paymentOrders.add(paymentOrder);
    }
    paymentOrderJpaRepository.saveAll(paymentOrders);
    String sign = lunchPay(payment,paymentOrders,hockParams,wechatOpenId);
    return new PaymentResultDTO(payment.getId(),sign,hockParams,orderIds);
}

private String lunchPay(PaymentDO payment,List<PaymentOrderDO> paymentOrders,String hockParams,String wechatOpenId) throws Exception {
    Optional<PaymentConfigDO> paymentConfigOptional = paymentConfigJpaRepository.findByPaymentChannelAndPaymentType(payment.getPaymentChannel(),payment.getPaymentType());
    if(!paymentConfigOptional.isPresent()){
        throw new InvalidOperationException("支付配置不存在");
    }
    PaymentConfigDO paymentConfig = paymentConfigOptional.get();
    //计算签名字符串
    String signString;
    PaymentChannelEnum paymentChannel = PaymentChannelEnum.getEnumByVal(paymentConfig.getPaymentChannel());
    switch (paymentChannel){
        case ALIPAY:
            AliPayUtil aliPayUtil = payUtilRepository.getAliPay(payment);
            signString = aliPayUtil.getSignStr(paymentConfig.getOrderNamePrefix() + ":" + payment.getId(),payment.getOutTradeNo(),payment.getPaymentAmount(),hockParams);
            break;
        case WECHATPAY:
            WechatPayUtil wechatPayUtil = payUtilRepository.getWechatPay(payment);
            if(StringUtils.isNotBlank(wechatOpenId)) {
                signString = wechatPayUtil.getJsApiSignStr(paymentConfig.getOrderNamePrefix() + ":" + payment.getId(), payment.getOutTradeNo(), payment.getPaymentAmount(), wechatOpenId, hockParams);
            }else {
                signString = wechatPayUtil.getSignStr(paymentConfig.getOrderNamePrefix() + ":" + payment.getId(), payment.getOutTradeNo(), payment.getPaymentAmount(), hockParams);
            }
            break;
        default:
            throw new InvalidOperationException("支付方式异常");
    }
    payment.lunchPay(signString);
    for (PaymentOrderDO po : paymentOrders) {
        po.lunchPay(signString);
    }
    PaymentFlowDO paymentFlow = new PaymentFlowDO(payment.getId(),payment.getOutTradeNo(), PaymentFlowEnum.RECEIVE_SIGNATURE,signString);

    paymentJpaRepository.save(payment);
    paymentOrderJpaRepository.saveAll(paymentOrders);
    paymentFlowJpaRepository.save(paymentFlow);

    return signString;
}

@Override
public void synchronizedCallback(String paymentId, boolean isSuccess) throws InvalidOperationException {
    Optional<PaymentDO> paymentOptional = paymentJpaRepository.findById(paymentId);
    if(!paymentOptional.isPresent()){
        throw new InvalidOperationException("支付不存在");
    }
    PaymentDO payment = paymentOptional.get();
    payment.synchronizedCallback(isSuccess);
    List<PaymentOrderDO> paymentOrders = paymentOrderJpaRepository.findByPaymentId(paymentId);
    for (PaymentOrderDO po : paymentOrders) {
        po.synchronizedCallback(isSuccess);
    }
    PaymentFlowDO paymentFlow = new PaymentFlowDO(payment.getId(),payment.getOutTradeNo(), PaymentFlowEnum.SYNCHRONIZE_CALLBACK,isSuccess + "");
    //主动查询订单在第三方支付的状态，确保就算没有收到异步回调，支付状态依然正确
    Optional<PaymentConfigDO> paymentConfigOptional = paymentConfigJpaRepository.findByPaymentChannelAndPaymentType(payment.getPaymentChannel(),payment.getPaymentType());
    if(!paymentConfigOptional.isPresent()){
        throw new InvalidOperationException("支付方式不存在");
    }
    PaymentConfigDO paymentConfig = paymentConfigOptional.get();
    PaymentQueryResult paymentQueryResult = getPaymentResult(paymentConfig,payment.getOutTradeNo());

    if(paymentQueryResult != null && paymentQueryResult.getTradeStatus().equals(PaymentQueryResult.TradeStatus.SUCCESS)){
        asyncCallback(paymentId,true,paymentQueryResult.getTradeNo());
    }
    paymentJpaRepository.save(payment);
    paymentOrderJpaRepository.saveAll(paymentOrders);
    paymentFlowJpaRepository.save(paymentFlow);
}

@Override
public void synchronizedCallback(Collection<String> orderIds, boolean isSuccess) {
    List<PaymentOrderDO> paymentOrders = paymentOrderJpaRepository.findByOrderIdInAndPaymentStatus(orderIds,PaymentStatusEnum.LAUNCH_PAY.getValue());
    Set<String> paymentIds = paymentOrders.stream().map(PaymentOrderDO::getPaymentId).collect(Collectors.toSet());
    for (String pId : paymentIds) {
        try {
            synchronizedCallback(pId,true);
        } catch (Exception e) {
            e.printStackTrace();
            log.error("支付同步通知异常：" + pId + ":" + e.getMessage());
        }
    }
}

@Override
public void asyncCallback(String paymentId, boolean isSuccess, String tradeNo) throws InvalidOperationException {
    Optional<PaymentDO> paymentOptional = paymentJpaRepository.findById(paymentId);
    if(!paymentOptional.isPresent()){
        throw new InvalidOperationException("支付不存在");
    }
    PaymentDO payment = paymentOptional.get();
    if(payment.getPaymentStatus().equals(PaymentStatusEnum.ASYNC_CALLBACK_SUCCEED.getValue())){
        return;
    }
    List<PaymentOrderDO> paymentOrders = paymentOrderJpaRepository.findByPaymentId(paymentId);
    List<String> orderIds = paymentOrders.stream().map(PaymentOrderDO::getOrderId).collect(Collectors.toList());
    //这些订单的其余支付：设置为重复
    List<PaymentOrderDO> oldOtherPaymentOrders = paymentOrderJpaRepository.
            findByOrderIdIn(orderIds).stream().
            filter(po -> !po.getPaymentId().equalsIgnoreCase(paymentId)).
            collect(Collectors.toList());
    if(!CollectionUtils.isEmpty(oldOtherPaymentOrders)){
        for (PaymentOrderDO opo : oldOtherPaymentOrders) {
            if(opo.getPaymentStatus().equals(PaymentStatusEnum.ASYNC_CALLBACK_SUCCEED.getValue()) ||
                    opo.getPaymentStatus().equals(PaymentStatusEnum.SYNCHRONIZE_CALLBACK_SUCCEED.getValue()) ||
                    opo.getPaymentStatus().equals(PaymentStatusEnum.LAUNCH_PAY.getValue())) {
                opo.fundRepeatPay();
            }
        }
        paymentOrderJpaRepository.saveAll(oldOtherPaymentOrders);
    }
    payment.asyncCallback(isSuccess,tradeNo);
    for (PaymentOrderDO po : paymentOrders) {
        po.asyncCallback(isSuccess);
        if(isSuccess){
            //todo 须要考虑通知业务系统
            Optional<OrderDO> orderOptional = orderJpaRepository.findById(po.getOrderId());
            if(orderOptional.isPresent()) {
                OrderDO order = orderOptional.get();
                order.paymentSucceed();
                orderJpaRepository.save(order);
            }
        }
    }
    PaymentFlowDO paymentFlow = new PaymentFlowDO(payment.getId(),payment.getOutTradeNo(), PaymentFlowEnum.ASYNC_CALLBACK,isSuccess + "");
    paymentJpaRepository.save(payment);
    paymentFlowJpaRepository.save(paymentFlow);
}

@Override
public void asyncCallbackForOutTradeNo(String outTradeNo, boolean isSuccess, String tradeNo) {
    Optional<PaymentDO> paymentOptional = paymentJpaRepository.findByOutTradeNo(outTradeNo);
    if(paymentOptional.isPresent()){
        PaymentDO payment = paymentOptional.get();
        try{
            asyncCallback(payment.getId(),true,tradeNo);
        }catch (Exception e) {
            e.printStackTrace();
            log.error("支付异步通知异常：" + payment.getId() + ":" + e.getMessage());
        }
    }
}

private PaymentQueryResult getPaymentResult(PaymentConfigDO paymentConfig,String outTradeNo) {
    Optional<PaymentDO> paymentOptional = paymentJpaRepository.findByOutTradeNo(outTradeNo);
    if(!paymentOptional.isPresent()){
        return null;
    }
    PaymentDO payment = paymentOptional.get();
    PaymentQueryResult paymentQueryResult;
    PaymentChannelEnum paymentChannel = PaymentChannelEnum.getEnumByVal(paymentConfig.getPaymentChannel());
    try{
        switch (paymentChannel){
            case ALIPAY:
                AliPayUtil aliPayUtil = payUtilRepository.getAliPay(payment);
                paymentQueryResult = aliPayUtil.paymentQuery(outTradeNo);
                break;
            case WECHATPAY:
                WechatPayUtil wechatPayUtil = payUtilRepository.getWechatPay(payment);
                paymentQueryResult = wechatPayUtil.paymentQuery(outTradeNo);
                break;
            default:
                throw new InvalidOperationException("支付方式异常");
        }
        return paymentQueryResult;
    }catch (Exception e){
        log.error(e.getMessage());
        return null;
    }
}

}

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

private final RefundJpaRepository refundJpaRepository;
private final RefundFlowJpaRepository refundFlowJpaRepository;
private final PaymentJpaRepository paymentJpaRepository;
private final PaymentOrderJpaRepository paymentOrderJpaRepository;

private final WechatPayUtil wechatPayUtil;
private final AliPayUtil aliPayUtil;
private final CcbPayUtil ccbPayUtil;

@Autowired
public RefundApplicationServiceImpl(RefundJpaRepository refundJpaRepository, RefundFlowJpaRepository refundFlowJpaRepository, PaymentJpaRepository paymentJpaRepository, PaymentOrderJpaRepository paymentOrderJpaRepository, WechatPayUtil wechatPayUtil, AliPayUtil aliPayUtil, CcbPayUtil ccbPayUtil) {
    this.refundJpaRepository = refundJpaRepository;
    this.refundFlowJpaRepository = refundFlowJpaRepository;
    this.paymentJpaRepository = paymentJpaRepository;
    this.paymentOrderJpaRepository = paymentOrderJpaRepository;
    this.wechatPayUtil = wechatPayUtil;
    this.aliPayUtil = aliPayUtil;
    this.ccbPayUtil = ccbPayUtil;
}

@Override
public void createRefund(String paymentId,String sysRefundTradeNo, BigDecimal refundAmount, RefundTypeEnum refundType, String reason) throws Exception {
    Optional<PaymentDO> paymentOptional = paymentJpaRepository.findById(paymentId);
    if(!paymentOptional.isPresent()){
        throw new InvalidOperationException("支付不存在,不可退款");
    }
    PaymentDO payment = paymentOptional.get();
    //检查支付是否完成，未完成就不可退款
    PaymentChannelEnum paymentChannel = PaymentChannelEnum.getEnumByVal(payment.getPaymentChannel());
    PaymentQueryResult paymentQueryResult = getPaymentResult(paymentChannel,payment.getOutTradeNo());
    log.info("pay query : {}",paymentQueryResult);
    if(paymentQueryResult == null ||
        paymentQueryResult.getTradeStatus().equals(PaymentQueryResult.TradeStatus.FAILED) ||
        paymentQueryResult.getTradeStatus().equals(PaymentQueryResult.TradeStatus.CLOSED) ||
        paymentQueryResult.getTradeStatus().equals(PaymentQueryResult.TradeStatus.PAYING)){
        throw new InvalidOperationException("支付状态异常，不可退款");
    }

    List<Integer> refundStatus = Arrays.asList(RefundStatusEnum.START.getValue(),RefundStatusEnum.SUCCESS.getValue(),RefundStatusEnum.FAIL.getValue());
    List<RefundDO> oldRefunds = refundJpaRepository.findByPaymentIdAndRefundStatusIn(paymentId,refundStatus);
    BigDecimal oldRefundsAmount = oldRefunds.stream().map(RefundDO::getRefundAmount).reduce(BigDecimal.ZERO,BigDecimal::add);
    if(oldRefundsAmount.add(refundAmount).compareTo(payment.getPaymentAmount()) > 0){
        throw new InvalidOperationException("退款总金额不可超过支付金额");
    }
    RefundDO refund;
    Optional<RefundDO> refundOptional = refundJpaRepository.findBySysRefundTradeNo(sysRefundTradeNo);
    if(refundOptional.isPresent()){
        RefundDO oldRefund = refundOptional.get();
        if(oldRefund.getRefundStatus().equals(RefundStatusEnum.SUCCESS.getValue())){
            throw new InvalidOperationException("退款已完成");
        }else if(oldRefund.getRefundStatus().equals(RefundStatusEnum.START.getValue())){
            throw new InvalidOperationException("退款处理中");
        }
    }else {
        refund = new RefundDO(paymentId,payment.getOutTradeNo(),sysRefundTradeNo,refundAmount, refundType,reason,payment.getPaymentChannel(), payment.getPaymentType(),payment.getPaymentAmount());
        refundJpaRepository.save(refund);
    }
}

@Override
public void createRefundByOrder(String orderId, String sysRefundTradeNo, BigDecimal refundAmount, RefundTypeEnum refundType, String reason) throws Exception {
    Optional<PaymentOrderDO> paymentOrderOptional = paymentOrderJpaRepository.findByOrderIdAndIsCurrent(orderId,true);
    if(paymentOrderOptional.isPresent()){
        PaymentOrderDO paymentOrder = paymentOrderOptional.get();
        createRefund(paymentOrder.getPaymentId(),sysRefundTradeNo,refundAmount,refundType,reason);
        paymentOrderJpaRepository.save(paymentOrder);
    }
}

@Override
public void refund(RefundDO refund) throws InvalidOperationException {
    PaymentChannelEnum paymentChannel = PaymentChannelEnum.getEnumByVal(refund.getPaymentChannel());
    RefundTypeEnum refundType = RefundTypeEnum.getEnumByVal(refund.getRefundType());
    String respData;
    try {
        switch (paymentChannel){
            case ALIPAY:
                respData = aliPayUtil.orderPayRefund(refund.getOutTradeNo(),refund.getOutRefundTradeNo(),refund.getPaymentAmount(),refund.getRefundAmount(),refundType);
                break;
            case WECHATPAY:
                respData = wechatPayUtil.orderPayRefund(refund.getOutTradeNo(),refund.getOutRefundTradeNo(),refund.getPaymentAmount(),refund.getRefundAmount(),refundType);
                break;
            case CCBPAY:
                respData = ccbPayUtil.orderPayRefund(refund.getOutTradeNo(),refund.getOutRefundTradeNo(),refund.getPaymentAmount(),refund.getRefundAmount(),refundType);
                break;
            default:
                throw new InvalidOperationException("支付方式异常");
        }
        refundSuccess(refund,respData);
    }catch (Exception e){
        refundFail(refund,e.getMessage());
    }
}

private void refundSuccess(RefundDO refund,String respData) throws InvalidOperationException {
    refund.asyncCallback(true);
    refundJpaRepository.save(refund);
    RefundFlowDO refundSyncFlow = new RefundFlowDO(refund.getId(), RefundFlowEnum.SYNCHRONIZE_CALLBACK_SUCCESS,respData);
    refundFlowJpaRepository.save(refundSyncFlow);
}
private void refundFail(RefundDO refund,String errorMessage) throws InvalidOperationException{
    refund.asyncCallback(false);
    refundJpaRepository.save(refund);
    RefundFlowDO refundSyncFlow = new RefundFlowDO(refund.getId(), RefundFlowEnum.SYNCHRONIZE_CALLBACK_FAIL,errorMessage);
    refundFlowJpaRepository.save(refundSyncFlow);
}

private PaymentQueryResult getPaymentResult(PaymentChannelEnum paymentChannel,String outTradeNo) {
    try {
        switch (paymentChannel){
            case ALIPAY:
                return aliPayUtil.paymentQuery(outTradeNo);
            case WECHATPAY:
                return wechatPayUtil.paymentQuery(outTradeNo);
            case CCBPAY:
                return ccbPayUtil.paymentQuery(outTradeNo);
            default:
                return null;
        }
    }catch (Exception e){
        log.error(e.getMessage());
        return null;
    }
}

}

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

@Autowired
private PaymentJpaRepository paymentJpaRepository;
@Autowired
private IPaymentQueryService paymentQueryService;

@Override
public void executeInternal(JobExecutionContext context) throws JobExecutionException {
    log.info("检查关闭支付定时器启动");
    List<PaymentDO> payments = paymentJpaRepository.findByPaymentStatus(PaymentStatusEnum.LAUNCH_PAY.getValue());
    LocalDateTime now = LocalDateTime.now();
    List<PaymentDO> closePayments = new ArrayList<>();
    for (PaymentDO p : payments) {
        long minutes = 10L;
        if(!now.minusMinutes(minutes).isBefore(p.getLaunchPayTime())){
            //超过十分钟没有支付，就进行关闭
            try {
                PaymentQueryResult result = paymentQueryService.getPaymentResult(p.getId());
                if(result == null){
                    p.close();
                    closePayments.add(p);
                    if(closePayments.size() > 100){
                        paymentJpaRepository.saveAll(closePayments);
                        closePayments.clear();
                        p = null;
                    }
                }
            } catch (Exception e) {
                log.error("关闭支付异常：" + p.getId() + ":" + e.getMessage());
            }
        }
    }
    paymentJpaRepository.saveAll(closePayments);
}

}

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

@Autowired
private PaymentOrderJpaRepository paymentOrderJpaRepository;
@Autowired
private IRefundApplicationService refundApplicationService;

@Override
public void executeInternal(JobExecutionContext context)throws JobExecutionException {
    log.info("检查重复支付定时器启动");
    //找到还没有处理的重复支付记录
    List<PaymentOrderDO> paymentOrders = paymentOrderJpaRepository.findByPaymentStatusAndIsCurrentAndRepeatPayProcess(PaymentStatusEnum.ASYNC_CALLBACK_SUCCEED.getValue(),false,false);
    paymentOrders.forEach(po -> {
        try {
            refundApplicationService.createRefund(po.getPaymentId(), ObjectId.get().toString(),po.getPaymentAmount(), RefundTypeEnum.REPEAT_PAY,RefundTypeEnum.REPEAT_PAY.getDescription());
            po.refundRepeatPay();
            paymentOrderJpaRepository.save(po);
        } catch (Exception e) {
            log.error("支付订单：" + po.getId() + "：重复支付退款异常：" + e.getMessage());
        }
    });
}

}

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

@Autowired
private PaymentJpaRepository paymentJpaRepository;
@Autowired
private PaymentFlowJpaRepository paymentFlowJpaRepository;
@Autowired
private IPaymentApplicationService paymentApplicationService;
@Autowired
private IPaymentQueryService paymentQuery;

@Override
public void executeInternal(JobExecutionContext context) throws JobExecutionException {
    log.info("检查支付成功定时器启动");
    List<PaymentDO> payments = paymentJpaRepository.findByPaymentStatusIn(Arrays.asList(PaymentStatusEnum.LAUNCH_PAY.getValue(),PaymentStatusEnum.SYNCHRONIZE_CALLBACK_SUCCEED.getValue()));
    for (PaymentDO p : payments) {
        PaymentQueryResult result = paymentQuery.getPaymentResult(p.getId());
        PaymentFlowDO paymentFlow;
        if(result != null) {
            paymentFlow = new PaymentFlowDO(p.getId(), p.getOutTradeNo(), PaymentFlowEnum.RECEIVE_PAYMENT_DETAIL, JSONObject.toJSONString(result));
        }else {
            if(p.getPaymentStatus().equals(PaymentStatusEnum.SYNCHRONIZE_CALLBACK_SUCCEED.getValue())) {
                String error = "支付：" + p.getId() + "app同步通知成功，可是第三方支付查询：未支付！";
                log.error(error);
                p.close();
                paymentJpaRepository.save(p);
                paymentFlow = new PaymentFlowDO(p.getId(), p.getOutTradeNo(), PaymentFlowEnum.RECEIVE_PAYMENT_DETAIL, error);
            }else {
                paymentFlow = new PaymentFlowDO(p.getId(), p.getOutTradeNo(), PaymentFlowEnum.RECEIVE_PAYMENT_DETAIL, "未支付");
            }
        }
        paymentFlowJpaRepository.save(paymentFlow);
        if(result != null){
            if(result.getTradeStatus().equals(PaymentQueryResult.TradeStatus.PAYING) ||
               result.getTradeStatus().equals(PaymentQueryResult.TradeStatus.SUCCESS)){
                //第三方支付成功，直接修改支付状态
                try {
                    paymentApplicationService.asyncCallback(p.getId(),true,result.getTradeNo());
                    PaymentFlowDO successPaymentFlow = new PaymentFlowDO(p.getId(),p.getOutTradeNo(), PaymentFlowEnum.ASYNC_CALLBACK_SUCCESS, JSONObject.toJSONString(result));
                    paymentFlowJpaRepository.save(successPaymentFlow);
                } catch (InvalidOperationException e) {
                    log.error("支付：" + p.getId() + "第三方交易成功，本地修改异常：" + e.getMessage());
                }
            }else if(result.getTradeStatus().equals(PaymentQueryResult.TradeStatus.FAILED)){
                try {
                    paymentApplicationService.asyncCallback(p.getId(),false,"");
                    PaymentFlowDO failPaymentFlow = new PaymentFlowDO(p.getId(),p.getOutTradeNo(), PaymentFlowEnum.ASYNC_CALLBACK_FAILED, JSONObject.toJSONString(result));
                    paymentFlowJpaRepository.save(failPaymentFlow);
                } catch (InvalidOperationException e) {
                    log.error("支付：" + p.getId() + "第三方交易失败，本地修改异常：" + e.getMessage());
                }
            }
        }
    }
}

}

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

@Autowired
private RefundJpaRepository refundJpaRepository;
@Autowired
private IRefundApplicationService refundApplicationService;

@Override
public void executeInternal(JobExecutionContext context) {
    log.info("检查退款成功定时器启动");
    List<RefundDO> refunds = refundJpaRepository.findByRefundStatusIn(Arrays.asList(RefundStatusEnum.FAIL.getValue(),RefundStatusEnum.START.getValue()));
    for (RefundDO r : refunds) {
        try {
            refundApplicationService.refund(r);
        } catch (InvalidOperationException e) {
            log.error("退款失败：" + r.getId() + ":" + e.getMessage());
        }
    }
}

}