SpringBoot 集成微信（微信支付）

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.登录微信开发平台创建移动应用

微信开发平台

1.创建移动应用

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

2.登录微信商户平台

微信商户平台

1.设置或获取到API密钥

如果是新开的微信商户号，设置API密钥一定要设置两遍、两遍、两遍，重要的事说三遍；别问为什么照做就对了。不然可能会出现签名错误哦！

注意了哦 这里的API密钥是所有API的密钥，设置好了最好不要乱改动，以免其他接入接口的使用不了！！！

账户中心 > API安全 > 设置API密钥。

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

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

3.导入依赖

<!-- https://mvnrepository.com/artifact/com.github.wxpay/wxpay-sdk -->
        <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.添加依赖

<!-- https://mvnrepository.com/artifact/com.github.wxpay/wxpay-sdk -->
        <dependency>
            <groupId>com.github.wxpay</groupId>
            <artifactId>wxpay-sdk</artifactId>
            <version>0.0.3</version>
        </dependency>

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

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);
    }

}

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生成二维码！