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

Java接入微信小程序支付、退款、发货通知_微信小程序订单发货接入

作者：酷酷是懒虫 | 2024-07-19 04:35:35

赞

踩

微信小程序订单发货接入

一，准备工作

申请应用号：appid

申请商户号：mchid

设置APIV3密钥：apiV3Key

下载并配置商户证书，商户证书序列号：mchSerialNo ；商户API私钥路径：privateKey

详情流程可见微信支付官网

二，小程序支付流程

 需要后端完成的一共有三个接口

1，拿到订单参数后，向微信发送请求支付消息，把拿到的参数返回给前端，用于用户付款

2，前端输入密码后，微信会异步回调一个接口，成功扣款后做对应业务处理

3，查询支付结果返回给前端

 三，设置常量和基本配置信息

1，导入依赖
  1. <!--微信小程序支付-->
  2. <dependency>
  3.     <groupId>com.github.wechatpay-apiv3</groupId>
  4.     <artifactId>wechatpay-apache-httpclient</artifactId>
  5.     <version>0.4.9</version>
  6. </dependency>
2，加载配置信息到yml文件中
  1. #  微信
  2. wx:
  3.   #  小程序支付
  4.   pay:
  5.     #  应用号
  6.     appId: ********
  7.     #  商户号
  8.     mchId: ********
  9.     #  商户APIV3密钥(32位)
  10.     apiV3Key: ********************************
  11.     #  商户证书序列号
  12.     mchSerialNo: ****************
  13.     #  支付成功回调 url 需要公网可访问
  14.     notifyUrl: http://改成自己的回调地址/system/order/wechatPayCallback
  15.     #  退款成功回调 url 需要公网可访问
  16.     refundNotifyUrl: http://改成自己的回调地址/system/order/wechatRefundBack
  17.     #  商户API私钥路径 【证书路径】
  18.     privateKey: "**********"
3，用工具类来保存配置信息WeChatToolConfig 
  1. @Data
  2. @Component
  3. public class WeChatToolConfig {
  4.     /**
  5.      * 应用id
  6.      */
  7.     @Value("${wx.pay.appId}")
  8.     private String appId;
  9.  
  10.     /**
  11.      * 商户id
  12.      */
  13.     @Value("${wx.pay.mchId}")
  14.     private String mchId;
  15.  
  16.     /**
  17.      * 商户APIV3密钥
  18.      */
  19.     @Value("${wx.pay.apiV3Key}")
  20.     private String apiV3Key;
  21.  
  22.     /**
  23.      * 商户证书序列号
  24.      */
  25.     @Value("${wx.pay.mchSerialNo}")
  26.     private String mchSerialNo;
  27.  
  28.     /**
  29.      * 商户私钥
  30.      */
  31.     @Value("${wx.pay.privateKey}")
  32.     private String privateKey;
  33.  
  34.     /**
  35.      * 支付成功回调url
  36.      */
  37.     @Value("${wx.pay.notifyUrl}")
  38.     private String notifyUrl;
  39.  
  40.      /**
  41.      * 退款成功回调url
  42.      */
  43.     @Value("${wx.pay.refundNotifyUrl}")
  44.     private String refundNotifyUrl;
  45. }
4，定义一个枚举来保存微信支付API WxApiTypeEnum 
  1. public enum WxApiTypeEnum {
  2.    /**
  3.      * 小程序 下单API
  4.      */
  5.     CREATE_ORDER("https://api.mch.weixin.qq.com/v3/pay/transactions/jsapi"),
  6.  
  7.     /**
  8.      * 申请退款API 通过 outTradeNo 商户订单号 退单
  9.      */
  10.     REFUND_ORDER("https://api.mch.weixin.qq.com/v3/refund/domestic/refunds"),
  11.  
  12.     /**
  13.      * 查询支付订单API ONE{}=>outTradeNo – 商户订单号 系统生 TOW{}=>mchId商户的商户号，由微信支付生成并下发。
  14.      */
  15.     QUERY_CREATE_ORDER("https://api.mch.weixin.qq.com/v3/pay/transactions/out-trade-no/{}?mchid={}"),
  16.  
  17.     /**
  18.      * 查询退款订单API {}=>outRefundNo 商户退款单号
  19.      */
  20.     QUERY_REFUND_ORDER("https://api.mch.weixin.qq.com/v3/refund/domestic/refunds/{}"),
  21.  
  22.     /**
  23.      * 关闭订单API {}=>outTradeNo 商户订单号
  24.      */
  25.     CLOSE_ORDER("https://api.mch.weixin.qq.com/v3/pay/transactions/out-trade-no/{}/close"),
  26.  
  27.     /**
  28.      * 货物录入
  29.      */
  30.     GOOD_ENTERING("https://api.weixin.qq.com/wxa/sec/order/upload_shipping_info?access_token={}"),
  31.  
  32.     /**
  33.      * 接口调用凭证
  34.      */
  35.     API_VOUCHER("https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential&appid={}&secret={}");
  36.  
  37.     private final String value;
  38.  
  39.     WxApiTypeEnum(String value) {
  40.         this.value = value;
  41.     }
  42.  
  43.     public String getValue() {
  44.         return value;
  45.     }
  46. }
5，定义一个类保存HTTP请求头常量 WechatPayHttpHeaders 
  1. public class WechatPayHttpHeaders {
  2.     // 请求头配置
  3.     public static final String ACCEPT = "Accept";
  4.  
  5.     public static final String CONTENT_TYPE = "Content-type";
  6.  
  7.     public static final String APPLICATION_JSON = "application/json";
  8.  
  9.     public static final String APPLICATION_JSON_UTF = "application/json; charset=utf-8";
  10.     /**
  11.      * 微信回调参数==>微信序列号
  12.      */
  13.     public static final String WECHATPAY_SERIAL = "Wechatpay-Serial";
  14.     /**
  15.      * 微信回调参数==>应答随机串
  16.      */
  17.     public static final String WECHATPAY_NONCE = "Wechatpay-Nonce";
  18.     /**
  19.      * 微信回调参数==>应答时间戳
  20.      */
  21.     public static final String WECHATPAY_TIMESTAMP = "Wechatpay-Timestamp";
  22.     /**
  23.      * 微信回调参数==>应答签名
  24.      */
  25.     public static final String WECHATPAY_SIGNATURE = "Wechatpay-Signature";
  26.  
  27.     private WechatPayHttpHeaders() {
  28.         // Don't allow instantiation
  29.     }
  30. }
6，微信小程序支付工具类
  1. public class WeChatUtil {
  2.     private static final Logger log = LoggerFactory.getLogger(WeChatUtil.class);
  3.     /**
  4.      * 签名生成 计算签名
  5.      *
  6.      * @param message    签名体
  7.      * @param privateKey 商户私钥
  8.      * @return String
  9.      */
  10.     public static String sign(byte[] message, PrivateKey privateKey) throws NoSuchAlgorithmException, SignatureException, InvalidKeyException {
  11.         Signature sign = Signature.getInstance("SHA256withRSA");
  12.         sign.initSign(privateKey);
  13.         sign.update(message);
  14.         return Base64.getEncoder().encodeToString(sign.sign());
  15.     }
  16.  
  17.     /**
  18.      * 构造HttpClient 实现 微信申请接口 调用功能
  19.      *
  20.      * @param verifier 微信验签器
  21.      * @return CloseableHttpClient
  22.      */
  23.     public static CloseableHttpClient getHttpClient(WeChatToolConfig config, Verifier verifier) {
  24.         PrivateKey merchantPrivateKey = PemUtil.loadPrivateKey(new ByteArrayInputStream(config.getPrivateKey().getBytes(StandardCharsets.UTF_8)));
  25.         // 通过WechatPayHttpClientBuilder构造的HttpClient，会自动的处理签名和验签
  26.         WechatPayHttpClientBuilder builder = WechatPayHttpClientBuilder.create()
  27.                 .withMerchant(config.getMchId(), config.getMchSerialNo(), merchantPrivateKey)
  28.                 .withValidator(new WechatPay2Validator(verifier));
  29.         return builder.build();
  30.     }
  31.  
  32.     /**
  33.      * 构造HttpClient 实现 微信申请接口 调用功能  不用微信签名认证 账单申请中可用到
  34.      *
  35.      * @param verifier 微信验签器
  36.      * @return CloseableHttpClient
  37.      */
  38.     public static CloseableHttpClient getHttpClientNoSign(WeChatToolConfig config, Verifier verifier) {
  39.         PrivateKey merchantPrivateKey = PemUtil.loadPrivateKey(new ByteArrayInputStream(config.getPrivateKey().getBytes(StandardCharsets.UTF_8)));
  40.         // 通过WechatPayHttpClientBuilder构造的HttpClient，会自动的处理签名和验签
  41.         WechatPayHttpClientBuilder builder = WechatPayHttpClientBuilder.create()
  42.                 .withMerchant(config.getMchId(), config.getMchSerialNo(), merchantPrivateKey)
  43.                 .withValidator(new WechatPay2Validator(verifier))
  44.                 .withValidator(response -> true);
  45.         return builder.build();
  46.     }
  47.  
  48.     /**
  49.      * 获取验证功能
  50.      *
  51.      * @return Verifier 微信验签器
  52.      */
  53.     public static Verifier getVerifier(WeChatToolConfig config) {
  54.         try {
  55.             PrivateKey merchantPrivateKey = PemUtil.loadPrivateKey(new ByteArrayInputStream(config.getPrivateKey().getBytes(StandardCharsets.UTF_8)));
  56.             // 定时更新平台证书功能
  57.             // 获取证书管理器实例
  58.             CertificatesManager certificatesManager = CertificatesManager.getInstance();
  59.             // 向证书管理器增加需要自动更新平台证书的商户信息
  60.             certificatesManager.putMerchant(config.getMchId(), new WechatPay2Credentials(config.getMchId(),
  61.                     new PrivateKeySigner(config.getMchSerialNo(), merchantPrivateKey)), config.getApiV3Key().getBytes(StandardCharsets.UTF_8));
  62.             // 从证书管理器中获取verifier=>验签器
  63.             return certificatesManager.getVerifier(config.getMchId());
  64.         } catch (Exception e) {
  65.             log.warn("验证出错");
  66.             throw new CustomException("微信证书出错 联系客服");
  67.         }
  68.     }
  69.  
  70.  
  71.     /**
  72.      * 回调验证
  73.      *
  74.      * @param request 微信回调请求
  75.      * @return String
  76.      */
  77.     public static Notification verifyBack(HttpServletRequest request, WeChatToolConfig config) throws IOException, ValidationException, ParseException {
  78.         // 应答报文主体
  79.         BufferedReader br = request.getReader();
  80.         String str;
  81.         StringBuilder builder = new StringBuilder();
  82.         while ((str = br.readLine()) != null) {
  83.             builder.append(str);
  84.         }
  85.         // 构建request，传入必要参数
  86.         // 参数 1.微信序列号 2.应答随机串 3.应答时间戳 4.应答签名 5.应答报文主体
  87.         NotificationRequest notificationRequest = new NotificationRequest.Builder()
  88.                 .withSerialNumber(request.getHeader(WechatPayHttpHeaders.WECHATPAY_SERIAL))
  89.                 .withNonce(request.getHeader(WechatPayHttpHeaders.WECHATPAY_NONCE))
  90.                 .withTimestamp(request.getHeader(WechatPayHttpHeaders.WECHATPAY_TIMESTAMP))
  91.                 .withSignature(request.getHeader(WechatPayHttpHeaders.WECHATPAY_SIGNATURE))
  92.                 .withBody(builder.toString())
  93.                 .build();
  94.         NotificationHandler handler = new NotificationHandler(WeChatUtil.getVerifier(config), config.getApiV3Key().getBytes(StandardCharsets.UTF_8));
  95.         // 验签和解析请求体
  96.         log.info("验签和解析请求体==============================开始验证==============================");
  97.         return handler.parse(notificationRequest);
  98.     }
  99.  
  100.     /**
  101.      * 验证用户支付金额 场景 微信回调验证
  102.      *
  103.      * @param jsonObject 微信回调json 返回参数
  104.      * @param total      数据库记录金额
  105.      * @return Boolean
  106.      */
  107.     public static Boolean verifyMoney(JSONObject jsonObject, Integer total) {
  108.         // 总金额计数值 用户支付计算
  109.         int userPayTotal = WeChatPayParam.NUM_ZERO;
  110.         // 1.验证订单金额
  111.         // 用户支付金额
  112.         int payerTotal = (int) jsonObject.getJSONObject(WeChatPayParam.AMOUNT).get(WeChatPayParam.AMOUNT_PAYER_TOTAL);
  113.         userPayTotal += payerTotal;
  114.         // CASH充值型代金券 要加上优惠金额 银行优惠 获取
  115.         // 排空 如果没有优惠则跳过
  116.         if (!ObjectUtil.isEmpty(jsonObject.get(WeChatPayParam.PROMOTION_DETAIL))) {
  117.             JSONArray jsonArray = jsonObject.getJSONArray(WeChatPayParam.PROMOTION_DETAIL);
  118.             for (Object object : jsonArray) {
  119.                 JSONObject json = (JSONObject) object;
  120.                 // 如果优惠类型为CASH 则要和 用户支付金额 累加
  121.                 if (WeChatPayParam.WX_DISCOUNT_TYPE.equals(json.get(WeChatPayParam.PROMOTION_DETAIL_TYPE).toString())) {
  122.                     userPayTotal += (int) json.get(WeChatPayParam.AMOUNT);
  123.                 }
  124.             }
  125.         }
  126.         // 2.总金额 预支付时的 金额 与 total 用户支付金额
  127.         // 微信端返回的支付总金额
  128.         int wxTotal = (int) jsonObject.getJSONObject(WeChatPayParam.AMOUNT).get(WeChatPayParam.AMOUNT_TOTAL);
  129.         // 校验通知的信息是否与商户侧的信息一致，防止数据泄露导致出现“假通知”，造成资金损失。
  130.         log.info("微信回调金额===比较=== " + "微信端返回的支付总金额" + jsonObject.getJSONObject(WeChatPayParam.AMOUNT).get(WeChatPayParam.AMOUNT_TOTAL) + "================用户支付总金额计算" + userPayTotal);
  131.         return wxTotal == userPayTotal && total == wxTotal;
  132.     }
  133.  
  134.  
  135.     /**
  136.      * 获取接口调用凭证
  137.      */
  138.     public static JSONObject getAccessToken(WeChatToolConfig config) throws Exception {
  139.         log.info("initAccessToken:开始运行...");
  140.         // 获取secret
  141.         String secret = WxMaConfiguration.getMaService(config.getAppId()).getWxMaConfig().getSecret();
  142.         // 获取url
  143.         String url = StrFormatter.format(WxApiTypeEnum.API_VOUCHER.getValue(), config.getAppId(), secret);
  144.         return getBodyAsJsonByGet(url, config);
  145.     }
  146.  
  147.     /**
  148.      * 调用微信支付 get请求 统一配置
  149.      * 要微信签名认证
  150.      *
  151.      * @param url 请求url
  152.      * @return JSONObject
  153.      */
  154.     public static JSONObject getBodyAsJsonByGet(String url, WeChatToolConfig config) throws IOException {
  155.         // 1.构造httpGet请求
  156.         HttpGet httpGet = new HttpGet(url);
  157.         httpGet.addHeader(WechatPayHttpHeaders.ACCEPT, WechatPayHttpHeaders.APPLICATION_JSON);
  158.         // 2.调起微信查询订单接口
  159.         CloseableHttpResponse response = WeChatUtil.getHttpClient(config, WeChatUtil.getVerifier(config)).execute(httpGet);
  160.         // 3.返回结果信息
  161.         String bodyAsString = EntityUtils.toString(response.getEntity());
  162.         // 转为JSON格式返回
  163.         return JSON.parseObject(bodyAsString);
  164.     }
  165.  
  166.     /**
  167.      * 调用微信支付 post请求 统一配置
  168.      * 要微信签名认证
  169.      *
  170.      * @param url          请求url
  171.      * @param requestParam 请求参数
  172.      * @param config       基本配置
  173.      * @return JSONObject
  174.      */
  175.     public static JSONObject getBodyAsJsonByPost(String url, JSONObject requestParam, WeChatToolConfig config) throws Exception {
  176.         // 1.设置请求url和请求头
  177.         HttpPost httpPost = new HttpPost(url);
  178.         httpPost.addHeader(WechatPayHttpHeaders.ACCEPT, WechatPayHttpHeaders.APPLICATION_JSON);
  179.         httpPost.addHeader(WechatPayHttpHeaders.CONTENT_TYPE, WechatPayHttpHeaders.APPLICATION_JSON_UTF);
  180.  
  181.         // 2.传入参数
  182.         String jsonString = JSON.toJSONString(requestParam);
  183.         httpPost.setEntity(new StringEntity(jsonString, StandardCharsets.UTF_8));
  184.  
  185.         // 3.调用接口 获取预支付交易会话标识 prepay_id
  186.         CloseableHttpResponse response = WeChatUtil.getHttpClient(config, WeChatUtil.getVerifier(config)).execute(httpPost);
  187.  
  188.         // 4.获取返回值 转为JSON
  189.         String bodyAsString = EntityUtils.toString(response.getEntity());
  190.         return JSON.parseObject(bodyAsString);
  191.     }
  192.  
  193.  
  194.     /**
  195.      * 获取签名
  196.      *
  197.      * @param appId      appId
  198.      * @param timestamp  时间戳
  199.      * @param nonce      随机字符串
  200.      * @param wxPackage  订单详情扩展字符串
  201.      * @param privateKey 商户私钥
  202.      */
  203.     public static String getSign(String appId, String timestamp, String nonce, String wxPackage, String privateKey) throws Exception {
  204.         // APP调起支付API 构造签名串
  205.         // 应用id
  206.         String builder = appId + "\n" +
  207.                 // 时间戳
  208.                 timestamp + "\n" +
  209.                 // 随机字符串
  210.                 nonce + "\n" +
  211.                 // 预支付交易会话标识 prepay_id=wx201410272009395522657a690389285100  必须以此格式
  212.                 wxPackage + "\n";
  213.  
  214.         // 读取privateKey商户私钥
  215.         PrivateKey merchantPrivateKey = PemUtils.getPrivateKey(privateKey);
  216.         // 计算签名
  217.         return WeChatUtil.sign(builder.getBytes(StandardCharsets.UTF_8), merchantPrivateKey);
  218.     }
  219.  
  220. }
7，微信支付参数 WeChatPayParam
  1. public class WeChatPayParam {
  2.  
  3.     /**
  4.      * 应用ID
  5.      */
  6.     public final static String APPID = "appid";
  7.  
  8.     /**
  9.      * 直连商户号
  10.      */
  11.     public final static String MCHID = "mchid";
  12.  
  13.     /**
  14.      * 用户支付状态
  15.      */
  16.     public final static String TRADE_STATE = "trade_state";
  17.  
  18.     /**
  19.      * 用户退款状态
  20.      */
  21.     public final static String STATUS = "status";
  22.  
  23.  
  24.     /**
  25.      * 商品描述
  26.      */
  27.     public final static String DESCRIPTION = "description";
  28.  
  29.     /**
  30.      * 通知地址
  31.      */
  32.     public final static String NOTIFY_URL = "notify_url";
  33.  
  34.     /**
  35.      * 预支付交易会话标识
  36.      */
  37.     public final static String PREPAY_ID = "prepay_id";
  38.  
  39.     /**
  40.      * 商户订单号
  41.      */
  42.     public final static String OUT_TRADE_NO = "out_trade_no";
  43.  
  44.     /**
  45.      * 商户退款单号
  46.      */
  47.     public final static String OUT_REFUND_NO = "out_refund_no";
  48.  
  49.     /**
  50.      * 微信支付系统生成的订单号
  51.      */
  52.     public final static String TRANSACTION_ID = "transaction_id";
  53.  
  54.     /**
  55.      * 微信支付系统生成的订单号
  56.      */
  57.     public final static String REFUND_ID = "refund_id";
  58.     /**
  59.      * 订单金额
  60.      */
  61.     public final static String AMOUNT = "amount";
  62.     /**
  63.      * 总金额	下单时系统计算金额 单位为分
  64.      */
  65.     public final static String AMOUNT_TOTAL = "total";
  66.  
  67.     /**
  68.      * 支付者
  69.      */
  70.     public final static String PAYER = "payer";
  71.  
  72.     /**
  73.      * 用户在直连商户appid下的唯一标识。 下单前需获取到用户的Openid
  74.      */
  75.     public final static String OPENID = "openid";
  76.  
  77.     /**
  78.      * 总金额	退款时 退款金额
  79.      */
  80.     public final static String AMOUNT_REFUND = "refund";
  81.  
  82.     /**
  83.      * 总金额	退款时 币种
  84.      */
  85.     public final static String AMOUNT_CURRENCY = "currency";
  86.  
  87.     /**
  88.      * 用户支付金额
  89.      */
  90.     public final static String AMOUNT_PAYER_TOTAL = "payer_total";
  91.     /**
  92.      * 优惠功能
  93.      */
  94.     public final static String PROMOTION_DETAIL = "promotion_detail";
  95.     /**
  96.      * 优惠类型
  97.      */
  98.     public final static String PROMOTION_DETAIL_TYPE = "type";
  99.     /**
  100.      * 微信优惠 CASH：充值型代金券
  101.      */
  102.     public final static String WX_DISCOUNT_TYPE = "CASH";
  103.  
  104.     /**
  105.      * 下单回调给微信支付成功信息
  106.      */
  107.     public final static String WX_BACK_OK = "SUCCESS";
  108.  
  109.     /**
  110.      * 退款回调 退款状态
  111.      */
  112.     public final static String REFUND_STATUS = "refund_status";
  113.  
  114.  
  115.     /**
  116.      * 微信回调 通知数据
  117.      */
  118.     public final static String RESOURCE = "resource";
  119.  
  120.     /**
  121.      * 微信账单类型 交易账单
  122.      */
  123.     public final static String TRADE_BILL = "tradebill";
  124.     /**
  125.      * 微信账单类型 资金账单
  126.      */
  127.     public final static String FUND_FLOW_BILL = "fundflowbill";
  128.     /**
  129.      * 微信账单下载地址
  130.      */
  131.     public final static String DOWNLOAD_URL = "download_url";
  132.  
  133.     /**
  134.      * 微信回调 通知数据=>数据密文
  135.      */
  136.     public final static String RESOURCE_CIPHERTEXT = "ciphertext";
  137.  
  138.     /**
  139.      * 微信回调 通知数据=>附加数据
  140.      */
  141.     public final static String RESOURCE_ASSOCIATED_DATA = "associated_data";
  142.  
  143.     /**
  144.      * 微信回调 通知数据=>随机串
  145.      */
  146.     public final static String RESOURCE_NONCE = "nonce";
  147.  
  148.     /**
  149.      * 发货信息 状态码
  150.      */
  151.     public final static String ERR_CODE = "errcode";
  152.  
  153.     /**
  154.      * 发货信息 状态信息
  155.      */
  156.     public final static String ERR_MSG = "errmsg";
  157.  
  158.  
  159.     /**
  160.      * 请求支付 错误状态码
  161.      */
  162.     public final static String CODE = "code";
  163.  
  164.     /**
  165.      * 请求支付 状态信息
  166.      */
  167.     public final static String MESSAGE = "message";
  168.  
  169.     /**
  170.      * 固定支付参数 package
  171.      */
  172.     public final static String WX_PACKAGE = "prepay_id=";
  173.  
  174.     /**
  175.      * 币种 RMB
  176.      */
  177.     public final static String CURRENCY_RMB = "CNY";
  178.  
  179.     /**
  180.      * 支付成功
  181.      */
  182.     public final static String PAY_SUCCESS = "支付成功";
  183.     /**
  184.      * 退款成功
  185.      */
  186.     public final static String REFUND_SUCCESS = "退款成功";
  187.  
  188.     /**
  189.      * 订单单号类型
  190.      */
  191.     public final static String ORDER_NUMBER_TYPE = "order_number_type";
  192.  
  193.     /**
  194.      * 商品信息
  195.      */
  196.     public final static String ITEM_DESC = "item_desc";
  197.  
  198.     /**
  199.      * 订单
  200.      */
  201.     public final static String ORDER_KEY = "order_key";
  202.  
  203.     /**
  204.      * 物流模式
  205.      */
  206.     public final static String LOGISTICS_TYPE = "logistics_type";
  207.  
  208.     /**
  209.      * 发货模式
  210.      */
  211.     public final static String DELIVERY_MODE = "delivery_mode";
  212.  
  213.     /**
  214.      * 物流信息列表
  215.      */
  216.     public final static String SHIPPING_LIST = "shipping_list";
  217.  
  218.     /**
  219.      * 上传时间
  220.      */
  221.     public final static String UPLOAD_TIME = "upload_time";
  222.  
  223.     /**
  224.      * 获取到的凭证
  225.      */
  226.     public final static String ACCESS_TOKEN = "access_token";
  227.  
  228.  
  229.     /**
  230.      * 数字 0~11
  231.      */
  232.     public final static int NUM_NEGATIVE_ONE = -1;
  233.     public final static int NUM_ZERO = 0;
  234.     public final static int NUM_ONE = 1;
  235.     public final static int NUM_TWO = 2;
  236.     public final static int NUM_THREE = 3;
  237.     public final static int NUM_FOUR = 4;
  238.     public final static int NUM_FIVE = 5;
  239.     public final static int NUM_SIX = 6;
  240.     public final static int NUM_SEVEN = 7;
  241.     public final static int NUM_EIGHT = 8;
  242.     public final static int NUM_NINE = 9;
  243.     public final static int NUM_TEN = 10;
  244.     public final static int NUM_ELEVEN = 11;
  245.     public final static int NUM_15 = 15;
  246.     public final static int NUM_16 = 16;
  247.     public final static int NUM_19 = 19;
  248.     public final static int NUM_TWENTY = 20;
  249.     public final static int NUM_30 = 30;
  250.     public final static int NUM_32 = 32;
  251.     public final static int NUM_50 = 50;
  252.     public final static int NUM_60 = 60;
  253.     public final static int NUM_64 = 64;
  254.     public final static int NUM_90 = 90;
  255.     public final static int NUM_100 = 100;
  256.     public final static int NUM_200 = 200;
  257.     public final static int NUM_1024 = 1024;
  258.     public final static int NUM_5000 = 5000;
  259.     public final static int NUM_24_time = 86400; // 60*60*60*24 一天
  260. }

四，微信支付请求下单接口

1，控制层 拿到需要支付订单id进行一系列操作
  1.     @Autowired
  2.     private WaybillService waybillService;
  3.     
  4.     /**
  5.      * 微信请求下单支付
  6.      *
  7.      * @param waybillId 运单id
  8.      * @return 付款所需参数
  9.      */
  10.     @RepeatSubmit
  11.     @GetMapping("/weChatCreateOrder/{waybillId}")
  12.     @Operation(summary = "微信请求下单支付")
  13.     public AjaxResult<CreateOrderVo> weChatCreateOrder(@PathVariable("waybillId") String waybillId) {
  14.         return waybillService.weChatCreateOrder(waybillId);
  15.     }
2，返回对象 CreateOrderVo 用户付款需要的参数
  1. @Data
  2. @AllArgsConstructor
  3. @NoArgsConstructor
  4. @EqualsAndHashCode(callSuper = false)
  5. public class CreateOrderVo implements Serializable {
  6.  
  7.     //     微信小程序需要参数
  8.     //    "appId": "wx499********7c70e",  // 微信开放平台 - 应用 - AppId，注意和微信小程序、公众号 AppId 可能不一致
  9.     //    "timeStamp": 1597935292,        // 时间戳（单位：秒）
  10.     //    "nonceStr": "c5sEwbaNPiXAF3iv", // 随机字符串
  11.     //    "package": "wx202254********************fbe90000", // 小程序下单接口返回的prepay_id参数值，提交格式如：prepay_id=***;示例值：prepay_id=wx201410272009395522657a690389285100
  12.     //    "signType": "RSA"    签名类型，默认为RSA，仅支持RSA。
  13.     //    "paySign": "A842B45937F6EFF60DEC7A2EAA52D5A0" // 签名，这里用的 MD5/RSA 签名
  14.  
  15.     @Serial
  16.     private static final long serialVersionUID = 1L;
  17.  
  18.     /**
  19.      * 时间戳
  20.      */
  21.     @Schema(description = "时间戳")
  22.     private String timeStamp;
  23.  
  24.     /**
  25.      * 随机字符串
  26.      */
  27.     @Schema(description = "随机字符串")
  28.     private String nonceStr;
  29.  
  30.     /**
  31.      * 订单详情扩展字符串 package
  32.      */
  33.     @Schema(description = "订单详情扩展字符串 package")
  34.     private String wxPackage;
  35.  
  36.     /**
  37.      * 签名方式
  38.      */
  39.     @Schema(description = "签名方式")
  40.     private String signType;
  41.  
  42.     /**
  43.      * 签名
  44.      */
  45.     @Schema(description = "签名")
  46.     private String paySign;
  47.  
  48.     /**
  49.      * 运单号
  50.      */
  51.     @Schema(description = "运单号")
  52.     private String outTradeNo;
  53.  
  54.  
  55. }
3，业务层 请求下单获取prepay_id构造签名
  1.     // 第三节中保存的微信配置信息 注入进来
  2.     @Autowired
  3.     private WeChatToolConfig config;
  4.  
  5.     @Autowired
  6.     private PayService payService;
  7.  
  8.     /**
  9.      * 微信请求下单支付
  10.      *
  11.      * @param waybillId 运单id
  12.      * @return 付款所需参数
  13.      */
  14.     @Override
  15.     public AjaxResult<CreateOrderVo> weChatCreateOrder(String waybillId) {
  16.         // 查询运单
  17.         Waybill waybill = getById(waybillId, "运单id不存在");
  18.         // 调用微信请求下单接口
  19.         int total = waybill.getGoodTotalPrice().multiply(new BigDecimal("100.00")).intValue();
  20.         // 获取付款所需参数
  21.         CreateOrderVo createOrder = payService.createPayOrder(waybill.getGoodName(), waybillId, waybill.getOpenId(), total, config);
  22.         log.info("支付返回" + createOrder);
  23.         return AjaxResult.success(createOrder);
  24.     }
  1.     /**
  2.      * 小程序请求下单
  3.      *
  4.      * @param description 商品描述
  5.      * @param outTradeNo  商户订单号
  6.      * @param openId      appid下的唯一标识
  7.      * @param total       总金额
  8.      * @param config      基本配置
  9.      * @return 小程序下单前端Vo
  10.      */
  11.     @Override
  12.     public CreateOrderVo createPayOrder(String description, String outTradeNo, String openId, int total, WeChatToolConfig config) {
  13.         // 配置下单参数
  14.         JSONObject requestParam = new JSONObject();
  15.         // 商户id
  16.         requestParam.put(WeChatPayParam.MCHID, config.getMchId());
  17.         // 应用id
  18.         requestParam.put(WeChatPayParam.APPID, config.getAppId());
  19.         // 商品描述
  20.         requestParam.put(WeChatPayParam.DESCRIPTION, description);
  21.         // 回调地址
  22.         requestParam.put(WeChatPayParam.NOTIFY_URL, config.getNotifyUrl());
  23.         // 订单号
  24.         requestParam.put(WeChatPayParam.OUT_TRADE_NO, outTradeNo);
  25.         // 金额
  26.         JSONObject amount = new JSONObject();
  27.         // 金额 单位 分
  28.         amount.put(WeChatPayParam.AMOUNT_TOTAL, "dev".equals(SpringUtils.getActiveProfile()) ? 1 : total);
  29.         // 货币类型 人民币
  30.         amount.put(WeChatPayParam.AMOUNT_CURRENCY, WeChatPayParam.CURRENCY_RMB);
  31.         // 金额
  32.         requestParam.put(WeChatPayParam.AMOUNT, amount);
  33.  
  34.         // 支付者
  35.         JSONObject payer = new JSONObject();
  36.         // 微信登录时生成的openid,创建订单时存入订单中
  37.         payer.put(WeChatPayParam.OPENID, openId);
  38.         // 支付者
  39.         requestParam.put(WeChatPayParam.PAYER, payer);
  40.  
  41.         try {
  42.             // 调用post请求
  43.             JSONObject jsonObject = WeChatUtil.getBodyAsJsonByPost(WxApiTypeEnum.CREATE_ORDER.getValue(), requestParam, config);
  44.             // 异常情况
  45.             if (Objects.nonNull(jsonObject.get(WeChatPayParam.CODE))) {
  46.                 throw new CustomException(jsonObject.get(WeChatPayParam.MESSAGE).toString());
  47.             }
  48.             // 时间戳
  49.             String timestamp = String.valueOf(DateUtil.currentSeconds());
  50.             // 随机字符串
  51.             String nonce = RandomUtil.randomString(WeChatPayParam.NUM_32);
  52.             // 订单详情扩展字符串 prepay_id=wx201410272009395522657a690389285100  必须以此格式
  53.             String wxPackage = WeChatPayParam.WX_PACKAGE + jsonObject.get(WeChatPayParam.PREPAY_ID);
  54.             // 获取签名
  55.             String sign = WeChatUtil.getSign(config.getAppId(), timestamp, nonce, wxPackage, config.getPrivateKey());
  56.  
  57.             return new CreateOrderVo(timestamp, nonce, wxPackage, "RSA", sign, outTradeNo);
  58.         } catch (Exception e) {
  59.             log.error("请求下单失败:" + outTradeNo);
  60.             log.error(e.getMessage());
  61.             throw new CustomException("请求下单失败:" + e.getMessage());
  62.         }
  63.     }

五，微信回调接口 注：需使用工具解决内网穿透问题 例：路由侠

1，控制层
  1.     /**
  2.      * 支付回调给微信确认
  3.      */
  4.     @Operation(summary = "支付回调给微信确认")
  5.     @IgnoreAuth
  6.     @PostMapping("/wechatPayCallback")
  7.     public Map<String, String> wechatCallback(HttpServletRequest request) {
  8.         Map<String, String> result = new HashMap<>(WeChatPayParam.NUM_TWO);
  9.         // 判断支付是否成功
  10.         if (waybillService.verifyCreateOrder(request)) {
  11.             result.put(WeChatPayParam.CODE, WeChatPayParam.WX_BACK_OK);
  12.         } else {
  13.             result.put(WeChatPayParam.CODE, "FAIL");
  14.             result.put(WeChatPayParam.MESSAGE, "失败");
  15.         }
  16.         return result;
  17.     }
2，业务层 判断验证是否成功
  1.     /**
  2.      * 微信支付回调验证判定 核对成功 数据异步入库
  3.      */
  4.     @Override
  5.     @Transactional
  6.     public Boolean verifyCreateOrder(HttpServletRequest request) {
  7.         log.info("===================================进入微信支付回调核对订单中========================================");
  8.         // 获取微信通知详情
  9.         JSONObject decryptData = payService.getDecryptData(request, config);
  10.  
  11.         // 获取运单号
  12.         String waybillId = decryptData.get(WeChatPayParam.OUT_TRADE_NO).toString();
  13.  
  14.         // 获取微信支付生成的订单号
  15.         String transactionId = decryptData.get(WeChatPayParam.TRANSACTION_ID).toString();
  16.  
  17.         log.info(decryptData.get(WeChatPayParam.OUT_TRADE_NO).toString() + "订单回调信息记录:订单状态:" + waybillId);
  18.  
  19.         // 判断支付是否成功
  20.         if (StrUtil.equals(WeChatPayParam.WX_BACK_OK, decryptData.get(WeChatPayParam.TRADE_STATE).toString())) {
  21.             // 查询运单
  22.             Waybill waybill = getById(waybillId, "运单id不存在");
  23.             // 判断金额是否与数据库一致
  24.             if (WeChatUtil.verifyMoney(decryptData, getAmountByOrderNo(waybillId))) {
  25.                 // 修改订单状态，保存微信支付订单号
  26.                 updateStatus(waybill, transactionId);
  27.                 // 判断发货是否成功
  28.                 if (payService.verifyDeliverGood(waybill.getGoodName(), waybill.getOpenId(), transactionId, config)) {
  29.                     // 修改发货状态 确认
  30.                     updateDeliverGood(waybill, ShipmentEnum.OK);
  31.                 } else {
  32.                     // 修改发货状态 未确认
  33.                     updateDeliverGood(waybill, ShipmentEnum.NOT);
  34.                 }
  35.                 return true;
  36.             }
  37.         }
  38.         return false;
  39.     }
  1.     /**
  2.      * 获取通知
  3.      *
  4.      * @param request 请求
  5.      * @param config  微信配置
  6.      * @return 通知详情
  7.      */
  8.     @Override
  9.     public JSONObject getDecryptData(HttpServletRequest request, WeChatToolConfig config) {
  10.         try {
  11.             // 解析微信通知
  12.             Notification notification = WeChatUtil.verifyBack(request, config);
  13.             // 获取通知简要说明
  14.             String summary = notification.getSummary();
  15.             // 判断支付状态
  16.             if (WeChatPayParam.PAY_SUCCESS.equals(summary) || WeChatPayParam.REFUND_SUCCESS.equals(summary)) {
  17.                 // 返回详情信息
  18.                 return JSON.parseObject(notification.getDecryptData());
  19.             } else {
  20.                 // 支付失败
  21.                 throw new CustomException(summary);
  22.             }
  23.         } catch (Exception e) {
  24.             log.error("回调失败验证" + e);
  25.             e.printStackTrace();
  26.             throw new CustomException("支付回调失败:" + e.getMessage());
  27.         }
  28.     }
  1.     /**
  2.      * 判断发货是否成功
  3.      *
  4.      * @param description   商品描述
  5.      * @param openId        appid下的唯一标识
  6.      * @param transactionId 微信支付生成订单号
  7.      * @param config        基本配置
  8.      * @return 是否成功
  9.      */
  10.     @Override
  11.     public Boolean verifyDeliverGood(String description, String openId, String transactionId, WeChatToolConfig config) {
  12.         try {
  13.             // 获取接口调用凭证
  14.             JSONObject jsonObject = WeChatUtil.getAccessToken(config);
  15.             // 异常情况
  16.             if (Objects.nonNull(jsonObject.get(WeChatPayParam.CODE))) {
  17.                 throw new CustomException(jsonObject.get(WeChatPayParam.MESSAGE).toString());
  18.             }
  19.             String accessToken = jsonObject.get(WeChatPayParam.ACCESS_TOKEN).toString();
  20.  
  21.             // 构建请求参数
  22.             JSONObject requestParam = new JSONObject();
  23.  
  24.             // 订单
  25.             JSONObject orderKey = new JSONObject();
  26.             orderKey.put(WeChatPayParam.ORDER_NUMBER_TYPE, OrderNumberTypeEnum.WECHAT.getCode());
  27.             orderKey.put(WeChatPayParam.TRANSACTION_ID, transactionId);
  28.             requestParam.put(WeChatPayParam.ORDER_KEY, orderKey);
  29.             // 物流模式 用户自提
  30.             requestParam.put(WeChatPayParam.LOGISTICS_TYPE, LogisticsTypeEnum.VIRTUAL.getCode());
  31.             // 发货模式 统一发货
  32.             requestParam.put(WeChatPayParam.DELIVERY_MODE, DeliveryModeEnum.UNIFIED_DELIVERY.getCode());
  33.             // 物流信息列表
  34.             List<JSONObject> shippingLists = new ArrayList<>();
  35.             Map<String, Object> map = new HashMap<>();
  36.             map.put(WeChatPayParam.ITEM_DESC, description);
  37.             shippingLists.add(new JSONObject(map));
  38.             requestParam.put(WeChatPayParam.SHIPPING_LIST, shippingLists);
  39.             // 上传时间
  40.             requestParam.put(WeChatPayParam.UPLOAD_TIME, new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSZ").format(new Date()));
  41.             // 支付者
  42.             JSONObject payer = new JSONObject();
  43.             // 微信登录时生成的openid,创建订单时存入订单中
  44.             payer.put(WeChatPayParam.OPENID, openId);
  45.             requestParam.put(WeChatPayParam.PAYER, payer);
  46.             // 设置请求url
  47.             String url = StrFormatter.format(WxApiTypeEnum.GOOD_ENTERING.getValue(), accessToken);
  48.             // 发送请求
  49.             JSONObject object = WeChatUtil.getBodyAsJsonByPost(url, requestParam, config);
  50.             // 发货失败
  51.             if (!object.get(WeChatPayParam.ERR_CODE).equals(WeChatPayParam.NUM_ZERO)) {
  52.                 log.error("发货失败：" + object.get(WeChatPayParam.ERR_CODE) + " " + object.get(WeChatPayParam.ERR_MSG));
  53.                 return false;
  54.             }
  55.         } catch (Exception e) {
  56.             e.printStackTrace();
  57.             throw new CustomException(e.getMessage());
  58.         }
  59.         return true;
  60.     }
  1.     /**
  2.      * 更新订单，运单状态 已完成
  3.      *
  4.      * @param waybill       运单
  5.      * @param transactionId 微信支付订单号
  6.      */
  7.     public void updateStatus(Waybill waybill, String transactionId) {
  8.         // 修改运单状态
  9.         waybill.setWaybillStatus(WaybillStatusEnum.COMPLETED);
  10.         waybill.setPayId(transactionId);
  11.         updateById(waybill);
  12.  
  13.         // 新增散户流水
  14.         individualAddFlow(waybill);
  15.  
  16.         // 查询订单
  17.         final OrderService orderService = SpringUtils.getBean(OrderService.class);
  18.         LambdaQueryWrapper<Order> queryWrapper = new LambdaQueryWrapper<>();
  19.         queryWrapper.eq(Order::getId, waybill.getOrderId());
  20.         Order order = orderService.getOne(queryWrapper);
  21.  
  22.         // 修改订单状态
  23.         LambdaUpdateWrapper<Order> orderWrapper = new LambdaUpdateWrapper<>();
  24.         orderWrapper.eq(Order::getId, waybill.getOrderId());
  25.         orderWrapper.set(Order::getOrderStatus, OrderStatusEnum.COMPLETED);
  26.         orderWrapper.set(Order::getGoodWeight, waybill.getNetWeight());
  27.         orderWrapper.set(Order::getGoodTotalPrice, waybill.getNetWeight().multiply(order.getGoodPrice()));
  28.         orderService.update(orderWrapper);
  29.     }
  30.  
  31.     /**
  32.      * 修改运单确认发货
  33.      *
  34.      * @param waybill  运单
  35.      * @param shipment 确认发货枚举
  36.      */
  37.     private void updateDeliverGood(JkwlWaybill waybill, ShipmentEnum shipment) {
  38.         waybill.setShipment(shipment);
  39.         updateById(waybill);
  40.     }

六，查询支付结果

1，控制层
  1.     /**
  2.      * 查询微信支付订单状态
  3.      *
  4.      * @param waybillId 运单id
  5.      */
  6.     @GetMapping("/getPayOrder/{waybillId}")
  7.     @Operation(summary = "查询微信支付订单状态")
  8.     public AjaxResult<Void> getPayOrder(@PathVariable("waybillId") String waybillId) {
  9.         return waybillService.getPayOrder(waybillId);
  10.     }
2，业务层
  1. /**
  2.  * 查询微信支付是否成功
  3.  *
  4.  * @param waybillId 运单id
  5.  */
  6. @Override
  7. public AjaxResult<Void> getPayOrder(String waybillId) {
  8.     try {
  9.         // 查询微信支付信息
  10.         JSONObject jsonObject = payService.getPayState(waybillId, config);
  11.         // 返回查单结果信息
  12.         final String res = jsonObject.get(WeChatPayParam.TRADE_STATE).toString();
  13.         // 支付成功
  14.         if (WeChatPayParam.WX_BACK_OK.equals(res)) {
  15.         // 根据业务 该干嘛干嘛
  16.         // 例： 修改订单
  17.         // updateStatus(orderId);
  18.         return AjaxResult.success("SUCCESS");
  19.     } catch (Exception e) {
  20.         log.error("支付查单失败" + orderId);
  21.         e.printStackTrace();
  22.     }
  23.     return AjaxResult.error();
  24. }
  1.     /**
  2.      * 获取支付状态
  3.      *
  4.      * @param waybillId 运单id
  5.      * @param config    配置
  6.      * @return 状态详情
  7.      */
  8.     @Override
  9.     public JSONObject getPayState(String waybillId, WeChatToolConfig config) throws IOException {
  10.         // 查单 微信接口 编辑 微信订单号 + 商户号
  11.         String url = StrFormatter.format(WxApiTypeEnum.QUERY_CREATE_ORDER.getValue(), waybillId, config.getMchId());
  12.         // 调用微信接口
  13.         JSONObject jsonObject = WeChatUtil.getBodyAsJsonByGet(url, config);
  14.         // 异常情况
  15.         if (Objects.nonNull(jsonObject.get(WeChatPayParam.CODE))) {
  16.             throw new CustomException(jsonObject.get(WeChatPayParam.MESSAGE).toString());
  17.         }
  18.         return jsonObject;
  19.     }

七，微信退款

  1.     /**
  2.      * 微信退款
  3.      *
  4.      * @param waybillId 运单id
  5.      */
  6.     @RepeatSubmit
  7.     @GetMapping("/weChatRefundOrder/{waybillId}/{amount}")
  8.     @Operation(summary = "微信退款")
  9.     @IgnoreAuth
  10.     public AjaxResult<Void> weChatRefundOrder(@PathVariable("waybillId") String waybillId, @PathVariable("amount") int amount) {
  11.         return waybillService.weChatRefundOrder(waybillId, amount);
  12.     }
  1.     /**
  2.      * 微信退款
  3.      *
  4.      * @param waybillId 运单id
  5.      */
  6.     @Override
  7.     public AjaxResult<Void> weChatRefundOrder(String waybillId, int amount) {
  8.         // 非开发环境 输入多少退多少
  9.         if (!"dev".equals(SpringUtils.getActiveProfile())) {
  10.             // 从数据库获取运单退款金额
  11.             amount = getAmountByOrderNo(waybillId);
  12.         }
  13.         // 调用微信退款接口
  14.         JSONObject jsonObject = payService.refundOrder(waybillId, amount, config);
  15.         // 获取微信退款状态
  16.         String status = jsonObject.get(WeChatPayParam.STATUS).toString();
  17.  
  18.         return switch (status) {
  19.             // 退款关闭
  20.             case "CLOSED" -> AjaxResult.success("退款关闭");
  21.             // 退款处理中
  22.             case "PROCESSING" -> AjaxResult.success("退款处理中 请稍后");
  23.             // 退款成功
  24.             case "SUCCESS" -> {
  25.                 // 可拓展 退款成功后进行的操作 例：修改订单退款订单，运单状态 微信退款入数据库
  26.                 // updateStatus(orderId);
  27.                 yield AjaxResult.success("退款申请成功 注意退款查收");
  28.             }
  29.             // 退款异常
  30.             default -> AjaxResult.error("退款账户异常 请联系管理人员");
  31.         };
  32.     }
  1.     /**
  2.      * 微信退款
  3.      *
  4.      * @param waybillId    运单id
  5.      * @param refundAmount 退款金额
  6.      * @param config       配置
  7.      * @return 状态详情
  8.      */
  9.     @Override
  10.     public JSONObject refundOrder(String waybillId, Integer refundAmount, WeChatToolConfig config) {
  11.         // 配置参数
  12.         JSONObject requestParam = new JSONObject();
  13.         // 商户订单号 orderId
  14.         requestParam.put(WeChatPayParam.OUT_TRADE_NO, waybillId);
  15.         // 商户退款单号
  16.         requestParam.put(WeChatPayParam.OUT_REFUND_NO, waybillId);
  17.         // 退款回调地址
  18.         requestParam.put(WeChatPayParam.NOTIFY_URL, config.getRefundNotifyUrl());
  19.         // 金额信息 amount (单位都是分)
  20.         JSONObject amount = new JSONObject();
  21.         // 原订单金额 total
  22.         amount.put(WeChatPayParam.AMOUNT_TOTAL, refundAmount);
  23.         // 退款金额 refund
  24.         amount.put(WeChatPayParam.AMOUNT_REFUND, refundAmount);
  25.         // 退款币种 CNY 人民币
  26.         amount.put(WeChatPayParam.AMOUNT_CURRENCY, WeChatPayParam.CURRENCY_RMB);
  27.         // 金额信息 amount: 原订单金额 total 退款金额 refund (单位都是分)
  28.         requestParam.put(WeChatPayParam.AMOUNT, amount);
  29.  
  30.         try {
  31.             // 调用请求接口
  32.             JSONObject jsonObject = WeChatUtil.getBodyAsJsonByPost(WxApiTypeEnum.REFUND_ORDER.getValue(), requestParam, config);
  33.             // 异常情况
  34.             if (Objects.nonNull(jsonObject.get(WeChatPayParam.CODE))) {
  35.                 throw new CustomException(jsonObject.get(WeChatPayParam.MESSAGE).toString());
  36.             }
  37.             log.info("微信申请退款返回结果" + "response:" + jsonObject);
  38.             return jsonObject;
  39.         } catch (Exception e) {
  40.             log.info("微信退款" + waybillId + "失败");
  41.             e.printStackTrace();
  42.             throw new CustomException("退款失败:" + e.getMessage());
  43.         }
  44.     }

八、退款回调

  1.     /**
  2.      * 微信退款回调接口
  3.      */
  4.     @IgnoreAuth
  5.     @Operation(summary = "微信退款回调接口")
  6.     @PostMapping("/wechatRefundBack")
  7.     public Map<String, String> wechatRefundBack(HttpServletRequest request) {
  8.         Map<String, String> result = new HashMap<>(WeChatPayParam.NUM_TWO);
  9.         // 根据退款返回结果 更新订单状态 返回结果
  10.         if (waybillService.verifyRefundOrder(request)) {
  11.             log.info("==============================微信退款成功订单=====================================");
  12.             result.put(WeChatPayParam.CODE, WeChatPayParam.WX_BACK_OK);
  13.         } else {
  14.             result.put(WeChatPayParam.CODE, "FAIL");
  15.             result.put(WeChatPayParam.MESSAGE, "失败");
  16.         }
  17.         return result;
  18.     }
  1.     @Override
  2.     public Boolean verifyRefundOrder(HttpServletRequest request) {
  3.         // 获取微信通知详情
  4.         JSONObject decryptData = jkwlPayService.getDecryptData(request, config);
  5.         // 商户退款单号
  6.         String outRefundNo = decryptData.get(WeChatPayParam.OUT_REFUND_NO).toString();
  7.  
  8.         log.info("微信退款成功订单:" + outRefundNo);
  9.  
  10.         // 退款状态
  11.         String refundStatus = decryptData.get(WeChatPayParam.REFUND_STATUS).toString();
  12.         // 数据库核对 如果退款状态已退款说明已处理 直接返回即可
  13.         if (WaybillStatusEnum.CANCELED.equals(getStatus(outRefundNo))) {
  14.             return true;
  15.         }
  16.         return switch (refundStatus) {
  17.             // 退款关闭
  18.             case "CLOSED" -> Boolean.FALSE;
  19.             // 退款成功
  20.             case "SUCCESS" -> {
  21.                 // 修改订单退款订单，运单状态 微信退款入数据库
  22.                 // updateStatus(outRefundNo);
  23.                 yield Boolean.TRUE;
  24.             }
  25.             // 退款异常
  26.             default -> Boolean.FALSE;
  27.         };
  28.     }

九，查询退款订单

  1.     /**
  2.      * 查询退款订单
  3.      *
  4.      * @param waybillId 运单id
  5.      */
  6.     @Operation(summary = "查询退款订单")
  7.     @GetMapping("/getRefundOrder/{waybillId}")
  8.     public AjaxResult<Void> getRefundOrder(@PathVariable("waybillId") String waybillId) {
  9.         return waybillService.getRefundOrder(waybillId);
  10.     }
  1.     /**
  2.      * 查询退款订单
  3.      *
  4.      * @param waybillId 运单id
  5.      */
  6.     @Override
  7.     public AjaxResult<Void> getRefundOrder(String waybillId) {
  8.         try {
  9.             // 调用微信查询退款订单接口
  10.             JSONObject jsonObject = payService.getRefundState(waybillId, config);
  11.             // 获取退款状态
  12.             String string = jsonObject.get(WeChatPayParam.STATUS).toString();
  13.  
  14.             return switch (string) {
  15.                 // 退款关闭
  16.                 case "CLOSED" -> AjaxResult.success("退款关闭");
  17.                 // 退款处理中
  18.                 case "PROCESSING" -> AjaxResult.success("退款处理中 请稍后");
  19.                 // 退款成功
  20.                 case "SUCCESS" -> AjaxResult.success("退款申请成功 注意退款查收");
  21.                 // 退款异常
  22.                 default -> AjaxResult.error("退款账户异常 请联系管理人员");
  23.             };
  24.         } catch (Exception e) {
  25.             log.error("支付查单失败" + waybillId);
  26.             e.printStackTrace();
  27.         }
  28.         return AjaxResult.error();
  29.     }
  1.     /**
  2.      * 获取退款状态
  3.      *
  4.      * @param waybillId 运单id
  5.      * @param config    配置
  6.      * @return 状态详情
  7.      */
  8.     @Override
  9.     public JSONObject getRefundState(String waybillId, WeChatToolConfig config) throws IOException {
  10.         // 查单 微信接口 拼接url
  11.         String url = StrFormatter.format(WxApiTypeEnum.QUERY_REFUND_ORDER.getValue(), waybillId);
  12.         // 调用微信接口
  13.         JSONObject jsonObject = WeChatUtil.getBodyAsJsonByGet(url, config);
  14.         // 异常情况
  15.         if (Objects.nonNull(jsonObject.get(WeChatPayParam.CODE))) {
  16.             throw new CustomException(jsonObject.get(WeChatPayParam.MESSAGE).toString());
  17.         }
  18.         return jsonObject;
  19.     }

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

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

  

闽ICP备14008679号