微信公众号支付备忘及填坑之路-java

一、背景　　

　　最近公司给第三方开发了一个公众号，其中最重要的功能是支付，由于是第一次开发，遇到的坑特别的多，截止我写博客时，支付已经完成，在这里我把遇到的坑记录一下（不涉及退款）。不得不吐槽一下，腾讯这么大的公司，写的代码真的烂，变量命名不规范（后来又开发了公众号分享，发现对于同一个变量，两个地方的变量名不同），文档写的垃圾，而且好多时候，有返回的错误码但是文档上没说明，另外线上线下测试极其不方便。

二、参考资料

　　1、JSAPI支付开发文档：主要是支付开发过程中接口、流程、注意事项、常见问题等；　　

　　2、微信公众平台：里面有公众号的运维配置，当然也有开发配置，咱们主要是用到了开发配置；　　

　　3、微信商户平台：要支付必须有微信商户，里面需配置开发设置；　　

　　4、花生壳：主要是用到花生壳的内网穿透，由于微信支付开发过程中，需要公网的微信服务器访问本地开发的电脑，包括重定向之类的，所以需要内网穿透，这样微信才能访问到局域网电脑；花生壳可以免费注册使用，但是呢，免费的带宽为1M，由于带宽太小，根本穿透不进来，所以我们后来购买了带宽，发现带宽为3M时，足以应付日场使用。当然Ngrok也可以内网穿透，但是带宽太低了；　　

　　5、微信公众平台支付接口调试工具：这个平台可以校验自己生成的sign与微信服务器生成的sign是否一致，很有用，尤其是提示签名失败时。

三、说明　　

　　1、在支付接入过程中，如果不顺利，不要怀疑微信服务器有问题，多想想自己哪儿可能出问题了，因为接入微信支付的商户已经达好几亿了，微信不可能出问题的；

　　2、微信的开发文档中说到，为保证商户接入质量，提升交易安全及用户体验，微信做了一个支付仿真沙箱环境，还说什么“微信支付的合作服务商在正式上线交易前，必须先根据本文指引完成验收”。这个别听微信的，他们的这个沙箱环境根本不成熟，用这个是瞎折腾，咱们可以直接用真实环境测试；

　　3、微信支付开发文档中提到“协议规则”，首先传输方式是HTTPS，是指微信服务器和商户服务器通讯协议是HTTPS，但是不要求微信客户端与商户服务器之间的通讯协议是HTTPS，用HTTP也行，也就是说商户服务器不用自己准备SSL证书。其次所有微信支付有关的接口都用POST。最后，提交和返回的数据都是XML格式，不是目前普标接受的JSON格式，这个要注意。 

四、微信支付流程

　　第3步：微信客户端请求商户后台系统，主要是携带商品的价格，其次如有必要携带商品的描述，或者传递一个参数可以让服务器唯一确定商品价格与商品描述；

　　第4步：这一步是在我们商户后台的数据库的"订单表"里面插入一条数据，数据里包含的基本信息有：用户id，订单金额，订单商品及描述，支付状态；

　　第5步：整个微信公众号支付流程图中，最重要的一步，这一步的目的是返回预支付订单号prepay_id，这一步起到承上启下的作用；这一步的详细代码见后文 “统一下单”；开发文档 ；

　　第6步：根据第5步形成的prepay_id附带其他参数一起发送给微信客户端，开发文档；

　　第7步：携带第6步的参数请求微信，这一步也是次重要的一步，开发文档，常见问题，

　　第10步、第11步：支付完成后，微信服务器通知商户后台系统，后台系统验证完毕后，需要改变商户订单表里订单的状态，即第4步的订单状态。之后需要后台系统给微信服务器返回特定的信息。但是开发文档中也说了，绝大部分情况下，我们支付成功，能接收到微信的通知，但是有时收不到，这时我们需要主动调用微信支付【查询订单API】确认订单状态 。这一步的详细代码见后文 “微信支付结果通知及商户服务器响应”，开发文档 。

五、微信公众号开通微信支付

　　见参考文档：微信公众号怎么申请微信支付。开通之后，从公众号内可以看到已经关联的商户（图1），同时从微信商户里可以看到关联的微信公众号（图2）。 

六、公众号开发参数配置

　　1、设置——公众号设置——功能设置：设置网页授权域名

　　微信是这么说的“用户在网页授权页同意授权给公众号后，微信会将授权数据传给一个回调页面，回调页面需在此域名下，以确保安全可靠”，我是这里理解的：网页需要重定向时才可以跳转到该域名下的地址。由于是在微信里面嵌套h5网页，所以网页的域名需要受到微信的监管。注意这里的设置的是域名，不是ip地址之类的，也不能带有端口号。这里就需要用到花生壳的内网穿透了。

　　　　假如服务器是tomcat，端口号是8080，微信给的文件是xxx.txt，花生壳地址是http://123asd.zicp.vip

　　　　1）首先你将微信给的xxx.txt文件下载到ROOT目录，然后启动tomcat，在本地浏览器用localhost:8080/xxx.txt访问，如果正常不能正常访问，那就是tomcat启动失败了，自己检查下log日志看看；

　　　　2）启动花生壳客户端，并且配置内网主机为localhost:8080,在本地浏览器访问http://123asd.zicp.vip/xxx.txt,这个受制于带宽的原因，可能需要等一会时间，也可能很快，如果不能访问成功，花生壳重启试试；

　　　　3）配置网页授权域名为123asd.zicp.vip。

　　  

2、开发——基本配置。

　　1）这里需要配置开发者密码（特别重要）、ip白名单（通过开发者ID及密码调用获取access_token接口时，需要设置访问来源IP为白名单）。

　　2）服务器配置，验证token。这一步也是微信防止没有经过鉴权的服务器访问自己的服务器做的一个验证吧，可以看做是为了安全考虑。这个需要服务端代码支持，代码见后面。这个配置有时候需要多试几次，有时提示“系统繁忙”。

七、微信商户开发参数配置

　　这里的支付授权目录配置的就是微信公众号调起支付页面的URL，和后端服务器无关。这里有坑，详见下面的填坑之路。

八、后端代码

　　1、微信常量类

 public class WeixinConstant {

     /**
      * 公众号-id
      */
     public static final String WX_CON_APPID = "xxx";
     /**
      * 公众号-秘钥
      */
     public static final String WX_CON_APPSECRET = "yyy";

     /**
      * 商户-商户号
      */
     public static final String WX_CON_MCH_ID = "zzz";
     /**
      * 商户-商户密钥
      */
     public static final String WX_CON_MCHSECRET = "uuu";

     /**
      * 请求结果-成功
      */
     public static final String RESULT_SUCCESS = "SUCCESS";
     /**
      * 请求结果-失败
      */
     public static final String RESULT_FAIL = "FAIL";

     /**
      * 微信支付成功回调响应Map
      */
     public static final Map<String, String> WX_CON_PAY_RESPMAP = new HashMap<String, String>() {{
         put("return_code", "SUCCESS");
         put("return_msg", "OK");
     }};

     /**
      * 接口-用户-通过code换取网页授权access_token URL
      */
     public static final String WX_URL_USER_GETOPENIDANDTOKEN = "https://api.weixin.qq.com/sns/oauth2/access_token";

     /**
      * 接口-用户-拉取用户信息
      */
     public static final String WX_URL_USER_GETUSERINFO = "https://api.weixin.qq.com/sns/userinfo";

     /**
      * 接口-支付-统一下单URL
      */
     public static final String WX_URL_PAY_UNIFIEDORDER = "https://api.mch.weixin.qq.com/pay/unifiedorder";

     /**
      * 接口-支付-查询订单URL
      */
     public static final String WX_URL_PAY_ORDERQUERY = "https://api.mch.weixin.qq.com/pay/orderquery";

 }

　　2、工具类/方法

　　2.1、map与xml转化工具（微信工具类提供的。因为我们熟悉使用map，所以我们把请求参数放在有序map里，然后再将map转化为xml）

 public class WXPayUtil {

     private static final String SYMBOLS = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";

     private static final Random RANDOM = new SecureRandom();

     /**
      * 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>();
             DocumentBuilder documentBuilder = WXPayXmlUtil.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 {
         org.w3c.dom.Document document = WXPayXmlUtil.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;
     }

     /**
      * 生成带有 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() {
         char[] nonceChars = new char[32];
         for (int index = 0; index < nonceChars.length; ++index) {
             nonceChars[index] = SYMBOLS.charAt(RANDOM.nextInt(SYMBOLS.length()));
         }
         return new String(nonceChars);
     }

     /**
      * 生成 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();
     }

     /**
      * 生成 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();
     }

 }

　　2.2、服务器token验证工具

 public class CheckoutUtil {

     // 与接口配置信息中的Token要一致
     private static String token = "83cea0ca4c9ee2dd60c15f2df17de4a2";

     /**
      * 验证签名
      *
      * @param signature
      * @param timestamp
      * @param nonce
      * @return
      */
     public static boolean checkSignature(String signature, String timestamp, String nonce) {
         String[] arr = new String[] { token, timestamp, nonce };
         // 将token、timestamp、nonce三个参数进行字典序排序
         // Arrays.sort(arr);
         sort(arr);
         StringBuilder content = new StringBuilder();
         for (int i = 0; i < arr.length; i++) {
             content.append(arr[i]);
         }
         MessageDigest md = null;
         String tmpStr = null;

         try {
             md = MessageDigest.getInstance("SHA-1");
             // 将三个参数字符串拼接成一个字符串进行sha1加密
             byte[] digest = md.digest(content.toString().getBytes());
             tmpStr = byteToStr(digest);
         } catch (NoSuchAlgorithmException e) {
             e.printStackTrace();
         }
         content = null;
         // 将sha1加密后的字符串可与signature对比，标识该请求来源于微信
         return tmpStr != null ? tmpStr.equals(signature.toUpperCase()) : false;
     }

     /**
      * 将字节数组转换为十六进制字符串
      *
      * @param byteArray
      * @return
      */
     private static String byteToStr(byte[] byteArray) {
         String strDigest = "";
         for (int i = 0; i < byteArray.length; i++) {
             strDigest += byteToHexStr(byteArray[i]);
         }
         return strDigest;
     }

     /**
      * 将字节转换为十六进制字符串
      *
      * @param mByte
      * @return
      */
     private static String byteToHexStr(byte mByte) {
         char[] Digit = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
         char[] tempArr = new char[2];
         tempArr[0] = Digit[(mByte >>> 4) & 0X0F];
         tempArr[1] = Digit[mByte & 0X0F];
         String s = new String(tempArr);
         return s;
     }
     public static void sort(String a[]) {
         for (int i = 0; i < a.length - 1; i++) {
             for (int j = i + 1; j < a.length; j++) {
                 if (a[j].compareTo(a[i]) < 0) {
                     String temp = a[i];
                     a[i] = a[j];
                     a[j] = temp;
                 }
             }
         }
     }

 }

　　2.3、支付加签工具

 public class WeixinSignUtil {

     private final static Log logger = LogFactory.getLog(WeixinSignUtil.class);

     /**
      * @param requestDataMap
      * @return
      * @function 微信参数签名
      * @remark flag=true 加密的参数为sign  flag=false 加密的参数是paySign
      */
     public static void getWeixinSign(Map<String, String> requestDataMap, Boolean isRequestFlag) {
         String paramStrTemp = "";
         Iterator<Map.Entry<String, String>> entries = requestDataMap.entrySet().iterator();
         while (entries.hasNext()) {
             Map.Entry<String, String> entry = entries.next();
             paramStrTemp += (entry.getKey() + "=" + entry.getValue() + "&");
         }
         String paramStr = paramStrTemp + "key=" + WeixinConstant.WX_CON_MCHSECRET;
         logger.info("签名前字符串：" + paramStr);
         String sign = DigestUtils.md5DigestAsHex(paramStr.getBytes()).toUpperCase();
         if (isRequestFlag) {
             logger.info("加签为sign:" + sign);
             requestDataMap.put("sign", sign);
         } else {
             logger.info("加签为paySign:" + sign);
             requestDataMap.put("paySign", sign);
         }
     }

 }

　　2.4、post方式提交xml数据工具（微信支付这样要求的）

 public Map<String, String> wxPayRequest(LinkedHashMap<String, String> requestDataMap, String requestUrl) {
         Map<String, String> wxResponseMap;
         try {
             URLConnection con = new URL(requestUrl).openConnection();
             con.setDoOutput(true);
             con.setRequestProperty("Cache-Control", "no-cache");
             con.setRequestProperty("Content-Type", "text/xml");

             OutputStreamWriter out = new OutputStreamWriter(con.getOutputStream());
             out.write(new String(WXPayUtil.mapToXml(requestDataMap).getBytes("UTF-8")));
             out.flush();
             out.close();

             String line = "";
             StringBuffer wxResponseStr = new StringBuffer();
             BufferedReader br = new BufferedReader(new InputStreamReader(con.getInputStream()));
             for (line = br.readLine(); line != null; line = br.readLine()) {
                 wxResponseStr.append(line);
             }

             logger.info("wxRespStr::" + wxResponseStr);
             wxResponseMap = WXPayUtil.xmlToMap(wxResponseStr.toString());
             logger.info("wxRespMap:" + wxResponseMap);
             return wxResponseMap;
         } catch (IOException e) {
             e.printStackTrace();
             return null;
         } catch (Exception e) {
             e.printStackTrace();
             return null;
         }
     }

　　3、服务器token验证（配合上文的   六、公众号开发参数配置——> 2）　　

 @GetMapping("weixinVerifyUrl")
     @LoggerManage(logDescription = "系统-微信校验URL的合法性")
     public void tokenVarify(HttpServletRequest request, HttpServletResponse response) {

         // 微信加密签名
         String signature = request.getParameter("signature");
         // 时间戳
         String timestamp = request.getParameter("timestamp");
         // 随机数
         String nonce = request.getParameter("nonce");
         // 随机字符串
         String echostr = request.getParameter("echostr");

         // 通过检验signature对请求进行校验，若校验成功则原样返回echostr，表示接入成功，否则接入失败
         if (signature != null && CheckoutUtil.checkSignature(signature, timestamp, nonce)) {
             try {
                 response.getWriter().write(echostr);
             } catch (IOException e) {
                 e.printStackTrace();
             }
             return;
         }
         return;
     }

　　4、统一下单

 public Map<String, Object> weixinPay(DealRecord dealRecord, Byte memberGrade, String userId) {
         Map<String, Object> retMap = new HashMap<>(2);

         /**
          * 1、用户背景校验
          */

         /**
          * 2、准备请求参数
          */
         LinkedHashMap<String, String> requestDataMap = new LinkedHashMap<>();
         requestDataMap.put("appid", WeixinConstant.WX_CON_APPID);
         requestDataMap.put("attach", memberGrade + "");
         requestDataMap.put("body", dealRecord.getGoodsName() + "-" + memberGrade);
         requestDataMap.put("device_info", "WEB");
         requestDataMap.put("fee_type", "CNY");
         requestDataMap.put("mch_id", WeixinConstant.WX_CON_MCH_ID);
         requestDataMap.put("nonce_str", UUIDUtil.getUUID());
         requestDataMap.put("notify_url", weixinPayNotifyUrl);
         requestDataMap.put("openid", dealRecord.getOpenid());
         requestDataMap.put("out_trade_no", dealRecord.getId());
         requestDataMap.put("sign_type", "MD5");
         requestDataMap.put("spbill_create_ip", dealRecord.getDeviceIp());
         requestDataMap.put("time_start", DateUtil.formatDate(dealRecord.getCreateTime(), DateUtil.SDF_yyyyMMddHHmmss));
         // 虽然文档上total_fee为int，但是String也可以
         requestDataMap.put("total_fee", dealRecord.getAmount() + "");
         requestDataMap.put("trade_type", "JSAPI");

         /**
          * 3、微信请求参数签名+下单
          */
         WeixinSignUtil.getWeixinSign(requestDataMap, true);
         Map<String, String> wxResponseMap = weixinService.wxPayRequest(requestDataMap, WeixinConstant.WX_URL_PAY_UNIFIEDORDER);

         /**
          * 4、逻辑处理
          */
         String return_code = wxResponseMap.get("return_code");
         if (WeixinConstant.RESULT_FAIL.equals(return_code)) {
             retMap.put("result", 0);
             retMap.put("data", wxResponseMap);
             return retMap;
         } else if (WeixinConstant.RESULT_SUCCESS.equals(return_code)) {
             String prepay_id = wxResponseMap.get("prepay_id");

             LinkedHashMap<String, String> wxDataMap = new LinkedHashMap<>(6);
             wxDataMap.put("appId", WeixinConstant.WX_CON_APPID);
             wxDataMap.put("nonceStr", UUIDUtil.getUUID());
             wxDataMap.put("package", "prepay_id=" + prepay_id);
             wxDataMap.put("signType", "MD5");
             wxDataMap.put("timeStamp", String.valueOf(System.currentTimeMillis() / 1000));

             // 微信请求参数签名
             WeixinSignUtil.getWeixinSign(wxDataMap, false);

             retMap.put("result", 0);
             retMap.put("data", wxDataMap);
             return retMap;
         }
         retMap.put("result", 9);
         return retMap;
     }

　　5、微信支付结果通知及商户服务器响应

 /**
      * @param request
      * @function 微信/支付通知
      */
     @RequestMapping(value = "/weixin/pay/notify")
     @LoggerManage(logDescription = "用户-微信/支付/回调通知")
     public void weixinPayNotify(HttpServletRequest request, HttpServletResponse response) {
         BufferedReader reader = null;
         StringBuilder wxRequestStr = new StringBuilder();
         Map<String, String> wxRequestMap = null;
         try {
             reader = new BufferedReader(new InputStreamReader(request.getInputStream(), "UTF-8"));
             String line = null;
             while ((line = reader.readLine()) != null) {
                 wxRequestStr.append(line);
             }

             logger.info("wxNotifyReqStr：" + wxRequestStr.toString());
             wxRequestMap = WXPayUtil.xmlToMap(wxRequestStr.toString());
             logger.info("wxNotifyReqMap:" + wxRequestMap);
         } catch (IOException e) {
             e.printStackTrace();
         } catch (Exception e) {
             e.printStackTrace();
         } finally {
             try {
                 if (null != reader) {
                     reader.close();
                 }
             } catch (IOException e) {
             }
         }

         String return_code = wxRequestMap.get("return_code");
         if (WeixinConstant.RESULT_FAIL.equals(return_code)) {
             // 支付失败
             logger.info("交易失败!");
         } else if (WeixinConstant.RESULT_SUCCESS.equals(return_code)) {

             try {
                 BufferedOutputStream out = new BufferedOutputStream(response.getOutputStream());
                 out.write(WXPayUtil.mapToXml(WeixinConstant.WX_CON_PAY_RESPMAP).getBytes("UTF-8"));
                 out.flush();
                 out.close();
             } catch (IOException e) {
                 e.printStackTrace();
             } catch (Exception e) {
                 e.printStackTrace();
             }
         }
     }

九、填坑之路

　　1、统一下单接口，请求微信，提示签名失败；

1）仔细检查统一下单接口里携带的参数，参数大小写、参数是否必须携带。比如是appid而不是appId；openid文档上写的是“否”，但是它在备注里写到trade_type=JSAPI时（即JSAPI支付），此参数必传，这个注意啊；

2）加密方式是否正确，可以把自己生成的sign与微信公众平台支付接口调试工具生成的sign做对比，如果不一致，那证明你的加签方式不正确，请仔细阅读加签安全规范这篇文章，比如里面提到的按照参数名ASCII字典序排序、拼接商户密钥、MD5加密并转化为大写；

3）如果第二步没问题，好吧，不要犹豫，去重置商户秘钥吧，注意是商户秘钥，因为支付加签时和商户秘钥有关，我当时就是卡在这一步了好久，至今记忆深刻；

4）如果第三步没问题，那么就是加签方法错误了，推荐使用微信工具包里面的加签方法。

　　2、微信内h5调起支付，提示“支付验证签名失败”

1）仔细检查参数，参数大小写、参数是否必须携带。比如是appId而不是appid(统一下单与这个正好相反)；package的value必须是“prepay_id=xxx”形式；

2）统一下单的签名的key是sign，而微信调起h5的签名的key是paySign,这个要注意；

3）加密方式是否正确，可以把自己生成的sign与微信公众平台支付接口调试工具生成的sign做对比，如果不一致，那证明你的加签方式不正确，请仔细阅读加签安全规范这篇文章，比如里面提到的按照参数名ASCII字典序排序、拼接商户密钥、MD5加密并转化为大写；

4）如果第三步没问题，好吧，不要犹豫，去重置商户秘钥吧。

　　3、微信内h5调起支付，提示“当前页面未注册 http：//xxx”

1）检查微信商户平台–>产品中心–>开发配置–>支付授权目录是否配置；

2）如果第一步没问题，但还是报错，那就得注意配置了。比如你的支付页是http://www.abc.com/pay/wxjspay/id/50.html，那配置为http://www.abc.com/pay/wxjspay/id/；假如是http://www.abc.com/pay/wxjspay.php，那配置为http://www.abc.com/pay/。规律就是去掉最后一个反斜杠的内容。