SpringBoot 集成微信（微信支付）

ゞ浴缸里的玫瑰 2023-10-03 12:52 39阅读 0赞

#### SpringBoot 集成微信 ####

*  微信支付（APP支付）
 *   *  1.登录微信开发平台创建移动应用
     *   *  1.创建移动应用
         *  2.查看APP是否开通了支付功能并能获取到APPID
     *  2.登录微信商户平台
     *   *  1.设置或获取到API密钥
         *  2.关联APPID、并查看商户号
     *  3.导入依赖
     *  4.创建自己的微信配置类
     *  5.这下可以开始自己的业务模块了
     *   *  1. 创建服务接口
         *  2.创建接口实现类
         *  3.创建自己的控制类
         *   *  这里是我的接口请求类可以根据自己的业务随意定制
 *  微信支付（二维码扫码支付）
 *   *  1.添加依赖
     *  2.创建配置类，基本和上面的一样。
     *  3. 业务模块
     *   *  1.创建业务接口
         *  2. 创建接口实现类
         *  3. 创建测试控制类

## 微信支付（APP支付） ##

### 1.登录微信开发平台创建移动应用 ###

[微信开发平台][Link 1]

#### 1.创建移动应用 ####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyNjI4OA_size_16_color_FFFFFF_t_70]

#### 2.查看APP是否开通了支付功能并能获取到APPID ####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyNjI4OA_size_16_color_FFFFFF_t_70 1]

### 2.登录微信商户平台 ###

[微信商户平台][Link 2]

#### 1.设置或获取到API密钥 ####

**如果是新开的微信商户号，设置API密钥一定要设置两遍、两遍、两遍，重要的事说三遍；别问为什么照做就对了。不然可能会出现签名错误哦！**  
***注意了哦 这里的API密钥是所有API的密钥，设置好了最好不要乱改动，以免其他接入接口的使用不了！！！***  
账户中心 > API安全 > 设置API密钥。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyNjI4OA_size_16_color_FFFFFF_t_70 2]

#### 2.关联APPID、并查看商户号 ####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyNjI4OA_size_16_color_FFFFFF_t_70 3]

**到这里我们的准备工作都昨晚啦！！！**

### 3.导入依赖 ###

<dependency>
                <groupId>com.github.wxpay</groupId>
                <artifactId>wxpay-sdk</artifactId>
                <version>0.0.3</version>
            </dependency>

### 4.创建自己的微信配置类 ###

import com.github.wxpay.sdk.WXPayConfig;
    import lombok.Data;
    import org.springframework.stereotype.Component;
    
    import java.io.InputStream;
    
    /**
     * 配置我们自己的信息
     *
     * @author Lenovo
     */
    @Component
    @Data
    public class WxPayAppConfig implements WXPayConfig {
        
        /**
         * appID
         */
        private String appID = "appID";
    
        /**
         * 商户号
         */
        private String mchID = "商户号";
    
        /**
         * AppSecret
         */
        private String appSecret = "AppSecret";
    
        /**
         * API 商户密钥
         */
        private String key = "API密钥";
    
        /**
         * API证书绝对路径 (本项目放在了 resources/cert/wxpay/apiclient_cert.p12")
         */
        private String certPath = "static/cert/wxpay/apiclient_cert.p12";
    
        /**
         * HTTP(S) 连接超时时间，单位毫秒
         */
        private int httpConnectTimeoutMs = 8000;
    
        /**
         * HTTP(S) 读数据超时时间，单位毫秒
         */
        private int httpReadTimeoutMs = 10000;
    
        /**
         * 微信支付异步通知地址
         */
        private String payNotifyUrl = "*******你的外网url********/wxPay/notify";
    
        /**
         * 微信退款异步通知地址
         */
        private String refundNotifyUrl;
    
        /**
         * 获取商户证书内容（这里证书需要到微信商户平台进行下载）
         *
         * @return 商户证书内容
         */
        @Override
        public InputStream getCertStream() {
        
            return getClass().getClassLoader().getResourceAsStream(certPath);
        }
    
    }

### 5.这下可以开始自己的业务模块了 ###

#### 1. 创建服务接口 ####

package com.communist.web.service;
    
    
    import com.communist.common.constant.Result;
    
    /**
     * 微信支付服务接口
     *
     * @author Lenovo
     */
    public interface WxAppPayService {
        
    
        /**
         * @return
         * @Description:
         * @Author:
         * @Date: 2019/8/1
         */
        /**
         * 微信支付统一下单
         *
         * @param orderNo 订单编号
         * @param amount  实际支付金额
         * @param body    订单描述
         * @param attach  附加数据
         * @return
         * @throws Exception
         */
        String unified(String orderNo, double amount, String body, String attach) throws Exception;
    
    //    /**
    //     * @param notifyStr: 微信异步通知消息字符串
    //     * @return
    //     * @Description: 订单支付异步通知
    //     * @Author:
    //     * @Date: 2019/8/1
    //     */
    //    String notify(String notifyStr) throws Exception;
    
        /**
         * 退款
         *
         * @param orderNo      :      订单编号
         * @param amount       :       实际支付金额
         * @param refundReason : 退款原因
         * @return
         */
        Result refund(String orderNo, double amount, String refundReason);
    
    
        /**
         * 查询订单
         *
         * @param outTradeNo    商户订单
         * @param transactionId 微信支付订单号
         * @return
         */
        Result orderQuery(String outTradeNo, String transactionId);
    
    }

#### 2.创建接口实现类 ####

import cn.hutool.core.lang.Assert;
    import cn.hutool.core.util.StrUtil;
    import com.alibaba.fastjson.JSONObject;
    import com.communist.common.config.WxPayAppConfig;
    import com.communist.common.constant.Result;
    import com.communist.common.util.SnowflakeUtils;
    import com.communist.web.service.WxAppPayService;
    import com.github.wxpay.sdk.WXPay;
    import com.github.wxpay.sdk.WXPayUtil;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.stereotype.Service;
    
    import javax.annotation.Resource;
    import java.net.Inet4Address;
    import java.net.InetAddress;
    import java.util.HashMap;
    import java.util.Map;
    
    /**
     * 微信支付
     *
     * @author Lenovo
     */
    @Slf4j
    @Service
    public class WxAppPayServiceImpl implements WxAppPayService {
        
    
        @Resource
        private WxPayAppConfig wxPayAppConfig;
    
        @Override
        public String unified(String orderNo, double amount, String body, String attach) throws Exception {
        
            Map<String, String> returnMap = new HashMap<>(7);
            Map<String, String> requestMap = new HashMap<>(7);
            WXPay wxpay = new WXPay(wxPayAppConfig);
            // 商品描述
            requestMap.put("body", body);
            // 商户订单号
            requestMap.put("out_trade_no", orderNo);
            // 总金额(分为单位)
    //        requestMap.put("total_fee", String.valueOf((int) (amount * 100)));
            requestMap.put("total_fee", "1");
            // 附加数据
            requestMap.put("attach", attach);
    
            InetAddress ip4 = Inet4Address.getLocalHost();
            // 终端IP
            requestMap.put("spbill_create_ip", ip4.getHostAddress());
            // App支付类型
            requestMap.put("trade_type", "APP");
            // 接收微信支付异步通知回调地址
            requestMap.put("notify_url", wxPayAppConfig.getPayNotifyUrl());
            Map<String, String> resultMap = wxpay.unifiedOrder(requestMap);
            //获取返回码
            log.info("\t\n" + JSONObject.toJSONString(resultMap));
            String returnCode = resultMap.get("return_code");
            //若返回码为SUCCESS，则会返回一个result_code,再对该result_code进行判断
            if ("SUCCESS".equals(returnCode)) {
        
                String resultCode = resultMap.get("result_code");
                String errCodeDes = resultMap.get("err_code_des");
                if ("SUCCESS".equals(resultCode)) {
        
                    Long time = System.currentTimeMillis() / 1000;
                    String timestamp = time.toString();
                    returnMap.put("appid", resultMap.get("appid"));
                    returnMap.put("noncestr", resultMap.get("nonce_str"));
                    returnMap.put("package", "Sign=WXPay");
                    returnMap.put("partnerid", resultMap.get("mch_id"));
                    returnMap.put("prepayid", resultMap.get("prepay_id"));
                    returnMap.put("timestamp", timestamp);
                    //微信支付签名
                    returnMap.put("sign", WXPayUtil.generateSignature(returnMap, wxPayAppConfig.getKey()));
                }
            }
            Assert.notEmpty(returnMap, "获取预支付交易会话标识失败！");
            return JSONObject.toJSONString(returnMap);
        }
    
    //    @Override
    //    public String notify(String notifyStr) {
        
    //        String xmlBack = "<xml><return_code><![CDATA[FAIL]]></return_code><return_msg><![CDATA[报文为空]]></return_msg></xml> ";
    //        try {
        
    //            // 转换成map
    //            Map<String, String> resultMap = WXPayUtil.xmlToMap(notifyStr);
    //            WXPay wxpayApp = new WXPay(wxPayAppConfig);
    //            if (wxpayApp.isPayResultNotifySignatureValid(resultMap)) {
        
    //                //状态
    //                String returnCode = resultMap.get("return_code");
    //                //商户订单号
    //                String outTradeNo = resultMap.get("out_trade_no");
    //                // 微信支付系统生成的订单号。
    //                String transactionId = resultMap.get("transaction_id");
    //                // 支付成功
    //                if (returnCode.equals("SUCCESS")) {
        
    //                    xmlBack = "<xml><return_code><![CDATA[SUCCESS]]></return_code><return_msg><![CDATA[OK]]></return_msg></xml>";
    //                }
    //            }
    //        } catch (Exception e) {
        
    //            e.printStackTrace();
    //        }
    //        return xmlBack;
    //    }
    
        @Override
        public Result refund(String orderNo, double amount, String refundReason) {
        
            Assert.isTrue(StrUtil.isNotBlank(orderNo), "订单编号不能为空!");
            Assert.isTrue(amount > 0, "退款金额必须大于0!");
    
            Map<String, String> responseMap = new HashMap<>(5);
            Map<String, String> requestMap = new HashMap<>(10);
            WXPay wxpay = new WXPay(wxPayAppConfig);
            requestMap.put("out_trade_no", orderNo);
    //        requestMap.put("out_refund_no", 。UUIDGenerator.getOrderNo());
            requestMap.put("out_refund_no", SnowflakeUtils.getIdStr());
            requestMap.put("total_fee", "订单支付时的总金额，需要从数据库查");
            //所需退款金额
            requestMap.put("refund_fee", String.valueOf((int) (amount * 100)));
            requestMap.put("refund_desc", refundReason);
            try {
        
                responseMap = wxpay.refund(requestMap);
            } catch (Exception e) {
        
                e.printStackTrace();
            }
            //返回状态码
            String returnCode = responseMap.get("return_code");
            //返回信息
            String returnMsg = responseMap.get("return_msg");
            if ("SUCCESS".equals(returnCode)) {
        
                //业务结果
                String resultCode = responseMap.get("result_code");
                //错误代码描述
                String errCodeDes = responseMap.get("errCodeDes");
                if ("SUCCESS".equals(resultCode)) {
        
                    //表示退款申请接受成功，结果通过退款查询接口查询
                    //修改用户订单状态为退款申请中或已退款。退款异步通知根据需求，可选
                    return Result.ok("退款申请成功");
                } else {
        
                    log.info("订单号:{}错误信息:{}", orderNo, errCodeDes);
                    return Result.error(400, errCodeDes);
                }
            } else {
        
                log.info("订单号:{}错误信息:{}", orderNo, returnMsg);
                return Result.error(400, returnMsg);
            }
        }
    
        /**
         * 查询订单
         *
         * @param outTradeNo    商户订单
         * @param transactionId 微信支付订单号
         * @return 结果
         */
        @Override
        public Result orderQuery(String outTradeNo, String transactionId) {
        
            Map<String, String> responseMap = new HashMap<>(5);
            Map<String, String> requestMap = new HashMap<>(5);
            WXPay wxpay = new WXPay(wxPayAppConfig);
            requestMap.put("out_trade_no", outTradeNo);
    //        requestMap.put("transactionId", transactionId);
            try {
        
                Map<String, String> resultMap = wxpay.orderQuery(requestMap);
                return Result.ok(resultMap);
               /* String returnCode = resultMap.get("return_code");
                String returnMsg = resultMap.get("return_msg");
                //若返回码为SUCCESS，则会返回一个resultCode,再对该resultCode进行判断
                if ("SUCCESS".equals(returnCode)) {
                    String resultCode = resultMap.get("resultCode");
                    String errCodeDes = resultMap.get("errCodeDes");
                    if ("SUCCESS".equals(resultCode)) {
                        responseMap = resultMap;
                        responseMap.remove("mch_id");
                        responseMap.remove("appid");
                        responseMap.remove("nonce_str");
                    }
                }
                if (responseMap == null || responseMap.isEmpty()) {
                    return Result.error(400, "查询订单失败！");
                }*/
            } catch (Exception e) {
        
                e.printStackTrace();
            }
            return Result.ok(responseMap);
        }
    }

#### 3.创建自己的控制类 ####

import cn.hutool.core.util.IdUtil;
    import cn.hutool.core.util.RandomUtil;
    import com.alibaba.fastjson.JSONObject;
    import com.communist.common.config.WxPayAppConfig;
    import com.communist.common.constant.Result;
    import com.communist.web.controller.req.PayReq;
    import com.communist.web.entity.ComOrderPay;
    import com.communist.web.service.ComOrderPayService;
    import com.communist.web.service.WxAppPayService;
    import com.github.wxpay.sdk.WXPay;
    import com.github.wxpay.sdk.WXPayUtil;
    import io.swagger.annotations.Api;
    import io.swagger.annotations.ApiOperation;
    import io.swagger.annotations.ApiParam;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.PostMapping;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RequestParam;
    import org.springframework.web.bind.annotation.RestController;
    
    import javax.annotation.Resource;
    import javax.servlet.http.HttpServletRequest;
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.InputStreamReader;
    import java.util.Map;
    
    /**
     * @author Lenovo
     */
    @Slf4j
    @Api(tags = "微信支付模块")
    @RestController
    @RequestMapping("/wxPay")
    public class WxAppPayController {
        
    
        @Autowired
        private WxAppPayService wxAppPayService;
        @Resource
        private ComOrderPayService orderPayService;
        @Autowired
        private WxPayAppConfig wxPayAppConfig;
    
        /**
         * 统一下单接口
         */
        @ApiOperation(value = "统一下单", notes = "统一下单")
        @PostMapping("/unifiedOrder")
        public Result unifiedOrder(PayReq payReq, HttpServletRequest request) {
        
            try {
        
                String body = RandomUtil.randomString(10);
                /** 1、验证订单是否存在*/
                String orderNo = IdUtil.fastSimpleUUID();
                // 2、开始微信支付统一下单
                /**生成预支付订单*/
                ComOrderPay orderPay = new ComOrderPay();
                orderPay.setPayOrderNo(orderNo);
                orderPay.setPayAmount(payReq.getAmount());
                orderPay.setPayType(2);
                boolean b = orderPayService.addOrderPay(orderPay);
                if (b) {
        
                    String s = JSONObject.toJSONString(payReq);
                    return Result.ok("SUCCESS", wxAppPayService.unified(orderNo, payReq.getAmount(), body, s));
                } else {
        
                    return Result.error("生产预支付订单失败！");
                }
            } catch (Exception e) {
        
                throw new RuntimeException(e);
            }
        }
    
        /**
         * 微信支付异步通知
         */
        @RequestMapping(value = "/notify")
        public String payNotify(HttpServletRequest request) {
        
            InputStream is = null;
            String xmlBack = "<xml><return_code><![CDATA[FAIL]]></return_code><return_msg><![CDATA[报文为空]]></return_msg></xml> ";
            try {
        
                is = request.getInputStream();
                // 将InputStream转换成String
                BufferedReader reader = new BufferedReader(new InputStreamReader(is));
                StringBuilder sb = new StringBuilder();
                String line;
                while ((line = reader.readLine()) != null) {
        
                    sb.append(line).append("\n");
                }
                log.info("\n\t微信支付回调成功！");
                // 转换成map
                Map<String, String> resultMap = WXPayUtil.xmlToMap(sb.toString());
                WXPay wxpayApp = new WXPay(wxPayAppConfig);
                if (wxpayApp.isPayResultNotifySignatureValid(resultMap)) {
        
                    // 状态
                    String returnCode = resultMap.get("return_code");
                    // 支付成功
                    if ("SUCCESS".equals(returnCode)) {
        
                        xmlBack = "<xml><return_code><![CDATA[SUCCESS]]></return_code><return_msg><![CDATA[OK]]></return_msg></xml>";
                        /** 支付回调处理*/
                        // 商户订单号
                        String outTradeNo = resultMap.get("out_trade_no");
                        // 微信支付系统生成的订单号。
                        String transactionId = resultMap.get("transaction_id");
                        // 附加数据
                        String attach = resultMap.get("attach");
                        // 支付完成时间
                        String successTime = resultMap.get("time_end");
                        PayReq payReq = JSONObject.parseObject(attach, PayReq.class);
                        /** 这里写自己业务代码 */
                      
                    }
                }
            } catch (Exception e) {
        
                log.error("微信手机支付回调通知失败：", e);
            } finally {
        
                if (is != null) {
        
                    try {
        
                        is.close();
                    } catch (IOException e) {
        
                        e.printStackTrace();
                    }
                }
            }
            return xmlBack;
        }
    
        @ApiOperation(value = "退款", notes = "退款", hidden = true)
        @PostMapping("/refund")
        public Result refund(@ApiParam(value = "订单号") @RequestParam String orderNo,
                             @ApiParam(value = "退款金额") @RequestParam double amount,
                             @ApiParam(value = "退款原因") @RequestParam(required = false) String refundReason) {
        
            return wxAppPayService.refund(orderNo, amount, refundReason);
        }
    
    
        @ApiOperation(value = "查询订单", notes = "查询订单")
        @PostMapping("/orderQuery")
        public Result orderQuery(String orderNo, String wxOrderNo) {
        
            return wxAppPayService.orderQuery(orderNo, wxOrderNo);
        }
    }

##### 这里是我的接口请求类可以根据自己的业务随意定制 #####

package com.communist.web.controller.req;
    
    import io.swagger.annotations.ApiModelProperty;
    import lombok.Data;
    
    /**
     * @Author ddz
     * @ClassName PayReq
     * @Description 支付请求
     * @Version 1.0
     **/
    @Data
    public class PayReq {
        
        @ApiModelProperty("类型 1 订单 2 商家入驻保证金 3 代理商入驻保证金 9 其他")
        private Integer type;
    
        @ApiModelProperty("金额")
        private Double amount;
    
        @ApiModelProperty("订单号")
        private String orderNo;
    
        @ApiModelProperty("用户id")
        private Long userId;
    
    }

## 微信支付（二维码扫码支付） ##

**获取API密钥、AppID、商户号的方法上面已经介绍过了，下面就开始我们的代码环节吧！**

### 1.添加依赖 ###

### 2.创建配置类，基本和上面的一样。 ###

### 3. 业务模块 ###

#### 1.创建业务接口 ####

import com.communist.common.constant.Result;
    
    /**
     * 微信支付服务接口
     *
     * @author Lenovo
     */
    public interface WxAppPayService {
        
        /**
         * 获取二维码
         *
         * @return 二维码url
         */
        String unifiedOrder() throws Exception;
    
    //    /**
    //     * @param notifyStr: 微信异步通知消息字符串
    //     * @return
    //     * @Description: 订单支付异步通知
    //     * @Author:
    //     * @Date: 2019/8/1
    //     */
    //    String notify(String notifyStr) throws Exception;
    
    
    
        /**
         * 查询订单
         *
         * @param outTradeNo    商户订单
         * @param transactionId 微信支付订单号
         * @return
         */
        Result orderQuery(String outTradeNo, String transactionId);
    
    }

#### 2. 创建接口实现类 ####

package com.communist.web.service.impl;
    
    import cn.hutool.core.date.DateTime;
    import cn.hutool.core.date.DateUtil;
    import cn.hutool.core.lang.Assert;
    import cn.hutool.core.util.IdUtil;
    import cn.hutool.core.util.StrUtil;
    import com.alibaba.fastjson.JSONObject;
    import com.communist.common.config.WxPayAppConfig;
    import com.communist.common.constant.Result;
    import com.communist.common.util.SnowflakeUtils;
    import com.communist.web.service.WxAppPayService;
    import com.github.wxpay.sdk.WXPay;
    import com.github.wxpay.sdk.WXPayConstants;
    import com.github.wxpay.sdk.WXPayUtil;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.stereotype.Service;
    
    import javax.annotation.Resource;
    import java.net.Inet4Address;
    import java.net.InetAddress;
    import java.util.HashMap;
    import java.util.Map;
    
    /**
     * 微信支付
     *
     * @author Lenovo
     */
    @Slf4j
    @Service
    public class WxAppPayServiceImpl implements WxAppPayService {
        
    
        @Resource
        private WxPayAppConfig wxPayAppConfig;
    
        /**
         * 获取二维码
         *
         * @return
         */
        @Override
        public String unifiedOrder() throws Exception {
        
            String orderNo = IdUtil.fastSimpleUUID();
            String body = "测试支付";
            // 构建参数
            Map<String, String> requestMap = new HashMap<>(7);
            // 商品描述
            requestMap.put("body", body);
            // 商户订单号
            requestMap.put("out_trade_no", orderNo);
            // 总金额(分为单位)
            requestMap.put("total_fee", "1");
            // 附加数据
    //        requestMap.put("attach", attach);
            InetAddress ip4 = Inet4Address.getLocalHost();
            // 终端IP
            requestMap.put("spbill_create_ip", ip4.getHostAddress());
            // 支付类型
            requestMap.put("trade_type", "NATIVE");
            // 接收微信支付异步通知回调地址
            requestMap.put("notify_url", wxPayAppConfig.getPayNotifyUrl());
            // 二维码过期时间  5分钟
            DateTime dateTime = DateUtil.offsetMinute(DateUtil.date(), 5);
            String format = DateUtil.format(dateTime, "yyyyMMddHHmmss");
            requestMap.put("time_expire", format);
            // 发起请求
            WXPay wxpay = new WXPay(wxPayAppConfig);
            Map<String, String> stringStringMap = wxpay.unifiedOrder(requestMap);
            log.info(JSONObject.toJSONString(stringStringMap));
            // 验签
            Assert.isTrue(WXPayUtil.isSignatureValid(stringStringMap, wxPayAppConfig.getKey(), WXPayConstants.SignType.MD5), "微信支付验签失败！");
            Assert.isTrue(stringStringMap.get("return_code").equals(WXPayConstants.SUCCESS) && stringStringMap.get("result_code").equals(WXPayConstants.SUCCESS), "获取付款二维码失败！");
            return stringStringMap.get("code_url");
        }
    
    //    @Override
    //    public String notify(String notifyStr) {
        
    //        String xmlBack = "<xml><return_code><![CDATA[FAIL]]></return_code><return_msg><![CDATA[报文为空]]></return_msg></xml> ";
    //        try {
        
    //            // 转换成map
    //            Map<String, String> resultMap = WXPayUtil.xmlToMap(notifyStr);
    //            WXPay wxpayApp = new WXPay(wxPayAppConfig);
    //            if (wxpayApp.isPayResultNotifySignatureValid(resultMap)) {
        
    //                //状态
    //                String returnCode = resultMap.get("return_code");
    //                //商户订单号
    //                String outTradeNo = resultMap.get("out_trade_no");
    //                // 微信支付系统生成的订单号。
    //                String transactionId = resultMap.get("transaction_id");
    //                // 支付成功
    //                if (returnCode.equals("SUCCESS")) {
        
    //                    xmlBack = "<xml><return_code><![CDATA[SUCCESS]]></return_code><return_msg><![CDATA[OK]]></return_msg></xml>";
    //                }
    //            }
    //        } catch (Exception e) {
        
    //            e.printStackTrace();
    //        }
    //        return xmlBack;
    //    }
    
    
        /**
         * 查询订单
         *
         * @param outTradeNo    商户订单
         * @param transactionId 微信支付订单号
         * @return 结果
         */
        @Override
        public Result orderQuery(String outTradeNo, String transactionId) {
        
            Map<String, String> responseMap = new HashMap<>(5);
            Map<String, String> requestMap = new HashMap<>(5);
            WXPay wxpay = new WXPay(wxPayAppConfig);
            requestMap.put("out_trade_no", outTradeNo);
            requestMap.put("transactionId", transactionId);
            try {
        
                Map<String, String> resultMap = wxpay.orderQuery(requestMap);
                return Result.ok(resultMap);
            } catch (Exception e) {
        
                e.printStackTrace();
            }
            return Result.ok(responseMap);
        }
    }

#### 3. 创建测试控制类 ####

import cn.hutool.core.util.IdUtil;
    import cn.hutool.core.util.RandomUtil;
    import com.alibaba.fastjson.JSONObject;
    import com.communist.common.config.WxPayAppConfig;
    import com.communist.common.constant.Result;
    import com.communist.web.service.ComOrderPayService;
    import com.communist.web.service.WxAppPayService;
    import com.github.wxpay.sdk.WXPay;
    import com.github.wxpay.sdk.WXPayUtil;
    import io.swagger.annotations.Api;
    import io.swagger.annotations.ApiOperation;
    import io.swagger.annotations.ApiParam;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.PostMapping;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RequestParam;
    import org.springframework.web.bind.annotation.RestController;
    
    import javax.annotation.Resource;
    import javax.servlet.http.HttpServletRequest;
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.InputStreamReader;
    import java.util.Map;
    
    /**
     * @author Lenovo
     */
    @Slf4j
    @Api(tags = "微信支付模块")
    @RestController
    @RequestMapping("/wxPay")
    public class WxAppPayController {
        
    
        @Autowired
        private WxAppPayService wxAppPayService;
        @Autowired
        private WxPayAppConfig wxPayAppConfig;
    
    
    
        /**
         * 获取二维码
         */
        @ApiOperation(value = "获取二维码", notes = "获取二维码")
        @PostMapping("/unified")
        public Result unifiedOrder() throws Exception {
        
            return Result.ok("SUCCESS", wxAppPayService.unifiedOrder());
        }
    
        /**
         * 微信支付异步通知
         */
        @RequestMapping(value = "/notify")
        public String payNotify(HttpServletRequest request) {
        
            InputStream is = null;
            String xmlBack = "<xml><return_code><![CDATA[FAIL]]></return_code><return_msg><![CDATA[报文为空]]></return_msg></xml> ";
            try {
        
                is = request.getInputStream();
                // 将InputStream转换成String
                BufferedReader reader = new BufferedReader(new InputStreamReader(is));
                StringBuilder sb = new StringBuilder();
                String line;
                while ((line = reader.readLine()) != null) {
        
                    sb.append(line).append("\n");
                }
                log.info("\n\t微信支付回调成功！");
                // 转换成map
                Map<String, String> resultMap = WXPayUtil.xmlToMap(sb.toString());
                WXPay wxpayApp = new WXPay(wxPayAppConfig);
                if (wxpayApp.isPayResultNotifySignatureValid(resultMap)) {
        
                    // 状态
                    String returnCode = resultMap.get("return_code");
                    // 支付成功
                    if ("SUCCESS".equals(returnCode)) {
        
                        xmlBack = "<xml><return_code><![CDATA[SUCCESS]]></return_code><return_msg><![CDATA[OK]]></return_msg></xml>";
                        /** 支付回调处理*/
                        // 商户订单号
                        String outTradeNo = resultMap.get("out_trade_no");
                        // 微信支付系统生成的订单号。
                        String transactionId = resultMap.get("transaction_id");
                        // 附加数据
                        String attach = resultMap.get("attach");
                        // 支付完成时间
                        String successTime = resultMap.get("time_end");
    
                    }
                }
            } catch (Exception e) {
        
                log.error("微信手机支付回调通知失败：", e);
            } finally {
        
                if (is != null) {
        
                    try {
        
                        is.close();
                    } catch (IOException e) {
        
                        e.printStackTrace();
                    }
                }
            }
            return xmlBack;
        }
    
        @ApiOperation(value = "查询订单", notes = "查询订单")
        @PostMapping("/orderQuery")
        public Result orderQuery(String orderNo, String wxOrderNo) {
        
            return wxAppPayService.orderQuery(orderNo, wxOrderNo);
        }
    }

到这里我们获取到微信返回的url，但是需要前端将url生成二维码！

[Link 1]: https://open.weixin.qq.com/
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyNjI4OA_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/d3b3f9dd1c1f41ea9bf25f4f219d405e.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyNjI4OA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyNjI4OA_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/a7d3c30662ac49e0b14f7f0c8c232fab.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyNjI4OA==,size_16,color_FFFFFF,t_70
[Link 2]: https://pay.weixin.qq.com/
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyNjI4OA_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/b13311e33d404b06ba5190810b343694.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyNjI4OA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyNjI4OA_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/9a6b0121b98344c19fb08f9ebf0961a8.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyNjI4OA==,size_16,color_FFFFFF,t_70