摘要：支付流程以上是微信支付的流程用戶進(jìn)入選擇商品進(jìn)行購買，在內(nèi)部結(jié)算時(shí)生成用戶本系統(tǒng)訂單待支付狀態(tài)，此時(shí)返回訂單信息與支付方式列表用戶確認(rèn)金額無誤，并選擇支付方式。

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

用戶進(jìn)入app選擇商品進(jìn)行購買，在app內(nèi)部結(jié)算時(shí)生成用戶本系統(tǒng)訂單（待支付狀態(tài)），此時(shí)返回訂單信息與支付方式列表

用戶確認(rèn)金額無誤，并選擇支付方式。此時(shí)app將訂單id與支付方式傳給服務(wù)器，服務(wù)器根據(jù)訂單金額與支付方式在外部支付系統(tǒng)下單（預(yù)支付訂單），并給app返回可以喚起響應(yīng)支付工具的‘支付數(shù)據(jù)’

app獲取到‘支付數(shù)據(jù)’調(diào)用響應(yīng)支付sdk，此時(shí)用戶會(huì)看見微信支付或支付寶支付的頁面，此時(shí)用戶需要確認(rèn)支付金額并輸入正確的密碼

sdk會(huì)檢查用戶的密碼信息是否正確并返回支付結(jié)果，此時(shí)app收到sdk同步通知的支付結(jié)果，并提交到服務(wù)器，服務(wù)器會(huì)記錄該筆支付的狀態(tài)，切記不能使用app上傳回來的支付結(jié)果作為最終的支付結(jié)果，不能信任前端數(shù)據(jù)

外部支付系統(tǒng)在處理完成該筆支付后會(huì)回調(diào)服務(wù)器設(shè)置的回調(diào)接口，通知服務(wù)器該筆支付的最終支付狀態(tài)
收到通知時(shí)需要注意：

同樣的通知可能會(huì)多次發(fā)送給商戶系統(tǒng)。商戶系統(tǒng)必須能夠正確處理重復(fù)的通知。

后臺(tái)通知交互時(shí)，如果微信收到商戶的應(yīng)答不符合規(guī)范或超時(shí)，微信會(huì)判定本次通知失敗，重新發(fā)送通知，直到成功為止，但微信不保證通知最終一定能成功。

在訂單狀態(tài)不明或者沒有收到微信支付結(jié)果通知的情況下，建議商戶主動(dòng)調(diào)用微信支付【查詢訂單API】確認(rèn)訂單狀態(tài)。

商戶系統(tǒng)對(duì)于支付結(jié)果通知的內(nèi)容一定要做簽名驗(yàn)證,并校驗(yàn)返回的訂單金額是否與商戶側(cè)的訂單金額一致，防止數(shù)據(jù)泄漏導(dǎo)致出現(xiàn)“假通知”，造成資金損失。

當(dāng)收到通知進(jìn)行處理時(shí)，首先檢查對(duì)應(yīng)業(yè)務(wù)數(shù)據(jù)的狀態(tài)，判斷該通知是否已經(jīng)處理過，如果沒有處理過再進(jìn)行處理，如果處理過直接返回結(jié)果成功。在對(duì)業(yè)務(wù)數(shù)據(jù)進(jìn)行狀態(tài)檢查和處理之前，要采用數(shù)據(jù)鎖進(jìn)行并發(fā)控制，以避免函數(shù)重入造成的數(shù)據(jù)混亂。

以上流程時(shí)微信與支付寶給出的官方流程，并且也是最標(biāo)準(zhǔn)的流程。但是當(dāng)外部支付系統(tǒng)并沒有微信與支付寶那么優(yōu)秀的時(shí)候，我們的系統(tǒng)就不能按照該流程正常運(yùn)行下去，下面我說說在使用‘建行支付’時(shí)遇到的問題

服務(wù)器收不到支付結(jié)果的回調(diào)

即使主動(dòng)查詢支付狀態(tài)‘建行支付’依然返回未支付的狀態(tài)

以上兩個(gè)問題會(huì)引發(fā)更復(fù)雜的問題

由于沒有支付回調(diào)，訂單狀態(tài)就不會(huì)發(fā)送改變用戶就會(huì)再次支付，造成重復(fù)支付的現(xiàn)象

系統(tǒng)沒有預(yù)料到會(huì)出現(xiàn)重復(fù)支付也就沒有相應(yīng)的策略去彌補(bǔ)

由于系統(tǒng)并不知道支付已經(jīng)成功，用戶在取消訂單的時(shí)候就不會(huì)收到退款

根據(jù)這些線上出現(xiàn)的問題，我們決定進(jìn)行重構(gòu)，并深層次的處理整個(gè)支付流程！

1.確認(rèn)支付方式

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

2.如何確保支付成功

1.外部支付系統(tǒng)（支付寶）成功后回調(diào)通知
2.本系統(tǒng)主動(dòng)查詢外部支付系統(tǒng)訂單狀態(tài)

3.如何避免用戶重復(fù)支付

1.本系統(tǒng)在發(fā)起支付的時(shí)候檢查‘訂單號(hào)’是否有已經(jīng)成功的支付記錄
2.本系統(tǒng)在發(fā)起支付的時(shí)候檢查‘訂單號(hào)’是否有已經(jīng)提交的支付記錄，如果有需要同步查詢外部支付系統(tǒng)該訂單的支付狀態(tài)

4.如果用戶出現(xiàn)重復(fù)支付系統(tǒng)如何處理

1.系統(tǒng)需要定時(shí)檢查是否有同一個(gè)‘訂單號(hào)’出現(xiàn)多條成功支付的記錄，如果有需要保留一筆支付，其余的進(jìn)行退款處理    

5.數(shù)據(jù)出現(xiàn)異常怎么辦（例如：用戶說支付完成，但是訂單依然是待支付的狀態(tài)）

1.所有的支付流程都需要進(jìn)行數(shù)據(jù)記錄，形成支付流水，這樣可以直觀的看到用戶支付的路徑，也方便外部支付系統(tǒng)查詢

‘支付’是一次支付的記錄，可能包含多個(gè)訂單的支付金額，因?yàn)橛脩粼谫徺I商品生成訂單的時(shí)候會(huì)根據(jù)商家拆單

‘支付與訂單的隱射’表明該支付中所有的訂單信息，每個(gè)‘映射’都記錄了訂單的金額與支付狀態(tài)，并且重復(fù)支付也是發(fā)生在該‘映射’上的，因?yàn)橐粋€(gè)訂單智能有一次最終成功支付的記錄,最終哪一個(gè)映射是有效的由‘是否當(dāng)前使用’決定，任何時(shí)候一個(gè)訂單只有一個(gè)映射有效

‘支付’可能有多條退款記錄，退款的總金額不能超過支付金額，并且每一筆退款都需要一個(gè)唯一的退款交易號(hào)來保證不會(huì)重復(fù)退款，退款交易號(hào)由具體業(yè)務(wù)系統(tǒng)生成（比如退貨，取消訂單，重復(fù)支付）

所有的退款必須成功

系統(tǒng)需要主動(dòng)查詢支付狀態(tài)是‘發(fā)起支付’，‘a(chǎn)pp同步通知成功’記錄在外部支付系統(tǒng)的支付狀態(tài)，如果在外部支付系統(tǒng)支付成功，這里需要重新設(shè)置支付狀態(tài)為‘已完成’

支付的外部交易號(hào)與退款的退款交易號(hào)都是唯一的

為了保證系統(tǒng)的正常工作我們還需要一些定時(shí)器來作為最后的防線

1. 支付業(yè)務(wù)邏輯

public interface IPaymentApplicationService {

/**
 * 創(chuàng)建支付，待支付狀態(tài)
 * @param orders 訂單JSONArray
 * @param paymentAmount 支付金額
 * @param paymentChannel 支付渠道
 * @param paymentType 支付方式
 * @param accountId 賬戶
 * @param serviceId 服務(wù)
 * @param platformId 平臺(tái)
 * @param hockParams 回傳參數(shù)
 * @return
 */
PaymentResultDTO createPayment(List orders, BigDecimal paymentAmount, PaymentChannelEnum paymentChannel, PaymentTypeEnum paymentType, String accountId, String serviceId, String platformId,String hockParams) throws InvalidOperationException;

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

/**
 * app、小程序、H5收到回調(diào)
 * @param orderIds 本次支付的所有訂單id
 * @param isSuccess 是否成功
 */
void synchronizedCallback(Collection orderIds,boolean isSuccess);

/**
 * 服務(wù)器端收到回調(diào)
 * @param paymentId 支付id
 * @param isSuccess 是否支付成功
 * @param tradeNo 交易號(hào)
 */
void asyncCallback(String paymentId,boolean isSuccess,String tradeNo) throws InvalidOperationException;


/**
 * 服務(wù)器端收到回調(diào)
 * @param outTradeNo 外部交易號(hào)
 * @param isSuccess 是否支付成功
 * @param tradeNo 交易號(hào)
 */
void asyncCallbackForOutTradeNo(String outTradeNo,boolean isSuccess,String tradeNo);

}

2.退款業(yè)務(wù)邏輯

public interface IRefundApplicationService {

/**
 * 發(fā)起退款
 * @param paymentId 支付id
 * @param sysRefundTradeNo 系統(tǒng)內(nèi)部退款單號(hào)
 * @param refundAmount 退款金額
 * @param refundType 退款類型
 * @param reason 退款理由
 * @return 退款id
 */
void createRefund(String paymentId,String sysRefundTradeNo, BigDecimal refundAmount, RefundTypeEnum refundType, String reason) throws Exception;

/**
 * 針對(duì)訂單發(fā)起退款
 * @param orderId 訂單id
 * @param sysRefundTradeNo 系統(tǒng)內(nèi)部退款單號(hào)
 * @param refundAmount 退款金額
 * @param refundType 退款類型
 * @param reason 退款理由
 * @return 退款id
 */
void createRefundByOrder(String orderId,String sysRefundTradeNo, BigDecimal refundAmount, RefundTypeEnum refundType, String reason) throws Exception;

/**
 * 退款
 * @param refund 退款實(shí)體
 */
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 orders, BigDecimal paymentAmount, PaymentChannelEnum paymentChannel, PaymentTypeEnum paymentType, String accountId, String serviceId, String platformId, String hockParams,String wechatOpenId) throws Exception {
    Optional paymentConfigOptional = paymentConfigJpaRepository.findByPaymentChannelAndPaymentType(paymentChannel.getValue(),paymentType.getValue());
    if(!paymentConfigOptional.isPresent()){
        throw new InvalidOperationException("支付方式不存在");
    }
    PaymentConfigDO paymentConfig = paymentConfigOptional.get();
    //成功支付的訂單不能再次支付
    List orderIds = orders.stream().map(PaymentOrderDTO::getOrderId).collect(Collectors.toList());
    List 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())){
            //可能是重復(fù)支付
            po.fundRepeatPay();
            paymentOrderJpaRepository.save(po);
            //主動(dòng)查詢支付是否成功
            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 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 paymentOrders,String hockParams,String wechatOpenId) throws Exception {
    Optional paymentConfigOptional = paymentConfigJpaRepository.findByPaymentChannelAndPaymentType(payment.getPaymentChannel(),payment.getPaymentType());
    if(!paymentConfigOptional.isPresent()){
        throw new InvalidOperationException("支付配置不存在");
    }
    PaymentConfigDO paymentConfig = paymentConfigOptional.get();
    //計(jì)算簽名字符串
    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 paymentOptional = paymentJpaRepository.findById(paymentId);
    if(!paymentOptional.isPresent()){
        throw new InvalidOperationException("支付不存在");
    }
    PaymentDO payment = paymentOptional.get();
    payment.synchronizedCallback(isSuccess);
    List paymentOrders = paymentOrderJpaRepository.findByPaymentId(paymentId);
    for (PaymentOrderDO po : paymentOrders) {
        po.synchronizedCallback(isSuccess);
    }
    PaymentFlowDO paymentFlow = new PaymentFlowDO(payment.getId(),payment.getOutTradeNo(), PaymentFlowEnum.SYNCHRONIZE_CALLBACK,isSuccess + "");
    //主動(dòng)查詢訂單在第三方支付的狀態(tài)，確保就算沒有收到異步回調(diào)，支付狀態(tài)依然正確
    Optional 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 orderIds, boolean isSuccess) {
    List paymentOrders = paymentOrderJpaRepository.findByOrderIdInAndPaymentStatus(orderIds,PaymentStatusEnum.LAUNCH_PAY.getValue());
    Set 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 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 paymentOrders = paymentOrderJpaRepository.findByPaymentId(paymentId);
    List orderIds = paymentOrders.stream().map(PaymentOrderDO::getOrderId).collect(Collectors.toList());
    //這些訂單的其他支付：設(shè)置為重復(fù)
    List 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 需要考慮通知業(yè)務(wù)系統(tǒng)
            Optional 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 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 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 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("支付狀態(tài)異常，不可退款");
    }

    List refundStatus = Arrays.asList(RefundStatusEnum.START.getValue(),RefundStatusEnum.SUCCESS.getValue(),RefundStatusEnum.FAIL.getValue());
    List 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 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 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("檢查關(guān)閉支付定時(shí)器啟動(dòng)");
    List payments = paymentJpaRepository.findByPaymentStatus(PaymentStatusEnum.LAUNCH_PAY.getValue());
    LocalDateTime now = LocalDateTime.now();
    List closePayments = new ArrayList<>();
    for (PaymentDO p : payments) {
        long minutes = 10L;
        if(!now.minusMinutes(minutes).isBefore(p.getLaunchPayTime())){
            //超過十分鐘沒有支付，就進(jìn)行關(guān)閉
            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("關(guān)閉支付異常：" + 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("檢查重復(fù)支付定時(shí)器啟動(dòng)");
    //找到尚未處理的重復(fù)支付記錄
    List 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() + "：重復(fù)支付退款異常：" + 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("檢查支付成功定時(shí)器啟動(dòng)");
    List 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)){
                //第三方支付成功，直接修改支付狀態(tài)
                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("檢查退款成功定時(shí)器啟動(dòng)");
    List 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());
        }
    }
}

}