微信支付功能的计划实现与关键实践（UniApp+Java）全代码 ...

微信支付功能的计划实现与关键实践（UniApp+Java）全代码

感觉本篇对你有资助可以关注一下我的微信公众号（深入浅出谈java），会不定期更新知识和面试资料、本领！！！

概述

在移动互联网时代，支付功能已成为应用开辟的焦点能力之一。本文将以 UniApp前端+Java后端技术栈为例，体系解析微信支付功能的计划实现与关键实践，为开辟者提供从技术架构到安全防护的全景视角。
微信支付功能是跨平台应用（UniApp前端 + Java后端）与微信支付体系对接的焦点模块，实现用户从下单到支付完成的闭环流程。支持多种支付场景（如APP支付、小步伐支付、H5支付），确保生意业务安全、实时性和数据一致性
对于支付体系，公司一般会对其举行独立，确保服务的安全、可靠、稳固。因此支付体系是现代互联网的关键焦点体系。本篇实现基本功能，提供思绪，部门代码不严谨，可以自行优化
微信支付流程图

大致如下：流程图中和流程步骤 描述的2、3 步举行了调换，不受影响，但是发起可以先创建订单

流程步骤

1、用户提交订单请求

• 行为主体：用户（通过UniApp前端操作）
  
• 动作描述：用户在UniApp中选择商品或服务，点击支付按钮，前端将订单信息（如商品ID、数目、金额等）发送至Java后端。
  

2、生成业务订单

• 行为主体：Java后端
  
• 动作描述：
  
  
  
  • 后端接收订单请求后，验证数据合法性（如金额、商品库存等）。
    
  • 在数据库中生成唯一业务订单号（out_trade_no），并记录订单状态为「待支付」
    
  
  

3、调用微信统一下单API

• 行为主体：Java后端 → 微信支付平台
  
• 动作描述：
  
  
  
  • 后端构造统一下单请求参数（包罗商户号、订单号、金额、回调地址等）。
    
  • 使用商户API密钥生成签名（保障请求安全性）。
    
  • 向微信支付平台发送HTTP请求，调用统一下单接口（URL: https://api.mch.weixin.qq.com/pay/unifiedorder）。
    
  
  

4、接收预支付生意业务单响应

• 行为主体：微信支付平台 → Java后端
  
• 动作描述：
  
  
  
  • 微信验证请求参数和签名，确认无误后生成预支付生意业务单。
    
  • 返回XML格式响应数据，包含关键字段：
    
    
    
    • prepay_id（预支付生意业务标识，用于后续支付）
      
    • return_code（通讯状态码，如SUCCESS/FAIL）
      
    • result_code（业务结果码，如SUCCESS/FAIL）
      
    
    
  
  

5、返回支付参数至前端

• 行为主体：Java后端 → UniApp前端
  
• 动作描述：
  
  
  • 后端解析微信返回的prepay_id，重新构造前端支付参数（需二次签名）。
    
  • 返回JSON数据给UniApp，包含：
    
    
    
    • appId（微信应用ID）
      
    • timeStamp（时间戳）
      
    • nonceStr（随机字符串）
      
    • package（固定值Sign=WXPay）
      
    • signType（签名类型，通常为MD5或HMAC-SHA256）
      
    • paySign（最终支付签名）
      
    
    
  
  

6、调起微信支付界面

• 行为主体：用户（UniApp前端） → 微信客户端
  
• 动作描述：
  
  
  
  • UniApp通过uni.requestPayment API，传入后端返回的支付参数。
    
  • 微信客户端（APP/小步伐）根据参数拉起支付界面，用户确认金额并输入密码。
    
  
  

7、用户完成支付

• 行为主体：微信支付平台 → 用户
  
• 动作描述：
  
  
  • 微信验证支付密码和账户余额，扣款成功后，向用户展示支付结果页面（成功/失败）。
    
  
  

8、异步通知支付结果

• 行为主体：微信支付平台 → Java后端
  
• 动作描述：
  
  
  • 微信通过POST请求调用后端预设的notify_url（需公网可访问）。
    
  • 推送XML格式回调数据，包含：
    
    
    
    • out_trade_no（商户订单号）
      
    • transaction_id（微信支付单号）
      
    • total_fee（实际支付金额）
      
    • result_code（支付结果，如SUCCESS/FAIL）
      
    
    
  
  

9、处理回调并响应微信

• 行为主体：Java后端 → 微信支付平台
  
• 动作描述：
  
  
  • 后端接收回调数据后：
    
    
    
    • 验证签名防止伪造请求
      
    • 检查订单金额与业务体系是否一致
      
    • 更新订单状态为「已支付」（需做幂等处理，制止重复更新）
      
    
    
  • 返回XML响应（必须包含），告知微信已正确处理。
    
  
  

10、通知前端最闭幕果

• 行为主体：Java后端 → UniApp前端
  
• 动作描述：
  
  
  • 若前端未实时感知支付结果（如用户关闭页面），可通过两种方式同步：
    
    
    
    • 轮询查询：前端定期请求后端订单状态接口
      
    • WebSocket推送：后端主动推送支付结果
      
    
    
  • 更新前端界面显示支付成功/失败状态。
    
  
  

账号预备工作

申请微信小步伐账号

1、开辟小步伐的第一步，你需要拥有一个小步伐账号，因此先申请小步伐账号
小步伐注册地址：小步伐

2、信息填好，举行注册，就会产生AppID、AppSecret

小步伐的 AppID 相称于小步伐平台的一个身份证，后续你会在很多地方要用到 AppID （注意这里要区别于服务号或订阅号的 AppID）
微信支付 官网开通商户支付能力

微信支付官网：微信支付 - 中国领先的第三方支付平台 ｜ 微信支付提供安全快捷的支付方式
1、找到接入微信支付，举行绑定注册
注册需要营业执照、法人信息，按照要求填写即可

2、注册微信支付商户号

3、填写须要信息举行注册

4、申请证书和AIPv3秘钥，v2现在有镌汰趋势，不需要申请v2，直接v3走起。

5、下载和保存好 秘钥及证书（PS:一定要好好保存）

6、获取商户号

接入实现

服务端代码

1、导入maven依赖

1.         
2.         <dependency>
3.             <groupId>com.github.wxpay</groupId>
4.             <artifactId>wxpay-sdk</artifactId>
5.             <version>0.0.3</version>
6.         </dependency>
7.         <dependency>
8.             <groupId>com.thoughtworks.xstream</groupId>
9.             <artifactId>xstream</artifactId>
10.             <version>1.4.20</version>
11.             <scope>compile</scope>
12.         </dependency>
14. <dependency>
15.     <groupId>com.github.wechatpay-apiv3</groupId>
16.     <artifactId>wechatpay-apache-httpclient</artifactId>
17.     <version>0.4.7</version>
18. </dependency>

复制代码

2、设置商户信息

1. # 微信支付配置
2. pay:
3.   appId: xxx #应用id
4.   mchId: xxx #商户id
5.   notifyUrl: https://服务器ip或对应域名/wxpay/weixin/callback #支付回调地址

复制代码

3、实体类代码

这个部门是需要用到的实体类代码
WeChatPay：微信支付预下单实体类

1. @Data
2. @Accessors(chain = true)
3. public class WeChatPay {
5.     /**
6.      * 返回状态码  此字段是通信标识，非交易标识，交易是否成功需要查看result_code来判断
7.      */
8.     public String return_code;
10.     /**
11.      * 返回信息 当return_code为FAIL时返回信息为错误原因 ，例如 签名失败 参数格式校验错误
12.      */
13.     private String return_msg;
15.     /**
16.      * 公众账号ID 调用接口提交的公众账号ID
17.      */
18.     private String appid;
20.     /**
21.      * 商户号 调用接口提交的商户号
22.      */
23.     private String mch_id;
25.     /**
26.      * api密钥 详见：https://pay.weixin.qq.com/index.php/extend/employee
27.      */
28.     private String api_key;
30.     /**
31.      * 设备号  自定义参数，可以为请求支付的终端设备号等
32.      */
33.     private String device_info;
35.     /**
36.      * 随机字符串    5K8264ILTKCH16CQ2502SI8ZNMTM67VS   微信返回的随机字符串
37.      */
38.     private String nonce_str;
40.     /**
41.      * 签名 微信返回的签名值，详见签名算法:https://pay.weixin.qq.com/wiki/doc/api/native.php?chapter=4_3
42.      */
43.     private String sign;
45.     /**
46.      * 签名类型
47.      */
48.     private String sign_type;
51.     /**
52.      * 业务结果 SUCCESS SUCCESS/FAIL
53.      */
54.     private String result_code;
56.     /**
57.      * 错误代码 当result_code为FAIL时返回错误代码，详细参见下文错误列表
58.      */
59.     private String err_code;
61.     /**
62.      * 错误代码描述 当result_code为FAIL时返回错误描述，详细参见下文错误列表
63.      */
64.     private String err_code_des;
66.     /**
67.      * 交易类型 JSAPI JSAPI -JSAPI支付 NATIVE -Native支付 APP -APP支付 说明详见；https://pay.weixin.qq.com/wiki/doc/api/native.php?chapter=4_2
68.      */
69.     private String trade_type;
71.     /**
72.      * 预支付交易会话标识 微信生成的预支付会话标识，用于后续接口调用中使用，该值有效期为2小时
73.      */
74.     private String prepay_id;
76.     /**
77.      * 二维码链接     weixin://wxpay/bizpayurl/up?pr=NwY5Mz9&groupid=00 trade_type=NATIVE时有返回，此url用于生成支付二维码，然后提供给用户进行扫码支付。注意：code_url的值并非固定，使用时按照URL格式转成二维码即可
78.      */
79.     private String code_url;
81.     /**
82.      * 商品描述  商品简单描述，该字段请按照规范传递，具体请见 https://pay.weixin.qq.com/wiki/doc/api/native.php?chapter=4_2
83.      */
84.     private String body;
86.     /**
87.      * 商家订单号 商户系统内部订单号，要求32个字符内，只能是数字、大小写字母_-|* 且在同一个商户号下唯一。详见商户订单号 https://pay.weixin.qq.com/wiki/doc/api/native.php?chapter=4_2
88.      */
89.     private String out_trade_no;
91.     /**
92.      * 标价金额 订单总金额，单位为分，详见支付金额 https://pay.weixin.qq.com/wiki/doc/api/native.php?chapter=4_2
93.      */
94.     private String total_fee;
96.     /**
97.      * 终端IP 支持IPV4和IPV6两种格式的IP地址。用户的客户端IP
98.      */
99.     private String spbill_create_ip;
101.     /**
102.      * 通知地址 异步接收微信支付结果通知的回调地址，通知url必须为外网可访问的url，不能携带参数。公网域名必须为https，如果是走专线接入，使用专线NAT IP或者私有回调域名可使用http
103.      */
104.     private String notify_url;
106.     /**
107.      * 子商户号 sub_mch_id 非必填（商户不需要传入，服务商模式才需要传入） 微信支付分配的子商户号
108.      */
109.     private String sub_mch_id;
111.     /**
112.      * 附加数据，在查询API和支付通知中原样返回，该字段主要用于商户携带订单的自定义数据
113.      */
114.     private String attach;
116.     /**
117.      * 商户系统内部的退款单号，商户系统内部唯一，只能是数字、大小写字母_-|*@ ，同一退款单号多次请求只退一笔。
118.      */
119.     private String out_refund_no;
121.     /**
122.      * 退款总金额，单位为分，只能为整数，可部分退款。详见支付金额 https://pay.weixin.qq.com/wiki/doc/api/native_sl.php?chapter=4_2
123.      */
124.     private String refund_fee;
126.     /**
127.      * 退款原因 若商户传入，会在下发给用户的退款消息中体现退款原因 注意：若订单退款金额≤1元，且属于部分退款，则不会在退款消息中体现退款原因
128.      */
129.     private String refund_desc;
131.     /**
132.      * 交易结束时间 订单失效时间，格式为yyyyMMddHHmmss，如2009年12月27日9点10分10秒表示为20091227091010。其他详见时间规则 注意：最短失效时间间隔必须大于5分钟
133.      */
134.     private String time_expire;
136.     /**
137.      * 用户标识 trade_type=JSAPI，此参数必传，用户在主商户appid下的唯一标识。openid和sub_openid可以选传其中之一，如果选择传sub_openid,则必须传sub_appid。下单前需要调用【网页授权获取用户信息: https://developers.weixin.qq.com/doc/offiaccount/OA_Web_Apps/Wechat_webpage_authorization.html 】接口获取到用户的Openid。
138.      */
139.     private String openid;
141.     /**
142.      * 时间戳
143.      */
144.     private String time_stamp;
146.     /**
147.      * 会员类型
148.      */
149.     private String memberShipType;
151. }

复制代码

PayParameterVO:微信支付，商品信息对象

1. @Data
2. public class PayParameterVO {
4.     /** 商品价格（单位：分） */
5.     private String price;
7.     /** 微信openId */
8.     private String wxOpenId;
10.     /** 商品描述 */
11.     private String goodsTitle;
13. }

复制代码

OrderReturnInfo:预下单成功之后返回结果对象

1. @Data
2. public class OrderReturnInfo {
5.         /** 返回状态码 */
6.         private String return_code;
8.         /** 返回信息 */
9.         private String return_msg;
11.         /** 业务结果 */
12.         private String result_code;
14.         /** 小程序appID */
15.         private String appid;
17.         /** 商户号 */
18.         private String mch_id;
20.         /** 随机字符串 */
21.         private String nonce_str;
23.         /** 签名 */
24.         private String sign;
26.         /**  预支付交易会话标识。用于后续接口调用中使用，该值有效期为2小时 */
27.         private String prepay_id;
29.         /** 交易类型 */
30.         private String trade_type;
31. }

复制代码

QueryReturnInfo：查询订单返回实体类

1. @Data
2. public class QueryReturnInfo {
4.     /** 返回状态码 */
5.     private String return_code;
7.     /** 返回信息 */
8.     private String return_msg;
11.     /** 业务结果 */
12.     private String result_code;
14.     /** 错误代码 */
15.     private String err_code;
17.     /** 错误代码描述 */
18.     private String err_code_des;
20.     /** 小程序appID */
21.     private String appid;
23.     /** 商户号 */
24.     private String mch_id;
26.     /** 随机字符串 */
27.     private String nonce_str;
29.     /** 签名 */
30.     private String sign;
32.     /** 签名类型 */
33.     private String sign_type;
35.     private String prepay_id;
37.     /** 交易类型 */
38.     private String trade_type;
40.     /** 设备号 */
41.     private String device_info;
43.     /** 用户标识 */
44.     private String openid;
46.     /** 是否关注公众账号 */
47.     private String is_subscribe;
49.     private String trade_state;
51.     /** 付款银行 */
52.     private String bank_type;
54.     /** 订单金额 */
55.     private int total_fee;
57.     /** 应结订单金额 */
58.     private int settlement_total_fee;
60.     /** 货币种类 */
61.     private String fee_type;
63.     /** 现金支付金额 */
64.     private int cash_fee;
66.     /** 现金支付货币类型 */
67.     private String cash_fee_type;
69.     /** 总代金券金额 */
70.     private int coupon_fee;
72.     /** 代金券使用数量 */
73.     private int coupon_count;
75.     /** 代金券类型 */
76.     private String coupon_type_$n;
78.     /** 代金券ID */
79.     private String coupon_id_$n;
81.     /** 单个代金券支付金额 */
82.     private String coupon_fee_$n;
84.     /** 微信支付订单号 */
85.     private String transaction_id;
87.     /** 商户订单号 */
88.     private String out_trade_no;
90.     /** 支付完成时间 */
91.     private String time_end;
93.     private String trade_state_desc;
95.     /** 商家数据包 */
96.     private String attach;
97. }

复制代码

SignInfo：签名实体类

1. @Data
2. public class SignInfo {
4.     private String appId;//小程序ID
6.     private String timeStamp;//时间戳
8.     private String nonceStr;//随机串
10.     @XStreamAlias("package")
11.     private String repay_id;
13.     private String signType;//签名方式
14.     public void setSignType(String signType) {
15.         this.signType = signType;
16.     }
17. }

复制代码

4、工具类代码

SignUtils：签名工具类

1. @Slf4j
2. public class SignUtils {
4.         /**
5.          * 签名算法
6.          *
7.          * @param o 要参与签名的数据对象
8.          * @return 签名
9.          * @throws IllegalAccessException
10.          */
11.         public static String getSign(Object o) throws IllegalAccessException {
12.             ArrayList<String> list = new ArrayList<String>();
13.             Class cls = o.getClass();
14.             Field[] fields = cls.getDeclaredFields();
15.             for (Field f : fields) {
16.                 f.setAccessible(true);
17.                 if (f.get(o) != null && f.get(o) != "") {
18.                     String name = f.getName();
19.                     XStreamAlias anno = f.getAnnotation(XStreamAlias.class);
20.                     if (anno != null) {
21.                         name = anno.value();
22.                     }
23.                     list.add(name + "=" + f.get(o) + "&");
24.                 }
25.             }
26.             int size = list.size();
27.             String[] arrayToSort = list.toArray(new String[size]);
28.             Arrays.sort(arrayToSort, String.CASE_INSENSITIVE_ORDER);
29.             StringBuilder sb = new StringBuilder();
30.             for (int i = 0; i < size; i++) {
31.                 sb.append(arrayToSort[i]);
32.             }
33.             String result = sb.toString();
34.             result += "key=" + Configure.getKey();
35.             log.info("签名数据：" + result);
36.             result = MD5.MD5Encode(result).toUpperCase();
37.             return result;
38.         }
40.         public static String getSign(Map<String, Object> map) {
41.             ArrayList<String> list = new ArrayList<String>();
42.             for (Map.Entry<String, Object> entry : map.entrySet()) {
43.                 if (entry.getValue() != "") {
44.                     list.add(entry.getKey() + "=" + entry.getValue() + "&");
45.                 }
46.             }
47.             int size = list.size();
48.             String[] arrayToSort = list.toArray(new String[size]);
49.             Arrays.sort(arrayToSort, String.CASE_INSENSITIVE_ORDER);
50.             StringBuilder sb = new StringBuilder();
51.             for (int i = 0; i < size; i++) {
52.                 sb.append(arrayToSort[i]);
53.             }
54.             String result = sb.toString();
55.             result += "key=" + Configure.getKey();
56.             //Util.log("Sign Before MD5:" + result);
57.             result = MD5.MD5Encode(result).toUpperCase();
58.             //Util.log("Sign Result:" + result);
59.             return result;
60.         }
61.     }

复制代码

MD5：MD5 加密工具类

1. public class MD5 {
2.     private final static String[] hexDigits = {"0", "1", "2", "3", "4", "5", "6", "7",
3.             "8", "9", "a", "b", "c", "d", "e", "f"};
5.     /**
6.      * 转换字节数组为16进制字串
7.      *
8.      * @param b 字节数组
9.      * @return 16进制字串
10.      */
11.     public static String byteArrayToHexString(byte[] b) {
12.         StringBuilder resultSb = new StringBuilder();
13.         for (byte aB : b) {
14.             resultSb.append(byteToHexString(aB));
15.         }
16.         return resultSb.toString();
17.     }
19.     /**
20.      * 转换byte到16进制
21.      *
22.      * @param b 要转换的byte
23.      * @return 16进制格式
24.      */
25.     private static String byteToHexString(byte b) {
26.         int n = b;
27.         if (n < 0) {
28.             n = 256 + n;
29.         }
30.         int d1 = n / 16;
31.         int d2 = n % 16;
32.         return hexDigits[d1] + hexDigits[d2];
33.     }
35.     /**
36.      * MD5编码
37.      *
38.      * @param origin 原始字符串
39.      * @return 经过MD5加密之后的结果
40.      */
41.     public static String MD5Encode(String origin) {
42.         String resultString = null;
43.         try {
44.             resultString = origin;
45.             MessageDigest md = MessageDigest.getInstance("MD5");
46.             resultString = byteArrayToHexString(md.digest(resultString.getBytes()));
47.         } catch (Exception e) {
48.             e.printStackTrace();
49.         }
50.         return resultString;
51.     }
52. }

复制代码

MapToObject：map 转化对象工具类

1. public class MapToObject {
5.     /**
6.      * Map数据转为java对象
7.      * @param map map数据
8.      * @param targetType 对象类型
9.      * @return
10.      * @param <T>
11.      * @throws IllegalAccessException
12.      * @throws InstantiationException
13.      */
14.     public static <T> T convertMapToObject(Map<String, String> map, Class<T> targetType) throws IllegalAccessException, InstantiationException {
15.         T targetObject = targetType.newInstance();
17.         for (Map.Entry<String, String> entry : map.entrySet()) {
18.             String key = entry.getKey();
19.             String value = entry.getValue();
21.             try {
22.                 // 使用反射获取字段
23.                 Field field = targetType.getDeclaredField(key);
25.                 // 设置字段可访问（如果是私有字段）
26.                 field.setAccessible(true);
28.                 // 获取字段的类型
29.                 Class<?> fieldType = field.getType();
31.                 // 将字符串值转换为字段类型
32.                 Object convertedValue = convertStringToType(value, fieldType);
34.                 // 设置字段的值
35.                 field.set(targetObject, convertedValue);
36.             } catch (NoSuchFieldException e) {
37.                 // 处理字段不存在的异常
38.                 e.printStackTrace();
39.             }
40.         }
42.         return targetObject;
43.     }
45.     private static Object convertStringToType(String value, Class<?> targetType) {
46.         if (targetType == int.class || targetType == Integer.class) {
47.             return Integer.parseInt(value);
48.         }
49.         // 添加其他可能的类型转换逻辑，例如 double、float、Date 等
51.         // 默认情况下，返回字符串值
52.         return value;
53.     }
54. }

复制代码

HttpRequest：请求工具类

1. public class HttpRequest {
5.     //连接超时时间，默认10秒
6.     private static final int socketTimeout = 10000;
8.     //传输超时时间，默认30秒
9.     private static final int connectTimeout = 30000;
11.     /**
12.      * post请求
13.      *
14.      * @throws IOException
15.      * @throws ClientProtocolException
16.      * @throws NoSuchAlgorithmException
17.      * @throws KeyStoreException
18.      * @throws KeyManagementException
19.      * @throws UnrecoverableKeyException
20.      */
21.     public static String sendPost(String url, Object xmlObj) throws ClientProtocolException, IOException, UnrecoverableKeyException, KeyManagementException, KeyStoreException, NoSuchAlgorithmException {
24.         HttpPost httpPost = new HttpPost(url);
25.         //解决XStream对出现双下划线的bug
26.         XStream xStreamForRequestPostData = new XStream(new DomDriver("UTF-8", new XmlFriendlyNameCoder("-_", "_")));
27.         xStreamForRequestPostData.alias("xml", xmlObj.getClass());
28.         //将要提交给API的数据对象转换成XML格式数据Post给API
29.         String postDataXML = xStreamForRequestPostData.toXML(xmlObj);
31.         //得指明使用UTF-8编码，否则到API服务器XML的中文不能被成功识别
32.         StringEntity postEntity = new StringEntity(postDataXML, "UTF-8");
33.         httpPost.addHeader("Content-Type", "text/xml");
34.         httpPost.setEntity(postEntity);
36.         //设置请求器的配置
37.         RequestConfig requestConfig = RequestConfig.custom().setSocketTimeout(socketTimeout).setConnectTimeout(connectTimeout).build();
38.         httpPost.setConfig(requestConfig);
40.         HttpClient httpClient = HttpClients.createDefault();
41.         HttpResponse response = httpClient.execute(httpPost);
42.         HttpEntity entity = response.getEntity();
43.         String result = EntityUtils.toString(entity, "UTF-8");
44.         return result;
45.     }
47.     /**
48.      * 自定义证书管理器，信任所有证书
49.      *
50.      * @author pc
51.      */
52.     public static class MyX509TrustManager implements X509TrustManager {
53.         @Override
54.         public void checkClientTrusted(
55.                 java.security.cert.X509Certificate[] arg0, String arg1)
56.                 throws CertificateException {
58.         }
60.         @Override
61.         public void checkServerTrusted(
62.                 java.security.cert.X509Certificate[] arg0, String arg1)
63.                 throws CertificateException {
65.         }
67.         @Override
68.         public java.security.cert.X509Certificate[] getAcceptedIssuers() {
69.             return null;
70.         }
71.     }
73. }

复制代码

5、设置类代码

WxPayConfig：微信支付设置

1. @Data
2. @Component
3. @Configuration
4. @ConfigurationProperties(prefix = "pay")
5. public class WxPayConfig {
7.     /**
8.      * 微信小程序appid
9.      */
10.     private String appId;
12.     /**
13.      * 小程序设置的API v2密钥
14.      */
15.     private String apiKey;
17.     /**
18.      * 微信商户平台 商户id
19.      */
20.     private String mchId;
22.     /**
23.      *小程序密钥
24.      */
25.     private String appSecret;
27.     /**
28.      * 小程序支付异步回调地址
29.      */
30.     private String notifyUrl;
32. }

复制代码

Configure：商户支付秘钥

1. public class Configure {
3.     /**
4.      * 商户支付秘钥
5.      */
6.     @Getter
7.     private static String key = "此处填写秘钥";
9.     public static void setKey(String key) {
10.         Configure.key = key;
11.     }
13. }

复制代码

6、常量类代码

WeChatPayUrlConstants：微信支付API地址常量

1. public class WeChatPayUrlConstants {
3.     /**
4.      * 统一下单预下单接口url
5.      */
6.     public static final String Uifiedorder = "https://api.mch.weixin.qq.com/pay/unifiedorder";
8.     /**
9.      * 订单状态查询接口URL
10.      */
11.     public static final String Orderquery = "https://api.mch.weixin.qq.com/pay/orderquery";
13.     /**
14.      * 订单申请退款
15.      */
16.     public static final String Refund = "https://api.mch.weixin.qq.com/secapi/pay/refund";
18.     /**
19.      * 付款码 支付
20.      */
21.     public static final String MicroPay = "https://api.mch.weixin.qq.com/pay/micropay";
23.     /**
24.      * 微信网页授权 获取“code”请求地址
25.      */
26.     public static final String GainCodeUrl = "https://open.weixin.qq.com/connect/oauth2/authorize";
28.     /**
29.      * 微信网页授权 获取“code” 回调地址
30.      */
31.     public static final String GainCodeRedirect_uri = "http://i5jmxe.natappfree.cc/boss/WeChatPayMobile/SkipPage.html";
33. }

复制代码

7、业务实现类代码

Controller 层

1. @Slf4j
2. @RestController
3. @RequestMapping("/system/wxpay")
4. public class WxPayController {
6.     @Autowired
7.     private WxPayInfoService wxPayInfoService;
9.     /**
10.      * 小程序支付下单接口
11.      *
12.      * @return 返回结果
13.      */
14.     @ApiOperation("小程序支付功能")
15.     @PostMapping("/pay")
16.     public InvokeResult wxPay(@RequestBody PayParameterVO payParameterVO) {
18.         PayParameterVO parameterVO = new PayParameterVO();
19.         parameterVO.setWxOpenId(payParameterVO.getWxOpenId());
20.         parameterVO.setPrice("1");
21.         parameterVO.setGoodsTitle("测试支付商品");
23.         HashMap<String, String> payHistory = wxPayInfoService.insertPayRecord(parameterVO);
24.         return InvokeResultBuilder.success(payHistory);
25.     }
28.     /**
29.      * 查询订单
30.      */
31.     @ApiOperation("订单查询")
32.     @PostMapping("/wx/query")
33.     public InvokeResult orderQuery(@RequestParam("out_trade_no") String out_trade_no) {
34.         QueryReturnInfo queryReturnInfo = wxPayInfoService.orderQuery(out_trade_no);
35. //        return InvokeResultBuilder.success(queryReturnInfo.getTrade_state_desc(), queryReturnInfo);
36.         return InvokeResultBuilder.success(queryReturnInfo);
37.     }
40.     /**
41.      * 微信小程序支付成功回调
42.      *
43.      * @param request  请求
44.      * @param response 响应
45.      * @return 返回结果
46.      * @throws Exception 异常处理
47.      */
48.     @RequestMapping("/weixin/callback")
49.     public String callBack(HttpServletRequest request, HttpServletResponse response) throws Exception {
50.         log.info("接收到微信支付回调信息");
51.         String notifyXml = IOUtils.toString(request.getInputStream(), StandardCharsets.UTF_8);
53.         // 解析返回结果
54.         Map<String, String> notifyMap = WXPayUtil.xmlToMap(notifyXml);
55.         // 判断支付是否成功
56.         if ("SUCCESS".equals(notifyMap.get("result_code"))) {
57.             //支付成功时候，处理业务逻辑
58.             wxPayInfoService.payCallbackSuccess(notifyMap);
59.             //返回处理成功的格式数据，避免微信重复回调
60.             return "<xml>" + "<return_code><![CDATA[SUCCESS]]></return_code>"
61.                     + "<return_msg><![CDATA[OK]]></return_msg>" + "</xml> ";
62.         }
64.         // 创建响应对象：微信接收到校验失败的结果后，会反复的调用当前回调函数
65.         Map<String, String> returnMap = new HashMap<>();
66.         returnMap.put("return_code", "FAIL");
67.         returnMap.put("return_msg", "");
68.         String returnXml = WXPayUtil.mapToXml(returnMap);
69.         response.setContentType("text/xml");
70.         System.out.println("校验失败");
71.         return returnXml;
72.     }
73. 、
74. }

复制代码

接口层

1. public interface  WxPayInfoService {
3.     /**
4.      * 创建统一支付订单
5.      */
6.     HashMap<String, String> insertPayRecord(PayParameterVO payParameterVO);
8.     /**
9.      * 查询订单
10.      * @param out_trade_no 订单号
11.      * @return 返回结果
12.      */
13.     QueryReturnInfo orderQuery(String out_trade_no);
15.     /**
16.      * 微信小程序支付成功回调
17.      * @param notifyMap
18.      */
19.     void payCallbackSuccess(Map<String, String> notifyMap);
21. }

复制代码

实现层

1. @Slf4j
2. @Service
3. public class WxPayInfoServiceImpl implements WxPayInfoService {
5.     //这是注入的业务处理类
6. //    @Autowired
7. //    private IFPayOrderService ifPayOrderService;
9.     @Resource
10.     private WxPayConfig payProperties;
12.     private static final DecimalFormat df = new DecimalFormat("#");
14.     /**
15.      * 创建统一支付订单
16.      *
17.      * @param payParameterVO 商品信息
18.      * @return 返回结果
19.      */
20.     @Override
21.     @Transactional
22.     public HashMap<String, String> insertPayRecord(PayParameterVO payParameterVO) {
23.         String title = payParameterVO.getGoodsTitle();
24.         //金额 * 100 以分为单位
25.         BigDecimal fee = BigDecimal.valueOf(1);
26.         BigDecimal RMB = new BigDecimal(payParameterVO.getPrice());
27.         BigDecimal totalFee = fee.multiply(RMB);
29.         try {
30.             WeChatPay weChatPay = new WeChatPay();
31.             weChatPay.setAppid(payProperties.getAppId());
32.             weChatPay.setMch_id(payProperties.getMchId());
33.             weChatPay.setNonce_str(getRandomStringByLength(32));
34.             weChatPay.setBody(title);
35.             weChatPay.setOut_trade_no(getRandomStringByLength(32));
36.             weChatPay.setTotal_fee(df.format(Double.parseDouble(String.valueOf(totalFee))));
37.             // 获取当前服务器IP地址
38. //            weChatPay.setSpbill_create_ip(IpUtils());
39.             weChatPay.setNotify_url(payProperties.getNotifyUrl());
40.             weChatPay.setTrade_type("JSAPI");
41.             //这里直接使用当前用户的openid
42.             weChatPay.setOpenid(payParameterVO.getWxOpenId());
43.             weChatPay.setSign_type("MD5");
44.             //生成签名
45.             String sign = SignUtils.getSign(weChatPay);
46.             weChatPay.setSign(sign);
48.             log.info("订单号：" + weChatPay.getOut_trade_no());
49.             //向微信发送下单请求
50.             String result = HttpRequest.sendPost(WeChatPayUrlConstants.Uifiedorder, weChatPay);
52.             //将返回结果从xml格式转换为map格式
53.             Map<String, String> wxResultMap = WXPayUtil.xmlToMap(result);
54.             if (StringUtils.isNotEmpty(wxResultMap.get("return_code")) && wxResultMap.get("return_code").equals("SUCCESS")) {
55.                 if (wxResultMap.get("result_code").equals("FAIL")) {
56.                     log.error("微信统一下单失败!");
57.                     return null;
58.                 }
59.             }
60.             OrderReturnInfo returnInfo = MapToObject.convertMapToObject(wxResultMap, OrderReturnInfo.class);
62.             // 二次签名
63.             if ("SUCCESS".equals(returnInfo.getReturn_code()) && returnInfo.getReturn_code().equals(returnInfo.getResult_code())) {
64.                 SignInfo signInfo = new SignInfo();
65.                 signInfo.setAppId(payProperties.getAppId());
66.                 long time = System.currentTimeMillis() / 1000;
67.                 signInfo.setTimeStamp(String.valueOf(time));
68.                 signInfo.setNonceStr(WXPayUtil.generateNonceStr());
69.                 signInfo.setRepay_id("prepay_id=" + returnInfo.getPrepay_id());
70.                 signInfo.setSignType("MD5");
71.                 //生成签名
72.                 String sign1 = SignUtils.getSign(signInfo);
73.                 HashMap<String, String> payInfo = new HashMap<>();
74.                 payInfo.put("timeStamp", signInfo.getTimeStamp());
75.                 payInfo.put("nonceStr", signInfo.getNonceStr());
76.                 payInfo.put("package", signInfo.getRepay_id());
77.                 payInfo.put("signType", signInfo.getSignType());
78.                 payInfo.put("paySign", sign1);
79.                 payInfo.put("placeOrderJsonMsg", JSON.toJSONString(weChatPay));
80.                 payInfo.put("orderNum", weChatPay.getOut_trade_no());
82.                 // 业务逻辑结束 回传给小程序端唤起支付
83.                 return payInfo;
84.             }
85.             return null;
86.         } catch (Exception e) {
87.             log.error(e.getMessage());
88.         }
89.         return null;
90.     }
92.     /**
93.      * 查询订单
94.      *
95.      * @param out_trade_no 订单号
96.      * @return 返回结果
97.      */
98.     @Override
99.     public QueryReturnInfo orderQuery(String out_trade_no) {
100.         try {
101.             WeChatPay weChatPay = new WeChatPay();
102.             weChatPay.setAppid(payProperties.getAppId());
103.             weChatPay.setMch_id(payProperties.getMchId());
104.             weChatPay.setNonce_str(WXPayUtil.generateNonceStr());
105.             weChatPay.setOut_trade_no(out_trade_no);
106.             //order.setSign_type("MD5");
107.             //生成签名
108.             String sign = SignUtils.getSign(weChatPay);
109.             weChatPay.setSign(sign);
110.             //向微信发送查询订单详情请求
111.             String result = HttpRequest.sendPost(WXPayConstants.ORDERQUERY_URL, weChatPay);
112.             Map<String, String> xmlToMap = WXPayUtil.xmlToMap(result);
114.             // 将 Map 转换为对象
115.             return MapToObject.convertMapToObject(xmlToMap, QueryReturnInfo.class);
116.         } catch (Exception e) {
117.             log.error("查询支付订单失败：[{}]", e.getMessage());
118.         }
119.         return null;
120.     }
122.     /**
123.      * 微信小程序支付成功回调
124.      *
125.      * @param notifyMap 回调Map数据
126.      */
127.     @Override
128.     public void payCallbackSuccess(Map<String, String> notifyMap) {
129.         //保存相关支付数据
130.         try {
131.             QueryReturnInfo queryReturnInfo = MapToObject.convertMapToObject(notifyMap, QueryReturnInfo.class);
132.             log.info("支付回调信息：" + queryReturnInfo);
133.             //处理回调信息，此处根据自己的项目业务进行处理
134. //            ifPayOrderService.receivePayCallback(queryReturnInfo);
135.         } catch (Exception e) {
136.             throw new RuntimeException(e);
137.         }
139.     }
141.     /**
142.      * 获取一定长度的随机字符串
143.      *
144.      * @param length 指定字符串长度
145.      * @return 一定长度的字符串
146.      */
147.     public static String getRandomStringByLength(int length) {
148.         String base = "abcdefghijklmnopqrstuvwxyz0123456789";
149.         Random random = new Random();
150.         StringBuilder sb = new StringBuilder();
151.         for (int i = 0; i < length; i++) {
152.             int number = random.nextInt(base.length());
153.             sb.append(base.charAt(number));
154.         }
155.         return sb.toString();
156.     }
157. }

复制代码

前端焦点代码

支付方法

1. goPay () {
2.       console.log('goPay');
3.       const that = this
5.       //向服务器发送下单请求(服务端会返回预下单信息)
6.       uni.request({
7.         url: common.api_base_url + "/system/wxpay/pay",
8.         header: {
9.           "Content-Type": "application/json",
10.           "Authorization": "Bearer " + uni.getStorageSync('token'),
11.         },
12.         method: 'POST',
13.         data: {
14.           goodsId: that.nowGoodsId,
15.         },
16.         success(res) {
17.           console.log("下单信息结果",res)
18.           if (res.data.code == 200){
19.             //成功，调用微信支付接口进行支付（）
20.             uni.requestPayment({
21.               provider: 'wxpay',
22.               timeStamp: res.data.data.timeStamp,
23.               nonceStr:  res.data.data.nonceStr,
24.               package:  res.data.data.package,
25.               signType: res.data.data.signType,
26.               paySign:  res.data.data.paySign,
27.               // appId: app.globalData.appid,
28.               success: function (ress) {
29.                 console.log("支付完成：",ress)
30.                 //支付成功后，查询订单情况，或者2 秒自动跳转到其他页面
31.                 uni.showToast({
32.                   title: '支付成功',
33.                   duration: 2000
34.                 });
35.               },
36.               fail: function (err) {
37.                 uni.showToast({
38.                   title: '支付失败!',err,
39.                   icon:"none",
40.                   duration: 2000
41.                 });
42.               }
43.             });
44.           }else {
45.             //弹出下单失败的提示
46.             uni.showToast({
47.               title:res.data.msg,
48.               icon:"none"
49.             });
50.           }
51.         }
52.       })
53.     },

复制代码

效果图

前端传递参数，后端生成预订单，返回前端，前端唤醒支付页面，随后支付即可，再调用订单状态查询接口，对差别状态的订单举行自己的业务逻辑判断。

最后文章有啥不对，欢迎大佬在评论区辅导！！！
如果感觉对你有资助就点赞推荐或者关注一下吧！！！

****

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。