Native扫码支付

开发步骤：

• 1.开发平台账号申请（已拥有请忽略）
• 2.开通支付（审核过程需要6-7个工作日）
• 3.下载开发平台支付DEMO,进行相关工具类的提取即学习（也可以通过继承WXPayConfig配置直接引用SDK）
• 4.阅读接口文档及注意事项，微信商户平台扫码支付文档

Native支付开通申请设置流程：

• 1.首先进行Native类型支付申请（微信扫码支付）

  
  
  点击支付产品进行选择

• 2.申请开通

  
  

• 3.填入你的回调地址,提交审核(回调地址后期可以修改)

  
  
  申请过程

• 4.申请成功进行相应回调地址设置

  
  
  产品设置
  
  
  注意事项

阅读接口文档进行开发：

• 1.下载API对应的SDK和调用示例，提取部分有用的代码放入项目中

所需要的工具类

WXPayConstants类

/**
 * 常量
 */
public class WXPayConstants {
    public enum SignType {
        MD5, HMACSHA256
    }
    public static final String FIELD_SIGN = "sign";
}

WXPayXmlUtil类

import org.w3c.dom.Document;
import javax.xml.XMLConstants;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import java.io.ByteArrayOutputStream;
import java.io.InputStream;


public final class WXPayXmlUtil {

    /**
     * XML解析
     *
     * @param inStream 微信发的流信息
     * @param encoding 编码格式
     * @return
     */
    public static String inputStream2String(InputStream inStream, String encoding) {
        String result = null;
        ByteArrayOutputStream outStream = null;
        try {
            if (inStream != null) {
                outStream = new ByteArrayOutputStream();
                byte[] tempBytes = new byte[1024];
                int count = 0;
                while ((count = inStream.read(tempBytes)) != -1) {
                    outStream.write(tempBytes, 0, count);
                }
                tempBytes = null;
                outStream.flush();
                result = new String(outStream.toByteArray(), encoding);
                outStream.close();
            }
        } catch (Exception e) {
            result = null;
        }
        return result;
    }

    public static DocumentBuilder newDocumentBuilder() throws ParserConfigurationException {
        DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
        documentBuilderFactory.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
        documentBuilderFactory.setFeature("http://xml.org/sax/features/external-general-entities", false);
        documentBuilderFactory.setFeature("http://xml.org/sax/features/external-parameter-entities", false);
        documentBuilderFactory.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", false);
        documentBuilderFactory.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, true);
        documentBuilderFactory.setXIncludeAware(false);
        documentBuilderFactory.setExpandEntityReferences(false);

        return documentBuilderFactory.newDocumentBuilder();
    }

    public static Document newDocument() throws ParserConfigurationException {
        return newDocumentBuilder().newDocument();
    }
}

WXPayUtil类

import com.itcast.dormmanagesys.utils.pay.WXPayConstants.SignType;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import javax.xml.parsers.DocumentBuilder;
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.ByteArrayInputStream;
import java.io.InputStream;
import java.io.StringWriter;
import java.security.MessageDigest;
import java.security.SecureRandom;
import java.util.*;

public class WXPayUtil {

    private static final String SYMBOLS = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";

    private static final Random RANDOM = new SecureRandom();

    /**
     * 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>();
            DocumentBuilder documentBuilder = WXPayXmlUtil.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) {
            WXPayUtil.getLogger().warn("Invalid XML, can not convert to map. Error message: {}. XML content: {}", ex.getMessage(), strXML);
            throw ex;
        }

    }

    /**
     * 将Map转换为XML格式的字符串
     *
     * @param data Map类型数据
     * @return XML格式的字符串
     * @throws Exception
     */
    public static String mapToXml(Map<String, String> data) throws Exception {
        org.w3c.dom.Document document = WXPayXmlUtil.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;
    }

    /**
     * 生成带有 sign 的 XML 格式字符串
     *
     * @param data Map类型数据
     * @param key  API密钥
     * @return 含有sign字段的XML
     */
    public static String generateSignedXml(final Map<String, String> data, String key) throws Exception {
        return generateSignedXml(data, key, SignType.MD5);
    }

    /**
     * 生成带有 sign 的 XML 格式字符串
     *
     * @param data     Map类型数据
     * @param key      API密钥
     * @param signType 签名类型
     * @return 含有sign字段的XML
     */
    public static String generateSignedXml(final Map<String, String> data, String key, SignType signType) throws Exception {
        String sign = generateSignature(data, key, signType);
        data.put(WXPayConstants.FIELD_SIGN, sign);
        return mapToXml(data);
    }

    /**
     * 判断签名是否正确
     *
     * @param xmlStr XML格式数据
     * @param key    API密钥
     * @return 签名是否正确
     * @throws Exception
     */
    public static boolean isSignatureValid(String xmlStr, String key) throws Exception {
        Map<String, String> data = xmlToMap(xmlStr);
        if (!data.containsKey(WXPayConstants.FIELD_SIGN)) {
            return false;
        }
        String sign = data.get(WXPayConstants.FIELD_SIGN);
        return generateSignature(data, key).equals(sign);
    }

    /**
     * 判断签名是否正确，必须包含sign字段，否则返回false。使用MD5签名。
     *
     * @param data Map类型数据
     * @param key  API密钥
     * @return 签名是否正确
     * @throws Exception
     */
    public static boolean isSignatureValid(Map<String, String> data, String key) throws Exception {
        return isSignatureValid(data, key, SignType.MD5);
    }

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

    /**
     * 生成签名
     *
     * @param data 待签名数据
     * @param key  API密钥
     * @return 签名
     */
    public static String generateSignature(final Map<String, String> data, String key) throws Exception {
        return generateSignature(data, key, SignType.MD5);
    }

    /**
     * 生成签名. 注意，若含有sign_type字段，必须和signType参数保持一致。
     *
     * @param data     待签名数据
     * @param key      API密钥
     * @param signType 签名方式
     * @return 签名
     */
    public static String generateSignature(final Map<String, String> data, String key, SignType 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(WXPayConstants.FIELD_SIGN)) {
                continue;
            }
            if (data.get(k).trim().length() > 0) // 参数值为空，则不参与签名
                sb.append(k).append("=").append(data.get(k).trim()).append("&");
        }
        sb.append("key=").append(key);
        if (SignType.MD5.equals(signType)) {
            return MD5(sb.toString()).toUpperCase();
        } else if (SignType.HMACSHA256.equals(signType)) {
            return HMACSHA256(sb.toString(), key);
        } else {
            throw new Exception(String.format("Invalid sign_type: %s", signType));
        }
    }

    /**
     * 获取随机字符串 Nonce Str
     *
     * @return String 随机字符串
     */
    public static String generateNonceStr() {
        char[] nonceChars = new char[32];
        for (int index = 0; index < nonceChars.length; ++index) {
            nonceChars[index] = SYMBOLS.charAt(RANDOM.nextInt(SYMBOLS.length()));
        }
        return new String(nonceChars);
    }

    /**
     * 生成 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();
    }

    /**
     * 日志
     *
     * @return
     */
    public static Logger getLogger() {
        Logger logger = LoggerFactory.getLogger("wxpay java sdk");
        return logger;
    }

    /**
     * 获取当前时间戳，单位秒
     *
     * @return
     */
    public static long getCurrentTimestamp() {
        return System.currentTimeMillis() / 1000;
    }

    /**
     * 获取当前时间戳，单位毫秒
     *
     * @return
     */
    public static long getCurrentTimestampMs() {
        return System.currentTimeMillis();
    }

}

• 2.相应后端代码如下：

import com.itcast.commom.util.Result;
import com.itcast.commom.util.ResultEnum;
import com.itcast.dormmanagesys.utils.pay.Httpclient;
import com.itcast.dormmanagesys.utils.pay.SystemUtil;
import com.itcast.dormmanagesys.utils.pay.WXPayUtil;
import com.itcast.dormmanagesys.utils.pay.WXPayXmlUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.InputStream;
import java.net.URLEncoder;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;

/**
 * 功能描述：
 *
 * @authro JIAQI
 * @date 2019/11/6 - 10:36
 */
@Slf4j
@Controller
@RequestMapping("/wechat/pay")
public class PayController {
    //公众账号ID
    final private String appid = "你的公众账号ID";
    //商户号
    final private String mch_id = "你的开放平台商户号";
    /*商户密钥*/
    final private String mch_Key = "你的开放平台商户密钥";
    //商品ID（这里写死了,若用到请自行修改使用随机数等等）
    final private String product_id = "CS20191133344";
    //异步回调地址
    final private String notify_url = "你的异步回调地址";

    /**
     * 扫码异步回调地址
     *
     * @param request
     * @param response
     * @return
     */
    @PostMapping("/paycallback")
    public String payCallBack(HttpServletRequest request,
                              HttpServletResponse response) {
        InputStream is = null;
        try {
            //获取请求的异步回调信息
            is = request.getInputStream();
            String xml = WXPayXmlUtil.inputStream2String(is, "UTF-8");
            final Map<String, String> map = WXPayUtil.xmlToMap(xml);
            //判断是否支付成功 业务结果：SUCCESS/FAIL
            if ("SUCCESS".equals(map.get("result_code"))) {
                //公众账号ID
                map.get("appid");
                //商户号
                map.get("mch_id");
                //随机字符串
                map.get("nonce_str");
                //签名
                map.get("sign");
                //用户标识
                map.get("openid");
                //是否关注公众账号
                map.get("is_subscribe");
                //交易类型
                map.get("trade_type");
                //付款银行
                map.get("bank_type");
                //订单金额
                map.get("total_fee");
                //货币种类
                map.get("fee_type");
                //现金支付金额
                map.get("cash_fee");
                //微信支付订单号
                map.get("transaction_id");
                //商户订单号
                map.get("out_trade_no");
                //支付完成时间
                map.get("time_end");
            }
            //回复微信服务器信息
            response.getWriter().write("<xml><return_code><![CDATA[SUCCESS]]></return_code></xml>");
            is.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 检验是否支付成功
     *
     * @param out_trade_no 订单号
     * @return 支付结果
     */
    private final String orderqueryURL = "https://api.mch.weixin.qq.com/pay/orderquery";

    @PostMapping("/queryOrder")
    @ResponseBody
    public Result ajaxCheckPay(@RequestBody String out_trade_no) {
        log.info("【所需校验支付状态的订单号】:{}", out_trade_no);
        Map<String, String> reqData = new HashMap<String, String>();
        try {
            reqData.put("appid", appid);
            reqData.put("mch_id", mch_id);
            reqData.put("out_trade_no", out_trade_no);
            reqData.put("nonce_str", WXPayUtil.generateNonceStr());
            //签名
            String sign = WXPayUtil.generateSignature(reqData, mch_Key);
            reqData.put("sign", sign);
            //XML转义即可
            String xml = WXPayUtil.mapToXml(reqData);
            String xmlStr = Httpclient.doPostJson(orderqueryURL, xml);
            final Map<String, String> map = WXPayUtil.xmlToMap(xmlStr);
            /*交易状态:
             *SUCCESS—支付成功
             *REFUND—转入退款
             *NOTPAY—未支付
             *CLOSED—已关闭
             *REVOKED—已撤销（付款码支付）
             * USERPAYING--用户支付中（付款码支付）
             */
            if ("SUCCESS".equals(map.get("trade_state"))) {
                log.info("【订单支付成功】:{}", out_trade_no);
                return Result.success();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return Result.failure(ResultEnum.FAILURE);
    }

    /**
     * 下单获取二维码
     *
     * @param request
     * @param model
     * @return
     */
    private final String unifiedorderURL = "https://api.mch.weixin.qq.com/pay/unifiedorder";

    @GetMapping("/pay")
    public String pay(HttpServletRequest request, Model model) {
        String code_url = null;
        try {
            Map<String, String> reqData = new HashMap<String, String>();
            //公众账号ID
            reqData.put("appid", appid);
            //商户号
            reqData.put("mch_id", mch_id);
            //随机字符串
            reqData.put("nonce_str", WXPayUtil.generateNonceStr());
            //商品描述
            reqData.put("body", "测试PC端支付");
            //商户订单号
            reqData.put("out_trade_no", product_id);
            //标价金额 / 分
            reqData.put("total_fee", "1");
            //终端IP
            reqData.put("spbill_create_ip", SystemUtil.getIpAddress(request));
//            //交易起始时间
//            final String dateStart = DateUtil.getDate(new Date(), DateStyle.YYYYMMDDHHMMSS);
//            reqData.put("time_start", dateStart);
//            System.out.println(dateStart);
//            //交易结束时间
//            reqData.put("time_expire", DateUtil.addMinute(dateStart, 2));
            //通知地址
            reqData.put("notify_url", notify_url);
            //交易类型
            reqData.put("trade_type", "NATIVE");
            //签名
            String sign = WXPayUtil.generateSignature(reqData, mch_Key);
            reqData.put("sign", sign);
            //XML转义即可
            String xml = WXPayUtil.mapToXml(reqData);
            String xmlStr = Httpclient.doPostJson(unifiedorderURL, xml);
            final Map<String, String> map = WXPayUtil.xmlToMap(xmlStr);
            if ("SUCCESS".equals(map.get("result_code")) && "OK".equals(map.get("return_msg"))) {
                code_url = map.get("code_url");
            }
            System.out.println(code_url);
        } catch (Exception e) {
            e.printStackTrace();
        }
        //二维码URL
        model.addAttribute("code_url", code_url);
        System.out.println(product_id);
        //订单号
        model.addAttribute("out_tradeno", product_id);
        return "/pay";
    }

• 3.相应工具类如下：

HttpClient工具类、pom依赖

 <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
            <version>4.5.3</version>
        </dependency>

import org.apache.http.NameValuePair;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.utils.URIBuilder;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;

import java.io.IOException;
import java.net.URI;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

public class Httpclient {

    public static String doGet(String url, Map<String, String> param) {

        // 创建Httpclient对象
        CloseableHttpClient httpclient = HttpClients.createDefault();

        String resultString = "";
        CloseableHttpResponse response = null;
        try {
            // 创建uri
            URIBuilder builder = new URIBuilder(url);
            if (param != null) {
                for (String key : param.keySet()) {
                    builder.addParameter(key, param.get(key));
                }
            }
            URI uri = builder.build();

            // 创建http GET请求
            HttpGet httpGet = new HttpGet(uri);

            // 执行请求
            response = httpclient.execute(httpGet);
            // 判断返回状态是否为200
            if (response.getStatusLine().getStatusCode() == 200) {
                resultString = EntityUtils.toString(response.getEntity(), "UTF-8");
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (response != null) {
                    response.close();
                }
                httpclient.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return resultString;
    }

    public static String doGet(String url) {
        return doGet(url, null);
    }

    public static String doPost(String url, Map<String, String> param) {
        // 创建Httpclient对象
        CloseableHttpClient httpClient = HttpClients.createDefault();
        CloseableHttpResponse response = null;
        String resultString = "";
        try {
            // 创建Http Post请求
            HttpPost httpPost = new HttpPost(url);
            // 创建参数列表
            if (param != null) {
                List<NameValuePair> paramList = new ArrayList<>();
                for (String key : param.keySet()) {
                    paramList.add(new BasicNameValuePair(key, param.get(key)));
                }
                // 模拟表单
                UrlEncodedFormEntity entity = new UrlEncodedFormEntity(paramList,"utf-8");
                httpPost.setEntity(entity);
            }
            // 执行http请求
            response = httpClient.execute(httpPost);
            resultString = EntityUtils.toString(response.getEntity(), "utf-8");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                response.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

        return resultString;
    }

    public static String doPost(String url) {
        return doPost(url, null);
    }

    public static String doPostJson(String url, String json) {
        // 创建Httpclient对象
        CloseableHttpClient httpClient = HttpClients.createDefault();
        CloseableHttpResponse response = null;
        String resultString = "";
        try {
            // 创建Http Post请求
            HttpPost httpPost = new HttpPost(url);
            // 创建请求内容
            StringEntity entity = new StringEntity(json, ContentType.APPLICATION_JSON);
            httpPost.setEntity(entity);
            // 执行http请求
            response = httpClient.execute(httpPost);
            resultString = EntityUtils.toString(response.getEntity(), "utf-8");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                response.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

        return resultString;
    }
}

系统工具类(用来获取ip地址)

package com.itcast.dormmanagesys.utils.pay;

import javax.servlet.http.HttpServletRequest;

/**
 * 功能描述：
 *
 * @authro JIAQI
 * @date 2019/7/18 - 17:55
 */
public class SystemUtil {

    /**
     * 获取用户真实IP地址，不使用request.getRemoteAddr();的原因是有可能用户使用了代理软件方式避免真实IP地址,
     * 可是，如果通过了多级反向代理的话，X-Forwarded-For的值并不止一个，而是一串IP值，究竟哪个才是真正的用户端的真实IP呢？
     * 答案是取X-Forwarded-For中第一个非unknown的有效IP字符串。
     * 如：X-Forwarded-For：192.168.1.110, 192.168.1.120, 192.168.1.130,
     * 192.168.1.100
     * 用户真实IP为： 192.168.1.110
     *
     * @param request
     * @return
     */
    public static String getIpAddress(HttpServletRequest request) {
        String ip = request.getHeader("x-forwarded-for");
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("Proxy-Client-IP");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("WL-Proxy-Client-IP");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("HTTP_CLIENT_IP");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("HTTP_X_FORWARDED_FOR");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getRemoteAddr();
        }
        return ip;
    }
}

• 4.相应前端代码如下：

页面中的二维码生成是使用qrcode.js生成的，可在此GitHub使用文档地址中进行下载

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <title>内嵌式——PC支付</title>
    <script th:src="@{/commom/js/jquery.min.js}"></script>
    <script th:src="@{/js/qrcode.js}"></script>
</head>
<body>
<div id="code"></div>
<div id="succer" hidden>支付成功</div>
</body>
<script>
    var qrcode = new QRCode(document.getElementById("code"), {
        width: 200,//设置宽高
        height: 200
    });
    qrcode.makeCode('[[${code_url}]]');

    //ajax长轮询 5s 循环一次
    var siv = setInterval(function () {
        $.ajax({
            type: "POST",
            url: "/wechat/pay/queryOrder",
            data: '[[${out_tradeno}]]',
            dataType: 'json',
            contentType: 'application/json',
            success: function (res) {
                if (res.code == 0) {
                    $("#code").hide();
                    $("#succer").show();
                    clearInterval(siv); //成功后
                }
            }, error: function () {
            }
        })
    }, 5000);

</script>
</html>

开发即注意事项：

• 1.在配置开放平台回调的时候注意不要回调的全地址，写网站地址即可

附录：

①：写法有很多种，个人觉得如果有多余的可以使用Websocket的方式进行支付成功通知,Websocket相比于Ajax长轮询会在性能上有所提升，避免每次多余的前后端交互，可以参考下此Websocket写法进行替换。

②：在本人的笔记中采用了SDK中部分工具类提取的方式，移除了原SDK中一些用不上的代码（开发中也可参考其写法自行进行需要的接口封装），如果说需要用到支付中很多功能的朋友可以直接引用SDK的代码然后通过继承类WXPayConfig的方式进行调用SDK中WXPayUtil类中已写好的方法即可，官网的SDK对微信支付开发者文档中给出的API进行了封装。

SDK调用示例

配置类MyConfig:

import com.github.wxpay.sdk.WXPayConfig;
import java.io.*;

public class MyConfig implements WXPayConfig{

    private byte[] certData;

    public MyConfig() throws Exception {
        String certPath = "/path/to/apiclient_cert.p12";
        File file = new File(certPath);
        InputStream certStream = new FileInputStream(file);
        this.certData = new byte[(int) file.length()];
        certStream.read(this.certData);
        certStream.close();
    }

    public String getAppID() {
        return "wx8888888888888888";
    }

    public String getMchID() {
        return "12888888";
    }

    public String getKey() {
        return "88888888888888888888888888888888";
    }

    public InputStream getCertStream() {
        ByteArrayInputStream certBis = new ByteArrayInputStream(this.certData);
        return certBis;
    }

    public int getHttpConnectTimeoutMs() {
        return 8000;
    }

    public int getHttpReadTimeoutMs() {
        return 10000;
    }
}

统一下单：

import com.github.wxpay.sdk.WXPay;

import java.util.HashMap;
import java.util.Map;

public class WXPayExample {

    public static void main(String[] args) throws Exception {

        MyConfig config = new MyConfig();
        WXPay wxpay = new WXPay(config);

        Map<String, String> data = new HashMap<String, String>();
        data.put("body", "腾讯充值中心-QQ会员充值");
        data.put("out_trade_no", "2016090910595900000012");
        data.put("device_info", "");
        data.put("fee_type", "CNY");
        data.put("total_fee", "1");
        data.put("spbill_create_ip", "123.12.12.123");
        data.put("notify_url", "http://www.example.com/wxpay/notify");
        data.put("trade_type", "NATIVE");  // 此处指定为扫码支付
        data.put("product_id", "12");

        try {
            Map<String, String> resp = wxpay.unifiedOrder(data);
            System.out.println(resp);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}