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

　　最近專案中支付部分涉及到微信支付，使用的是h5支付，官方文件中是沒有demo的，所以摸著石頭過河，將踩過的坑記錄如下。

一 應用場景

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

二 服務商模式介紹

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

三 實現程式碼

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獲取是否正確以及配置了(見如上)。

 

2.域名問題

 　　還是出現跳轉到微信支付頁面時候，如果測試的時候直接將微信返回的mweb_url粘到瀏覽器中可能會出現商家引數格式有誤，請聯絡商家解決，如下圖，一般是由於調起H5支付的referer為空導致。

　　Referer 是 HTTP 請求header 的一部分，當瀏覽器（或者模擬瀏覽器行為）向web 伺服器傳送請求的時候，頭資訊裡有包含 Referer 。比如我在www.google.com 裡有一個www.baidu.com 連結，那麼點選這個www.baidu.com ，它的header 資訊裡就有：Referer=http://www.google.com，由此可以看出來吧。它就是表示一個來源。

　　這個問題的解決方式就是你獲取到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編碼，安利一個自己常用的線上編碼網站--站長工具。

五 總結

　　以上基本就是所遇到的坑，從一開始查資料瞭解微信子商戶模式，到了解介面，到編寫程式碼，再到除錯，問題總結是這兩個，但是整個過程中想盡各種辦法來測試，還有很多小問題的解決不是本文能寫完的，當看到支付頁面調起那一刻，心裡那種成就感，這也是隻有程式設計師才懂的吧，最後附上一張支付成功的圖。