devbox
weixin_40725706
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

微信支付踩坑血泪史(JAVA -V3版本)_weixin-java-pay

作者：weixin_40725706 | 2024-07-24 10:35:46

赞

踩

weixin-java-pay

背景介绍

最近第一次接触到微信支付,踩了很多坑，赶紧写下来，全是心酸和眼泪。话不多说。开始展示。

项目中使用的接入方式是JSAPI（参考 产品中心 - 微信支付商户平台），当然也可以使用其他接入方式，根据需求来。

微信支付提供了两种对接方式（SDK，工具 | 微信支付商户平台文档中心）。一种是SDK，一种是Client，我个人偏向于SDK，因为它更简单，基本都封装好了。

项目中我们选择的非官方SDK binarywang，没什么别的原因，主要是更方便。

官网：Binary Wang；

GitHub：GitHub - binarywang/weixin-java-pay-demo: 基于Spring Boot 和 WxJava 实现的微信支付Java后端Demo

一、接入前准备

接入前需要创建账号等步骤，可以参考官方文档：JSAPI支付-接入前准备 | 微信支付商户平台文档中心​​​​​​​x

二、引入依赖

  1.         <dependency>
  2.             <groupId>com.github.binarywang</groupId>
  3.             <artifactId>weixin-java-mp</artifactId>
  4.         </dependency>
  5.         <dependency>
  6.             <groupId>com.github.binarywang</groupId>
  7.             <artifactId>weixin-java-pay</artifactId>
  8.         </dependency>

三、编写配置文件

开发环境下可以把秘钥存到本地，线上建议放到服务器。

因为支付会有回调和退款等操作，本地接口不能被访问。建议使用内网穿透工具进行测试（Sunny-Ngrok内网转发内网穿透 - 国内内网映射服务器）

  1. wechat-pay:
  2.   #商户id
  3.   mchId: 111111
  4.   #公众号appid
  5.   appid: wxce9662d47d419qwvw
  6.   #APIv3密钥
  7.   apiV3key: oLV98ZUF1Kdsfwefgwq7nCazqpew
  8.   #商户证书序列号
  9.   serialNo: 234235r598C803FersvdvB380A4F9CA77C8538AE7F
  10.   #商户私钥
  11.   privateKeyPath: E:/Project/devOps/key/apiclient_key.pem
  12.   privateCertPath: E:/Project/devOps/key/apiclient_cert.pem
  13.   #接收结果通知地址
  14.   notifyUrl: http://howfhu.frfe.idcwfwgye.com/notify/pay/wx
  15.   #退款通知地址
  16.   refundNotifyUrl: http://hu.free.idefengye.com/notify/refund/wx

四、数据库设计

订单表

退款表 支付单表

 订单与支付单和退款单关系为一对多 不同用户扫码会产生多个支付记录，同样退款有多个退款记录。业务代码需要做支付幂等，同一笔不允许重复支付，重复支付需要调用退款接口。

 五、业务代码

 1.控制层

  1. @Api(tags = "订单管理")
  2. @RestController
  3. public class OrderController {
  4.     @Autowired
  5.     private OrderService orderService;
  6.  
  7.     @Operation(summary = "提交订单")
  8.     @PostMapping("/order/create")
  9.     public BizResult<String> createOrder(@Valid @RequestBody OrderCreateReq req) {
  10.         String orderNO = orderService.createOrder(req);
  11.         return BizResult.create(orderNO);
  12.     }
  13.  
  14.     @Operation(summary = "订单详情")
  15.     @GetMapping("/order/detail")
  16.     public BizResult<OrderRsp> orderDetail(@RequestParam String orderNo) {
  17.         OrderRsp orderRsp = orderService.orderDetail(orderNo);
  18.         return BizResult.create(orderRsp);
  19.     }
  20.  
  21.     @Operation(summary = "轮询订单")
  22.     @GetMapping("/order/polling")
  23.     public BizResult<Boolean> pollingOrder(@RequestParam String orderNo) {
  24.         Boolean result = orderService.pollingOrder(orderNo);
  25.         return BizResult.create(result);
  26.     }
  27.  
  28.     @Operation(summary = "订单列表")
  29.     @PostMapping("/order/list")
  30.     public BizResult<PageData<OrderListRsp>> queryOrderList(@RequestBody OrderListReq req) {
  31.         req.check();
  32.         PageData<OrderListRsp> pageData = orderService.queryOrderList(req);
  33.         return BizResult.create(pageData);
  34.     }
  35.  
  36. }

2.业务层

  1. @Slf4j
  2. @Service
  3. public class OrderService {
  4.  
  5.  
  6.     /**
  7.      * 创建订单
  8.      */
  9.     @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
  10.     public String createOrder(OrderCreateReq req) 
  11.  
  12.         //判断用户是否短时间多次提交 
  13.         // 加锁  RLock rLock
  14.  
  15.         try {
  16.             //查询商品是否存在  不存在处理异常 
  17.             OrderDO orderDO = OrderConverter.init(req, traceCodeGoodsDO, merchantDO, orderTypeEnum);
  18.             orderMapper.insert(orderDO);
  19.             return orderDO.getOrderNo();
  20.         } finally {
  21.             if (rLock.isHeldByCurrentThread()) {
  22.                 rLock.unlock();
  23.             }
  24.         }
  25.     }
  26.  
  27.  
  28.     /**
  29.      * 查询订单详情
  30.      */
  31.     public OrderRsp orderDetail(String orderNo) {
  32.         if (StringUtils.isBlank(orderNo)) {
  33.             throw BizException.create(BaseErrorCodeEnum.PARAMS_ERROR, "订单号不存在");
  34.         }
  35.         //查询订单
  36.         OrderDO orderDO = orderMapper.findByOrderNo(orderNo);
  37.         if (Objects.isNull(orderDO)) {
  38.             throw BizException.create(BizErrorCodeEnum.ORDER_NOT_EXITS);
  39.         }
  40.         return OrderConverter.toOrderRsp(orderDO);
  41.     }
  42.  
  43.  
  44.     /**
  45.      * 订单轮询   前端轮询这个接口 判断当前订单状态 进行响应状态修改
  46.      */
  47.     @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
  48.     public Boolean pollingOrder(String orderNo) {
  49.         if (StringUtils.isBlank(orderNo)) {
  50.             throw BizException.create(BaseErrorCodeEnum.PARAMS_ERROR, "订单号不存在");
  51.         }
  52.         OrderDO orderDO = orderMapper.findByOrderNo(orderNo);
  53.         if (Objects.isNull(orderDO)) {
  54.             throw BizException.create(BizErrorCodeEnum.ORDER_NOT_EXITS);
  55.         }
  56.         //状态支付中 将状态改为未支付
  57.         if (Objects.equals(orderDO.getStatus(), OrderStatusEnum.PAYING.getCode())) {
  58.             orderMapper.updateStatus(orderNo, OrderStatusEnum.UNPAID.getCode(), orderDO.getStatus());
  59.             return false;
  60.         }
  61.         //未支付
  62.         if (Objects.equals(orderDO.getStatus(), OrderStatusEnum.UNPAID.getCode())) {
  63.             return false;
  64.         }
  65.         String payNo = orderDO.getPayNo();
  66.         if (StringUtils.isBlank(payNo)) {
  67.             return false;
  68.         }
  69.         //查询支付单是否存在
  70.         PaymentDO paymentDO = paymentMapper.findByPayNo(payNo);
  71.         if (Objects.isNull(paymentDO)) {
  72.             log.error("轮询订单，支付单不存在。orderNo:{},payNo:{}", orderDO, payNo);
  73.             return false;
  74.         }
  75.         if (!Objects.equals(orderDO.getStatus(), OrderStatusEnum.UNPAID.getCode()) && !Objects.equals(orderDO.getStatus(), OrderStatusEnum.PAYING.getCode())) {
  76.             // 查询需要取消支付单记录
  77.             List<PaymentDO> paymentList = paymentMapper.queryPaymentList(orderDO.getOrderNo(), PayStatusEnum.UNPAID.getCode(), paymentDO.getPayNo());
  78.             if (ObjectUtil.isNotEmpty(paymentList)) {
  79.                 // 修改支付单取消状态
  80.                 paymentMapper.cancelPay(orderDO.getOrderNo(), PayStatusEnum.CANCEL.getCode(), paymentDO.getPayNo(), PayStatusEnum.UNPAID.getCode());
  81.             }
  82.             return true;
  83.         }
  84.         PayStatusEnum payStatusEnum = LocalEnumUtils.findByCodeWithoutDefault(PayStatusEnum.class, paymentDO.getStatus());
  85.         if (Objects.equals(payStatusEnum, PayStatusEnum.CANCEL)
  86.                 || Objects.equals(payStatusEnum, PayStatusEnum.FAIL)) {
  87.             //取消支付或支付失败，可重新扫码创建支付单
  88.             return false;
  89.         } else if (Objects.equals(payStatusEnum, PayStatusEnum.UNPAID)) {
  90.             //支付单待支付，查询第三方渠道
  91.             WxPayOrderQueryV3Result wxPayOrderQueryV3Result = null;
  92.             try {
  93.                 WxPayOrderQueryV3Request request = new WxPayOrderQueryV3Request();
  94.                 request.setOutTradeNo(paymentDO.getPayNo());
  95.                 wxPayOrderQueryV3Result = wxManager.getWxPayService().queryOrderV3(request);
  96.             } catch (WxPayException e) {
  97.                 log.error("查询微信支付订单失败。payNo:{}", paymentDO.getPayNo(), e);
  98.                 return false;
  99.             }
  100.             //查询第三方支付信息并更新订单
  101.             if (orderManager.queryOrderByWx(wxPayOrderQueryV3Result, orderDO, paymentDO, payStatusEnum)) {
  102.                 producerHelper.sendOrderMsg(orderDO);
  103.                 return true;
  104.             }
  105.         } else {
  106.             //其他状态，更新订单状态。
  107.             int orgOrderStatus = orderDO.getStatus();
  108.             OrderStatusEnum tarOrderStatus = OrderStatusEnum.PAID;
  109.             if (Objects.equals(payStatusEnum, PayStatusEnum.REFUND)) {
  110.                 tarOrderStatus = OrderStatusEnum.REFUND;
  111.                 orderDO.setRefundTime(paymentDO.getRefundTime());
  112.                 orderDO.setRefundAmount(paymentDO.getRefundAmount());
  113.             }
  114.             orderDO.setFinishTime(paymentDO.getPayTime());
  115.             orderDO.setStatus(tarOrderStatus.getCode());
  116.             orderDO.setUpdateTime(new Date());
  117.             int i = orderMapper.updateStatusByOrderNo(orderDO, orgOrderStatus);
  118.             if (i > 0) {
  119.                 producerHelper.sendOrderMsg(orderDO);
  120.             }
  121.             return true;
  122.         }
  123.         return false;
  124.     }
  125.  
  126.     /**
  127.      * jsapi下单并返回前端唤起参数
  128.      */
  129.     @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
  130.     public OrderJsApiRsq jsapiPay(JsAPIReq req) {
  131.         String orderNo = req.getOrderNo();
  132.         String openId = req.getOpenid();
  133.         // 加锁 RLock lock 
  134.         if (lock == null) {
  135.             throw BizException.create(CommonErrorCodeEnum.RESUBMIT_ERROR, "订单支付中");
  136.         }
  137.         //查询订单
  138.         OrderDO orderDO = orderMapper.findByOrderNo(orderNo);
  139.         if (Objects.isNull(orderDO)) {
  140.             throw BizException.create(BizErrorCodeEnum.ORDER_NOT_EXITS);
  141.         }
  142.         Integer orgStatus = orderDO.getStatus();
  143.         //校验重复支付
  144.         if (Objects.equals(orgStatus, OrderStatusEnum.PAID.getCode())) {
  145.             throw BizException.create(BizErrorCodeEnum.ORDER_PAY, "订单已支付,请勿重复支付");
  146.         }
  147.         // 查询支付单,没有则新增
  148.         // 对比openid，如果一样直接发起支付，不一样新增支付单
  149.         PaymentDO paymentDO = paymentMapper.findByPayNo(orderDO.getPayNo());
  150.         if (Objects.isNull(paymentDO) || !Objects.equals(paymentDO.getOpenid(), req.getOpenid())) {
  151.             //插入支付单数据
  152.             paymentMapper.insert(paymentDO);
  153.             //更新订单号中支付单号
  154.  
  155.             // 幂等更新
  156.             int i = orderMapper.updateStatusByOrderNo(orderDO, orgStatus);
  157.             if (i == 0) {
  158.                 throw BizException.create(BizErrorCodeEnum.ORDER_PAY, "订单已支付");
  159.             }
  160.         }
  161.  
  162.         WxPayUnifiedOrderV3Request request = WxPayConverter.toWxPayUnifiedOrderV3Request(orderDO, paymentDO.getPayNo(), openId);
  163.         WxPayUnifiedOrderV3Result.JsapiResult result = null;
  164.         try {
  165.             result = wxManager.getWxPayService().createOrderV3(TradeTypeEnum.JSAPI, request);
  166.         } catch (WxPayException e) {
  167.             log.error("JSAPI下单支付异常,orderNo:{}", orderNo, e);
  168.             throw BizException.create(BizErrorCodeEnum.ORDER_UNIFIED_ERROR, "支付唤起失败");
  169.         } finally {
  170.             if (lock.isHeldByCurrentThread()) {
  171.                 lock.unlock();
  172.             }
  173.         }
  174.         return WxPayConverter.toOrderJsApiRsq(result);
  175.     }
  176.  
  177.     /**
  178.      * 支付通知
  179.      */
  180.     @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
  181.     public OrderPayNotify payNotify(JSONObject jsonObject, HttpServletRequest request, HttpServletResponse response) {
  182.         log.info("微信支付结果通知:{}", jsonObject);
  183.         //获取请求头
  184.         SignatureHeader header = PayUtil.getWXRequestHeader(request);
  185.         //请求体
  186.         //解析回调通知
  187.         WxPayOrderNotifyV3Result wxPayOrderNotifyV3Result = getWxPayOrderNotifyV3Result(jsonObject, header);
  188.         WxPayOrderNotifyV3Result.DecryptNotifyResult result = wxPayOrderNotifyV3Result.getResult();
  189.         WxPayTradeStateEnum wxPayStatus = WxPayTradeStateEnum.findByCode(result.getTradeState());
  190.         //中间态，直接返回，继续通知
  191.         if (Objects.equals(wxPayStatus, WxPayTradeStateEnum.NOT_PAY)
  192.                 || Objects.equals(wxPayStatus, WxPayTradeStateEnum.ACCEPT)
  193.                 || Objects.equals(wxPayStatus, WxPayTradeStateEnum.USER_PAYING)) {
  194.             log.error("微信支付回调,中间态继续通知,payNo:{}", wxPayOrderNotifyV3Result.getResult().getOutTradeNo());
  195.             response.setStatus(HttpStatus.SC_INTERNAL_SERVER_ERROR);
  196.             return OrderPayNotify.fail();
  197.         }
  198.         //加锁RLock lock 
  199.         if (lock == null) {
  200.             throw BizException.create(BizErrorCodeEnum.PAY_FAIL);
  201.         }
  202.         try {
  203.             //查询支付单
  204.             PaymentDO paymentDO
  205.             log.info("支付单结果解析:{},支付单号{}", paymentDO, paymentDO.getPayNo());
  206.             //查询订单
  207.             OrderDO orderDO 
  208.             log.info("订单结果解析:{},支付单号{}", orderDO, orderDO.getOrderNo());
  209.             Integer status = paymentDO.getStatus();
  210.             //订单已支付  订单状态不等于未支付和支付中
  211.             if (!Objects.equals(orderDO.getStatus(), OrderStatusEnum.UNPAID.getCode())) {
  212.                 if (!Objects.equals(orderDO.getStatus(), OrderStatusEnum.PAYING.getCode())) {
  213.                     //订单已支付 判断是否同一支付单， 是则表示同一笔订单重复支付
  214.                     if (!Objects.equals(orderDO.getPayNo(), paymentDO.getPayNo())) {
  215.                         //支付通知状态
  216.                         RefundDO refundDO = null;
  217.                         if (Objects.equals(wxPayStatus, WxPayTradeStateEnum.SUCCESS)) {
  218.                             //重复支付，新增退款记录
  219.                             refundDO = RefundConverter.init(paymentDO);
  220.                             refundMapper.insert(refundDO);
  221.                             paymentDO.setRefundTime(refundDO.getRefundTime());
  222.                             paymentDO.setRefundAmount(refundDO.getRefundAmount());
  223.                             //申请退款
  224.                             WxPayRefundV3Request wxPayRefundV3Request = WxPayConverter.toWxPayRefundV3(refundDO);
  225.                             wxPayRefundV3Request.setNotifyUrl(wxPayProperties.getRefundNotifyUrl());
  226.                             WxPayRefundV3Result wxPayRefundV3Result = wxManager.getWxPayRefundService().refundV3(wxPayRefundV3Request);
  227.                             log.info("申请退款结果解析:{}", wxPayRefundV3Result);
  228.                         }
  229.                         //更新支付单
  230.                         paymentDO.setStatus(PayStatusEnum.REFUNDING.getCode());
  231.                         paymentMapper.updatePayStatus(paymentDO, status);
  232.                         response.setStatus(HttpStatus.SC_OK);
  233.                         return OrderPayNotify.success();
  234.                     }
  235.                     response.setStatus(HttpStatus.SC_OK);
  236.                     return OrderPayNotify.success();
  237.                 }
  238.             }
  239.             //未支付订单
  240.             //更新订单和支付单状态
  241.             if (orderManager.payNotify(result, orderDO, paymentDO, wxPayStatus)) {
  242.                 //生成码包
  243.                 producerHelper.sendOrderMsg(orderDO);
  244.             }
  245.             response.setStatus(HttpStatus.SC_OK);
  246.             return OrderPayNotify.success();
  247.         } catch (Exception e) {
  248.             log.error("微信回调结果异常,第三方流水号{},异常支付单号{}", result.getTransactionId(), wxPayOrderNotifyV3Result.getResult().getOutTradeNo(), e);
  249.             response.setStatus(HttpStatus.SC_INTERNAL_SERVER_ERROR);
  250.             return OrderPayNotify.fail();
  251.         } finally {
  252.             if (lock.isHeldByCurrentThread()) {
  253.                 lock.unlock();
  254.             }
  255.         }
  256.     }
  257.  
  258.     /**
  259.      * 退款通知
  260.      */
  261.     @Transactional(rollbackFor = Exception.class)
  262.     public OrderPayNotify payRefundNotify(JSONObject jsonObject, HttpServletRequest request, HttpServletResponse response) {
  263.         //获取请求头
  264.         SignatureHeader header = PayUtil.getWXRequestHeader(request);
  265.         //解析回调
  266.         WxPayRefundNotifyV3Result wxPayRefundNotifyV3Result = getWxPayRefundNotifyV3Result(jsonObject, header);
  267.         WxPayRefundNotifyV3Result.DecryptNotifyResult result = wxPayRefundNotifyV3Result.getResult();
  268.         log.info("微信退款结果通知:{}", result);
  269.         WxPayRefundStateEnum wxPayRefundStateEnum = WxPayRefundStateEnum.findByCode(result.getRefundStatus());
  270.         //退款关闭或者退款异常，直接返回，继续通知
  271.         if (Objects.equals(wxPayRefundStateEnum, WxPayRefundStateEnum.CLOSED) || Objects.equals(wxPayRefundStateEnum, WxPayRefundStateEnum.ABNORMAL)
  272.         ) {
  273.             log.error("微信退款异常回调,退款单号,refundNo:{}", result.getOutRefundNo());
  274.             response.setStatus(HttpStatus.SC_INTERNAL_SERVER_ERROR);
  275.             return OrderPayNotify.fail();
  276.         }
  277.         //加锁 RLock lock 
  278.         if (lock == null) {
  279.             throw BizException.create(BizErrorCodeEnum.REFUND_NOTIFY_FAIL);
  280.         }
  281.         try {
  282.             //查询退款单
  283.             RefundDO refundDo 
  284.             log.info("微信退款单解析:{},退款单号", refundDo, refundDo.getRefundNo());
  285.             //查询支付单
  286.             PaymentDO payment 
  287.             log.info("支付单结果解析:{},支付单号{}", payment, payment.getPayNo());
  288.             //查询订单
  289.             OrderDO order 
  290.             log.info("订单结果解析:{},订单号{}", order, order.getOrderNo());
  291.  
  292.             Integer paymentStatus = payment.getStatus();
  293.             Integer orderStatus = order.getStatus();
  294.             Integer refundStatus = refundDo.getStatus();
  295.  
  296.             //退款单状态退款中 并且退款通知成功   更新支付单和退款单
  297.             if (Objects.equals(refundStatus, RefundStateEnum.REFUNDING.getCode())) {
  298.                 //更新退款单
  299.                 if (!Objects.equals(refundStatus, RefundStateEnum.SUCCESS.getCode())) {
  300.                     refundDo = RefundConverter.toRefund(wxPayRefundNotifyV3Result, refundDo);
  301.                     int r = refundMapper.updateStatus(refundDo, refundStatus);
  302.                     if (r == 0) {
  303.                         throw BizException.create(BizErrorCodeEnum.REFUND_UPDATE_FAIL, "退款单更新失败");
  304.                     }
  305.                 }
  306.                 //更新支付单
  307.                 payment.setStatus(PayStatusEnum.REFUND.getCode());
  308.                 payment.setRefundTime(DateUtil.parse(result.getSuccessTime()));
  309.                 BigDecimal refundAmount = LocalMoneyUtils.fen2yuan(Long.valueOf(result.getAmount().getRefund()));
  310.                 payment.setPayAmount(refundAmount);
  311.                 int p = paymentMapper.updatePayStatus(payment, paymentStatus);
  312.                 if (p == 0) {
  313.                     throw BizException.create(BizErrorCodeEnum.PAYMENT_UPDATE_FAIL, "支付单状态更新失败");
  314.                 }
  315.                 response.setStatus(HttpStatus.SC_OK);
  316.                 return OrderPayNotify.success();
  317.             }
  318.             response.setStatus(HttpStatus.SC_INTERNAL_SERVER_ERROR);
  319.             return OrderPayNotify.fail();
  320.         } catch (Exception e) {
  321.             response.setStatus(HttpStatus.SC_INTERNAL_SERVER_ERROR);
  322.             return OrderPayNotify.fail();
  323.         } finally {
  324.             if (lock.isHeldByCurrentThread()) {
  325.                 lock.unlock();
  326.             }
  327.         }
  328.     }
  329.  
  330.     /**
  331.      * 订单列表
  332.      */
  333.     public PageData<OrderListRsp> queryOrderList(OrderListReq req, MerchantContext loginUser) {
  334.         Long count = orderMapper.orderTotal(req, loginUser.getMerchantId());
  335.         if (count <= 0) {
  336.             return PageData.create(Lists.newArrayList(), count, req.getPage(), req.getSize());
  337.         }
  338.         List<OrderDO> orderList = orderMapper.queryOrderList(req, loginUser.getMerchantId());
  339.         List<OrderListRsp> OrderRsp = OrderConverter.toOrderListReq(orderList);
  340.         return PageData.create(OrderRsp, count, req.getPage(), req.getSize());
  341.     }
  342.  
  343.     /**
  344.      * 关闭订单
  345.      */
  346.     @Transactional(rollbackFor = Exception.class)
  347.     public boolean closeOrder(String orderNo) throws WxPayException {
  348.         //查询订单是否已支付
  349.         OrderDO orderDO = orderMapper.findByOrderNo(orderNo);
  350.         if (!OrderStatusEnum.UNPAID.getCode().equals(orderDO.getStatus())) {
  351.             return false;
  352.         }
  353.         Date expireTime = orderDO.getExpireTime();
  354.         Date date = new Date();
  355.         if (expireTime.compareTo(date) > 0) {
  356.             //时间未到
  357.             return false;
  358.         }
  359.  
  360.         log.info("订单超期关闭,单号为{}", orderDO.getOrderNo());
  361.         orderDO.setCloseTime(date);
  362.         orderDO.setUpdateTime(date);
  363.         orderDO.setStatus(OrderStatusEnum.CLOSED.getCode());
  364.         int i = orderMapper.updateStatusByOrderNo(orderDO, OrderStatusEnum.UNPAID.getCode());
  365.         if (i == 0) {
  366.             //订单状态以改变
  367.             return false;
  368.         }
  369.         //关闭支付单
  370.         PaymentDO paymentDO = paymentMapper.findByPayNo(orderDO.getPayNo());
  371.         if (Objects.isNull(paymentDO)) {
  372.             return false;
  373.         }
  374.         //更新支付单
  375.         Integer payStatus = paymentDO.getStatus();
  376.         paymentDO.setStatus(PayStatusEnum.CANCEL.getCode());
  377.         paymentDO.setUpdateTime(date);
  378.         paymentMapper.updatePayStatus(paymentDO, payStatus);
  379.         //第三方渠道关单
  380.         WxPayOrderCloseV3Request request = new WxPayOrderCloseV3Request();
  381.         request.setOutTradeNo(paymentDO.getPayNo());
  382.         wxManager.getWxPayService().closeOrderV3(request);
  383.         return true;
  384.     }
  385.  
  386.     /**
  387.      * 解析微信支付回调通知
  388.      */
  389.     private WxPayOrderNotifyV3Result getWxPayOrderNotifyV3Result(JSONObject jsonObject, SignatureHeader header) {
  390.  
  391.         WxPayOrderNotifyV3Result wxPayOrderNotifyV3Result = null;
  392.         try {
  393.             wxPayOrderNotifyV3Result = wxManager.getWxPayService().parseOrderNotifyV3Result(jsonObject.toJSONString(), header);
  394.             log.info("微信支付结果解析:{}", wxPayOrderNotifyV3Result.getResult());
  395.         } catch (Exception e) {
  396.             log.info("微信支付结果异常解析:{},异常信息{}", wxPayOrderNotifyV3Result.getResult(), e);
  397.         }
  398.         return wxPayOrderNotifyV3Result;
  399.     }
  400.  
  401.     /**
  402.      * 解析微信退款回调通知
  403.      */
  404.     private WxPayRefundNotifyV3Result getWxPayRefundNotifyV3Result(JSONObject jsonObject, SignatureHeader header) {
  405.  
  406.         WxPayRefundNotifyV3Result wxPayRefundNotifyV3Result = null;
  407.         try {
  408.             wxPayRefundNotifyV3Result = wxManager.getWxPayRefundService().parseRefundNotifyV3Result(jsonObject.toJSONString(), header);
  409.             log.info("微信退款结果解析:{}", wxPayRefundNotifyV3Result.getResult());
  410.         } catch (WxPayException e) {
  411.             log.info("微信退款结果异常解析:{},异常信息{}", wxPayRefundNotifyV3Result.getResult(), e);
  412.         }
  413.         return wxPayRefundNotifyV3Result;
  414.     }
  415. }

3.manager

  1. @Slf4j
  2. @Component
  3. public class WxManager {
  4.  
  5.     @Autowired
  6.     WxPayProperties wxPayProperties;
  7.     @Resource
  8.     private RedissonClient redissonClient;
  9.     @Autowired
  10.     private WxMpProperties wxMpProperties;
  11.  
  12.     public WxMpService getWxMpService() {
  13.         WxMpRedissonConfigImpl config = new WxMpRedissonConfigImpl(redissonClient, CommonConstants.NAMESPACE);
  14.         config.setAppId(wxMpProperties.getAppId());
  15.         config.setSecret(wxMpProperties.getSecret());
  16.  
  17.         WxMpService service = new WxMpServiceImpl();
  18.         service.setWxMpConfigStorage(config);
  19.         return service;
  20.     }
  21.  
  22.     public WxPayService getWxPayService() {
  23.         WxPayConfig payConfig = new WxPayConfig();
  24.         payConfig.setAppId(wxPayProperties.getAppid());
  25.         payConfig.setMchId(wxPayProperties.getMchId());
  26.         payConfig.setPrivateKeyPath(wxPayProperties.getPrivateKeyPath());
  27.         payConfig.setNotifyUrl(wxPayProperties.getNotifyUrl());
  28.         payConfig.setApiV3Key(wxPayProperties.getApiV3key());
  29.         payConfig.setPrivateCertPath(wxPayProperties.getPrivateCertPath());
  30.         WxPayService wxPayService = new WxPayServiceImpl();
  31.         wxPayService.setConfig(payConfig);
  32.         return wxPayService;
  33.     }
  34.  
  35.     public WxPayService getWxPayRefundService() {
  36.         WxPayConfig payConfig = new WxPayConfig();
  37.         payConfig.setAppId(wxPayProperties.getAppid());
  38.         payConfig.setMchId(wxPayProperties.getMchId());
  39.         payConfig.setPrivateKeyPath(wxPayProperties.getPrivateKeyPath());
  40.         payConfig.setNotifyUrl(wxPayProperties.getRefundNotifyUrl());
  41.         payConfig.setApiV3Key(wxPayProperties.getApiV3key());
  42.         payConfig.setPrivateCertPath(wxPayProperties.getPrivateCertPath());
  43.         WxPayService wxPayService = new WxPayServiceImpl();
  44.         wxPayService.setConfig(payConfig);
  45.         return wxPayService;
  46.     }
  47.  
  48.  
  49. }
  1. @Slf4j
  2. @Component
  3. public class OrderManager {
  4.     @Autowired
  5.     OrderMapper orderMapper;
  6.     @Autowired
  7.     PaymentMapper paymentMapper;
  8.     @Autowired
  9.     WxManager wxManager;
  10.  
  11.     /**
  12.      * 查询第三方支付，更新订单
  13.      *
  14.      * @param orderDO
  15.      * @param paymentDO
  16.      */
  17.     @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
  18.     public Boolean queryOrderByWx(WxPayOrderQueryV3Result wxPayOrderQueryV3Result, OrderDO orderDO, PaymentDO paymentDO, PayStatusEnum payStatusEnum) {
  19.         //未支付 支付中 等待扣款 直接返回
  20.         WxPayTradeStateEnum wxPayTradeStateEnum = WxPayTradeStateEnum.findByCode(wxPayOrderQueryV3Result.getTradeState());
  21.         if (Objects.equals(wxPayTradeStateEnum, WxPayTradeStateEnum.NOT_PAY)
  22.                 || Objects.equals(wxPayTradeStateEnum, WxPayTradeStateEnum.ACCEPT)
  23.                 || Objects.equals(wxPayTradeStateEnum, WxPayTradeStateEnum.USER_PAYING)) {
  24.             return false;
  25.         }
  26.  
  27.         if (!wxPayOrderQueryV3Result.getPayer().getOpenid().equals(paymentDO.getOpenid())) {
  28.             //记录日志，更新openid
  29.             log.error("查询微信支付，openid与本地不一致，paymentDO:{},payer:{}", paymentDO, wxPayOrderQueryV3Result.getPayer());
  30.         }
  31.         //更新支付单状态
  32.         paymentDO = PaymentConverter.toPaymentByWxPayOrderQueryV3Result(wxPayOrderQueryV3Result, paymentDO);
  33.         int p = paymentMapper.updatePayStatus(paymentDO, payStatusEnum.getCode());
  34.         if (p == 0) {
  35.             throw BizException.create(BizErrorCodeEnum.PAYMENT_UPDATE_FAIL, "支付单状态更新失败");
  36.         }
  37.         //已关闭 已撤销 支付失败 不更新订单状态 可重新支付
  38.         if (Objects.equals(wxPayTradeStateEnum, WxPayTradeStateEnum.CLOSED)
  39.                 || Objects.equals(wxPayTradeStateEnum, WxPayTradeStateEnum.REVOKED)
  40.                 || Objects.equals(wxPayTradeStateEnum, WxPayTradeStateEnum.PAY_ERROR)) {
  41.             return false;
  42.         }
  43.         //更新订单状态  幂等
  44.         int orgOrderStatus = orderDO.getStatus();
  45.         orderDO = OrderConverter.toOrderByPayment(paymentDO, orderDO, payStatusEnum);
  46.         int o = orderMapper.updateStatusByOrgStatus(orderDO, orgOrderStatus);
  47.         if (o == 0) {
  48.             throw BizException.create(BizErrorCodeEnum.ORDER_UPDATE_FAIL, "订单状态更新失败");
  49.         }
  50.         return true;
  51.     }
  52.  
  53.     /**
  54.      * 支付回调 更新订单
  55.      */
  56.     public Boolean payNotify(WxPayOrderNotifyV3Result.DecryptNotifyResult result, OrderDO order, PaymentDO payment, WxPayTradeStateEnum wxPayTradeStateEnum) {
  57.         if (!result.getPayer().getOpenid().equals(payment.getOpenid())) {
  58.             //记录日志
  59.             log.error("查询微信支付，openid与本地不一致，paymentDO:{},payer:{}", payment, result.getPayer());
  60.         }
  61.         PayStatusEnum payStatusEnum = LocalEnumUtils.findByCodeWithoutDefault(PayStatusEnum.class, payment.getStatus());
  62.         Integer orderStatus = order.getStatus();
  63.         //非 未支付 代扣款 支付中 更新支付单信息
  64.         if (Objects.equals(wxPayTradeStateEnum, WxPayTradeStateEnum.NOT_PAY)
  65.                 || Objects.equals(wxPayTradeStateEnum, WxPayTradeStateEnum.ACCEPT)
  66.                 || Objects.equals(wxPayTradeStateEnum, WxPayTradeStateEnum.USER_PAYING)) {
  67.             return false;
  68.         }
  69.         //更新支付单
  70.         payment = PaymentConverter.fromWxPayOrderNotifyV3Result(result, payment);
  71.         int p = paymentMapper.updatePayStatus(payment, payStatusEnum.getCode());
  72.         if (p == 0) {
  73.             throw BizException.create(BizErrorCodeEnum.PAYMENT_UPDATE_FAIL, "支付单状态更新失败");
  74.         }
  75.         //已关闭 已撤销 支付失败 不更新订单状态 可重新支付
  76.         if (Objects.equals(wxPayTradeStateEnum, WxPayTradeStateEnum.CLOSED)
  77.                 || Objects.equals(wxPayTradeStateEnum, WxPayTradeStateEnum.REVOKED)
  78.                 || Objects.equals(wxPayTradeStateEnum, WxPayTradeStateEnum.PAY_ERROR)) {
  79.             return false;
  80.         }
  81.         PayStatusEnum statusEnum = LocalEnumUtils.findByCodeWithoutDefault(PayStatusEnum.class, payment.getStatus());
  82.         //更新订单状态  幂等
  83.         order = OrderConverter.toOrderByPayment(payment, order, statusEnum);
  84.         int o = orderMapper.updateStatusByOrgStatus(order, orderStatus);
  85.         if (o == 0) {
  86.             throw BizException.create(BizErrorCodeEnum.ORDER_UPDATE_FAIL, "订单状态更新失败");
  87.         }
  88.         return true;
  89.     }
  90. }

4.Properties

  1. @Data
  2. @Component
  3. @Configuration
  4. @ConfigurationProperties(prefix = "wechat-pay")
  5. public class WxPayProperties {
  6.     /**
  7.      * 商户号
  8.      */
  9.     private String mchId;
  10.     /**
  11.      * 证书解密的密钥
  12.      */
  13.     private String apiV3key;
  14.     /**
  15.      * 商户私钥文件
  16.      */
  17.     private String privateKeyPath;
  18.  
  19.     /**
  20.      * apiclient_cert.pem证书文件
  21.      */
  22.     private String privateCertPath;
  23.  
  24.     /**
  25.      * 商户证书序列号
  26.      */
  27.     private String serialNo;
  28.     /**
  29.      * 赋选供应链 服务号appid
  30.      */
  31.     private String appid;
  32.     /**
  33.      * 支付回调通知地址
  34.      */
  35.     private String notifyUrl;
  36.  
  37.     /**
  38.      * 退款回调通知地址
  39.      */
  40.     private String refundNotifyUrl;
  41. }

总结

以上就是核心业务代码，涉及到具体业务mapper没有放上来，但是核心的处理步骤已经体现出来了。主要是对订单状态需要仔细判断，不同操作会引起状态的变更。业务中，当多个人扫同一个码，后续扫码成功会调用退款接口。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/weixin_40725706/article/detail/874155
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号