到处是坑的微信公众号支付开发（java）

之前公司项目开发中支付是用阿里的支付做的，那叫一个简单，随意；悲催的是，现在公司开发了微信公众号，所以我步入了全是坑的微信支付开发中。。。

-----------------------------------------------------------------------------------------------------------

业务流程：

　　这个微信官网说的很详细的（传送门：https://pay.weixin.qq.com/wiki/doc/api/jsapi.php?chapter=7_4）。

　　

　　大概的流程就是：用户点击一个支付按钮-->后台处理（其实就是封装支付必要的数据以及获取prepay_id，然后将它和一些必须参数封装传给前台）-->前台接收数据并且调用微信的js处理数据并调用支付-->用户看到了一个输入密码的界面，包含金额等一些信息-->用户输入密码后出来一个支付成功的页面，同时微信会回调我们的接口通知我们支付结果（这部分流程都是微信自己完成的，我们不用管）-->返回系统自己的页面。

开发步骤：

一、设置支付目录

　　这个官方文档写的很恶心，看的我一头雾水，真心有点晕。虽然看不懂，但是觉得很厉害的样子！传送门：https://pay.weixin.qq.com/wiki/doc/api/jsapi.php?chapter=7_3

二、设置授权域名

这2步完成之后，你可以休息一下了，因为巨坑要来了。。。

三、商户server调用统一下单接口请求订单

这是干啥的？刚开始做的时候一头雾水，但是谁叫人家微信支付团队nb啊，不整点你不理解的东西，怎能体现出他们的高大上。。。不理解，没关系照着文档做呗

传送门：,https://pay.weixin.qq.com/wiki/doc/api/jsapi.php?chapter=9_1  微信官方给了个参数的详细说明。看了半天，总结了一下，就是封装一些必要参数然后去访问https://api.mch.weixin.qq.com/pay/unifiedorder这个接口获取数据。下面是几个常用的参数，直接copy别人的介绍非常详细：

appid ==应用ID==登陆微信公众号后台-开发-基本配置

mch_id == 微信支付商户号==登陆微信支付后台，即可看到

device_info==设备号==终端设备号(门店号或收银设备ID)，注意：PC网页或公众号内支付请传"WEB"

body==商品描述==商品或支付单简要描述（建议刚开始最好传英文，尽量先别传汉子，要不之后签名出问题都没法查）

trade_type==交易类型==取值如下：JSAPI，NATIVE，APP。我们这里使用的JSAPI。标题已经说了，是微信公众号支付。他们的区别，请参考https://pay.weixin.qq.com/wiki/doc/api/jsapi.php?chapter=4_2

　　　　　　ps：JSAPI--公众号支付、NATIVE--原生扫码支付、APP--app支付，统一下单接口trade_type的传参可参考这里。MICROPAY--刷卡支付，刷卡支付有单独的支付接口，不调用统一下单接口

nonce_str==随机字符串==随机字符串，不长于32位（参考算法https://pay.weixin.qq.com/wiki/doc/api/jsapi.php?chapter=4_3）　　　

notify_url==通知地址==接收微信支付异步通知回调地址，通知url必须为直接可访问的url，不能携带参数。（这，起个什么名字好呢。随便起吧，反正一时半会也用不到）

out_trade_no==商户订单号==商户系统内部的订单号,32个字符内、可包含字母（参考：https://pay.weixin.qq.com/wiki/doc/api/jsapi.php?chapter=4_2）（每次看完微信的官方解释就更迷茫了，有木有。没关系，我就传个1咋了。）

total_fee==总金额==订单总金额，单位为分（这个注意一下，我开始没注意，传的是0.01，开发么都用1分钱，然后就悲剧了，看了好多遍才发现单位是分 分 分）

openid==用户标识==trade_type=JSAPI，此参数必传，用户在商户appid下的唯一标识。（要是不知道这个从哪里来的话，没关系。微信不是给咱写文档了吗https://pay.weixin.qq.com/wiki/doc/api/jsapi.php?chapter=4_4）

还有最最重要的一个，重要的角色总要在最后登场。

attach==附加数据，在查询API和支付通知中原样返回，可作为自定义参数使用。（这个我觉得挺有用的，可以用来放业务数据，因为我是在微信回调中处理业务数据的，用这个参数安全无痛）

sign==签名==官方给的签名算法。https://pay.weixin.qq.com/wiki/doc/api/jsapi.php?chapter=4_3。没有看懂，看不太懂，你觉得你看懂了，没关系，不遇到几次签名错误，好意思说自己做过微信支付开发吗（个人推荐开发时候用官方sdk中的工具来做，能省很多麻烦https://pay.weixin.qq.com/wiki/doc/api/jsapi.php?chapter=11_1在这里下载java的API对应的SDK和调用示例，里面工具很全）

说道这个sign还有一个更重要的参数。参与签名的参数。反正我是找了好久才找到。（公司运营申请的微信支付，当我找她要的时候，他的表情是这样子的。）

key==key设置路径：微信商户平台(pay.weixin.qq.com)-->账户设置-->API安全-->密钥设置（这个很重要，签名都用它）

这部分总结就是，先将数据封装成map然后通过工具转化成xml(工具上面提到了，自己回去看)，然后通过post请求请求【微信统一下单接口】，如果sign没有问题就会返回一个xml,里面很多数据，其中我们要的是prepay_id，就是这个参数，然后生成签名返回到前台,ok这步也完成了。

问题总结（我在这过程中遇到的问题）：1（重要）appid与openid必须是匹配的，换句话说就是用户的openid必须是在当前的公众号下用户（我们好几个公众号，可能你们不会遇到这个问题，但是这很重要，说以第一个说）2

第二步，生成签名并返回到前台这个过程中一定要注意参数一定要写对了，大小写，是否有空格，我在这上面掉了一个大坑，界面调用支付时一直闪退，注意.

四、H5调起微信支付的内置JS

 后台传回前台的参数中，应包含以下几项：

appId==这个是不变的==永远不变

timeStamp==时间戳==规则：https://pay.weixin.qq.com/wiki/doc/api/jsapi.php?chapter=4_2。看完仍是一脸迷茫的，没关系，我们有工具类。

nonceStr ==反正我用的跟刚才签名是同一个随机字符串。理论上不用应该也没有关系的，勤快的小伙伴可以试试

package==订单详情扩展字符串==统一下单接口返回的prepay_id参数值，提交格式如：prepay_id=***（你猜对了。刚才我们费那么大力气，获得到的prepay_id就是在这里用的）

signType==签名方式==签名算法，暂支持MD5

paySign==签名==这个签名，要重新生成，在后台。使用如上4个参数+一个key（永远不变）。（我生成签名的时间戳和传回给前台的时间戳就是timeStamp是同一个。不一样行不行，木有验证）

生成paySign的代码

注意:生成prepay_id时appid是小写的i,生成paySign时，appId是大写的I，这俩是不同的

如果一切顺利的话，就会出现这个页面

这些都做完了你就可以放松一下了

五，微信回调处理

该部分有以下3小步骤

　　　　1）解析传过来的流信息，通过重新签名的方式验证流中包含的信息的正确性。就是判断这个信息到底是不是微信发的

　　　　2）return_code和result_code都是SUCCESS的话，处理商户自己的业务逻辑。就是订单的支付状态啊等一些信息。

　　　　3）告诉微信，我收到你的返回值了。不用在发了。

话不多说，直接贴代码！

public String return_data(HttpServletRequest request, HttpServletResponse response) throws Exception {
        logger.info("微信支付请求回调了");
        String resXml = "";
        Map<String, String> backxml = new HashMap<String, String>();
        InputStream inStream;
        try {
            inStream = request.getInputStream();
            ByteArrayOutputStream outSteam = new ByteArrayOutputStream();
            byte[] buffer = new byte[];
            int len = ;
            while ((len = inStream.read(buffer)) != -) {
                outSteam.write(buffer, , len);
            }
            outSteam.close();
            inStream.close();
            String result = new String(outSteam.toByteArray(), "utf-8");// 获取微信调用我们notify_url的返回信息
            Map<String, String> map = WXPayUtil.xmlToMap(result);
            if (map.get("result_code").toString().equalsIgnoreCase("SUCCESS")) {
                if (WXPayUtil.isSignatureValid(map, PayConfigUtil.API_KEY)) {
                    logger.info("微信支付-签名验证成功");
//                    backxml.put("return_code", "SUCCESS");
//                    backxml.put("return_msg", "OK");
//                    String toXml = WXPayUtil.mapToXml(backxml);
//                    response.getWriter().write(toXml);
                    resXml = "<xml>" + "<return_code><![CDATA[SUCCESS]]></return_code>"
                            + "<return_msg><![CDATA[OK]]></return_msg>" + "</xml> ";
                    //业务处理开始

                    //业务处理结束
                }
                BufferedOutputStream out = new BufferedOutputStream(response.getOutputStream());
                out.write(resXml.getBytes());
                out.flush();
                out.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return resXml;
    }

还记得，三、商户server调用统一下单接口请求订单 中attach参数么，这里用来带业务数据很方便

补充工具类代码

package com.qicheshetuan.backend.util.wxPay;

import com.qicheshetuan.backend.util.wxPay.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.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 java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.io.StringWriter;
import java.security.MessageDigest;
import java.util.*;

public class WXPayUtil {

    /**
     * @Author SongZS
     * @Date 2017/6/30 14:57
     *
     * 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;
        }

    }

    /**
     * @Author SongZS
     * @Date 2017/6/30 14:57
     *
     * 将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("\n|\r", "");
        try {
            writer.close();
        }
        catch (Exception ex) {
        }
        return output;
    }

    /**
     * @Author SongZS
     * @Date 2017/6/30 14:57
     *
     * 生成带有 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);
    }

    /**
     * @Author SongZS
     * @Date 2017/6/30 14:57
     *
     * 生成带有 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);
    }

    /**
     * @Author SongZS
     * @Date 2017/6/30 14:57
     *
     * 判断签名是否正确
     *
     * @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);
    }

    /**
     * @Author SongZS
     * @Date 2017/6/30 14:57
     *
     * 判断签名是否正确，必须包含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);
    }

    /**
     * @Author SongZS
     * @Date 2017/6/30 14:57
     *
     * 判断签名是否正确，必须包含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);
    }

    /**
     * @Author SongZS
     * @Date 2017/6/30 14:57
     *
     * 生成签名
     *
     * @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);
    }

    /**
     * @Author SongZS
     * @Date 2017/6/30 14:57
     *
     * 生成签名. 注意，若含有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));
        }
    }

    /**
     * @Author SongZS
     * @Date 2017/6/30 14:57
     *
     * 获取随机字符串 Nonce Str
     *
     * @return String 随机字符串
     */
    public static String generateNonceStr() {
        return UUID.randomUUID().toString().replaceAll("-", "").substring(0, 32);
    }

    /**
     * @Author SongZS
     * @Date 2017/6/30 14:57
     *
     * 生成 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();
    }

    /**
     * @Author SongZS
     * @Date 2017/6/30 14:57
     *
     * 生成 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();
    }

    /**
     * @Author SongZS
     * @Date 2017/6/30 14:57
     *
     * 日志
     * @return
     */
    public static Logger getLogger() {
        Logger logger = LoggerFactory.getLogger("wxpay java sdk");
        return logger;
    }

    /**
     * @Author SongZS
     * @Date 2017/6/30 14:57
     *
     * 获取当前时间戳，单位秒
     * @return
     */
    public static long getCurrentTimestamp() {
        return System.currentTimeMillis()/1000;
    }

    /**
     * @Author SongZS
     * @Date 2017/6/30 14:57
     *
     * 获取当前时间戳，单位毫秒
     * @return
     */
    public static long getCurrentTimestampMs() {
        return System.currentTimeMillis();
    }

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

}
------------------------------------------------------------------------------

package com.qicheshetuan.backend.util.wxPay;

/**
 * 常量
 */
public class WXPayConstants {

    public enum SignType {
        MD5, HMACSHA256
    }

    public static final String DOMAIN_API = "api.mch.weixin.qq.com";
    public static final String DOMAIN_API2 = "api2.mch.weixin.qq.com";
    public static final String DOMAIN_APIHK = "apihk.mch.weixin.qq.com";
    public static final String DOMAIN_APIUS = "apius.mch.weixin.qq.com";

    public static final String FAIL     = "FAIL";
    public static final String SUCCESS  = "SUCCESS";
    public static final String HMACSHA256 = "HMAC-SHA256";
    public static final String MD5 = "MD5";

    public static final String FIELD_SIGN = "sign";
    public static final String FIELD_SIGN_TYPE = "sign_type";

    public static final String MICROPAY_URL_SUFFIX     = "/pay/micropay";
    public static final String UNIFIEDORDER_URL_SUFFIX = "/pay/unifiedorder";
    public static final String ORDERQUERY_URL_SUFFIX   = "/pay/orderquery";
    public static final String REVERSE_URL_SUFFIX      = "/secapi/pay/reverse";
    public static final String CLOSEORDER_URL_SUFFIX   = "/pay/closeorder";
    public static final String REFUND_URL_SUFFIX       = "/secapi/pay/refund";
    public static final String REFUNDQUERY_URL_SUFFIX  = "/pay/refundquery";
    public static final String DOWNLOADBILL_URL_SUFFIX = "/pay/downloadbill";
    public static final String REPORT_URL_SUFFIX       = "/payitil/report";
    public static final String SHORTURL_URL_SUFFIX     = "/tools/shorturl";
    public static final String AUTHCODETOOPENID_URL_SUFFIX = "/tools/authcodetoopenid";

    // sandbox
    public static final String SANDBOX_MICROPAY_URL_SUFFIX     = "/sandboxnew/pay/micropay";
    public static final String SANDBOX_UNIFIEDORDER_URL_SUFFIX = "/sandboxnew/pay/unifiedorder";
    public static final String SANDBOX_ORDERQUERY_URL_SUFFIX   = "/sandboxnew/pay/orderquery";
    public static final String SANDBOX_REVERSE_URL_SUFFIX      = "/sandboxnew/secapi/pay/reverse";
    public static final String SANDBOX_CLOSEORDER_URL_SUFFIX   = "/sandboxnew/pay/closeorder";
    public static final String SANDBOX_REFUND_URL_SUFFIX       = "/sandboxnew/secapi/pay/refund";
    public static final String SANDBOX_REFUNDQUERY_URL_SUFFIX  = "/sandboxnew/pay/refundquery";
    public static final String SANDBOX_DOWNLOADBILL_URL_SUFFIX = "/sandboxnew/pay/downloadbill";
    public static final String SANDBOX_REPORT_URL_SUFFIX       = "/sandboxnew/payitil/report";
    public static final String SANDBOX_SHORTURL_URL_SUFFIX     = "/sandboxnew/tools/shorturl";
    public static final String SANDBOX_AUTHCODETOOPENID_URL_SUFFIX = "/sandboxnew/tools/authcodetoopenid";

}

----------------------------------------------就这些了，至于退款，查询订单什么的，以后用到了在继续吧，如果我有什么不对的地方，欢迎各位留言指点