微信支付之手机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编码，安利一个自己常用的在线编码网站--站长工具。

五 总结

　　以上基本就是所遇到的坑，从一开始查资料了解微信子商户模式，到了解接口，到编写代码，再到调试，问题总结是这两个，但是整个过程中想尽各种办法来测试，还有很多小问题的解决不是本文能写完的，当看到支付页面调起那一刻，心里那种成就感，这也是只有程序员才懂的吧，最后附上一张支付成功的图。