PC网站微信扫码支付之Native支付（模式二）

简介

Native支付是指商户系统按微信支付协议生成支付二维码，用户再用微信“扫一扫”完成支付的模式。该模式适用于PC网站、实体店单品或订单、媒体广告支付等场景。

Native支付的两种模式（本次介绍模式二）

模式一：商户后台系统根据微信支付规则链接生成二维码，链接中带固定参数productid（可定义为产品标识或订单号），用户扫码后，微信支付系统将productid和用户唯一标识(openid)回调商户后台系统(需要设置支付回调URL)，商户后台系统根据productid生成支付交易，最后微信支付系统发起用户支付流程。

模式二：商户后台系统先调用微信支付的统一下单接口，微信后台系统返回链接参数code_url，商户后台系统将code_url值生成二维码图片，用户使用微信客户端扫码后发起支付。注意：code_url有效期为2小时，过期后扫码不能再发起支付。

官方开发指引及时序图

开发前准备

1、注册微信商户号

微信商户平台官方注册网站

注册登录后可获取开发需要信息(微信支付商户号，平台API密钥) 

 获取微信支付商户号：

设置或修改微信平台API密钥

2、注册微信公众平台(服务号)

注意：到这里可能很多朋友会问我们做的是PC扫码支付又不是公众号支付，为什么还要注册公众号呢？【微信接口需要】，切记不要误注册微信开发平台【不需要而且还要花300大洋】。

微信公众平台服务号官方注册网站

注册登录后可获取开发需要信息(服务号appID，服务号app密钥) 

 3、关联绑定商户平台和公众平台

登录商户平台输入公众号AppID进行关联授权

微信公众号授权页面

商户平台设置回调地址

项目代码

常量类：WxConstants

/**
 * @description 微信公众号常量类
 */
public class WxConstants {
    /**
     * 默认编码
     */
    public static final String DEFAULT_CHARSET = "UTF-8";

    /**
     * 统一下单-扫描支付
     */
    public static String PAY_UNIFIEDORDER = "https://api.mch.weixin.qq.com/pay/unifiedorder";

    /**
     * 统一下单-查询订单
     */
    public static String PAY_ORDERQUERY = "https://api.mch.weixin.qq.com/pay/orderquery";

    /**
     * 统一下单-关闭订单
     */
    public static String PAY_CLOSEORDER = "https://api.mch.weixin.qq.com/pay/closeorder";

    /**
     * 返回状态码
     */
    public final static String RETURN_CODE = "return_code";

    /**
     * 结果状态码
     */
    public final static String RESULT_CODE = "result_code";

    /**
     * 签名类型 MD5
     */
    public final static String SING_MD5 = "MD5";

    /**
     * 签名类型 HMAC-SHA256
     */
    public final static String SING_HMACSHA256 = "HMAC-SHA256";
}

微信参数配置类：WxProperties

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;

/**
 * @description 微信公众号开发配置类
 */
@Data
@Configuration
@ConfigurationProperties("demo.wx")
public class WxProperties {
    /**
     * 服务号APPID 
     */
    public String serviceAppId = "wxbe**************";

    /**
     * 服务号APP密码
     */
    public String serviceAppSecret = "31e6**************";

    /**
     * 商户号
     */
    public String mchId = "166*******";

    /**
     * API密钥
     */
    public String apiKey = "8061**************";

    /**
     * 统一下单-回调通知地址
     */
    public String notifyUrl = "http://www.demo.com/wxPay/native/orderNotify";

}

微信SHA1算法：WxSha1

import java.security.MessageDigest;

/**
 * @description 微信SHA1算法
 */
public class WxSha1 {
    private static final char[] HEX_DIGITS = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};

    /**
     * 将字节并格式化
     *
     * @param bytes 原始字节
     * @return 格式化字节
     */
    private static String getFormattedText(byte[] bytes) {
        int len = bytes.length;
        StringBuilder buf = new StringBuilder(len * 2);
        // 把密文转换成十六进制的字符串形式
        for (int j = 0; j < len; j++) {
            buf.append(HEX_DIGITS[(bytes[j] >> 4) & 0x0f]);
            buf.append(HEX_DIGITS[bytes[j] & 0x0f]);
        }
        return buf.toString();
    }

    public static String encode(String str) {
        if (str == null) {
            return null;
        }
        try {
            MessageDigest messageDigest = MessageDigest.getInstance("SHA1");
            messageDigest.update(str.getBytes());
            return getFormattedText(messageDigest.digest());
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

微信公众号接口工具类：WxUtil

import lombok.extern.slf4j.Slf4j;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import javax.servlet.http.HttpServletResponse;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import java.io.*;
import java.security.MessageDigest;
import java.util.*;

/**
 * @description 微信公众号接口工具类
 */

@Slf4j
public class WxUtil {

    /**
     * 加密/校验流程如下：
     * 1. 将token、timestamp、nonce 三个参数进行字典序排序
     * 2. 将三个参数字符串拼接成一个字符串进行 sha1 加密
     * 3. 开发者获得加密后的字符串可与 signature 对比，标识该请求来源于微信
     *
     * @param token     Token验证密钥
     * @param signature 微信加密签名，signature 结合了开发者填写的 token 参数和请求中的 timestamp 参数，nonce 参数
     * @param timestamp 时间戳
     * @param nonce     随机数
     * @return 验证成功返回：true, 失败返回：false
     */
    public static boolean checkSignature(String token, String signature, String timestamp, String nonce) {
        List<String> params = new ArrayList<String>();
        params.add(token);
        params.add(timestamp);
        params.add(nonce);
        //1. 将token、timestamp、nonce三个参数进行字典序排序
        Collections.sort(params, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.compareTo(o2);
            }
        });
        //2. 将三个参数字符串拼接成一个字符串进行sha1加密
        String temp = WxSha1.encode(params.get(0) + params.get(1) + params.get(2));
        //3. 开发者获得加密后的字符串可与signature对比，标识该请求来源于微信
        return temp.equals(signature);
    }

    /**
     * 输入流转化为字符串
     *
     * @param inputStream 流
     * @return String 字符串
     * @throws Exception
     */
    public static String getStreamString(InputStream inputStream) throws Exception {
        StringBuffer buffer = new StringBuffer();
        InputStreamReader inputStreamReader = null;
        BufferedReader bufferedReader = null;
        try {
            inputStreamReader = new InputStreamReader(inputStream, WxConstants.DEFAULT_CHARSET);
            bufferedReader = new BufferedReader(inputStreamReader);
            String line;
            while ((line = bufferedReader.readLine()) != null) {
                buffer.append(line);
            }
        } catch (Exception e) {
            throw new Exception();
        } finally {
            if (bufferedReader != null) {
                bufferedReader.close();
            }
            if (inputStreamReader != null) {
                inputStreamReader.close();
            }
            if (inputStream != null) {
                inputStream.close();
            }
        }
        return buffer.toString();
    }

    /**
     * 获取随机字符串 Nonce Str
     *
     * @return String 随机字符串
     */
    public static String getNonceStr() {
        return UUID.randomUUID().toString().replaceAll("-", "").substring(0, 32);
    }

    /**
     * 生成签名. 注意，若含有sign_type字段，必须和signType参数保持一致。
     *
     * @param data 待签名数据
     * @param key  API密钥
     * @return 签名
     */
    public static String getSignature(final Map<String, String> data, String key, String signType) throws Exception {
        Set<String> keySet = data.keySet();
        String[] keyArray = keySet.toArray(new String[keySet.size()]);
        Arrays.sort(keyArray);
        StringBuilder sb = new StringBuilder();
        for (String k : keyArray) {
            if (k.equals("sign")) {
                continue;
            }
            //参数值为空，则不参与签名
            if (data.get(k).trim().length() > 0) {
                sb.append(k).append("=").append(data.get(k).trim()).append("&");
            }
        }
        sb.append("key=").append(key);//加上key 再生成签名
        if (signType.equals(WxConstants.SING_MD5)) {
            return MD5(sb.toString()).toUpperCase();
        } else if (signType.equals(WxConstants.SING_HMACSHA256)) {
            return HmacSHA256(sb.toString(), key);
        } else {
            throw new Exception(String.format("Invalid sign_type: %s", signType));
        }
    }

    /**
     * 生成 MD5
     *
     * @param data 待处理数据
     * @return MD5结果
     */
    public static String MD5(String data) throws Exception {
        MessageDigest md = MessageDigest.getInstance("MD5");
        byte[] array = md.digest(data.getBytes("UTF-8"));
        StringBuilder sb = new StringBuilder();
        for (byte item : array) {
            sb.append(Integer.toHexString((item & 0xFF) | 0x100).substring(1, 3));
        }
        return sb.toString().toUpperCase();
    }

    /**
     * 生成 HmacSHA256
     *
     * @param data 待处理数据
     * @param key  密钥
     * @return 加密结果
     * @throws Exception
     */
    public static String HmacSHA256(String data, String key) throws Exception {
        Mac sha256_HMAC = Mac.getInstance("HmacSHA256");
        SecretKeySpec secret_key = new SecretKeySpec(key.getBytes("UTF-8"), "HmacSHA256");
        sha256_HMAC.init(secret_key);
        byte[] array = sha256_HMAC.doFinal(data.getBytes("UTF-8"));
        StringBuilder sb = new StringBuilder();
        for (byte item : array) {
            sb.append(Integer.toHexString((item & 0xFF) | 0x100).substring(1, 3));
        }
        return sb.toString().toUpperCase();
    }

    /**
     * 将Map转换为XML格式的字符串
     *
     * @param data Map类型数据
     * @return XML格式的字符串
     * @throws Exception
     */
    public static String mapToXml(Map<String, String> data) throws Exception {
        DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
        DocumentBuilder documentBuilder = documentBuilderFactory.newDocumentBuilder();
        org.w3c.dom.Document document = documentBuilder.newDocument();
        org.w3c.dom.Element root = document.createElement("xml");
        document.appendChild(root);
        for (String key : data.keySet()) {
            String value = data.get(key);
            if (value == null) {
                value = "";
            }
            value = value.trim();
            org.w3c.dom.Element filed = document.createElement(key);
            filed.appendChild(document.createTextNode(value));
            root.appendChild(filed);
        }
        TransformerFactory tf = TransformerFactory.newInstance();
        Transformer transformer = tf.newTransformer();
        DOMSource source = new DOMSource(document);
        transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
        transformer.setOutputProperty(OutputKeys.INDENT, "yes");
        StringWriter writer = new StringWriter();
        StreamResult result = new StreamResult(writer);
        transformer.transform(source, result);
        String output = writer.getBuffer().toString(); //.replaceAll("\n|\r", "");
        try {
            writer.close();
        } catch (Exception ex) {
        }
        return output;
    }

    /**
     * 处理 HTTPS API返回数据，转换成Map对象。return_code为SUCCESS时，验证签名。
     *
     * @param xmlStr API返回的XML格式数据
     * @return Map类型数据
     * @throws Exception
     */
    public static Map<String, String> processResponseXml(String xmlStr, String signType, String apiKey) throws Exception {
        String RETURN_CODE = WxConstants.RETURN_CODE;
        String return_code;
        Map<String, String> respData = xmlToMap(xmlStr);
        if (respData.containsKey(RETURN_CODE)) {
            return_code = respData.get(RETURN_CODE);
        } else {
            throw new Exception(String.format("No `return_code` in XML: %s", xmlStr));
        }

        if (return_code.equals("FAIL")) {
            return respData;
        } else if (return_code.equals("SUCCESS")) {
            //如果通信正常 验证签名
            if (isResponseSignatureValid(respData, signType,apiKey)) {
                return respData;
            } else {
                throw new Exception(String.format("Invalid sign value in XML: %s", xmlStr));
            }
        } else {
            throw new Exception(String.format("return_code value %s is invalid in XML: %s", return_code, xmlStr));
        }
    }


    /**
     * XML格式字符串转换为Map
     *
     * @param strXML XML字符串
     * @return XML数据转换后的Map
     * @throws Exception
     */
    public static Map<String, String> xmlToMap(String strXML) throws Exception {
        try {
            Map<String, String> data = new HashMap<String, String>();
            DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();

            String FEATURE = "http://apache.org/xml/features/disallow-doctype-decl";
            documentBuilderFactory.setFeature(FEATURE, true);

            FEATURE = "http://xml.org/sax/features/external-general-entities";
            documentBuilderFactory.setFeature(FEATURE, false);

            FEATURE = "http://xml.org/sax/features/external-parameter-entities";
            documentBuilderFactory.setFeature(FEATURE, false);

            FEATURE = "http://apache.org/xml/features/nonvalidating/load-external-dtd";
            documentBuilderFactory.setFeature(FEATURE, false);

            documentBuilderFactory.setXIncludeAware(false);
            documentBuilderFactory.setExpandEntityReferences(false);
            DocumentBuilder documentBuilder = documentBuilderFactory.newDocumentBuilder();
            InputStream stream = new ByteArrayInputStream(strXML.getBytes("UTF-8"));
            org.w3c.dom.Document doc = documentBuilder.parse(stream);
            doc.getDocumentElement().normalize();
            NodeList nodeList = doc.getDocumentElement().getChildNodes();
            for (int idx = 0; idx < nodeList.getLength(); ++idx) {
                Node node = nodeList.item(idx);
                if (node.getNodeType() == Node.ELEMENT_NODE) {
                    org.w3c.dom.Element element = (org.w3c.dom.Element) node;
                    data.put(element.getNodeName(), element.getTextContent());
                }
            }
            try {
                stream.close();
            } catch (Exception ex) {
                // do nothing
            }
            return data;
        } catch (Exception ex) {
            throw ex;
        }
    }

    /**
     * 判断xml数据的sign是否有效，必须包含sign字段，否则返回false。
     *
     * @param reqData 向wxpay post的请求数据
     * @return 签名是否有效
     * @throws Exception
     */
    private static boolean isResponseSignatureValid(final Map<String, String> reqData, String signType,String apiKey) throws Exception {
        // 返回数据的签名方式和请求中给定的签名方式是一致的 由于签名的时候加上了key 所以验证的时候也需要
        return isSignatureValid(reqData, apiKey, signType);
    }

    /**
     * 判断签名是否正确，必须包含sign字段，否则返回false。
     *
     * @param data     Map类型数据
     * @param key      API密钥
     * @param signType 签名方式
     * @return 签名是否正确
     * @throws Exception
     */
    public static boolean isSignatureValid(Map<String, String> data, String key, String signType) throws Exception {
        if (!data.containsKey("sign")) {
            return false;
        }
        String sign = data.get("sign");
        return getSignature(data, key, signType).equals(sign);
    }


    /**
     * 返回信息给微信 商户已经接收到回调
     *
     * @param response
     * @param content  内容
     * @throws Exception
     */
    public static void responsePrint(HttpServletResponse response, String content) throws Exception {
        response.setCharacterEncoding("UTF-8");
        response.setContentType("text/xml");
        response.getWriter().print(content);
        response.getWriter().flush();
        response.getWriter().close();
    }
}

订单实体类：TenantOrder

import com.baomidou.mybatisplus.annotation.TableName;
import com.fasterxml.jackson.annotation.JsonInclude;
import lombok.Data;
import lombok.experimental.Accessors;

import java.math.BigDecimal;


@Data
@TableName(value = "tenant_order")
public class TenantOrder {

    private String no; // 订单号
    private String tenantId;// 租户ID
    private String describe;// 描述
    private BigDecimal fee;// 费用
    private String productId;// 商品ID
    private String clintIp;// 订单支付端ip
}

微信支付Service：WxPayService

/**
 * 微信支付类接口
 */
public interface WxPayService {

    /**
     * 生成支付二维码URL
     *
     * @param tenantOrder    订单类
     * @param signType 签名类型
     * @throws Exception
     */
    ResultData wxPayUrl(TenantOrder tenantOrder, String signType) throws Exception;

    /**
     * 查询微信订单
     *
     * @param orderNo  订单号
     * @param signType 签名类型
     * @return
     */
    ResultData wxOrderQuery(String orderNo, String signType) throws Exception;

    /**
     * 关闭微信支付订单
     *
     * @param orderNo  订单号
     * @param signType 签名类型
     * @return
     */
    ResultData wxCloseOrder(String orderNo, String signType) throws Exception;
}

微信支付ServiceImpl：WxPayServiceImpl

import cn.hutool.http.HttpUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.math.BigDecimal;
import java.util.HashMap;
import java.util.Map;

/**
 * @description 微信支付实现类
 */
@Service("wxPayService")
@Slf4j
public class WxPayServiceImpl implements WxPayService {

    @Autowired
    private WxProperties wxProperties;

    @Override
    public ResultData wxPayUrl(TenantOrder tenantOrder, String signType) throws Exception {
        HashMap<String, String> data = new HashMap<String, String>();
        //公众账号ID
        data.put("appid", wxProperties.getServiceAppId());
        //商户号
        data.put("mch_id", wxProperties.getMchId());
        //随机字符串
        data.put("nonce_str", WxUtil.getNonceStr());
        //订单描述
        data.put("body", tenantOrder.getDescribe());
        //商户订单号
        data.put("out_trade_no", tenantOrder.getNo());
        //附加数据（附加参数租户id）
        data.put("attach",tenantOrder.getTenantId());
        //支付币种
        data.put("fee_type", "CNY");
        //订单金额(精确到分不含小数点)
        BigDecimal fee = tenantOrder.getFee();
        int intTotalFee = fee.multiply(new BigDecimal(100)).intValue();
        data.put("total_fee", String.valueOf(intTotalFee));
        //用户的IP
        data.put("spbill_create_ip", tenantOrder.getClintIp());
        //通知地址
        data.put("notify_url", wxProperties.getNotifyUrl());
        //交易类型
        data.put("trade_type", "NATIVE");
        //签名类型
        data.put("sign_type", signType);
        //商品id
        data.put("product_id", tenantOrder.getProductId());
        //签名
        data.put("sign", WxUtil.getSignature(data, wxProperties.getApiKey(), signType));

        String requestXML = WxUtil.mapToXml(data);
        String responseString =  HttpUtil.post(WxConstants.PAY_UNIFIEDORDER,requestXML);
        //解析返回的xml
        Map<String, String> resultMap = WxUtil.processResponseXml(responseString, signType,wxProperties.getApiKey());
        log.info(">>>>>>>>解析统一下单返回数据：" + resultMap);
        if (resultMap.get(WxConstants.RETURN_CODE).equals("SUCCESS")) {
            if(resultMap.get(WxConstants.RESULT_CODE).equals("FAIL")){
                // 调用成功后结果异常
                return ResultData.failed(resultMap.get("err_code_des"));
            }
            return ResultData.succeed(resultMap.get("code_url"));
        }else{
            return ResultData.failed(resultMap.get("return_msg"));
        }
    }

    @Override
    public ResultData wxOrderQuery(String orderNo, String signType) throws Exception {
        HashMap<String, String> data = new HashMap<String, String>();
        //公众账号ID
        data.put("appid", wxProperties.getServiceAppId());
        //商户号
        data.put("mch_id", wxProperties.getMchId());
        //随机字符串
        data.put("nonce_str", WxUtil.getNonceStr());
        //商户订单号
        data.put("out_trade_no", orderNo);
        //签名类型
        data.put("sign_type", signType);
        //签名
        data.put("sign", WxUtil.getSignature(data, wxProperties.getApiKey(), signType));
        String requestXML = WxUtil.mapToXml(data);
        String responseString =  HttpUtil.post(WxConstants.PAY_ORDERQUERY,requestXML);
        //解析返回的xml
        Map<String, String> resultMap = WxUtil.processResponseXml(responseString, signType,wxProperties.getApiKey());
        log.info(">>>>>>>>解析订单查询返回数据：" + resultMap);
        if (resultMap.get(WxConstants.RETURN_CODE).equals("SUCCESS")) {
            /**
             * 订单支付状态
             * SUCCESS—支付成功
             * REFUND—转入退款
             * NOTPAY—未支付
             * CLOSED—已关闭
             * REVOKED—已撤销（刷卡支付）
             * USERPAYING--用户支付中
             * PAYERROR--支付失败(其他原因，如银行返回失败)
             */
            return ResultData.succeed(resultMap.get("trade_state"));
        }else{
            return ResultData.failed(resultMap.get("return_msg"));
        }
    }


    @Override
    public ResultData wxCloseOrder(String orderNo, String signType) throws Exception {
        HashMap<String, String> data = new HashMap<String, String>();
        //公众账号ID
        data.put("appid", wxProperties.getServiceAppId());
        //商户号
        data.put("mch_id", wxProperties.getMchId());
        //随机字符串
        data.put("nonce_str", WxUtil.getNonceStr());
        //商户订单号
        data.put("out_trade_no", orderNo);
        //签名类型
        data.put("sign_type", signType);
        //签名 签名中加入key
        data.put("sign", WxUtil.getSignature(data, wxProperties.getApiKey(), signType));
        String requestXML = WxUtil.mapToXml(data);
        String responseString =  HttpUtil.post(WxConstants.PAY_CLOSEORDER,requestXML);
        //解析返回的xml
        Map<String, String> resultMap = WxUtil.processResponseXml(responseString, signType,wxProperties.getApiKey());
        log.info(">>>>>>>>解析订单关闭返回数据：" + resultMap);
        if (resultMap.get(WxConstants.RETURN_CODE).equals("SUCCESS")) {
            /**
             * 关闭订单状态
             * SUCCESS—关闭成功
             * FAIL—关闭失败
             */
            return ResultData.succeed(resultMap.get("result_code"));
        }else{
            return ResultData.failed(resultMap.get("return_msg"));
        }
    }
}

微信支付Controller：WxPayController

import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.Map;

/**
 * @description 微信扫码支付下单生成支付地址接口
 *
 * 微信支付接口官方文档地址:https://pay.weixin.qq.com/wiki/doc/api/native.php?chapter=6_5
 * 微信扫码支付（模式二）说明:
 * 1.商户调用微信统一下单接口生成订单获取二维码链接 code_url (请求参数请见官方文档)
 * 3.请求参数中的 notify_url 为用户支付成功后, 微信服务端回调商户的接口地址
 * 4.根据微信返回的 code_url 生成二维码
 * 5.用户使用微信扫码进行支付
 * 6.支付成功后, 微信服务端会调用 notify_url 通知商户支付结果
 * 7.商户接到通知后, 执行业务操作(修改订单状态等)并告知微信服务端接收通知成功
 */
@Slf4j
@RestController
@RequestMapping("/wxPay")
public class WxPayController {
    @Autowired
    private WxProperties wxProperties;
    @Resource
    private WxPayService wxPayService;

    /**
     * @description 微信支付统一下单-生成付款URL
     *
     * 1.请求微信预下单接口
     * 2.根据预下单返回的 code_url 生成提供给前端生成二维码
     */
    @PostMapping(value = {"/native/payUrl"})
    public ResultData payUrl(@RequestBody TenantOrder tenantOrder) throws Exception {
        // 参数校验
        if(null != tenantOrder){
            String no = tenantOrder.getNo();
            if(StringUtils.isEmpty(no)){
                return ResultData.failed("订单号不能为空!");
            }
            // todo 此处处理业务相关数据

            //获取二维码链接
            return wxPayService.wxPayUrl(tenantOrder, WxConstants.SING_MD5);
        }
        return ResultData.failed("订单参数异常!");
    }

    /**
     * @description 扫码支付回调接口
     *
     * 1.用户支付成功后
     * 2.微信回调该方法
     */
    @PostMapping(value = {"/native/orderNotify"})
    @Transactional
    public void orderNotify(HttpServletRequest request, HttpServletResponse response) throws Exception {
        log.info(">>>>>>>>微信支付回调start");
        String xmlContent = "<xml>" +
                "<return_code><![CDATA[FAIL]]></return_code>" +
                "<return_msg><![CDATA[签名失败]]></return_msg>" +
                "</xml>";

        try {
            String requestXml = WxUtil.getStreamString(request.getInputStream());
            log.info(">>>>>>>>微信支付回调返回数据requestXml：" + requestXml);
            Map<String, String> map = WxUtil.xmlToMap(requestXml);
            String returnCode = map.get(WxConstants.RETURN_CODE);
            // 成功支付
            if (StringUtils.isNotBlank(returnCode) && StringUtils.equals(returnCode, "SUCCESS") && WxUtil.isSignatureValid(map, wxProperties.getApiKey(), WxConstants.SING_MD5)) {
                // todo 此处处理支付成功后订单相关业务逻辑

                // 给微信的应答xml通过response回写
                xmlContent = "<xml>" +
                        "<return_code><![CDATA[SUCCESS]]></return_code>" +
                        "<return_msg><![CDATA[OK]]></return_msg>" +
                        "</xml>";
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        WxUtil.responsePrint(response, xmlContent);
        log.info(">>>>>>>>微信支付回调end");
    }

    /**
     * @description 前台页面定时器查询是否已支付(用来刷新页面)
     * 1.前台页面轮询
     * 2.查询订单支付状态
     */
    @RequestMapping(value = {"/native/payStatus"})
    @ResponseBody
    public ResultData payStatus(@RequestBody TenantOrder tenantOrder) {
        if(null != tenantOrder){
            // todo 获取订单状态业务
            return ResultData.succeed("支付成功");
        }
        return ResultData.failed("参数异常！");
    }

    /**
     * 微信支付订单查询
     * 1.如果由于网络通信问题 导致微信没有通知到商户支付结果
     * 2.商户主动去查询支付结果 而后执行其他业务操作
     */
    @RequestMapping(value = {"/native/orderQuery"})
    @ResponseBody
    public ResultData orderQuery( @RequestBody TenantOrder tenantOrder) throws Exception {
        String no = tenantOrder.getNo();
        if(StringUtils.isNotEmpty(no)){
            return wxPayService.wxOrderQuery(no, WxConstants.SING_MD5);
        }
        return ResultData.failed("订单号异常！");
    }

    /**
     * 关闭微信支付订单
     * 1.商户订单支付失败需要生成新单号重新发起支付，要对原订单号调用关单，避免重复支付
     * 2.系统下单后，用户支付超时，系统退出不再受理，避免用户继续，请调用关单接口
     */
    @PostMapping(value = {"/native/closeOrder"})
    @ResponseBody
    public ResultData closeOrder( @RequestBody TenantOrder tenantOrder) throws Exception {
        String no = tenantOrder.getNo();
        if(StringUtils.isNotEmpty(no)){
            return wxPayService.wxCloseOrder(no, WxConstants.SING_MD5);
        }
        return ResultData.failed("订单号异常！");
    }
}

注意问题

付款成功后微信不回调系统，可以按照以下几点检查，

1，检查回调url是否正确，回调url是不能带参数的，请注意。
2，是否有按照文档要求正确返回参数给到微信。

<xml>
    <return_code>
        <![CDATA[SUCCESS]]>
    </return_code>
    <return_msg>
        <![CDATA[OK]]>
    </return_msg>
</xml>

3，是否开启了防火墙把微信的通知给屏蔽了。

4，是否响应超时。

5、核实是否有安全策略拦截微信支付回调通知

6，是否正确使用post请求。

7，回调url修改成http协议试试。