公众号微信支付开发手记

　　作者：wallimn　时间：2017-02-27

　　本人原创，欢迎转载，转载请保留本文链接。本文地址：http://wallimn.iteye.com/blog/2359379

　　花了两天时间，琢磨了一下微信支付。感觉坑并不像传言中那么多，主要有两个：
　　一、app的key与商户的key是两个不一样的key。我用了错误的key，花了很长时间解决支付时签名错误。
　　二、最后页面调起支付时，一直报错：get_brand_wcpay_request:fail。花了很长时间排除。
　　由于页面在手机上，很难调试。后来想到一个办法，在页面上建一个div元素，设置其ID为actionResult，然后使用jQuery提供的方法显示调用结果：
$("#actionResult").text(JSON.stringify(res)) 
　　可以很容易地看到出错原因。
　　常见的原因有三个：
　　1、参数数量不足或名称错误。查看开发文档，提供足够的参数，名称、大小写要正确，注意timeStamp的单位为秒。　
　　2、签名不正确。注意查看签名的要求。
　　3、地址没有授权、或填写错误。“微信支付”->“开发配置”中，设置授权目录。授权要较长时间才能生效。如果地址为：http://wallimn.iteye.com/weixin/paytest，那么微信平台中的授权地址应为：http://wallimn.iteye.com/weixin/paytest

　　还有两个要注意的小问题：
　　一、定单号(out_trade_no)如果重复会导致支付失败。
　　二、测试用户要加入白名单。

　　微信的流程图有一点点儿不太直观，我画了一个简单的，应该一看就会明白。

　　程序的主体代码如下。

一、几个基本的辅助类
1.统一定单类

package com.wallimn.weixin;
/**
 * 统一定单，用于向微信提供信息，进行支付
 * @author wallimn
 *
 */
public class UnifiedOrder {

	private String appid;
	private String mch_id;
	private String nonce_str;
	private String sign_type;//="MD5"
	private String body;//商品描述
	private String device_info="WEB";//设备号
	
	private String detail;
	private String out_trade_no;//商户订单号
	private String fee_type;//，非必需="CNY"
	private String total_fee;//分为单位
	
	private String spbill_create_ip;
	private String notify_url;
	private String trade_type;//JSAPI、NATIVE、APP三种
	private String product_id="something";//商品ID，非必需
	private String openid;//JSAPI时，必传
	public String getAppid() {
		return appid;
	}
	public void setAppid(String appid) {
		this.appid = appid;
	}
	public String getMch_id() {
		return mch_id;
	}
	public void setMch_id(String mch_id) {
		this.mch_id = mch_id;
	}
	public String getNonce_str() {
		return nonce_str;
	}
	public void setNonce_str(String nonce_str) {
		this.nonce_str = nonce_str;
	}
	public String getBody() {
		return body;
	}
	public void setBody(String body) {
		this.body = body;
	}
	public String getDetail() {
		return detail;
	}
	public void setDetail(String detail) {
		this.detail = detail;
	}
	public String getOut_trade_no() {
		return out_trade_no;
	}
	public void setOut_trade_no(String out_trade_no) {
		this.out_trade_no = out_trade_no;
	}
	public String getFee_type() {
		return fee_type;
	}
	public void setFee_type(String fee_type) {
		this.fee_type = fee_type;
	}
	public String getSpbill_create_ip() {
		return spbill_create_ip;
	}
	public void setSpbill_create_ip(String spbill_create_ip) {
		this.spbill_create_ip = spbill_create_ip;
	}
	public String getNotify_url() {
		return notify_url;
	}
	public void setNotify_url(String notify_url) {
		this.notify_url = notify_url;
	}
	public String getTrade_type() {
		return trade_type;
	}
	public void setTrade_type(String trade_type) {
		this.trade_type = trade_type;
	}
	public String getProduct_id() {
		return product_id;
	}
	public void setProduct_id(String product_id) {
		this.product_id = product_id;
	}
	public String getOpenid() {
		return openid;
	}
	public void setOpenid(String openid) {
		this.openid = openid;
	}
	public String getDevice_info() {
		return device_info;
	}
	public void setDevice_info(String device_info) {
		this.device_info = device_info;
	}
	public String getTotal_fee() {
		return total_fee;
	}
	public void setTotal_fee(String total_fee) {
		this.total_fee = total_fee;
	}
	public String getSign_type() {
		return sign_type;
	}
	public void setSign_type(String sign_type) {
		this.sign_type = sign_type;
	}
	
}

2.统一定单结果类

package com.wallimn.weixin;

/**
 * 微信定单返回信息
 * @author wallimn
 *
 */
public class UnifiedOrderResult {
	
	private String return_code;
	private String return_msg;
	private String appid;
	private String mch_id;
	private String nonce_str;
	private String sign;
	private String result_code;
	private String prepay_id;
	private String trade_type;
	

	public String getReturn_msg() {
		return return_msg;
	}

	public void setReturn_msg(String return_msg) {
		this.return_msg = return_msg;
	}

	public String getReturn_code() {
		return return_code;
	}

	public void setReturn_code(String return_code) {
		this.return_code = return_code;
	}

	public String getNonce_str() {
		return nonce_str;
	}

	public void setNonce_str(String nonce_str) {
		this.nonce_str = nonce_str;
	}

	public String getAppid() {
		return appid;
	}

	public void setAppid(String appid) {
		this.appid = appid;
	}

	public String getMch_id() {
		return mch_id;
	}

	public void setMch_id(String mch_id) {
		this.mch_id = mch_id;
	}

	public String getSign() {
		return sign;
	}

	public void setSign(String sign) {
		this.sign = sign;
	}

	public String getResult_code() {
		return result_code;
	}

	public void setResult_code(String result_code) {
		this.result_code = result_code;
	}

	public String getPrepay_id() {
		return prepay_id;
	}

	public void setPrepay_id(String prepay_id) {
		this.prepay_id = prepay_id;
	}

	public String getTrade_type() {
		return trade_type;
	}

	public void setTrade_type(String trade_type) {
		this.trade_type = trade_type;
	}
}

3.与微信相关的常量类

package com.wallimn.weixin;

import java.net.URLEncoder;

/**
 * 与微信相关的常量
 * @author Administrator
 *
 */
public class Config {
	public static final String app_id="";
	public static final String app_sercet="";
	/**
	 * 微信登录授权时使用的state参数
	 */
	public static final String state="wallimn";
	/**
	 * 微信登录授权时使用的scope参数
	 */
	public static final String scope="snsapi_userinfo";
	
	
	/**
	 * 获取code的Servlet地址，微信平台提供
	 */
	public static final String code_url = "http://www.day2up.com/bzslql/sso/weixin";
	/**
	 * 默认的登录后跳转地址
	 */
	public static final String default_back_url = "/index.jsp";
	
	/**
	 * 微信支付的商户号，微信商户注册时获得
	 */
	public static final String mch_id="";
	/**
	 * 商户的api的key，在微信的商户平台中设置。与app的key不一样．这个是个坑！
	 */
	public static final String mch_secret="";
	/**
	 * 微信统一下单接口
	 */
	public static final String unifiedorder_url = "https://api.mch.weixin.qq.com/pay/unifiedorder";
	
	/**
	 * 用户支付成功后，微信平台的通知地址
	 */
	public static final String pay_notify_url="";
	
	/**
	 * 返回微信的获取code的地址。将backurl编码到地址中。授权成功后，自动返回backurl对应的地址。
	 * <br>
	 * 时间：2017年2月27日，作者：http://wallimn.iteye.com
	 * @param backUrl
	 * @return
	 */
	public static String getCodeUrl(String backUrl){
		try {
			String url = code_url;
			//这样可以灵活返回到指定的地址，不必在Servlet中硬编码
			if(backUrl!=null){
				url += "?backurl="+backUrl;
			}
			String ru = URLEncoder.encode(url,"utf-8");
			return "https://open.weixin.qq.com/connect/oauth2/authorize?appid="+app_id+"&redirect_uri="+ru+"&response_type=code&scope="+scope+"&state="+state+"#wechat_redirect";
		} catch (Exception e) {
			e.printStackTrace();
		}
		return null;
	}
	/**
	 * 获取access_token的链接
	 * <br>
	 * 时间：2017年2月27日，作者：http://wallimn.iteye.com
	 * @param code
	 * @return
	 */
	public static String getTokenUrl(String code){
    	return "https://api.weixin.qq.com/sns/oauth2/access_token?appid="+app_id+"&secret="+app_sercet+"&code="+code+"&grant_type=authorization_code";
    }
	
	/**
	 * 刷新access_token的链接
	 * @param token
	 * @return
	 * 作者：wallimn<br/>
	 * 时间：2017年1月22日<br/>
	 * 联系：[e-mail]<br/>
	 */
	public static String getFreshTokenUrl(String token){
    	return "https://api.weixin.qq.com/sns/oauth2/refresh_token?appid="+app_id+"&grant_type=refresh_token&refresh_token="+token;
    }
    
	/**
	 * 使用access_token获取用户信息的链接
	 * @param token
	 * @param openid
	 * @return
	 * 作者：wallimn<br/>
	 * 时间：2017年1月22日<br/>
	 * 联系：[e-mail]<br/>
	 */
	public static String getUserInfoUrl(String token,String openid){
    	return "https://api.weixin.qq.com/sns/userinfo?access_token="+token+"&openid="+openid+"&lang=zh_CN";
    }
}

二、支付工具类

package com.wallimn.weixin;

import java.io.InputStream;
import java.lang.reflect.InvocationTargetException;
import java.security.MessageDigest;
import java.util.Arrays;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.UUID;

import org.apache.commons.beanutils.BeanUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

import com.fasterxml.jackson.databind.ObjectMapper;

/**
 * 微信支付处理辅助类
 * @author http://wallimn.iteye.com
 *
 */
public class PayUtils {
	private static final Logger log = LogManager.getLogger(PayUtils.class);

	/**
	 * 解析统一定单结果数据。
	 * 
	 * @param xml
	 * @return
	 * <br>
	 * 时间：2017年2月27日<br>
	 * 作者：http://wallimn.iteye.com<br>
	 * 联系：[e-mail]
	 */
	public static UnifiedOrderResult parseUnifiedOrderResult(String xml) {
		UnifiedOrderResult result = new UnifiedOrderResult();
		//AXReader reader = new SAXReader();
		Document doc=null;
		try {
			//doc = reader.read(xml);
			doc = DocumentHelper.parseText(xml);
			result.setReturn_code(((Element) doc.selectSingleNode("/xml/return_code")).getText());
			result.setReturn_msg(((Element) doc.selectSingleNode("/xml/return_msg")).getText());
			if("SUCCESS".equals(result.getReturn_code())){
				result.setAppid(((Element) doc.selectSingleNode("/xml/appid")).getText());
				result.setMch_id(((Element) doc.selectSingleNode("/xml/mch_id")).getText());
				result.setNonce_str(((Element) doc.selectSingleNode("/xml/nonce_str")).getText());
				//result.setOpenid(((Element) doc.selectSingleNode("/xml/openid")).getText());
				result.setSign(((Element) doc.selectSingleNode("/xml/sign")).getText());
				result.setResult_code(((Element) doc.selectSingleNode("/xml/result_code")).getText());
				result.setPrepay_id(((Element) doc.selectSingleNode("/xml/prepay_id")).getText());
				result.setTrade_type(((Element) doc.selectSingleNode("/xml/trade_type")).getText());
				
			}
			doc = null;
			//reader = null;
		} catch (DocumentException e) {
			log.error("解析统一定单返回结果错误：{}",e.getMessage());
			e.printStackTrace();
		}
		return result;
	}

	/**
	 * 使用必须用户提供的参数，生成统计定单对象
	 * 
	 * @param body
	 * @param detail
	 * @param openid
	 * @param out_trade_no
	 * @param spbill_create_ip
	 * @param total_fee
	 * @param trade_type
	 * @return
	 * <br>
	 * 时间：2017年2月27日<br>
	 * 作者：http://wallimn.iteye.com<br>
	 * 联系：[e-mail]
	 */
	public static UnifiedOrder getUnifiedOrder(String body, String detail, String openid, String out_trade_no,
			String spbill_create_ip, String total_fee, String trade_type) {
		UnifiedOrder order = new UnifiedOrder();
		/*
		 * String wx_order = Config.order_url;// 获取统一下单接口地址 String mchappid =
		 * Config.appid;// 商户appid String mchid = Config.mch_id;// 商户ID String
		 * wx_callback = Config.paycallback_url;// 获取微信支付回调接口 String wx_key =
		 * Config.appsercet;// 微信商户后台设置的key String app_mchid = Config.appid;//
		 * APP调起微信支付的商户ID String app_mchappid = Config.mch_id;// APP调起微信的APPID
		 */
		order.setAppid(Config.app_id);
		order.setBody(body);
		order.setMch_id(Config.mch_id);
		order.setNonce_str(UUID.randomUUID().toString().replace("-", ""));
		order.setNotify_url(Config.pay_notify_url);
		order.setOpenid(openid);
		order.setOut_trade_no(out_trade_no);
		order.setSpbill_create_ip(spbill_create_ip);
		order.setTotal_fee(total_fee);
		order.setTrade_type(trade_type);
		order.setDetail(detail);

		return order;
	}

	/**
	 * 将bean转化为Map，方便下一步签名、转化xml使用
	 * 
	 * @param bean
	 * @return
	 * <br>
	 * 时间：2017年2月27日<br>
	 * 作者：http://wallimn.iteye.com<br>
	 * 联系：[e-mail]
	 */
	public static Map<String, String> BeanToMap(Object bean) {
		Map<String, String> map = null;
		try {
			map = BeanUtils.describe(bean);
			map.remove("class");
		} catch (IllegalAccessException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (InvocationTargetException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (NoSuchMethodException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return map;
	}

	/**
	 * 将Map数据转化为统一定单要求的xml数据。
	 * 
	 * @param map
	 * @return
	 * <br>
	 * 时间：2017年2月27日<br>
	 * 作者：http://wallimn.iteye.com<br>
	 * 联系：[e-mail]
	 */
	public static String MapToXML(Map<String, String> map) {
		if (map == null)
			return null;
		StringBuilder sb = new StringBuilder();
		sb.append("<xml>");
		String value = null;
		Set<String> keySet = map.keySet();
		String [] keyArray = keySet.toArray(new String[0]);
		Arrays.sort(keyArray);

		for (String key :keyArray) {
			value = map.get(key);
			if (value == null) {
				value = "";
			} else if (value.length() > 60) {
				// 简单处理一下，如果过长，就加上XML的转义
				value = "<![CDATA[" + value + "]]";
			}
			sb.append("<").append(key).append(">").append(value).append("</").append(key)
					.append(">");
		}
		sb.append("</xml>");
		return sb.toString();
	}
	
	/**
	 * 读取流中的xml数据，转化为Map<String,String>
	 * 
	 * @param is
	 * @return
	 * <br>
	 * 时间：2017年2月27日<br>
	 * 作者：http://wallimn.iteye.com<br>
	 * 联系：[e-mail]
	 */
	public static Map<String,String> XmlToMap(InputStream is){
		HashMap<String, String> map = new HashMap<String, String>();
		log.info("------------微信回调函数----------------");
		// 1、读取传入信息并转换为map
		SAXReader reader = new SAXReader();
		Document document = null;
		try {
			document = reader.read(is);
			log.info("支付返回结果：/n/r"+document.asXML());
			Element root = document.getRootElement();
			List<Element> list = root.elements();
			for (Element e : list) {
				map.put(e.getName().trim(), e.getText().trim());
			}
			document = null;
			reader = null;
		}
		catch(Exception e){
			log.error("XML转化为bean错误，原因：{}",e.getMessage());
			e.printStackTrace();
		}
		return map;
		
	}

	/**
	 * 提交统一定单，仅对应于JSAPI类型
	 * 
	 * @param orderXml
	 * @return 返回结果为适合公众号页面上使用的JSON数据。格式与微信要求一致。
	 * <br>
	 * 时间：2017年2月27日<br>
	 * 作者：http://wallimn.iteye.com<br>
	 * 联系：[e-mail]
	 */
	public static String postUnifiedOrder(String orderXml) {
		String response = "";
		try {// 注意，此处的httputil一定发送请求的时候一定要注意中文乱码问题，中文乱码问题会导致在客户端加密是正确的，可是微信端返回的是加密错误
			log.info("统一定单发送："+Config.unifiedorder_url);
			response = HttpUtils.post(Config.unifiedorder_url, orderXml);
			log.info("统一定单结果："+response);
			UnifiedOrderResult orderResult = PayUtils.parseUnifiedOrderResult(response);

			// 6、处理请求结果
			log.info("return_code={}, result_code={}",orderResult.getReturn_code(),orderResult.getResult_code());
			if ("SUCCESS".equals(orderResult.getReturn_code()) && "SUCCESS".equals(orderResult.getResult_code())) {
				log.error("微信支付统一下单请求成功：" + orderResult.getPrepay_id());
			} else {
				log.error("微信支付统一下单请求错误：{}" + orderResult.getReturn_msg());
				return null;
			}

			HashMap<String, String> back = new HashMap<String, String>();
			ObjectMapper mapper = new ObjectMapper();

			// 生成客户端调时需要的信息对象
			// 网页调起的时候
			//时戳，要求转化为以秒为单位
			String time = Long.toString(System.currentTimeMillis() / 1000);
			back.put("appId", Config.app_id);
			back.put("timeStamp", time);
			String uuid = UUID.randomUUID().toString().replace("-","");
			back.put("nonceStr", uuid);
			back.put("package", "prepay_id=" + orderResult.getPrepay_id());
			back.put("signType", "MD5");
			
			//根据以上参数，计算签名。
			String sign = signature(back, Config.mch_secret);
			back.put("paySign", sign);

			String json = mapper.writeValueAsString(back);
			//log.info("返回也面的JSON：/n/r{}"+json);
			return json;

		} catch (Exception e) {
			log.error("微信支付统一下单失败，http请求失败：{}", e.getMessage());
			e.printStackTrace();
		}

		return null;

	}

	/**
	 * 查检定单数据
	 * 
	 * @param order
	 * @return
	 * <br>
	 * 时间：2017年2月27日<br>
	 * 作者：http://wallimn.iteye.com<br>
	 * 联系：[e-mail]
	 */
	public static boolean checkUnifiedOrder(UnifiedOrder order) {

//		if (StringUtils.isBlank(order.getDetail()) ) {
//			log.error("微信支付统一下单请求错误：detail为空！");
//			return false;
//		}

		if ( StringUtils.isBlank(order.getBody())) {
			log.error("微信支付统一下单请求错误：body为空！");
			return false;
		}

		if ( StringUtils.isBlank(order.getSpbill_create_ip())) {
			log.error("微信支付统一下单请求错误：spbill_create_ip为空！");
			return false;
		}

		if (StringUtils.isBlank(order.getOut_trade_no()) ) {
			log.error("微信支付统一下单请求错误：out_trade_no为空！");
			return false;
		}

		if (StringUtils.isBlank(order.getTotal_fee())) {
			log.error("微信支付统一下单请求错误：total_fee为空！");
			return false;
		}

		if (StringUtils.isBlank(order.getTrade_type())) {
			log.error("微信支付统一下单请求错误：trade_type为空！");
			return false;
		}

		try {// 进行格式转换异常获取，保证数目正确
			int fee = Integer.parseInt(order.getTotal_fee());
			if (fee == 0 || !order.getTotal_fee().equals(String.valueOf(fee))) {// 微信支付的支付金额必须为大于0的int类型，单位为分
				log.error("微信支付统一下单请求错误：请求金额不能为0，不能为小数");
				return false;
			}
		} catch (Exception e) {
			log.error("微信支付统一下单请求错误：请求金额格式错误，值：{}", order.getTotal_fee());
			return false;
		}

		if (!("JSAPI".equalsIgnoreCase(order.getTrade_type()) || "NATIVE".equalsIgnoreCase(order.getTrade_type())
				|| "APP".equalsIgnoreCase(order.getTrade_type()))) {
			log.error("微信支付统一下单请求错误：支付类型不正确，{}", order.getTrade_type());
			return false;
		}

		/* 公众号调起微信支付的时候，必须要有openID */
		if ("JSAPI".equalsIgnoreCase(order.getTrade_type()) && StringUtils.isBlank(order.getOpenid())) {
			log.error("微信支付统一下单请求错误：请求参数不足，当类型为JSAPI时，必须提供openid");
			return false;
		}

		if (StringUtils.isBlank(order.getAppid()) || StringUtils.isBlank(order.getMch_id())
				|| StringUtils.isBlank(order.getNotify_url())) {
			log.error("微信支付统一下单请求错误：系统配置信息缺失，appid, mch_id, notify_url");
			return false;
		}

		return true;
	}

	/**
	 * 签名生成的通用步骤如下：
	 * 第一步，设所有发送或者接收到的数据为集合M，将集合M内非空参数值的参数按照参数名ASCII码从小到大排序（字典序），使用URL键值对的格式（即key1=value1&key2=value2…）拼接成字符串stringA。
	 * 特别注意以下重要规则： ◆ 参数名ASCII码从小到大排序（字典序）； ◆ 如果参数的值为空不参与签名； ◆ 参数名区分大小写； ◆
	 * 验证调用返回或微信主动通知签名时，传送的sign参数不参与签名，将生成的签名与该sign值作校验。 ◆
	 * 微信接口可能增加字段，验证签名时必须支持增加的扩展字段
	 * 第二步，在stringA最后拼接上key得到stringSignTemp字符串，并对stringSignTemp进行MD5运算，再将得到的字符串所有字符转换为大写，得到sign值signValue。
	 * key设置路径：微信商户平台(pay.weixin.qq.com)-->账户设置-->API安全-->密钥设置 *
	 */
	
	/**
	 * 为微信支付发送数据进行签名的类。
	 * 
	 * @param map
	 * @param app_secret
	 * @return
	 * <br>
	 * 时间：2017年2月27日<br>
	 * 作者：http://wallimn.iteye.com<br>
	 * 联系：[e-mail]
	 */
	public static String signature(Map<String, String> map, String app_secret) {
		List<String> keyList = new LinkedList<String>();
		// 如果参数不为空，加入签名的字符串
		for (Entry<String, String> entry : map.entrySet()) {
			if (StringUtils.isNotEmpty(entry.getValue())) {
				keyList.add(entry.getKey());
			}
		}

		String[] keyArray = keyList.toArray(new String[0]);
		Arrays.sort(keyArray);
		StringBuilder sbInfo = new StringBuilder();
		// 进行字典排序
		for (String str : keyArray) {
			sbInfo.append(str).append("=").append(map.get(str)).append("&");
		}
		if (StringUtils.isNotEmpty(app_secret)) {
			sbInfo.append("key=" + app_secret);
		}
		String tosend = sbInfo.toString();
		MessageDigest md = null;
		byte[] bytes = null;
		try {

			md = MessageDigest.getInstance("MD5");
			bytes = md.digest(tosend.getBytes("utf-8"));
		} catch (Exception e) {
			e.printStackTrace();
		}

		String sign = byteToStr(bytes);
		System.out.println("签名字符串："+tosend);
		sign = sign.toUpperCase();
		System.out.println("签名字结果："+sign);
		return sign;

	}

	/**
	 * 字节数组转换为字符串
	 * 
	 * @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;
	}
	/**
	 * SHA-1签名，这个在实际中并未使用
	 * <br>
	 * 时间：2017年2月27日，作者：http://wallimn.iteye.com
	 * @param map
	 * @return
	 */
	public static String signatureSHA1(Map<String, String> map) {
		Set<String> keySet = map.keySet();
		String[] str = new String[map.size()];
		StringBuilder tmp = new StringBuilder();
		// 进行字典排序
		str = keySet.toArray(str);
		Arrays.sort(str);
		for (int i = 0; i < str.length; i++) {
			String t = str[i] + "=" + map.get(str[i]) + "&";
			tmp.append(t);
		}

		String tosend = tmp.toString().substring(0, tmp.length() - 1);
		MessageDigest md = null;
		byte[] bytes = null;
		try {

			md = MessageDigest.getInstance("SHA-1");
			bytes = md.digest(tosend.getBytes("utf-8"));
		} catch (Exception e) {
			e.printStackTrace();
		}

		String singe = byteToStr(bytes);
		return singe.toLowerCase();

	}
}

三、HttpClient辅助类

package com.wallimn.weixin;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.HttpClient;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.message.BasicNameValuePair;

public class HttpUtils {
	private static final String Charset = "utf-8";
	public static HttpClient client;
	static {
		client = HttpClientBuilder.create().build();

	}

	/**
	 * 发送请求，如果失败，会返回null
	 * @param url
	 * @param map
	 * @return
	 */
	public static String post(String url, Map<String, String> map) {
		// 处理请求地址
		try {
			URI uri = new URI(url);
			HttpPost post = new HttpPost(uri);

			// 添加参数
			List<NameValuePair> params = new ArrayList<NameValuePair>();
			for (String str : map.keySet()) {
				params.add(new BasicNameValuePair(str, map.get(str)));
			}
			post.setEntity(new UrlEncodedFormEntity(params, Charset));
			// 执行请求
			HttpResponse response = client.execute(post);

			if (response.getStatusLine().getStatusCode() == 200) {
				// 处理请求结果
				StringBuffer buffer = new StringBuffer();
				InputStream in = null;
				try {
					in = response.getEntity().getContent();
					BufferedReader reader = new BufferedReader(new InputStreamReader(in,Charset));
					String line = null;
					while ((line = reader.readLine()) != null) {
						buffer.append(line);
					}

				} catch (UnsupportedOperationException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				} finally {
					// 关闭流
					if (in != null)
						try {
							in.close();
						} catch (IOException e) {
							// TODO Auto-generated catch block
							e.printStackTrace();
						}
				}

				return buffer.toString();
			} else {
				return null;
			}
		} catch (URISyntaxException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (UnsupportedEncodingException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		} catch (ClientProtocolException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		} catch (IOException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		}
		return null;

	}

	/**
	 * 发送请求，如果失败会返回null
	 * @param url
	 * @param str
	 * @return
	 */
	public static String post(String url, String str) {
		// 处理请求地址
		try {
			URI uri = new URI(url);
			HttpPost post = new HttpPost(uri);
			post.setEntity(new StringEntity(str, Charset));
			// 执行请求
			HttpResponse response = client.execute(post);

			if (response.getStatusLine().getStatusCode() == 200) {
				// 处理请求结果
				StringBuffer buffer = new StringBuffer();
				InputStream in = null;
				try {
					in = response.getEntity().getContent();
					BufferedReader reader = new BufferedReader(new InputStreamReader(in,"utf-8"));
					String line = null;
					while ((line = reader.readLine()) != null) {
						buffer.append(line);
					}

				} finally {
					// 关闭流
					if (in != null)
						in.close();
				}

				return buffer.toString();
			} else {
				return null;
			}
		} catch (URISyntaxException | IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return null;

	}

	/**
	 * 发送GET方式的请求，并返回结果字符串。
	 * <br>
	 * 时间：2017年2月27日，作者：http://wallimn.iteye.com
	 * @param url
	 * @return 如果失败，返回为null
	 */
	public static String get(String url) {
		try {
			URI uri = new URI(url);
			HttpGet get = new HttpGet(uri);
			HttpResponse response = client.execute(get);
			if (response.getStatusLine().getStatusCode() == 200) {
				StringBuffer buffer = new StringBuffer();
				InputStream in = null;
				try {
					in = response.getEntity().getContent();
					BufferedReader reader = new BufferedReader(new InputStreamReader(in,Charset));
					String line = null;
					while ((line = reader.readLine()) != null) {
						buffer.append(line);
					}

				} finally {
					if (in != null)
						in.close();
				}

				return buffer.toString();
			} else {
				return null;
			}
		} catch (URISyntaxException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (ClientProtocolException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return null;

	}

}

四、Controller中相关的代码

package com.wallimn.bzslql.controller;

import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.h2.util.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;

import com.wallimn.weixin.Config;
import com.wallimn.weixin.HttpUtils;
import com.wallimn.weixin.PayUtils;
import com.wallimn.weixin.UnifiedOrder;
import com.wallimn.weixin.User;

/**
 * 与微信相关的处理Controller
 * 
 * @author wallimn
 *
 */
@Controller
@RequestMapping("/weixin")
public class WeixinController extends CommonController {

	private static Logger log = LogManager.getLogger(WeixinController.class);
	@Autowired
	private HttpServletRequest request;
	@Autowired
	protected HttpServletResponse response;

	/**
	 * 接受用户提供的信息，生成标准的统一订单，提交到微信平台进行处理，提交成功后，返回JSON数据，
	 * 公众号网页依据此JSON内容，调用微信平台的接口、输入密码，完成支付
	 * 
	 * @param body
	 * @param detail
	 * @param out_trade_no
	 * @param total_fee
	 * @return
	 * @throws Exception
	 * <br>
	 * 时间：2017年2月27日<br>
	 * 作者：http://wallimn.iteye.com<br>
	 * 联系：[e-mail]
	 */
	@RequestMapping("/unifiedorder")
	@ResponseBody
	public String unifiedorder(String body, String detail, String out_trade_no, String total_fee) throws Exception {
		String spbill_create_ip = request.getRemoteAddr();
		String openid = this.getLoginUserId();
		log.info("创建定单：body:{}, detail:{},out_trade_no:{},total_fee:{}", body, detail, out_trade_no, total_fee);
		UnifiedOrder order = PayUtils.getUnifiedOrder(body, "", openid, out_trade_no, spbill_create_ip, total_fee,
				"JSAPI");
		if (PayUtils.checkUnifiedOrder(order) == true) {
			Map<String, String> map = PayUtils.BeanToMap(order);
			String sign = PayUtils.signature(map, Config.mch_secret);
			log.info("签名：" + sign);
			map.put("sign", sign);//加入签名
			String orderXml = PayUtils.MapToXML(map);//生成xml定单数据
			log.info("统一定单：" + orderXml);
			String result = PayUtils.postUnifiedOrder(orderXml);
			log.info("统一定单结果：" + result);
			// String result = WechatOrderUtils.createOrder(detail, body,
			// openid, ip, goodSn, orderSn, total_fee, "JSAPI");
			return result;
		} else {
			return this.getFailJSON("FAIL", "定单参数错误！");
		}
	}

	/**
	 * 微信支付回调函数。 当用户支付成功后，通过此地址通知操作结果
	 * 该地址在向微信发送统一定单时，告知微信平台。
	 * 
	 * @param request
	 * @param response
	 * @throws IOException
	 * <br>
	 * 时间：2017年2月27日<br>
	 * 作者：http://wallimn.iteye.com<br>
	 * 联系：[e-mail]
	 */
	@RequestMapping(value = "/paycallback", method = RequestMethod.POST)
	public void payCallBack(HttpServletRequest request, HttpServletResponse response) throws IOException {
		InputStream is = request.getInputStream();
		Map<String, String> map = PayUtils.XmlToMap(is);
		String result_code = map.get("result_code");
		// 支付成功
		if ("SUCCESS".equals(result_code)) {
			String sign = map.get("sign");
			// System.out.println(map.toString());
			// 2、克隆传入的信息并进行验签
			map.remove("sign");
			String sign2 = PayUtils.signature(map, Config.mch_secret);
			if (StringUtils.equals(sign, sign2)) {
				log.info("微信支付回调函数，验答正确。处理业务逻辑。");
				// TODO:添加业务处理逻辑
			} else {
				log.error("微信支付回调函数：验签错误！");

			}
		} else if ("FAIL".equals(result_code)) {
			log.error("微信支付回调函数：失败！失败代码为：{}", map.get("return_code"));

		}

		// 返回信息，防止微信重复发送报文
		// 由于微信后台会同时回调多次，所以需要做防止重复提交操作的判断
		// 此处放防止重复提交操作
		String result = "<xml>" + "<return_code><![CDATA[SUCCESS]]></return_code>"
				+ "<return_msg><![CDATA[OK]]></return_msg>" + "</xml>";
		PrintWriter out = new PrintWriter(response.getOutputStream());
		out.print(result);
		out.flush();
		out.close();

	}

	/**
	 * 支付操作准备界面(测试用)。
	 * 注意映射地址为：/weinxin/paytest/170228，那么在微信设置界面中，填写的授权地址应为：/weinxin/paytest/
	 * 这是一个坑
	 * 
	 * @return
	 * <br>
	 * 时间：2017年2月27日<br>
	 * 作者：http://wallimn.iteye.com<br>
	 * 联系：[e-mail]
	 */
	@RequestMapping("/paytest/170228")
	public String paytest() {
		return "paytest";
	}

	/**
	 * 支付操作准备界面。
	 * 注意映射地址为：/weinxin/paytest/170228，那么在微信设置界面中，填写的授权地址应为：/weinxin/payreal/
	 * 
	 * @return
	 * <br>
	 * 时间：2017年2月27日<br>
	 * 作者：http://wallimn.iteye.com<br>
	 * 联系：[e-mail]
	 */
	@RequestMapping("/payreal/170228")
	public String payreal() {
		return "payreal";
	}
}

五、公众号页面

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>
<!DOCTYPE html>
<!--
	作者: wallimn, http://wallimn.iteye.com
	时间:2017年1月26日
	功能：
-->
<html lang="zh-cn">
<head>
    <meta name="viewport" content="width=device-width, initial-scale=1.0, minimum-scale=1.0, maximum-scale=1.0, user-scalable=no">
    <title>JSAPI方式支付调起页面</title>
	<c:set var="ctx" value="${pageContext.request.contextPath}"></c:set>
    <script type="text/javascript" src="${ctx }/js/jquery-1.11.1.min.js"></script>
    <script type="text/javascript" src="http://res.wx.qq.com/open/js/jweixin-1.2.0.js"></script>
    <script type="text/javascript">
        function submit(){
        	$("#actionResult").text("");
            $.ajax({
                type: 'POST',
                url: '${ctx }/weixin/unifiedorder?dt='+(new Date()).getTime(),
                data: {'detail':'测试detail','body':'商户名-商品名','out_trade_no':(new Date()).getTime().toString(16),'total_fee':$("input[name=total_fee]").val()},
                success: function(json){
	                if(!json || !json.appId){
	                	$("#actionResult").text("参数错误！");
	                	return ;
	                }
	               wxpay(json);
            	},
                dataType: "json"});

        }
		function wxpay(json){
			function onBridgeReady(){
				   WeixinJSBridge.invoke(
				       'getBrandWCPayRequest', {
				           "appId" :json.appId,     //公众号名称，由商户传入     
				           "timeStamp":json.timeStamp,         //时间戳，自1970年以来的秒数     
				           "nonceStr" :json.nonceStr, //随机串     
				           "package" : json.package,     
				           "signType" :json.signType,         //微信签名方式：     
				           "paySign" :json.paySign //微信签名 
				       },
				       function(res){     
				           if(res.err_msg == "get_brand_wcpay_request:ok" ) {
				        	   $("#actionResult").text("支付成功！");
				           }     // 使用以上方式判断前端返回,微信团队郑重提示：res.err_msg将在用户支付成功后返回    ok，但并不保证它绝对可靠。 
				           else{
				        	   $("#actionResult").text("支付失败："+JSON.stringify(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();
				}		
		}
        $(function(){
                $("#sub").click(function(){
                    submit();
                });
                $("#actionResult").text("WeixinJSBridge");
        });

    </script>
</head>
<body>
<div style="text-align:center">
	<div id="actionResult">注意单位为（分）</div>
	<input type="text" placeholder="请输入金额(分)" name="total_fee" value="1"><br>
	<input type="button" id="sub" value="支付">
</div>
</body>
</html>