微信支付服務商模式說明

微信支付分爲普通商戶版，服務商版以及銀行服務商版，我們主講服務商版。

官方地址：https://pay.weixin.qq.com/wiki/doc/api/sl.html

微信支付服務商模式

如果把服務商模式比作公司的話，普通商戶就好比個人。公司可以聘請很多“個人”（員工）。也就是說，服務商可以發展很多自己的子商戶。並且在費率上面服務商也是有優勢的。

服務商模式比普通商戶模式，從下單參數上面來看，主要多了子商戶號：sub_mch_id（必填），sub_appid和sub_openId（非必填）。

這裏我們選擇JSAPI支付。

 

1. 支付主要會用到5個參數

appid：微信公衆號（服務號）appid

appsecret：微信公衆平臺的 AppSecret(應用密鑰)，用於獲取用戶openId

mchId：微信商戶ID

apiKey： 微信商戶平臺設置的 API密鑰-用於簽名驗證

sub_mchId：子商戶ID

點擊查看如何獲取支付參數，未更新，僅供參考

子商戶從通過商戶平臺，進件審覈通過之後，微信分配。

 

準備請求參數

ScanPayReqDataSp.java

package com.pay.wechat.protocol.pay_protocol;

import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;

import com.pay.wechat.util.Config;
import com.pay.wechat.util.RandomStringGenerator;
import com.pay.wechat.util.Signature;
import com.pay.wechat.util.xmlstream.XStreamCDATA;
import com.tenet.util.DateUtil;

/**
 * 統一下單請求數據模型-- 服務商版本<br>
 * 
 * API接口地址說明：https://pay.weixin.qq.com/wiki/doc/api/jsapi.php?chapter=9_1
 * 
 * 是否需要證書: 不需要
 * 
 * @author libaibai
 * @version 1.0 2017年11月2日
 */
public class ScanPayReqDataSp {

	// 更多詳情查看API接口地址說明
	private String appid = ""; // 微信分配的公衆賬號ID（企業號corpid即爲此appId）
	private String mch_id = ""; // 微信支付分配的商戶號

	private String sub_appid; // 否 String(32) wxd678efh567hg6999
	// // 微信分配的子商戶公衆賬號ID，如需在支付完成後獲取sub_openid則此參數必傳。

	private String sub_mch_id;// 是 String(32) 1900000109 微信支付分配的子商戶號

	private String device_info = ""; // 設備號(非必填)
	private String nonce_str = ""; // 隨機字符串,不長於32位
	private String sign = ""; // 簽名
	private String body = ""; // 商品描述
	private String detail = ""; // 商品詳情(非必填)
	
	@XStreamCDATA
	private String attach = ""; // 附加數據(非必填) - 目前存放車牌號或卡號
	private String out_trade_no = ""; // 商戶訂單號,調用方產生,32個字符(必填***)
	private String fee_type = ""; // 貨幣類型(非必填)
	private int total_fee = 0; // 總金額(單位:分,必填***)
	private String spbill_create_ip = ""; // 終端IP
	private String time_start = ""; // 交易起始時間(格式爲yyyyMMddHHmmss)
	private String time_expire = ""; // 交易結束時間(格式爲yyyyMMddHHmmss)
	private String goods_tag = ""; // 商品標記(非必填)

	// 通知地址,接收微信支付異步通知回調地址，通知url必須爲直接可訪問的url，不能攜帶參數。(以Config.java爲準)
	private String notify_url = Config.NOTIFY_URL;

	private String trade_type = "JSAPI"; // 交易類型,默認:JSAPI(JSAPI,NATIVE,APP)
	private String product_id = ""; // 商品ID(trade_type=NATIVE,此參數必傳)
	private String limit_pay = ""; // 指定支付方式(no_credit--指定不能使用信用卡支付)
	private String openid = ""; // 用戶標識(trade_type=JSAPI,此參數必傳)
	private String sub_openid = ""; // trade_type=JSAPI，此參數必傳，用戶在子商戶appid下的唯一標識。openid和sub_openid可以選傳其中之一，如果選擇傳sub_openid,則必須傳sub_appid。

	public ScanPayReqDataSp(String appid, String mch_id, String sub_appid, String sub_mch_id, String key, String body, String detail, String attach,
			String out_trade_no, int total_fee, String spbill_create_ip, String trade_type, String product_id, String openid, String sub_openid) {
		this.appid = appid;
		this.mch_id = mch_id;
		this.sub_appid = sub_appid;
		this.sub_mch_id = sub_mch_id;
		this.body = body;
		this.detail = detail;
		this.attach = attach;
		this.out_trade_no = out_trade_no;
		this.total_fee = total_fee;
		this.spbill_create_ip = spbill_create_ip;
		this.trade_type = trade_type;
		this.product_id = product_id;
		this.openid = openid;
		this.sub_openid = sub_openid;

		// 需要附屬值字段,可在此處統一生成
		this.nonce_str = RandomStringGenerator.getRandomStringByLength(32);

		// 交易時間限制
		this.time_start = DateUtil.getDateTimeStr(null); // 當前時間
		long time_expireLong = DateUtil.getTimeStampLong() + Config.ORDER_EXPIRE_TIME;
		this.time_expire = DateUtil.getDateTimeStr(DateUtil.getTimeStampToDate(time_expireLong)); // 當前時間+600秒

		// sign簽名
		// 根據API給的簽名規則進行簽名
		this.sign = Signature.getSign(toMap(), key);
	}

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

	public void setDevice_info(String device_info) {
		this.device_info = device_info;
	}

	public String getNonce_str() {
		return nonce_str;
	}

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

	public String getSign() {
		return sign;
	}

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

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

	public void setAttach(String attach) {
		this.attach = attach;
	}

	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 int getTotal_fee() {
		return total_fee;
	}

	public void setTotal_fee(int total_fee) {
		this.total_fee = total_fee;
	}

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

	public void setTime_start(String time_start) {
		this.time_start = time_start;
	}

	public String getTime_expire() {
		return time_expire;
	}

	public void setTime_expire(String time_expire) {
		this.time_expire = time_expire;
	}

	public String getGoods_tag() {
		return goods_tag;
	}

	public void setGoods_tag(String goods_tag) {
		this.goods_tag = goods_tag;
	}

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

	public void setLimit_pay(String limit_pay) {
		this.limit_pay = limit_pay;
	}

	public String getOpenid() {
		return openid;
	}

	public void setOpenid(String openid) {
		this.openid = openid;
	}

	public String getSub_mch_id() {
		return sub_mch_id;
	}

	public void setSub_mch_id(String sub_mch_id) {
		this.sub_mch_id = sub_mch_id;
	}

	public String getSub_appid() {
		return sub_appid;
	}

	public void setSub_appid(String sub_appid) {
		this.sub_appid = sub_appid;
	}
	
	public String getSub_openid() {
		return sub_openid;
	}

	public void setSub_openid(String sub_openid) {
		this.sub_openid = sub_openid;
	}

	public Map<String, Object> toMap() {
		Map<String, Object> map = new HashMap<String, Object>();
		Field[] fields = this.getClass().getDeclaredFields();
		for (Field field : fields) {
			Object obj;
			try {
				obj = field.get(this);
				if (obj != null) {
					map.put(field.getName(), obj);
				}
			} catch (IllegalArgumentException e) {
			} catch (IllegalAccessException e) {
			}
		}
		return map;
	}

}

簽名工具類

package com.pay.wechat.util;

import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import org.xml.sax.SAXException;

import com.wsimpl.bo.wx.einvoice.HMacShaUtil;

import javax.xml.parsers.ParserConfigurationException;

import java.io.IOException;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;

/**
 * 簽名util 類
 *
 * 
 * @depc 將key修改成傳入,不從Configure類獲取
 * @author libaibai
 * @version 2.0 2016年2月22日
 */
public class Signature {
	private static final Logger LOG = LogManager.getLogger(Signature.class);

	/**
	 * 簽名算法
	 * 
	 * @param o 要參與簽名的數據對象
	 * @return 簽名
	 * @throws IllegalAccessException
	 */
	public static String getSign(Object o, String key) throws IllegalAccessException {
		ArrayList<String> list = new ArrayList<String>();
		Class<?> cls = o.getClass();
		Field[] fields = cls.getDeclaredFields();
		for (Field f : fields) {
			f.setAccessible(true);
			if (f.get(o) != null && f.get(o) != "") {
				list.add(f.getName() + "=" + f.get(o) + "&");
			}
		}
		int size = list.size();
		String[] arrayToSort = list.toArray(new String[size]);
		Arrays.sort(arrayToSort, String.CASE_INSENSITIVE_ORDER);
		StringBuilder sb = new StringBuilder();
		for (int i = 0; i < size; i++) {
			sb.append(arrayToSort[i]);
		}
		String result = sb.toString();
		result += "key=" + key;
		result = MD5.MD5Encode(result).toUpperCase();
		return result;
	}

	/**
	 * 簽名算法
	 * 
	 * @param map
	 * @param key
	 * @return
	 */
	public static String getSign(Map<String, Object> map, String key) {
		ArrayList<String> list = new ArrayList<String>();
		for (Map.Entry<String, Object> entry : map.entrySet()) {
			if (entry.getValue() != "") {
				list.add(entry.getKey() + "=" + entry.getValue() + "&");
			}
		}
		int size = list.size();
		String[] arrayToSort = list.toArray(new String[size]);
		Arrays.sort(arrayToSort, String.CASE_INSENSITIVE_ORDER);
		StringBuilder sb = new StringBuilder();
		for (int i = 0; i < size; i++) {
			sb.append(arrayToSort[i]);
		}
		String result = sb.toString();
		result += "key=" + key;
		result = MD5.MD5Encode(result).toUpperCase();
		return result;
	}
	
	/**
	 * 簽名算法（ HMAC-SHA256）
	 * 
	 * @param map
	 * @param key
	 * @return
	 */
	public static String getSignSha(Map<String, Object> map, String key) {
		ArrayList<String> list = new ArrayList<String>();
		for (Map.Entry<String, Object> entry : map.entrySet()) {
			if (entry.getValue() != "") {
				list.add(entry.getKey() + "=" + entry.getValue() + "&");
			}
		}
		int size = list.size();
		String[] arrayToSort = list.toArray(new String[size]);
		Arrays.sort(arrayToSort, String.CASE_INSENSITIVE_ORDER);
		StringBuilder sb = new StringBuilder();
		for (int i = 0; i < size; i++) {
			sb.append(arrayToSort[i]);
		}
		String result = sb.toString();
		result += "key=" + key;
		result = HMacShaUtil.sha256_HMAC(result, key).toUpperCase();
		return result;
	}

	/**
	 * 從API返回的XML數據裏面重新計算一次簽名
	 * 
	 * @param responseString API返回的XML數據
	 * @return 新鮮出爐的簽名
	 * @throws ParserConfigurationException
	 * @throws IOException
	 * @throws SAXException
	 */
	public static String getSignFromResponseString(String responseString, String key)
			throws IOException, SAXException, ParserConfigurationException {
		Map<String, Object> map = XMLParser.getMapFromXML(responseString);
		// 清掉返回數據對象裏面的Sign數據（不能把這個數據也加進去進行簽名），然後用簽名算法進行簽名
		map.put("sign", "");
		// 將API返回的數據根據用簽名算法進行計算新的簽名，用來跟API返回的簽名進行比較
		return Signature.getSign(map, key);
	}

	/**
	 * 檢驗API返回的數據裏面的簽名是否合法，避免數據在傳輸的過程中被第三方篡改
	 * 
	 * @param responseString API返回的XML數據字符串
	 * @return API簽名是否合法
	 * @throws ParserConfigurationException
	 * @throws IOException
	 * @throws SAXException
	 */
	public static boolean checkIsSignValidFromResponseString(String responseString, String key)
			throws ParserConfigurationException, IOException, SAXException {

		Map<String, Object> map = XMLParser.getMapFromXML(responseString);

		String signFromAPIResponse = map.get("sign").toString();
		if (signFromAPIResponse == "" || signFromAPIResponse == null) {
			LOG.error("API返回的數據簽名數據不存在，有可能被第三方篡改!!!");
			return false;
		}
		// 清掉返回數據對象裏面的Sign數據（不能把這個數據也加進去進行簽名），然後用簽名算法進行簽名
		map.put("sign", "");
		// 將API返回的數據根據用簽名算法進行計算新的簽名，用來跟API返回的簽名進行比較
		String signForAPIResponse = Signature.getSign(map, key);

		if (!signForAPIResponse.equals(signFromAPIResponse)) {
			// 簽名驗不過，表示這個API返回的數據有可能已經被篡改了
			LOG.error("API返回的數據簽名數據不存在，有可能被第三方篡改!!!");
			return false;
		}
		return true;
	}

}

支付請求類

ScanPayService .java

package com.pay.wechat.service;

import org.springframework.stereotype.Component;

import com.pay.wechat.protocol.pay_protocol.ScanPayReqDataSp;
import com.pay.wechat.util.Config;

/**
 * 支付請求
 *
 * @author libaibai
 * @version 1.0 2015年8月31日
 */
@Component
public class ScanPayService extends BaseService {

	/**
	 * 請求支付服務-- 服務商版
	 * 
	 * @param scanPayReqData 這個數據對象裏面包含了API要求提交的各種數據字段
	 * @return API返回的數據
	 * @throws Exception
	 */
	public String requestSp(ScanPayReqDataSp scanPayReqDataSp) throws Exception {

		super.apiURL = Config.UNIFIEDORDER_API;
		// --------------------------------------------------------------------
		// 發送HTTPS的Post請求到API地址
		// --------------------------------------------------------------------
		String responseString = sendPost(scanPayReqDataSp);

		return responseString;
	}



}

BaseService.java

package com.pay.wechat.service;

import java.io.IOException;
import java.security.KeyManagementException;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.UnrecoverableKeyException;

import javax.annotation.Resource;

import com.dlys.pay.wechat.util.HttpsRequest;

/**
 * 
 * @author libaibai
 *
 */
public class BaseService {

	// API的地址
	public String apiURL;

	// 發請求的HTTPS請求器

	@Resource
	private HttpsRequest httpsRequest;

	protected String sendPost(Object xmlObj) throws UnrecoverableKeyException, IOException,
			NoSuchAlgorithmException, KeyStoreException, KeyManagementException,
			ClassNotFoundException, InstantiationException, IllegalAccessException {
		return httpsRequest.sendPost(apiURL, xmlObj);
	}

}

HttpsRequest.java

package com.pay.wechat.util;

import java.io.IOException;
import java.io.InputStream;
import java.security.KeyManagementException;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.UnrecoverableKeyException;

import javax.net.ssl.SSLContext;

import org.apache.commons.lang.StringEscapeUtils;
import org.apache.http.HttpEntity;
import org.apache.http.HttpHeaders;
import org.apache.http.HttpResponse;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.conn.ssl.SSLContexts;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.springframework.stereotype.Component;

import com.pay.wechat.protocol.pay_protocol.ScanPayReqDataSp;
import com.pay.wechat.util.xmlstream.XStreamFactory;
import com.thoughtworks.xstream.XStream;
import com.thoughtworks.xstream.io.xml.XmlFriendlyNameCoder;

/**
 * HTTP 請求類
 *
 * @author libaibai
 * @version 1.0 2015年8月31日
 */
@Component
public class HttpsRequest {
	public interface ResultListener {
		public void onConnectionPoolTimeoutError();
	}

	private static Logger LOG = LogManager.getLogger(HttpsRequest.class);

	private boolean hasInit = false;

	// 連接超時時間，默認10秒
	private int socketTimeout = 10000;

	// 傳輸超時時間，默認30秒
	private int connectTimeout = 30000;

	// 請求器的配置
	private RequestConfig requestConfig;

	// HTTP請求器
	private CloseableHttpClient httpClient;

	/**
	 * 證書初始化
	 * 
	 * @throws UnrecoverableKeyException
	 * @throws KeyManagementException
	 * @throws NoSuchAlgorithmException
	 * @throws KeyStoreException
	 * @throws IOException
	 */
	public HttpsRequest() throws UnrecoverableKeyException, KeyManagementException, NoSuchAlgorithmException, KeyStoreException, IOException {
		init();
	}

	private void init() throws IOException, KeyStoreException, UnrecoverableKeyException, NoSuchAlgorithmException, KeyManagementException {

		KeyStore keyStore = KeyStore.getInstance("PKCS12");
		InputStream instream = HttpsRequest.class.getClassLoader().getResourceAsStream(Configure.CERTLOCAL_PATHx);// 加載本地的證書進行https加密傳輸
		try {
			keyStore.load(instream, Configure.CERTPASSWORD.toCharArray());// 設置證書密碼
		} catch (Exception e) {
			LOG.error("加載證書異常", e);
		} finally {
			instream.close();
		}
		SSLContext sslcontext = SSLContexts.custom().loadKeyMaterial(keyStore, Configure.CERTPASSWORD.toCharArray()).build();
		SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(sslcontext, new String[] { "TLSv1" }, null,
				SSLConnectionSocketFactory.BROWSER_COMPATIBLE_HOSTNAME_VERIFIER);

		httpClient = HttpClients.custom().setSSLSocketFactory(sslsf).build();

		// 根據默認超時限制初始化requestConfig
		requestConfig = RequestConfig.custom().setSocketTimeout(socketTimeout).setConnectTimeout(connectTimeout).build();

		hasInit = true;
	}

	/**
	 * 通過Https往API GET
	 *
	 * @param url API地址
	 * @return API回包的實際數據
	 * @throws IOException
	 * @throws KeyStoreException
	 * @throws UnrecoverableKeyException
	 * @throws NoSuchAlgorithmException
	 * @throws KeyManagementException
	 */

	public String sendGET(String url)
			throws IOException, KeyStoreException, UnrecoverableKeyException, NoSuchAlgorithmException, KeyManagementException {

		if (!hasInit) {
			init();
		}

		String result = null;

		HttpGet httpGet = new HttpGet(url);

		// 得指明使用UTF-8編碼，否則到API服務器XML的中文不能被成功識別
		httpGet.addHeader("Content-Type", "text/xml");

		// 設置請求器的配置
		httpGet.setConfig(requestConfig);

		try {
			HttpResponse response = httpClient.execute(httpGet);

			HttpEntity entity = response.getEntity();

			result = EntityUtils.toString(entity, "UTF-8");

		} catch (Exception e) {
			LOG.error("HTTP Get請示異常", e);
		} finally {
			httpGet.abort();
		}
		return result;
	}

	/**
	 * 通過Https往API post
	 *
	 * @param url API地址
	 * @param Object 要提交的Object數據對象
	 * @return API回包的實際數據
	 * @throws IOException
	 * @throws KeyStoreException
	 * @throws UnrecoverableKeyException
	 * @throws NoSuchAlgorithmException
	 * @throws KeyManagementException
	 */

	public String sendPostObject(String url, HttpEntity postEntity)
			throws IOException, KeyStoreException, UnrecoverableKeyException, NoSuchAlgorithmException, KeyManagementException {

		if (!hasInit) {
			init();
		}

		String result = null;
		HttpPost httpPost = new HttpPost(url);
		httpPost.setHeader(HttpHeaders.CONTENT_TYPE, ContentType.MULTIPART_FORM_DATA.getMimeType());
		httpPost.setEntity(postEntity);

		// 設置請求器的配置
		httpPost.setConfig(requestConfig);
		try {
			HttpResponse response = httpClient.execute(httpPost);
			HttpEntity entity = response.getEntity();

			result = EntityUtils.toString(entity, "UTF-8");

		} catch (Exception e) {
			LOG.error("HTTP POST 請求異常", e);
		} finally {
			httpPost.abort();
		}

		return result;
	}

	/**
	 * 通過Https往API post xml數據
	 *
	 * @param url API地址
	 * @param xmlObj 要提交的XML數據對象
	 * @return API回包的實際數據
	 * @throws IOException
	 * @throws KeyStoreException
	 * @throws UnrecoverableKeyException
	 * @throws NoSuchAlgorithmException
	 * @throws KeyManagementException
	 */

	public String sendPost(String url, Object xmlObj)
			throws IOException, KeyStoreException, UnrecoverableKeyException, NoSuchAlgorithmException, KeyManagementException {

		if (!hasInit) {
			init();
		}

		String result = null;
		HttpPost httpPost = new HttpPost(url);

		// 解決XStream對出現雙下劃線的bug
		// XStream xStreamForRequestPostData = new XStream(new DomDriver("UTF-8",
		// new XmlFriendlyNameCoder("-_", "_")));

		XStream xStream = XStreamFactory.getXStream(new XmlFriendlyNameCoder("_-", "_"));

		// 將要提交給API的數據對象轉換成XML格式數據Post給API
		String postDataXML = xStream.toXML(xmlObj);
		LOG.info("請求微信接口->url=" + url + ",data=" + postDataXML);
		// LOG.info("data="+StringEscapeUtils.unescapeXml(postDataXML));// 轉義字符

		// 得指明使用UTF-8編碼，否則到API服務器XML的中文不能被成功識別
		StringEntity postEntity = new StringEntity(postDataXML, "UTF-8");
		httpPost.addHeader("Content-Type", "text/xml");
		httpPost.setEntity(postEntity);

		// 設置請求器的配置
		httpPost.setConfig(requestConfig);

		try {
			HttpResponse response = httpClient.execute(httpPost);

			HttpEntity entity = response.getEntity();

			result = EntityUtils.toString(entity, "UTF-8");

		} catch (Exception e) {
			LOG.error("HTTP POST 請求異常", e);

		} finally {
			// httpPost.abort();
			httpPost.releaseConnection();
		}

		return result;
	}

	/**
	 * 設置連接超時時間
	 *
	 * @param socketTimeout 連接時長，默認10秒
	 */
	public void setSocketTimeout(int socketTimeout) {
		this.socketTimeout = socketTimeout;
		resetRequestConfig();
	}

	/**
	 * 設置傳輸超時時間
	 *
	 * @param connectTimeout 傳輸時長，默認30秒
	 */
	public void setConnectTimeout(int connectTimeout) {
		this.connectTimeout = connectTimeout;
		resetRequestConfig();
	}

	private void resetRequestConfig() {
		requestConfig = RequestConfig.custom().setSocketTimeout(socketTimeout).setConnectTimeout(connectTimeout).build();
	}

	/**
	 * 允許商戶自己做更高級更復雜的請求器配置
	 *
	 * @param requestConfig 設置HttpsRequest的請求器配置
	 */
	public void setRequestConfig(RequestConfig requestConfig) {
		this.requestConfig = requestConfig;
	}

}

UnifiedOrderSp .java

package com.dlys.pay.wechat;

import java.util.Map;

import javax.annotation.Resource;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.springframework.stereotype.Component;

import com.dlys.pay.wechat.protocol.pay_protocol.ScanPayReqDataSp;
import com.dlys.pay.wechat.service.ScanPayService;
import com.dlys.pay.wechat.util.Util;
import com.dlys.pay.wechat.util.XMLParser;

/**
 * 微信支付統一下單公用入口--服務商版本
 * 
 * @author libaibai
 * @version 1.0 2017年11月2日
 */
@Component
public class UnifiedOrderSp {

	private static final Logger LOG = LogManager.getLogger(UnifiedOrderSp.class);

	@Resource
	private ScanPayService scanPayService; // wechat sdk

	/**
	 * 微信支付統一下單(JSAPI)
	 */
	public Map<String, Object> unifiedOrderJSAPI(String appid, String mch_id,String sub_appid, String sub_mch_id, String key,
			String body, String detail, String attach, String out_trade_no, int total_fee, String spbill_create_ip,
			String openid, String sub_openid) {

		return this.unifiedOrder(appid, mch_id, sub_appid, sub_mch_id, key, body, detail, attach, out_trade_no, total_fee,
				spbill_create_ip, "JSAPI", Util.getProduct_id(), openid, sub_openid);
	}

	
	/**
	 * 微信支付統一下單(JSAPI/NATIVE/APP方法均可)
	 * 
	 * @param appid 公衆號的唯一標識
	 * @param mch_id 微信支付分配的商戶號
	 * @param key 微信應用祕鑰
	 * @param body 商品名稱
	 * @param detail 商品詳情(非必填)
	 * @param attach 附加數據(非必填) - 目前存放車牌號或卡號
	 * @param out_trade_no 商戶訂單號
	 * @param total_fee 支付金額(單位:分)
	 * @param spbill_create_ip 終端IP
	 * @param trade_type 交易類型(JSAPI/NATIVE/APP)
	 * @param product_id 商品ID(trade_type=NATIVE時,必填)
	 * @param openid 用戶標識(trade_type=JSAPI時,必填)
	 * @return 響應信息
	 */
	private Map<String, Object> unifiedOrder(String appid, String mch_id, String sub_appid, String sub_mch_id,
			String key, String body, String detail, String attach, String out_trade_no, int total_fee,
			String spbill_create_ip, String trade_type, String product_id, String openid, String sub_openid) {

		ScanPayReqDataSp data = new ScanPayReqDataSp(appid, mch_id, sub_appid, sub_mch_id, key, body, detail, attach,
				out_trade_no, total_fee, spbill_create_ip, trade_type, product_id, openid, sub_openid);
		// LOG.info("微信支付統一下單參數:" + JSONObject.fromObject(data).toString());
		try {
			String xmlMsg = scanPayService.requestSp(data);
//			LOG.info("微信支付統一下單返回數據:" + XMLParser.getMapFromXML(xmlMsg));
			return XMLParser.getMapFromXML(xmlMsg);

		} catch (Exception e) {
			LOG.error("微信支付統一下單時出錯!", e);
			return null;
		}
	}
}

以上是支付的工具類，基本上只要是微信支付API，都是通用的

 

以下是業務代碼，大家自行修改

GetPayOrder.java

package com.pay.wechat.bo;

import java.math.BigDecimal;
import java.util.HashMap;
import java.util.Map;

import javax.annotation.Resource;

import org.apache.commons.beanutils.BeanUtils;
import org.apache.commons.lang.StringUtils;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.fastquery.service.FQuery;
import org.springframework.stereotype.Component;

import com.db.ParkingCarInfoDBService;
import com.db.PayOrderDBService;
import com.db.PunitDBService;
import com.db.PunitParamDBService;
import com.pay.bo.ParkingPayBo;
import com.pay.bo.PayOrderBo;
import com.pay.bo.PayOrderSpBo;
import com.pay.wechat.UnifiedOrder;
import com.pay.wechat.UnifiedOrderSp;
import com.pay.wechat.WxPayBo;
import com.pay.wechat.protocol.JsapiRequestData;
import com.wsimpl.bo.operate.InvoiceBusinessBo;
import com.wsimpl.bo.wx.WxCardBo;
import com.bean.ParkingCarInfo;
import com.bean.PayOrder;
import com.bean.Punit;
import com.bean.WxCard;
import com.util.ChargeMoneyUtil;
import com.util.Config;
import com.util.Const;
import com.util.bean.ChargeMoneyBean;
import com.util.DateUtil;
import com.util.lang.StringUtil;

/**
 * 生成支付訂單,微信統一下單,並返回調取JSAPI所需參數
 * 
 * @author libaibai
 * @version 1.0 2016年3月4日
 */
@Component
public class GetPayOrder {

	private static final Logger LOG = LogManager.getLogger(GetPayOrder.class);

	/* db */
	private PunitDBService punitDBService = FQuery.getRepository(PunitDBService.class); // 物業單位
	private PunitParamDBService punitParamDBService = FQuery
			.getRepository(PunitParamDBService.class); // 物業單位
	private PayOrderDBService payOrderDBService = FQuery.getRepository(PayOrderDBService.class); // 物業單位

	private ParkingCarInfoDBService parkingCarInfoDBService = FQuery
			.getRepository(ParkingCarInfoDBService.class); // 在場車輛信息

	/* 微信支付相關 */
	@Resource
	private PayOrderBo payOrderBo; // 支付總訂單

	@Resource
	private PayOrderSpBo payOrderSpBo; // 支付總訂單-- 服務商

	@Resource
	private WxPayBo weChatBo; // 微信支付共用類

	@Resource
	private UnifiedOrder unifiedOrder; // 微信支付統一下單

	@Resource
	private UnifiedOrderSp unifiedOrderSp; // 微信支付統一下單 -- 服務商

	@Resource
	private ParkingPayBo parkingPayBo;

	@Resource
	private ChargeMoneyUtil chargeMoneyUtil;
	
	@Resource
	private InvoiceBusinessBo invoiceBusinessBo;

	/**
	 * 執行方法
	 * 
	 * @param code
	 * @param punitId
	 * @param iden
	 * @param chargeMoney
	 * @return
	 */
	public Map<String, Object> get(String code, Long punitId, String iden, Double chargeMoney,
			Long channelId, Long ruid, Long outTime, String cardId, String encryptCode) {
		LOG.info("weixin_下單請求，punitId=" + punitId + "，iden=" + iden + "，chargeMoney=" + chargeMoney + 
				"，channelId=" + channelId + "，ruid=" + ruid + "，outTime=" + outTime);
		
		Map<String, Object> returnMap = new HashMap<String, Object>(); // 返回Map

		// 參數不完整
		if (punitId == null || punitId.longValue() <= 0 || code == null || "".equals(code.trim())) {
			LOG.error("信息不完整,請返回重新進入，punitId=" + punitId + "，code=" + code);
			returnMap.put("isPay", "0");
			returnMap.put("errorMsg", "信息不完整,請返回重新進入");
			return returnMap;
		}

		// 獲取停車場微信支付所需參數appid,mch_id,appSecret,key -- begin
		Punit punit = punitDBService.findById(punitId);
		if (punit == null) {
			LOG.error("信息不完整,請返回重新進入，未找到停車場信息，punitId=" + punitId);
			returnMap.put("isPay", "0");
			returnMap.put("errorMsg", "信息不完整,請返回重新進入");
			return returnMap;
		}

		// 停車場對應公衆號基本參數(雲平臺填入)，如果是泊鏈支付，則直接使用德立雲停車參數
		String appid = punit.getAppId();
		String mch_id = punit.getMchId();
		String appSecret = punit.getAppSecret();
		String key = punit.getWx_key();
		String sub_mchId = punit.getSub_mchId();

		// 微信支付所需參數不完整
		if (StringUtils.isEmpty(mch_id) && StringUtils.isEmpty(sub_mchId)) {
			LOG.error("信息不完整,請返回重新進入，必須參數不完整");
			returnMap.put("isPay", "0");
			returnMap.put("errorMsg", "信息不完整,請返回重新進入");
			return returnMap;
		}
		// 獲取停車場微信支付所需參數appid,mch_id,appSecret,key -- end

		// 判斷是否啓用服務商
		Map<String, Object> map = punitParamDBService.findParam(punitId);
		int isSpPay = 0;
		if (map != null && !map.isEmpty()) {
			isSpPay = Const.getInteger(map.get("isSpPay"));
		}

		// 使用德立雲停車爲服務商
		String subappid = null;
		String openid = null;
		String sub_openid = null;
		if (isSpPay == 1) {
			appid = Config.APPID;
			mch_id = Config.MCHIDSP;
			appSecret = Config.APPSECRET;
			key = Config.APIKEY;
			openid = weChatBo.getOauth2Openid(appid, appSecret, code);
		} else if (isSpPay == 2) {
			subappid = Config.APPID;
			sub_openid = weChatBo.getOauth2Openid(subappid, Config.APPSECRET, code);
		} else {
			openid = weChatBo.getOauth2Openid(appid, appSecret, code);
		}
		if (StringUtils.isEmpty(openid) && StringUtils.isEmpty(sub_openid)) {
			LOG.error("信息不完整,請返回重新進入，openId爲空, appid=" + appid + "，appSecret=" + appSecret + "，isSpPay=" + isSpPay + "，code=" + code);
			returnMap.put("isPay", "0");
			returnMap.put("errorMsg", "信息不完整,請返回重新進入");
			return returnMap;
		}

		// db查詢-用戶停車信息
		ParkingCarInfo pcInfo = null;
		try {
			pcInfo = parkingCarInfoDBService.findByIden(iden);
		} catch (Exception e) {
			pcInfo = null;
			LOG.error("根據iden查詢停車信息時出錯!", e);
		}
		// 無停車信息
		if (pcInfo == null) {
			LOG.error("信息不完整,請返回重新進入，未找到在場車輛信息，iden=" + iden);
			returnMap.put("isPay", "0");
			returnMap.put("errorMsg", "信息不完整,請返回重新進入");
			return returnMap;
		}

		// 判斷是否二次繳費，0元不需要繳費
		byte isEmptyPay = Const.getByte(map.get("isEmptyPay")); // 支持0元支付
		if (pcInfo.getPayTime() != null && pcInfo.getPayTime() > 0 || isEmptyPay == 0) {
			if (chargeMoney == null || chargeMoney.doubleValue() <= 0) {
				returnMap.put("isPay", "0");
				returnMap.put("errorMsg", "0元不需繳費");
				return returnMap;
			}
		}
		
		// 重新計算繳費金額
		ChargeMoneyBean chargeMoneyBean = null;
		long orderDate = 0;
		// 如果存在出場時間，而且在5分鐘之內（考慮到存在時間差）
		if (outTime != null && outTime > 0 && (Math.abs(DateUtil.getTimeStampLong() - outTime.longValue()) <= 5 * 60)) {
			chargeMoneyBean = chargeMoneyUtil.getMoney(pcInfo, punit, outTime);
			orderDate = outTime;
		} else {
			chargeMoneyBean = chargeMoneyUtil.getMoney(pcInfo, punit);
			orderDate = DateUtil.getTimeStampLong();
		}
		double chargeMoneydb = StringUtil.getDoubleDecimal(Const.getDouble(chargeMoneyBean.getRealMoney()), 2);
		if (chargeMoney.doubleValue() != chargeMoneydb) {
			LOG.warn("weixin_下單失敗，punitId=" + punitId + ", plateNum=" + pcInfo.getPlate() + "，頁面金額chargeMoney=" + chargeMoney
					+ "，重新計算金額chargeMoneydb=" + chargeMoneydb);
			returnMap.put("isPay", "0");
			returnMap.put("errorMsg", "下單失敗,請返回重新進入");
			return returnMap;
		}
		double saleMoney = chargeMoneyBean.getSaleMoney();
		Double shouldPay = chargeMoney;// 實付金額（可能會有優惠卷）
		LOG.info("GetPayOrder-微信支付開始保存訂單，punitId=" +punitId + "，plateNum=" +  pcInfo.getPlate() + "，iden=" + iden );
		// 保存支付總訂單表- (byte) 1
		PayOrder payOrder = null;
		if (isSpPay == 0) {
			byte payway = 0; // 支付途徑
			payOrder = payOrderBo.savePayOrderToParkingPay(payway, (byte) 1, iden, punit.getTenantId(), punitId, ruid, pcInfo.getPlate(),
					pcInfo.getCardNo(), pcInfo.getEntranceTime(), chargeMoney, appid, mch_id, openid, saleMoney, channelId, 0L, orderDate);
		} else {
			payOrder = payOrderSpBo.savePayOrderToParkingPay((byte) 1, iden, punit.getTenantId(), punitId, ruid, pcInfo.getPlate(),
					pcInfo.getCardNo(), chargeMoney, saleMoney, appid, mch_id, openid, sub_mchId, pcInfo.getEntranceTime(), channelId, 0L, (byte) 0, orderDate);
		}
		if (payOrder == null) {
			LOG.error("weixin_保存訂單失敗");
			returnMap.put("isPay", "0");
			returnMap.put("errorMsg", "下單失敗,請返回重新進入");
			return returnMap;
		}
		
		// 0元支付
		if (chargeMoney.doubleValue() == 0) {
			LOG.info("weixin-0元支付成功，punitId=" + punitId + "，plateNum=" + pcInfo.getPlate());
			// 修改訂單信息
			PayOrder temp = FQuery.reset(PayOrder.class);
			temp.setId(payOrder.getId());
			temp.setPayState((byte) 1);
			temp.setPayTime(DateUtil.getTimeStampLong());
			payOrder = payOrderDBService.update(temp);
			
			// 處理在場車輛信息
			parkingPayBo.handle(payOrder);
			returnMap.put("isPay", "2");
			returnMap.put("errorMsg", "支付成功");
			return returnMap;
		}

		// 微信統一下單,調用公用入口
		String body = punit.getUnitName() + "-停車費（"
				+ (pcInfo.getPlate() == null ? "" : pcInfo.getPlate()) + "）";
		String detail = body; // 商品詳情
		String attach = pcInfo.getPlate(); // 車牌號
		if (attach == null || "".equals(attach)) {
			attach = pcInfo.getCardNo();
		}
		// 判斷是否開通微信無感支付
		if (Const.getByte(punit.getIsWxFreePay()) == 1) {
			attach = "#*#{\"pn\":\""+pcInfo.getPlate()+"\",\"aid\":\""+appid+"\", \"vm\":\"true\"}#*#"; 
			LOG.info("wx-判斷是否開通無感支付，attach=" + attach + "，plateNum=" + pcInfo.getPlate());
		}

		String out_trade_no = payOrder.getPayOrderId();
		Double payMoney = shouldPay * 100;
		int total_fee = payMoney.intValue();
		String spbill_create_ip = "127.0.0.1";
		
		//開發票參數
		String receipt = null;
		if(isSpPay==0){
			boolean openWxFaPiaoByAfterPay = invoiceBusinessBo.isOpenWxFaPiaoByAfterPay(punitId, "LTC");
			if(openWxFaPiaoByAfterPay){
				receipt = "Y";
			}
		}

		Map<String, Object> unifiedOrderMap = null;
		if (isSpPay == 0) {
			unifiedOrderMap = unifiedOrder.unifiedOrderJSAPI(appid, mch_id, key, body, detail,
					attach, out_trade_no, total_fee, spbill_create_ip, openid,receipt);
		} else {
			unifiedOrderMap = unifiedOrderSp.unifiedOrderJSAPI(appid, mch_id, subappid, sub_mchId, key, body,
					detail, attach, out_trade_no, total_fee, spbill_create_ip, openid, sub_openid);
		}
		if (unifiedOrderMap == null) {
			returnMap.put("isPay", "0");
			returnMap.put("errorMsg", "下單失敗,請返回重新進入");
			return returnMap;
		}

		// 下單成功,組裝JSAPI調用所需參數
		try {
			if ("SUCCESS".equals(unifiedOrderMap.get("result_code"))) {

				// 組裝JSAPI調用所需參數
				String timeStamp = DateUtil.getTimeStamp();
				String nonceStr = Const.getStr(unifiedOrderMap.get("nonce_str"));

				String package1 = "prepay_id=" + Const.getStr(unifiedOrderMap.get("prepay_id"));

				JsapiRequestData jsapiRequestData = new JsapiRequestData(appid, key, timeStamp,
						nonceStr, package1);
				String paySign = jsapiRequestData.getPaySign();

				// 組裝頁面響應Map
				returnMap.put("isPay", "1");
				returnMap.put("appid", appid);
				returnMap.put("timeStamp", timeStamp);
				returnMap.put("nonceStr", Const.getStr(unifiedOrderMap.get("nonce_str")));
				returnMap.put("package1", package1);
				returnMap.put("signType", "MD5");
				returnMap.put("paySign", paySign);
				returnMap.put("payOrderId", payOrder.getPayOrderId());
			}
		} catch (Exception e) {
			LOG.error("下單成功,組裝JSAPI調用所需參數時出錯!", e);
		}

		return returnMap;
	}

	/**
	 * 乘 2位小數 四捨五入
	 * 
	 * @param value1
	 * @param value2
	 * @return
	 */
	private Double mul(Double value1, Double value2) {
		BigDecimal b1 = new BigDecimal(Double.toString(value1));
		BigDecimal b2 = new BigDecimal(Double.toString(value2));
		BigDecimal multiply = b1.multiply(b2);
		return multiply.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
	}

	/**
	 * 減 2位小數 四捨五入
	 * 
	 * @param value1
	 * @param value2
	 * @return
	 */
	public Double sub(Double value1, Double value2) {
		BigDecimal b1 = new BigDecimal(Double.toString(value1));
		BigDecimal b2 = new BigDecimal(Double.toString(value2));
		BigDecimal sub = b1.subtract(b2);
		return sub.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
	}
}

後臺下單成功之後，我們在jsp頁面就可以調起微信支付了

// 微信公衆號支付
function weixinpay (wxCode, punitId, iden, chargeMoney, channelId) {
	var encryptCode=$("#encryptCode").val();
	var cardId=$("#cardId").val();
	var outTime=$("#outTime").val();
	
	// 統一下單返回JS調取支付所需參數
	$.tenetAjax({
		url: PATH + "/punitWS/getPayOrder",
		data: {'code':wxCode,'punitId':punitId,'iden':iden,'chargeMoney':chargeMoney,'channelId':channelId, 'outTime':outTime, 'cardId':cardId,'encryptCode':encryptCode},//卡券傳值
		async: false,
		success: function(data){
			//alert(JSON.stringify(data));
			if(data.payOrderMap==null){
				$("#iformbtndID").html('<a class="btna bg1">支付失敗,請返回重新進入</a>');
				return;
			}
			
			var isPay = data.payOrderMap.isPay;
			var errorMsg = data.payOrderMap.errorMsg;
			if(isPay==null || isPay==0){
				alert(errorMsg);
				$("#iformbtndID").html('<a class="btna bg1">'+errorMsg+'</a>');
				return;
			} else if (isPay==2) {
				$("#iformbtndID").html('<p>支付成功</p>');
				return;
			}
			
			// JS調取微信支付
			var appid = data.payOrderMap.appid;
			var timeStamp = data.payOrderMap.timeStamp;
			var nonceStr = data.payOrderMap.nonceStr;
			var package1 = data.payOrderMap.package1;
			var signType = data.payOrderMap.signType;
			var paySign = data.payOrderMap.paySign;
			var payOrderId = data.payOrderMap.payOrderId;
			if (typeof window.WeixinJSBridge == "undefined"){
				$(document).on('WeixinJSBridgeReady',function(){ 
					onBridgeReady(appid, timeStamp, nonceStr, package1, signType, paySign, payOrderId);
				})
			} else {
				onBridgeReady(appid, timeStamp, nonceStr, package1, signType, paySign, payOrderId);
			}
		}
	});
}


// JS調取微信支付
function onBridgeReady(appId, timeStamp, nonceStr, package1, signType,
		paySign, payOrderId) {
	WeixinJSBridge.invoke('getBrandWCPayRequest', {
		"appId" : appId, //公衆號名稱，由商戶傳入
		"timeStamp" : timeStamp, //時間戳，自1970年以來的秒數
		"nonceStr" : nonceStr, //隨機串
		"package" : package1, //訂單詳情擴展字符串
		"signType" : signType, //微信簽名方式MD5
		"paySign" : paySign
	//微信簽名
	}, function(res) {
		// 			alert(res.err_msg);
		if (res.err_msg == null) {
			$("#iformbtndID").html('<a class="btna bg1">支付失敗,請返回重新進入</a>');
			return;
		}

		// 支付成功
		if (res.err_msg == "get_brand_wcpay_request:ok") {
			var punitId = $("#punitId").val();
			var stayTime = $("#outDelayID").text();
			var unitName= $("#unitNameID").text();
			var chargeMoney = $("#chargeMoney").val();
			window.location.href="paysuc?punitId="+punitId+"&payOrderId="+payOrderId+"&stayTime="+stayTime+"&unitName="+unitName+"&payMoney="+chargeMoney;
			return;
		} else {
			$("#iformbtndID").html('<a class="btna bg1">支付失敗,請返回重新進入</a>');
			return;
		}
	});
}

 

ok，微信支付就到此結束了