实战技能：小小微信支付业务，何必虚惊一场

记得上次接触微信支付是2016年底，那次也是我程序生涯中首次碰及支付业务，慌张谈不上但是懵逼怀疑时时都有。说起第三方登录或者支付，想必都清楚是直接调用人家现成的API，完全没有开发成本和技术含量。但是我想说：如果你没有过一次从零开发并维护过一个完整支付模块的话，我相信有很多坑对你来说都是黑盒的，也许现在的公司或多或少都涵盖了支付业务，可能被早先的老程序员们已经维护的差不多完美了，完全是可以当成模板功能来使用，新手只需复制大体功能架子填充支付后的业务逻辑即可。

好了，切入正题吧。为什么突然在各位前辈面前摆上这么一篇没有任何技术含量的文章呢？因为好久没有在博客园发布过文章了，刚刚瞻仰完各位大佬分享的东西后心里很空虚。其次是主要原因，由于前几天休假刚回来就被刚刚入职的哥们拉住绕了一会儿，说这俩天测试人员反应充一次钱之后会看到好几条充值记录并且是偶现的，而且相应的游戏币也累加了很多次等等，然后还有一个更坑的现象就是照着微信开发文档调用接口，唤醒微信支付的组件开始调用预支付(统一下单)接口时抛签名错误的异常，竟然调不通(声明：签名方式已经是确保无误的)。。。真的，听他一说还真回忆起当年那个手忙脚乱的自己，在开发过程中各种懵逼、各种怀疑人生。所以今天就把这些踩坑经历分享一下，仅献给圈里刚刚接触或要开始接手支付业务的朋友，希望各位在铸造支付模块时能够一马平川。

准备工作：

• 申请注册微信开发平台账号，申请需支付300元，心里有个数啊。

• 在注册通过之后，到管理中心申请添加你们的APP应用。

• 如果APP应用审核通过之后，就可以申请开放微信支付功能，比如像分享到朋友圈、微信登录等功能都是自动开放的，无需申请。

• 最后如果微信支付功能审核也通过后，微信会给你分配一个微信商户号，基本包含了：登录账户号、密码、APPID和支付商户号等信息，这些信息要自己保留好，后续调用支付相关的接口时会用到。

 服务端支付业务开发步骤：

 1、登录微信商户平台，注意是商户平台不是开放平台，根据业务场景选择适合自己的支付类型，进入之后就可以看看具体的API列表，除此之外还提供了业务场景举例、业务流程时序图等非常清晰。提醒一点微信还提供了专门的demo压缩包，里面包含了工具类WXPayUtil建议下载，因为相信你能用到，是百分百能用到。

package com.qy.utils;

import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.io.StringWriter;
import java.util.*;
import java.security.MessageDigest;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

import com.qy.utils.WXPayConstants.SignType;

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
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 org.slf4j.Logger;
import org.slf4j.LoggerFactory;


public class WXPayUtil {

    /**
     * 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();
            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) {
            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 {
        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("
|
", "");
        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() {
        return UUID.randomUUID().toString().replaceAll("-", "").substring(0, 32);
    }


    /**
     * 生成 MD5
     *
     * @param data 待处理数据
     * @return MD5结果
     */
    public static String MD5(String data) throws Exception {
        java.security.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();
    }

    /**
     * 生成 uuid， 即用来标识一笔单，也用做 nonce_str
     * @return
     */
    public static String generateUUID() {
        return UUID.randomUUID().toString().replaceAll("-", "").substring(0, 32);
    }

}

2、移动端唤起微信支付的组件，首先发起开始支付的动作，服务端就会相应的调用预支付(统一下单)接口https://api.mch.weixin.qq.com/pay/unifiedorder，注意该过程需要对参数进行签名，然后将带有签名字段的参数作为接口形参，过程比较繁琐建议封装一下，后续的操作还有会用到的，最后拿到微信服务器返回的结果后解析出移动端需要的参数，记得签名后返给前端。好了部分源码可以参考一下：

　　　　　　　String body = "抓乐GO";
            String nonceStr = WXPayUtil.generateNonceStr();     //获取随机字符串
            String outTradeNo = WXPayUtil.generateUUID();         //商户订单号(本次交易订单号)
            String tradeType = "APP";                            //支付类型：APP
            Double money = tokenInfo.getMoney() * 100.0;         //金额(单位/分)
            //int totalFee = (new Double(money)).intValue();
            int totalFee = (int) Math.ceil(money);
            logger.info("------------------支付金额为:{}",totalFee);
            String parames = "<xml><appid>"+appID+"</appid><body>"+body+"</body><mch_id>"
                    +mchID+"</mch_id><nonce_str>"+nonceStr+"</nonce_str><notify_url>"+notifyUrl
                    +"</notify_url><out_trade_no>"+outTradeNo+"</out_trade_no><spbill_create_ip>"+spbillCreateIp
                    +"</spbill_create_ip><total_fee>"+totalFee+"</total_fee><trade_type>"+tradeType
                    +"</trade_type></xml>";
            Map<String, String> mapXML = WXPayUtil.xmlToMap(parames);    //将不包含sign字段的xml字符串转成map
            String sign = WXPayUtil.generateSignature(mapXML, appKey);    //生成签名

            String signParames = "<xml><appid>"+appID+"</appid><body>"+body+"</body><mch_id>"
                    +mchID+"</mch_id><nonce_str>"+nonceStr+"</nonce_str><notify_url>"+notifyUrl
                    +"</notify_url><out_trade_no>"+outTradeNo+"</out_trade_no><spbill_create_ip>"+spbillCreateIp
                    +"</spbill_create_ip><total_fee>"+totalFee+"</total_fee><trade_type>"+tradeType
                    +"</trade_type><sign>"+sign+"</sign></xml>";        //预支付接口xml参数(包含sign)
            Map<String, String> mapXML1 = WXPayUtil.xmlToMap(signParames);
            boolean boo = WXPayUtil.isSignatureValid(mapXML1, appKey);    //校验签名是否正确

　　if("SUCCESS".equals(dataMap.get("result_code"))){
                    logger.info("预支付接口调用成功：");
                    //预支付调用成功
                    //二次签名
                    Map<String,String> signMap = new LinkedHashMap<String,String>();
                    signMap.put("appid", dataMap.get("appid"));
                    signMap.put("partnerid", dataMap.get("mch_id"));
                    signMap.put("prepayid", dataMap.get("prepay_id"));
                    signMap.put("package", "Sign=WXPay");
                    signMap.put("noncestr", WXPayUtil.generateNonceStr());
                    signMap.put("timestamp", String.valueOf(System.currentTimeMillis()/1000));
                    String appSign = WXPayUtil.generateSignature(signMap, appKey);
                    signMap.put("sign", appSign);
                    signMap.put("outTradeNo", outTradeNo);        //支付订单号
                    //String signXml = WXPayUtil.mapToXml(signMap);
                    //System.out.println(signXml);
                    dataJson.put("code", Constants.HTTP_RESPONSE_SUCCESS);
                    dataJson.put("msg", Constants.HTTP_RESPONSE_SUCCESS_MSG);
                    dataJson.put("data", signMap);
                    logger.info("返给APP的二次签名数据：{}",signMap);

3、移动端拿到支付参数后就会真正调起支付操作，这时后端只需做一个供微信回调的接口，该接口的作用主要是接受每次支付的支付结果。注意：该回调地址需要在发起预支付接口时务必告诉微信服务器，而且还要保证能够畅通无阻。当完成一笔支付操作后，微信服务器就立刻会调用你提供的自定义回调接口告诉你支付结果，你只需完成支付成功后的业务逻辑，即视为本次支付过程结束。

public String payCallback(HttpServletRequest request, HttpServletResponse response){
        BufferedReader reader = null;
        try {
            reader = request.getReader();
            String line = "";
            String xmlString = null;
            StringBuffer inputString = new StringBuffer();
            while ((line = reader.readLine()) != null) {
                inputString.append(line);
            }
            xmlString = inputString.toString();
            if(WXPayUtil.isSignatureValid(xmlString,appKey)){
                logger.info("微信支付结果{}",xmlString);
                request.getReader().close();
                Map<String, String> resultMap = WXPayUtil.xmlToMap(xmlString);     //支付结果
                if("SUCCESS".equals(resultMap.get("return_code"))){
　　　　　　　　　　　　　　　支付成功后的业务逻辑....

4、当然，微信也专门提供了查询某笔支付订单的支付结果的接口https://api.mch.weixin.qq.com/pay/orderquery，详情自行查询。

public String getOrderResult(String outTradeNo){
        logger.info("查询支付订单号{}支付结果================",outTradeNo);
        Map<String,Object> dataJson = new LinkedHashMap<String,Object>();
        try {
            String nonceStr = WXPayUtil.generateNonceStr();     //获取随机字符串
            //请求参数
            String parames = "<xml><appid>"+appID+"</appid><mch_id>"+mchID+"</mch_id>"
                            +"<nonce_str>"+nonceStr+"</nonce_str>"
                            + "<out_trade_no>"+outTradeNo+"</out_trade_no></xml>";
            String signXMLData = WXPayUtil.generateSignedXml(WXPayUtil.xmlToMap(parames), appKey);   //生成带有签名的xml
            String queryResult = HttpClient.doPostXML(orderQueryURL, signXMLData);        //查询结果xml
            if(WXPayUtil.isSignatureValid(queryResult,appKey)){
                Map<String, String> wxPayResult = WXPayUtil.xmlToMap(queryResult);            //微信支付的结果通知

OK，到这儿整个支付业务算是真正跑通了，勉强画条暂时的分割线吧。

---

•  为什么调用统一下单(预支付)接口在正确签名后，还是调不通，总提示签名错误？

这个问题确实对于很多新手来说是狠TM扯淡的，调不通还老提示签名错误可能是因为：http请求的参数列表中body那个字段你传的是中文，并且微信开发文档中的案例模板也是中文。

解决方案：只需将最终发送的参数列表进行编码处理即可，但是你也可以全部传入英文。

//如果校验通过，则调用预支付
                logger.info("开始调用微信预支付接口：https://api.mch.weixin.qq.com/pay/unifiedorder");
                signParames = new String(signParames.getBytes("UTF-8"), "ISO-8859-1");
                String result = HttpClient.doPostXML(payURL, signParames);
                Map<String, String> dataMap = WXPayUtil.xmlToMap(result);
                logger.info("预支付结果：{}",result);

• 为什么支付会给产生多条充值明细，并且还给用户累加多次余额？

这个问题就有点考验你写接口的质量了，出现仅支付一次产生多条支付明细记录的情况，首先是因为你没有做好在成功拿到微信回调结果后及时对当前支付记录做好重复处理的逻辑，因为那哥们儿发起一笔支付请求后在成功拿到支付结果没有告诉微信支付成功，所以微信认为通知失败，微信会通过一定的策略定期重新发起通知，尽可能提高通知的成功率，但微信不保证通知最终能成功，通知频率为15/15/30/180/1800/1800/1800/1800/3600，单位：秒。所以不断处理同一笔支付订单。其次就是没有考虑并发的情况，需要对拿到的回调结果做线程安全的处理，可以有俩种方案：第一种就是在数据库层面上做限制，设置联合主键将重复操作的支付记录数据挡在外面不允许插入数据库；第二种是在业务层加锁，在处理每笔支付结果时判断是否已经处理过了，如果处理过就忽略当前回调结果否则正常处理。提醒一点：不要直接在方法上直接添加synchronized，还有在加锁的时候尽量将锁的粒度控制到最小，否则会影响接口的性能。（参考：http://www.cnblogs.com/1315925303zxz/p/7561236.html）

更多实战技能，请关注本人技术文章公众号：xz_303  期待与君共勉！