微信支付之手機H5支付實踐

時間 2019-11-11

標籤微信支付手機 h5 實踐简体版

原文原文鏈接

　　最近項目中支付部分涉及到微信支付，使用的是h5支付，官方文檔中是沒有demo的，因此摸着石頭過河，將踩過的坑記錄以下。php

一應用場景

　　H5支付是指商戶在微信客戶端外的移動端網頁展現商品或服務，用戶在前述頁面確認使用微信支付時，商戶發起本服務呼起微信客戶端進行支付。主要用於觸屏版的手機瀏覽器請求微信支付的場景。能夠方便的從外部瀏覽器喚起微信支付。有關於h5支付接口詳細相關內容能夠參考官方文檔微信H5支付，本文主要記錄實現代碼及遇到的問題。git

二服務商模式介紹

　　服務商模式，適用於幫助其餘商戶接入微信支付的開發公司，該公司在微信開通的商戶稱爲服務商。服務商在商戶平臺的服務商配置裏，能夠幫助商戶提交公司或者個體戶的資料，申請經過後能夠得到特約商戶號和密碼，這個特約商戶也能夠稱爲是子商戶，服務商能夠對其下的子商戶的功能進行配置。這樣在一個服務商下面，能夠實現對不一樣的客戶提供微信支付服務，資金直接進入子商戶的微信帳戶中(或銀行對公戶中)。程序員

三實現代碼

1.調用微信統一下單接口

public class WxPay {

　　private static final Logger logger = Logger.getLogger(WxPay.class);

　　public Map<String,String> wxPay(HttpServletRequest request){
        // 帳號信息
        String appid = "";          // 公衆帳號ID
        String mch_id = "";         // 商戶號
        String sub_mch_id = "";     // 子商戶號
        String key = ""; 　　　　　　 // 微信密鑰key
        String nonce_str = creRandStr();    　　　　　　　　// 隨機字符串
        String body = "1";           　　　  　　　　　　　　// 商品描述
        String out_trade_no = "wxTest2";    　　　　　　　　// 商戶訂單號
        String total_fee = "1";      　　　  　　　　　　　　// 總金額,單位爲分
        String spbill_create_ip = getRealIp(request);    // 終端IP
        String notify_url = "";     　　　　　　　　　　　　 // 回調通知地址
        String trade_type = "MWEB"; 　　　　　　　　　　　　 // 交易類型,H5支付的交易類型爲MWEB
        String scene_info = "{\"h5_info\": {\"type\":\"Wap\",\"wap_url\": \"https://pay.qq.com\",\"wap_name\": \"騰訊充值\"}}";  // 場景信息，可參考官方文檔

        Map<String,String> packageParams = new HashMap<>();
        packageParams.put("appid",appid);                   　　　　// 公衆帳號ID
        packageParams.put("mch_id",mch_id);                 　　　　// 商戶號
        packageParams.put("sub_mch_id",sub_mch_id);         　　　　// 子商戶號
        packageParams.put("nonce_str",nonce_str);           　　　　// 隨機字符串
        packageParams.put("body",body);                     　　　　// 商品描述
        packageParams.put("out_trade_no",out_trade_no);     　　　　// 商戶訂單號
        packageParams.put("total_fee",total_fee);           　　　　// 總金額,單位爲分
        packageParams.put("spbill_create_ip",spbill_create_ip); 　 // 終端IP
        packageParams.put("notify_url",notify_url);         　　　　// 通知地址
        packageParams.put("trade_type",trade_type);         　　　　// 交易類型,H5支付的交易類型爲MWEB
        packageParams.put("scene_info",scene_info);         　　　　// 場景信息

        String sign = createSign(packageParams,key);           　　// 簽名
        packageParams.put("sign",sign);

        String xml = getRequestXml(packageParams);
        logger.info("xml-->" + xml);
        //請求微信統一下單接口，成功後返回預支付交易會話標識prepay_id
        String createOrderURL = "https://api.mch.weixin.qq.com/pay/unifiedorder";
        String result = getPayNo(createOrderURL,xml);　　　　　　//返回結果，String
　　　　　Map<String,String> result = doXMLParse(result);　　　　 //將返回結果解析封裝到Map中
        return resultMap;　　
    }

　　 public static String getPayNo(String url,String xmlParam){
        String prepay_id = "";
        String jsonStr = null;
        try {
            Map<String, String> querys = new HashMap<String, String>();
            Map<String, String> headers = new HashMap<String, String>();
            HttpResponse response = HttpUtils.doPost(url,"","POST",headers,querys,xmlParam);

            jsonStr = EntityUtils.toString(response.getEntity(), "UTF-8");
            Map<String, Object> dataMap = new HashMap<String, Object>();
            System.out.println("json是:"+jsonStr);

            Map map = doXMLParse(jsonStr);
            String return_code  = (String) map.get("return_code");
            prepay_id  = (String) map.get("prepay_id");
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return jsonStr;
    }
　　
　　 /**
     * 解析xml,返回第一級元素鍵值對。若是第一級元素有子節點，則此節點的值是子節點的xml數據。
     * @param strxml
     * @return
     * @throws JDOMException
     * @throws IOException
     */
    private static Map doXMLParse(String strxml) throws JDOMException,IOException {
        if(null == strxml || "".equals(strxml)) {
            return null;
        }

        Map m = new HashMap();
        InputStream in = new ByteArrayInputStream(strxml.getBytes());
        SAXBuilder builder = new SAXBuilder();
        Document doc = builder.build(in);
        Element root = doc.getRootElement();
        List list = root.getChildren();
        Iterator it = list.iterator();
        while(it.hasNext()) {
            Element e = (Element) it.next();
            String k = e.getName();
            String v = "";
            List children = e.getChildren();
            if(children.isEmpty()) {
                v = e.getTextNormalize();
            } else {
                v = getChildrenText(children);
            }
            m.put(k, v);
        }
        //關閉流
        in.close();
        return m;
    }

　　    /**
     * 獲取子結點的xml
     * @param children
     * @return String
     */
    private static String getChildrenText(List children) {
        StringBuffer sb = new StringBuffer();
        if(!children.isEmpty()) {
            Iterator it = children.iterator();
            while(it.hasNext()) {
                Element e = (Element) it.next();
                String name = e.getName();
                String value = e.getTextNormalize();
                List list = e.getChildren();
                sb.append("<" + name + ">");
                if(!list.isEmpty()) {
                    sb.append(getChildrenText(list));
                }
                sb.append(value);
                sb.append("</" + name + ">");
            }
        }
        return sb.toString();
    }

    /**
     * 將請求參數轉換爲xml格式的string
     * @param parameters 請求參數
     * @return
     */
    private static String getRequestXml(Map<String, String> parameters) {
        StringBuffer sb = new StringBuffer();
        sb.append("<xml>");
        Set es = parameters.entrySet();
        Iterator it = es.iterator();
        while (it.hasNext()) {
            Map.Entry entry = (Map.Entry) it.next();
            String k = (String) entry.getKey();
            String v = (String) entry.getValue();
            if (null != v && !"".equals(v)) {
                sb.append("<" + k + ">" + v + "</" + k + ">");
            }
        }
        sb.append("</xml>");
        return sb.toString();
    }

    /**
     * 建立md5摘要,規則是:按參數名稱a-z排序,遇到空值的參數不參加簽名。
     */
    private String createSign(Map<String, String> packageParams ,String partnerkey) {
        StringBuffer sb = new StringBuffer();

        List<String> keys = new ArrayList<String>(packageParams.keySet());
        Collections.sort(keys);
        for (int i = 0; i < keys.size(); i++) {
            String key = keys.get(i);
            String value = packageParams.get(key);
            if (null != value && !"".equals(value) && !"sign".equals(key)
                    && !"key".equals(key)) {
                sb.append(key + "=" + value + "&");
            }
        }

        /*Set es = packageParams.entrySet();
        Iterator it = es.iterator();
        while (it.hasNext()) {
            Map.Entry entry = (Map.Entry) it.next();
            String k = (String) entry.getKey();
            String v = (String) entry.getValue();
            if (null != v && !"".equals(v) && !"sign".equals(k)
                    && !"key".equals(k)) {
                sb.append(k + "=" + v + "&");
            }
        }*/
        sb.append("key=" + partnerkey);
        System.out.println("md5 sb:" + sb+",key=" + partnerkey);

        String sign = MD5Util.MD5Encode(sb.toString(), "utf-8").toUpperCase();
        System.out.println("packge簽名:" + sign);
        return sign;
    }

    /**
     * 產生隨機字符串
     * @return
     */
    private String creRandStr(){
        String currTime = getCurrTime();//獲取當前時間
        String strTime = currTime.substring(8, currTime.length());//8位日期
        String strRandom = buildRandom(4) + "";//四位隨機數
        String strReq = strTime + strRandom;//10位序列號,能夠自行調整
        return strReq;
    }

    /**
     * 獲取當前時間 yyyyMMddHHmmss
     * @return String
     */
    public static String getCurrTime() {
        Date now = new Date();
        SimpleDateFormat outFormat = new SimpleDateFormat("yyyyMMddHHmmss");
        String s = outFormat.format(now);
        return s;
    }

    /**
     * 取出一個指定長度大小的隨機正整數.
     * @param length int 設定所取出隨機數的長度。length小於11
     * @return int 返回生成的隨機數。
     */
    private static int buildRandom(int length) {
        int num = 1;
        double random = Math.random();
        if (random < 0.1) {
            random = random + 0.1;
        }
        for (int i = 0; i < length; i++) {
            num = num * 10;
        }
        return (int) ((random * num));
    }

    /**
     * 獲取客戶端的真實ip
     * @param request
     * @return
     */
    private String getRealIp(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.getRemoteAddr();
        }
        /*ip = request.getHeader("HTTP_CLIENT_IP");
        ip = request.getHeader("HTTP_X_FORWARDED_FOR");
        ip = request.getHeader("X-Real-IP");*/
        logger.info(ip);
        return ip.equals("0:0:0:0:0:0:0:1")?"127.0.0.1":ip;
//        return "192.168.1.1";
    }
}

2.MD5簽名

public class MD5Util {

    private static String byteArrayToHexString(byte b[]) {
        StringBuffer resultSb = new StringBuffer();
        for (int i = 0; i < b.length; i++)
            resultSb.append(byteToHexString(b[i]));

        return resultSb.toString();
    }

    private static String byteToHexString(byte b) {
        int n = b;
        if (n < 0)
            n += 256;
        int d1 = n / 16;
        int d2 = n % 16;
        return hexDigits[d1] + hexDigits[d2];
    }

    public static String MD5Encode(String origin, String charsetname) {
        String resultString = null;
        try {
            resultString = new String(origin);
            MessageDigest md = MessageDigest.getInstance("MD5");
            if (charsetname == null || "".equals(charsetname))
                resultString = byteArrayToHexString(md.digest(resultString
                        .getBytes()));
            else
                resultString = byteArrayToHexString(md.digest(resultString
                        .getBytes(charsetname)));
        } catch (Exception exception) {
        }
        return resultString;
    }

    private static final String hexDigits[] = { "0", "1", "2", "3", "4", "5",
            "6", "7", "8", "9", "a", "b", "c", "d", "e", "f" };
}

3.發送https請求

    /**
     * Post String
     *
     * @param host
     * @param path
     * @param method
     * @param headers
     * @param querys
     * @param body
     * @return
     * @throws Exception
     */
    public static HttpResponse doPost(String host, String path, String method,
                                      Map<String, String> headers,
                                      Map<String, String> querys,
                                      String body)
            throws Exception {
        HttpClient httpClient = wrapClient(host);

        HttpPost request = new HttpPost(buildUrl(host, path, querys));
        for (Map.Entry<String, String> e : headers.entrySet()) {
            request.addHeader(e.getKey(), e.getValue());
        }

        if (StringUtils.isNotBlank(body)) {
            request.setEntity(new StringEntity(body, "utf-8"));
        }

        return httpClient.execute(request);
    }

        private static HttpClient wrapClient(String host) {
        HttpClient httpClient = new DefaultHttpClient();
        if (host.startsWith("https://")) {
            sslClient(httpClient);
        }

        return httpClient;
    }

    private static String buildUrl(String host, String path, Map<String, String> querys) throws UnsupportedEncodingException {
        StringBuilder sbUrl = new StringBuilder();
        sbUrl.append(host);
        if (!StringUtils.isBlank(path)) {
            sbUrl.append(path);
        }
        if (null != querys) {
            StringBuilder sbQuery = new StringBuilder();
            for (Map.Entry<String, String> query : querys.entrySet()) {
                if (0 < sbQuery.length()) {
                    sbQuery.append("&");
                }
                if (StringUtils.isBlank(query.getKey()) && !StringUtils.isBlank(query.getValue())) {
                    sbQuery.append(query.getValue());
                }
                if (!StringUtils.isBlank(query.getKey())) {
                    sbQuery.append(query.getKey());
                    if (!StringUtils.isBlank(query.getValue())) {
                        sbQuery.append("=");
                        sbQuery.append(URLEncoder.encode(query.getValue(), "utf-8"));
                    }
                }
            }
            if (0 < sbQuery.length()) {
                sbUrl.append("?").append(sbQuery);
            }
        }

        return sbUrl.toString();
    }

    private static void sslClient(HttpClient httpClient) {
        try {
            SSLContext ctx = SSLContext.getInstance("TLS");
            X509TrustManager tm = new X509TrustManager() {
                public X509Certificate[] getAcceptedIssuers() {
                    return null;
                }
                public void checkClientTrusted(X509Certificate[] xcs, String str) {

                }
                public void checkServerTrusted(X509Certificate[] xcs, String str) {

                }
            };
            ctx.init(null, new TrustManager[] { tm }, null);
            SSLSocketFactory ssf = new SSLSocketFactory(ctx);
            ssf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
            ClientConnectionManager ccm = httpClient.getConnectionManager();
            SchemeRegistry registry = ccm.getSchemeRegistry();
            registry.register(new Scheme("https", 443, ssf));
        } catch (KeyManagementException ex) {
            throw new RuntimeException(ex);
        } catch (NoSuchAlgorithmException ex) {
            throw new RuntimeException(ex);
        }
    }

四遇到的問題

1.ip獲取問題

　　H5支付要求商戶在統一下單接口中上傳用戶真實ip地址「spbill_create_ip」，具體實現代碼能夠見如上發起統一下單部分getRealIp(request)，若是有代理的話須要配置代理服務器，能夠參見獲取用戶ip指引。這裏可能會遇到的問題是，調用微信的統一訂單接口成功了，根據微信返回的路徑跳轉到微信支付頁面時可能會出現網絡環境未能經過安全驗證，請稍後再試，以下圖，這是由於你跳轉微信支付頁面時微信檢測到你的客戶端ip地址，而且會和你在統一下單接口中上傳的spbill_create_ip比較，不一致就會出現以下問題。當出現這個問題時，須要檢查你的ip獲取是否正確以及配置了(見如上)。web

2.域名問題

　　仍是出現跳轉到微信支付頁面時候，若是測試的時候直接將微信返回的mweb_url粘到瀏覽器中可能會出現商家參數格式有誤，請聯繫商家解決，以下圖，通常是因爲調起H5支付的referer爲空致使。json

　　Referer 是 HTTP 請求header 的一部分，當瀏覽器（或者模擬瀏覽器行爲）向web 服務器發送請求的時候，頭信息裏有包含 Referer 。好比我在www.google.com 裏有一個www.baidu.com 連接，那麼點擊這個www.baidu.com ，它的header 信息裏就有：Referer=http://www.google.com，由此能夠看出來吧。它就是表示一個來源。api

　　這個問題的解決方式就是你獲取到mweb_url以後當前頁面跳轉過去，並且當前頁面域名必須是你申請微信h5支付是給定的域名，否則又會報另一個錯商家存在未配置的參數，請聯繫商家解決，以下圖。這是因爲調起H5支付的域名（微信側從referer中獲取）與申請H5支付時提交的受權域名不一致致使的，若是以前沒有配置也能夠登錄商戶號對應的商戶平臺--"產品中心"--"開發配置"自行配置。瀏覽器

3.使用場景

　　使用場景是在手機端，若是在電腦端上測試，是不行的，親測是跳轉到微信支付頁面時跳轉不過去，最後又回到開始的頁面，個人理解是跳轉到微信支付頁面實際上是調起硬件上安裝的微信，在微信環境中完成支付，而在pc端調起微信會失敗(即使是電腦上裝了微信)，因此又跳轉回去了。安全

4.關於支付成功跳轉

　　正常流程用戶支付完成後默認會返回至發起支付的頁面，如需返回至指定頁面，則能夠在MWEB_URL後拼接上redirect_url參數，來指定回調頁面。好比但願用戶支付完成後跳轉至https://www.wechatpay.com.cn，則能夠作以下處理：服務器

假設您經過統一下單接口獲到的MWEB_URL= https://wx.tenpay.com/cgi-bin/mmpayweb-bin/checkmweb?prepay_id=wx20161110163838f231619da20804912345&package=1037687096微信

則拼接後的地址爲MWEB_URL= https://wx.tenpay.com/cgi-bin/mmpayweb-bin/checkmweb?prepay_id=wx20161110163838f231619da20804912345&package=1037687096&redirect_url=https%3A%2F%2Fwww.wechatpay.com.cn

這裏有個須要注意的問題，需對redirect_url進行urlencode處理，就是將:、/、=、？等符號進行urlEncode編碼，安利一個本身經常使用的在線編碼網站--站長工具。