微信支付的那些事(JAVA开发微信支付-公众号支付/微信浏览器支付JSAPI) 一篇很详细的微信支付文档

最新推荐文章于 2025-06-27 18:00:20 发布

置顶爪哇还是java

最新推荐文章于 2025-06-27 18:00:20 发布

阅读量1k

点赞数

CC 4.0 BY-SA版权

分类专栏：微信支付文章标签：微信支付微信公众号

本文链接：https://blog.youkuaiyun.com/qq_41507845/article/details/83068090

微信支付专栏收录该内容

1 篇文章

订阅专栏

这个微信支付坑还是挺多的,本以为官网下载的JAVA-SDK-DEMO和网上的那些博客可以帮助我顺利的完成支付,但是,真正开发起来还是有些棘手,我也是第一次接触这个微信支付,写这篇文章目的也是避免更多的人走弯路.

第一步你得需要获取四大参数 appid appsecret mchId apisecret

1.我们先用微信公众号和密码登录我们的微信公众号平台微信公众号的账号和密码你可以去问你的老大要来

点击我们的左下角,我们就能获取到AppID和AppSecret参数值

2.点击左下角的公众号设置点击上方的功能设置我们点击配置网页授权域名填写顶级域名就可以比如nhhq.xxx.edu.cn

点击配置的时候就会出现以下的页面

我们需要将文件MP_verifyXXX.txt放在你的项目的中放心,这边你点击确认的话它会自动给你校验如下不然支付过程需要获取用户openid,必须经过网页授权配置才可以,要不然获取不到openid 下面会说到.

3.我们开始登陆商户平台商户平台的密码和账号你还是去要要不到你就发二维码让他扫描让你登陆就好了

点击上方的账号中心

我们就可以在里面配置我们的APISecret 次步骤需要商户管理者来配置因为设置过程中有各种各样的手机验证码啊微信验证啥

再点击上方的产品中心记住的商户mchId 点击支付授权目录添加我们的支付目录比方我们的的支付页面是http://nhhq.xxx.edu.cn/XXx/XXX/XXX/pay.html 那么我们需要配置的支付授权目录就填nhhq.xxx.edu.cn/XXx/XXX/XXX/

千万不要填错,不然后面会失败

二我们获取appid appsecret mchId apisecret 四大参数和配置之后我们成功了三分之一哈哈

1.先访问微信公众号的API列表中的统一下单https://pay.weixin.qq.com/wiki/doc/api/jsapi.php?chapter=9_1

眼观参数找出那些必填的参数未获取的也就openid 其他的代码中有

已经获取的:

appid (已获取) mchId 商户ID(已获取)

未获取的:

nonce_str 随机字符串 ,sign 签名,body 所支付的名称,out_trade_no 咱们自己所提供的订单号,需要唯一,total_fee 支付金额,spbill_create_ip IP地址,notify_url 回调地址,trade_type 支付类型,openid 支付人的微信公众号对应的唯一标识

2.这儿我们需要先获取openid, 授权发送下面的请求就可以获取code

https://open.weixin.qq.com/connect/oauth2/authorize?appid=填写你的appid&redirect_uri=你的url&response_type=code&scope=snsapi_base&state=STATE#wechat_redirect

这里解释下 scope：用snsapi_base就行 url请使用 urlEncode 对链接进行处理。 url是你将一些参数和获取到的code 带到你的支付页面前面提到的(http://nhhq.xxx.edu.cn/XXx/XXX/XXX/pay.html )

url= http://nhhq.xxx.edu.cn/XXx/XXX/XXX/pay.html?_token='+token+'&cost='+ $scope.cost )

将我们的参数和code带到pay.html页面上,我们就可以向后端发送请求了,问号后面是参数测试阶段建议就带code就好除非你做的也需要_token

http://XXX.xxxx.edu.cn/xxxx/xxx/xxxx/pay1?money="+cost+"&code="+code+'&out_trade_no='+ddbh+'&_token='+token

3.接下来我们最熟悉的Java代码来了

贴上接收的代码

    //公众号id
	private static final String appid = "xxxx"; 
	//公众号秘钥
	private static final String secret = "xxxx"; 
	//商户id
	private static final String mchId = "xxxx"; 
	//API秘钥
	private static final String paternerKey = "xxxx" ;


    @ResponseBody
	@RequestMapping(value="/order/pay1")
	public Map orders(HttpServletRequest request,HttpServletResponse response) {
		
		/*------1.获取参数信息------- */
		//商户订单号 前端传的值 如果没有传 那么注释掉
		//String out_trade_no= request.getParameter("out_trade_no");
		//价格  前端传的值 如果没有传 那么注释掉
		//String money = request.getParameter("money");
		//金额转化为分为单位
		//String finalmoney = WeChat.getMoney(money);
		//获取用户的code 必传 如果不确定有没有值 那么我们需要用F12 看前端有没有传过来
		String code = request.getParameter("code");
        //后端也可以用logger.debug看
		logger.debug(code+"111111111111111111"+code);
		/*------2.根据code获取微信用户的openId和access_token------- */
		//注： 如果后台程序之前已经得到了用户的openId 可以不需要这一步，直接从存放openId的位置或session中获取就可以。
		//提交的url路径也就不需要再经过微信重定向。写成：http://localhost:8080/项目名/wechat/pay?money=${sumPrice}&state=${orderId}
		String openid=null;
		try {
			List<Object> list = accessToken(code);//这方法下面有
			openid=list.get(1).toString();
		} catch (IOException e) {
			logger.error("根据code获取微信用户的openId出现错误", e);
			//mv.setViewName("error");
		}
		
		/*------3.生成预支付订单需要的的package数据------- */
		//随机数 
		String nonce_str= WXPayUtil.generateNonceStr();//工具类下面有
		
		//这里notify_url是 微信处理完支付后的回调的应用系统接口url,我下面贴上代码
		String notify_url ="" + Tool.getBasePath(request) + "/xxx/xxx/resultInformUrl";
		
		//拼接统一下单地址参数
		Map<String, String> paraMap = new HashMap<String, String>();
		//获取请求ip地址
		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();
	    }
	    if(ip.indexOf(",")!=-1){
	    	String[] ips = ip.split(",");
	    	ip = ips[0].trim();
	    }
		
		paraMap.put("appid", appid);   //appid号
		paraMap.put("body", "hotel_pay"); //支付描述 这边是个坑 下面说 
		paraMap.put("mch_id", mchId);  //商户id号
		paraMap.put("nonce_str", WXPayUtil.generateNonceStr()); //随机字符串  
		paraMap.put("openid", openid);
		paraMap.put("out_trade_no", out_trade_no);//订单号 保证唯一就好
		paraMap.put("spbill_create_ip", ip);  //订单生成的机器 IP
		paraMap.put("total_fee",1);  //支付金额  1  单位分  测试建议先填写1
		paraMap.put("trade_type", "JSAPI");  //交易类型 ：jsapi代表微信公众号支付
		// 此路径是微信服务器调用支付结果通知路径随意写
		try {
		String sign = WXPayUtil.generateSignature(paraMap, paternerKey);
		paraMap.put("sign", sign);
		String xml = WXPayUtil.mapToXml(paraMap);//将所有参数(map)转xml格式
		xml = new String(xml.getBytes("UTF-8"), "ISO-8859-1");			
		// 统一下单 https://api.mch.weixin.qq.com/pay/unifiedorder
		String unifiedorder_url = "https://api.mch.weixin.qq.com/pay/unifiedorder";
        //可以打印出 我们向微信的统一下单发送的xml
		logger.debug("111111111"+xml);
		
		String xmlStr = HttpRequest.sendPost(unifiedorder_url, xml);//发送post请求"统一下单接口"返回预支付id:prepay_id
		
		
		//以下内容是返回前端页面的json数据
		String prepay_id = "";//预支付id
		try {
			if (xmlStr.indexOf("SUCCESS") != -1) {  
				Map<String, String> map = WXPayUtil.xmlToMap(xmlStr);  
				logger.debug("mappppppppppp"+map.toString());
				prepay_id = (String) map.get("prepay_id");  
			}
			if(prepay_id.equals("")){
				//mv.addObject("ErrorMsg", "支付错误");
				logger.error("支付错误"+ prepay_id);
			
			}
		} catch (Exception e) {
			logger.error("统一支付接口获取预支付订单出错", e);
			
		}
		/*将prepay_id存到库中*/
		logger.debug("prepay_id------"+prepay_id);
		
		
		/*------7.将预支付订单的id和其他信息生成签名并一起返回到页面 ------- */
		nonce_str= WXPayUtil.generateNonceStr();;
		SortedMap<String, String> finalpackage = new TreeMap<String, String>();
		String timestamp = String.valueOf(System.currentTimeMillis() / 1000);
		
		String packages = "prepay_id="+prepay_id;
		finalpackage.put("appId",  appid);  
		finalpackage.put("timeStamp", timestamp);  
		finalpackage.put("nonceStr", nonce_str);  
		finalpackage.put("package", packages);  
		finalpackage.put("signType", "MD5");
		
		String finalsign = WXPayUtil.generateSignature(finalpackage, paternerKey);;
		
		finalpackage.put("paySign", finalsign);
		//打印出返回前端的map值
		logger.debug("22222222222222222222"+finalpackage);
	
		return finalpackage;
		} catch (Exception e) {
			e.printStackTrace();
		}  
	   return null;
	}



	 /**
     * 通过微信用户的code换取网页授权access_token
     * @return
     * @throws IOException
     * @throws
     */

    public List<Object> accessToken(String code) throws IOException {
        List<Object> list = new ArrayList<Object>();
        String url = "https://api.weixin.qq.com/sns/oauth2/access_token?appid="
                + appid + "&secret=" + secret + "&code=" + code + "&grant_type=authorization_code";
        HttpClient client = new DefaultHttpClient();
        HttpPost post = new HttpPost(url);
        HttpResponse res = client.execute(post);
        if (res.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
            HttpEntity entity = res.getEntity();
            String str = org.apache.http.util.EntityUtils.toString(entity, "utf-8");
            ObjectMapper mapper=new ObjectMapper();
            Map<String,Object> jsonOb=mapper.readValue(str, Map.class);
            list.add(jsonOb.get("access_token"));
            list.add(jsonOb.get("openid"));
        }
        return list;
    }

4.到这儿来,就说明我们的预支付(可以查看微信返回的xmlStr,如果fail 那么就查看里面错误代码)已经成功了,微信返回给我们的参数我们只需要把参数传到前端,上面的pay1方法我们完全可以用微信者开发工具调试和 postman测试, 下面是前端的代码

<body>
        <!-- <div>支付回调</div> -->
        <script>
             var LocString = String(window.document.location.href);
              function GetQueryString(name) {
                    var rs = new RegExp("(^|)" + name + "=([^&]*)(&|$)", "gi").exec(LocString), tmp;
                    if (tmp = rs) return tmp[2];
                    return null;
              }
        
              var keyType = decodeURI(GetQueryString("keyType"))

           //获取前面带回来的参数和code值
            var code =  decodeURI(GetQueryString("code"))
            var token = decodeURI(GetQueryString("token"))
			var ddbh = decodeURI(GetQueryString("ddbh"))
			var cost = decodeURI(GetQueryString("cost"))
            console.log(code,token,ddbh,cost)
        
            $.ajax({
				type: "POST",
				url: "http://XXX.xxxx.edu.cn/xxxx/xxx/xxxx/pay1?money="+cost+"&code="+code+'&out_trade_no='+ddbh+'&_token='+token,
				beforeSend: function(request) {
					request.setRequestHeader("Authorization", token);
				},
				success: function(res) {
					console.log(res)
					pay(res)
				}
        	});

//发起预支付
         function pay(res){
			if (typeof WeixinJSBridge == "undefined"){
			   if( document.addEventListener ){
				document.addEventListener('WeixinJSBridgeReady', onBridgeReady, false);
			   }else if (document.attachEvent){
				document.attachEvent('WeixinJSBridgeReady', onBridgeReady); 
				document.attachEvent('onWeixinJSBridgeReady', onBridgeReady);
			   }
			}else{
			   onBridgeReady(res);
			}   	
	    }
		function onBridgeReady(res){
            WeixinJSBridge.invoke(
			   'getBrandWCPayRequest',{
				  "timeStamp" : res.timeStamp,
				  "package" : res.package,
				  "paySign" : res.paySign,
				  "appId" : res.appid,
				  "signType" : "MD5",
				  "nonceStr" :res.nonceStr
		       },function(res){
	            if(res.err_msg == "get_brand_wcpay_request:ok"){  
					alert("微信支付成功!");
					window.history.go(-2)
	            }else if(res.err_msg == "get_brand_wcpay_request:cancel"){  
					alert("用户取消支付!");
					window.history.go(-1)
	            }else{  
	                alert("支付失败!"+JSON.stringify(res));
	            }  
			}); 
		} 


    </script>
</body>

5.支付成功后的回调函数notify_url方法

    /**
	 * 支付返回的回调函数
	 * 
	 * @param request
	 * @param response
	 * @return
	 */
	@RequestMapping(value = "resultInformUrl")
	@ResponseBody
	public void resultInformUrl(HttpServletRequest request, HttpServletResponse response) {
		System.out.println("进入----------------------》");
		String out_trade_no=null;
	    String return_code =null;
	    try {
	        InputStream inStream = request.getInputStream();
	        ByteArrayOutputStream outSteam = new ByteArrayOutputStream();
	        byte[] buffer = new byte[1024];
	        int len = 0;
	        while ((len = inStream.read(buffer)) != -1) {
	            outSteam.write(buffer, 0, len);
	        }
	        outSteam.close();
	        inStream.close();
	        String resultStr  = new String(outSteam.toByteArray(),"utf-8");
	        logger.info("支付成功的回调："+resultStr);
	        Map<String, String> resultMap = WXPayUtil.xmlToMap(resultStr);
	        String is_subscribe = (String) resultMap.get("is_subscribe");
	        String transaction_id = (String) resultMap.get("transaction_id");
	        String sign = (String) resultMap.get("sign");
	        String time_end = (String) resultMap.get("time_end");
	        String bank_type = (String) resultMap.get("bank_type");
	        System.out.println("打印出来的响应map===="+resultMap.toString());
	        out_trade_no = (String) resultMap.get("out_trade_no");
	        return_code = (String) resultMap.get("return_code");

	        request.setAttribute("out_trade_no", out_trade_no);
	        //通知微信.异步确认成功.必写.不然微信会一直通知后台.八次之后就认为交易失败了.
	        response.getWriter().write("<xml><return_code><![CDATA[SUCCESS]]></return_code></xml>");
	    }  catch (Exception e) {
	        logger.error("微信回调接口出现错误：",e);
	        try {
	            response.getWriter().write("<xml><return_code><![CDATA[FAIL]></return_code></xml>");
	        } catch (IOException e1) {
	            e1.printStackTrace();
	        }
	    } 
	    
	    boolean equals = return_code.equals("SUCCESS");
	    logger.info("支付成功的return_code："+equals+"==="+return_code+"----"+out_trade_no);
	    if(return_code.equals("SUCCESS")){
	        //支付成功的业务逻辑
	    	System.out.println("111111111");
	    	
	    	
	    }else{
	        //支付失败的业务逻辑
	    	System.out.println("222222222");
	    	
	    }
	}

6.下面是pay1中的一些工具类比如WXPayUtil 啥的你下载微信官方的JAVA-SDK-DEMO 里面有

package com.dtyun.base.utils.wx;

import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.io.StringWriter;
import java.security.MessageDigest;
import java.security.SecureRandom;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.Random;
import java.util.Set;

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import javax.xml.parsers.DocumentBuilder;
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;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

import com.dtyun.base.utils.wx.WXPayConstants.SignType;

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 {
	        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();
	    }
}

工具类较多我已经将一些工具类传到积分上了下载地址链接https://download.youkuaiyun.com/download/qq_41507845/10723373

三微信支付的坑

1.签名问题我完全用的工具类也就是微信官方文档中的方法生成

2.那个paraMap.put("body", "hotel_pay"); 中的body 如果写成中文那么就需要改编码格式

3.问题:get_brand_wcpay_request:fail

首先我们排查我们上面在商户平台授权目录是否有问题因为 .微信OAuth网页授权。服务号（订阅号不行）可以在公众号后台开通微信OAuth网页授权，用户在网页中进行授权操作时你会得到用户的openid

其次每次弹出的错误不一样有时候get_brand_wcpay_request:fail 缺少appid 或者签名不正确你得按它的指示查看你的参数也就是这六个左边的大小写也不能写错

"timeStamp" : res.timeStamp,
"package" : res.package,
"paySign" : res.paySign,
"appId" : res.appid,
"signType" : "MD5",
"nonceStr" :res.nonceStr

最后实在不行你就按照步骤继续来几遍 .

四如果还有什么问题可以留言看到就回复谢谢