微信支付的代码实现过程

悠悠 2023-07-09 10:25 6阅读 0赞

一.根据官方api（[https://pay.weixin.qq.com/wiki/doc/api/app/app.php?chapter=9\_1][https_pay.weixin.qq.com_wiki_doc_api_app_app.php_chapter_9_1]），以及微信提供的dome代码（

链接：https://pan.baidu.com/s/1JUhY6KtjtyJTSlfK6e6OFQ   
提取码：q99h

），代码展示如下：

（1）控制类代码：

/**
 	 * 微信支付（返回参数给前端）
 	 * @param request
 	 * @param response
 	 * @return
 	 * @throws Exception
 	 */
 	@ResponseBody
 	@RequestMapping(value="/doWxPay")
 	public Object doWxPay(HttpServletRequest request, HttpServletResponse response)throws Exception {
 		Map<String, Object> returnMap = new HashMap<>();
 		PageData pd = this.getPageData();
 		if(StringUtils.isEmpty(pd.getString("openId"))){
 			returnMap.put("result", "no openId");
 			return AppUtil.returnObject(returnMap);
 		}
 		return doWxPay(request, response, pd.getString("openId"),pd.getInteger("totalFee"));
 	}
 	
 	/**
 	 * 微信支付
 	 * @param request
 	 * @param response
 	 * @param openId
 	 * @return
 	 * @throws Exception
 	 */
 	public Object doWxPay(HttpServletRequest request, HttpServletResponse response, String openId,Integer totalFee) throws Exception {
 		// 发起微信支付
 		WXPay wxpay = null;		
 		Map<String, String> result = new HashMap<>();
 		TMembers tMembers = memberService.getMemberByMpOpenId(openId);
 		// 获取请求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();
 		}
 		try {
 			// ******************************************
 			//
 			// 统一下单
 			//
 			// ******************************************
 			wxpay = new WXPay(iWxPayConfig); // *** 注入自己实现的微信配置类, 创建WXPay核心类, WXPay 包括统一下单接口
 
 			Map<String, String> data = new HashMap<String, String>();
 			data.put("body", "微课充值中心-微币充值");
 			data.put("out_trade_no", UuidUtil.get32UUID().substring(0,20)+"_"+tMembers.getMemberId()); // 订单唯一编号, 不允许重复(uuid前20位_memberId)
 			data.put("total_fee", String.valueOf(new BigDecimal(totalFee).intValue())); // 订单金额, 单位分
 			data.put("spbill_create_ip", ip); // 下单ip
 			data.put("openid", openId); // 微信公众号统一标示openid
 			data.put("notify_url", WXPayConstants.NOTIFYURL); // 订单结果通知, 微信主动回调此接口
 			data.put("trade_type", "JSAPI"); // 固定填写
 
 			Map<String, String> responseDate = wxpay.unifiedOrder(data); // 微信sdk集成方法, 统一下单接口unifiedOrder, 此处请求 MD5加密 加密方式
 			String returnCode = responseDate.get("return_code");
 			if (!WXPayConstants.SUCCESS.equals(returnCode)) {
 				return null;
 			}
 			String resultCode = responseDate.get("result_code");
 			if (!WXPayConstants.SUCCESS.equals(resultCode)) {
 				return null;
 			}
 			String prepay_id = responseDate.get("prepay_id");
 			if (prepay_id == null) {
 				return null;
 			}
 
 			// ******************************************
 			//
 			// 前端调起微信支付必要参数
 			//
 			// ******************************************
 			String packages = "prepay_id=" + prepay_id;
 			Map<String, String> wxPayMap = new HashMap<String, String>();
 			wxPayMap.put("appId", iWxPayConfig.getAppID());
 			wxPayMap.put("nonceStr", UuidUtil.get32UUID());
 			wxPayMap.put("package", packages);
 			wxPayMap.put("signType", "MD5");
 			wxPayMap.put("timeStamp", String.valueOf(System.currentTimeMillis()));									
 			// 加密串中包括 appId timeStamp nonceStr package signType 5个参数, 通过sdk WXPayUtil类加密, 注意, 此处使用 MD5加密 方式
 			String sign = WXPayUtil.generateSignature(wxPayMap, iWxPayConfig.getKey());
 
 			// ******************************************
 			//
 			// 返回给前端调起微信支付的必要参数
 			//
 			// ******************************************
 			result.put("prepay_id", prepay_id);
 			result.put("sign", sign);
 			result.putAll(wxPayMap);
 			return result;
 		} catch (Exception e) {
 		}
 		return null;
 	}

2.IWxPayConfig类：

import org.springframework.stereotype.Service;
    
    import java.io.ByteArrayInputStream;
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.InputStream;
    
    @Service(value = "wxPayConfig")
    public class IWxPayConfig extends WXPayConfig { // 继承sdk WXPayConfig 实现sdk中部分抽象方法
    
        private byte[] certData;
    
        private String app_id = WXPayConstants.APPID;
    
        private String wx_pay_key = WXPayConstants.PATERNERKEY;
    
        private String wx_pay_mch_id = WXPayConstants.MCHID;
    
        public IWxPayConfig() throws Exception { // 构造方法读取证书, 通过getCertStream 可以使sdk获取到证书
            String certPath = WXPayConstants.CERTPATH;
            File file = new File(certPath);
            InputStream certStream = new FileInputStream(file);
            this.certData = new byte[(int) file.length()];
            certStream.read(this.certData);
            certStream.close();
        }
    
        @Override
        public String getAppID() {
            return app_id;
        }
    
        @Override
        public String getMchID() {
            return wx_pay_mch_id;
        }
    
        @Override
        public String getKey() {
            return wx_pay_key;
        }
    
        @Override
        public InputStream getCertStream() {
            return new ByteArrayInputStream(this.certData);
        }
    
        @Override
        public IWXPayDomain getWXPayDomain() { // 这个方法需要这样实现, 否则无法正常初始化WXPay
            IWXPayDomain iwxPayDomain = new IWXPayDomain() {
                @Override
                public void report(String domain, long elapsedTimeMillis, Exception ex) {
    
                }
                @Override
                public DomainInfo getDomain(WXPayConfig config) {
                    return new IWXPayDomain.DomainInfo(WXPayConstants.DOMAIN_API, true);
                }
            };
            return iwxPayDomain;
        }
    }

3.WXPayConstants类：

import org.apache.http.client.HttpClient;
    
    /**
     * 微信支付常量
     * @author Administrator
     *
     */
    public class WXPayConstants {
    	
    	public static final Double PERCENTGAINED = 0.8;//提现获取百分比
    	
    	public static final String CERTPATH = "cert证书保存位置";//cert证书保存位置
    	
    	public static final String APPID = "APPID";//APPID
    	
    	public static final String MCHID ="微信支付商户号";//微信支付商户号
    	
    	public static final String PATERNERKEY = "支付秘钥";//支付秘钥
    	
    	public static final String APPSECRET = "身份秘钥";//身份秘钥
    	
    	public static final String NOTIFYURL = "支付成功回调接口";//支付成功回调接口
    	
    	public enum SignType {
            MD5, HMACSHA256
        }
    
        public static final String DOMAIN_API = "api.mch.weixin.qq.com";
        public static final String DOMAIN_API2 = "api2.mch.weixin.qq.com";
        public static final String DOMAIN_APIHK = "apihk.mch.weixin.qq.com";
        public static final String DOMAIN_APIUS = "apius.mch.weixin.qq.com";
    
    
        public static final String FAIL     = "FAIL";
        public static final String SUCCESS  = "SUCCESS";
        public static final String HMACSHA256 = "HMAC-SHA256";
        public static final String MD5 = "MD5";
    
        public static final String FIELD_SIGN = "sign";
        public static final String FIELD_SIGN_TYPE = "sign_type";
    
        public static final String WXPAYSDK_VERSION = "WXPaySDK/3.0.9";
        public static final String USER_AGENT = WXPAYSDK_VERSION +
                " (" + System.getProperty("os.arch") + " " + System.getProperty("os.name") + " " + System.getProperty("os.version") +
                ") Java/" + System.getProperty("java.version") + " HttpClient/" + HttpClient.class.getPackage().getImplementationVersion();
    
        public static final String MICROPAY_URL_SUFFIX     = "/pay/micropay";
        public static final String UNIFIEDORDER_URL_SUFFIX = "/pay/unifiedorder";
        public static final String ORDERQUERY_URL_SUFFIX   = "/pay/orderquery";
        public static final String REVERSE_URL_SUFFIX      = "/secapi/pay/reverse";
        public static final String CLOSEORDER_URL_SUFFIX   = "/pay/closeorder";
        public static final String REFUND_URL_SUFFIX       = "/secapi/pay/refund";
        public static final String REFUNDQUERY_URL_SUFFIX  = "/pay/refundquery";
        public static final String DOWNLOADBILL_URL_SUFFIX = "/pay/downloadbill";
        public static final String REPORT_URL_SUFFIX       = "/payitil/report";
        public static final String SHORTURL_URL_SUFFIX     = "/tools/shorturl";
        public static final String AUTHCODETOOPENID_URL_SUFFIX = "/tools/authcodetoopenid";
    
        // sandbox
        public static final String SANDBOX_MICROPAY_URL_SUFFIX     = "/sandboxnew/pay/micropay";
        public static final String SANDBOX_UNIFIEDORDER_URL_SUFFIX = "/sandboxnew/pay/unifiedorder";
        public static final String SANDBOX_ORDERQUERY_URL_SUFFIX   = "/sandboxnew/pay/orderquery";
        public static final String SANDBOX_REVERSE_URL_SUFFIX      = "/sandboxnew/secapi/pay/reverse";
        public static final String SANDBOX_CLOSEORDER_URL_SUFFIX   = "/sandboxnew/pay/closeorder";
        public static final String SANDBOX_REFUND_URL_SUFFIX       = "/sandboxnew/secapi/pay/refund";
        public static final String SANDBOX_REFUNDQUERY_URL_SUFFIX  = "/sandboxnew/pay/refundquery";
        public static final String SANDBOX_DOWNLOADBILL_URL_SUFFIX = "/sandboxnew/pay/downloadbill";
        public static final String SANDBOX_REPORT_URL_SUFFIX       = "/sandboxnew/payitil/report";
        public static final String SANDBOX_SHORTURL_URL_SUFFIX     = "/sandboxnew/tools/shorturl";
        public static final String SANDBOX_AUTHCODETOOPENID_URL_SUFFIX = "/sandboxnew/tools/authcodetoopenid";
    	
    }

4.WXPayUtil类：

import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 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 org.w3c.dom.Node;
 import org.w3c.dom.NodeList;
 
 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.LoggerFactory;
 import com.ldkj.smms.util.wxtools.pay.WXPayConstants.SignType;
 
 import org.slf4j.Logger;
 
 import javax.crypto.Mac;
 import javax.crypto.spec.SecretKeySpec;
 /**
 * 微信支付工具类
 * 
 * @author Administrator
 *
 */
 public class WXPayUtil {
 
 /**
 	 * 生成签名
 	 *
 	 * @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));
 		}
 	}
 
 }

5.WXPay类：

import java.util.HashMap;
 import java.util.Map;
 
 import com.ldkj.smms.util.wxtools.pay.WXPayConstants.SignType;
 
 public class WXPay {
 	
 	private WXPayConfig config;
 private SignType signType;
 private boolean autoReport;
 private boolean useSandbox;
 private String notifyUrl;
 private WXPayRequest wxPayRequest;
 
 public WXPay(final WXPayConfig config) throws Exception {
 this(config, null, true, false);
 }
 
 public WXPay(final WXPayConfig config, final boolean autoReport) throws Exception {
 this(config, null, autoReport, false);
 }
 
 
 public WXPay(final WXPayConfig config, final boolean autoReport, final boolean useSandbox) throws Exception{
 this(config, null, autoReport, useSandbox);
 }
 
 public WXPay(final WXPayConfig config, final String notifyUrl) throws Exception {
 this(config, notifyUrl, true, false);
 }
 
 public WXPay(final WXPayConfig config, final String notifyUrl, final boolean autoReport) throws Exception {
 this(config, notifyUrl, autoReport, false);
 }
 
 public WXPay(final WXPayConfig config, final String notifyUrl, final boolean autoReport, final boolean useSandbox) throws Exception {
 this.config = config;
 this.notifyUrl = notifyUrl;
 this.autoReport = autoReport;
 this.useSandbox = useSandbox;
 if (useSandbox) {
 this.signType = SignType.MD5; // 沙箱环境
 }
 else {
 	//默认的加密方式，这是个坑，因为开发代码默认是HMACSHA256，而我们都用MD5，一定要注意修改
 //this.signType = SignType.HMACSHA256;
 	this.signType = SignType.MD5;
 }
 this.wxPayRequest = new WXPayRequest(config);
 }
 
 @SuppressWarnings("unused")
 	private void checkWXPayConfig() throws Exception {
 if (this.config == null) {
 throw new Exception("config is null");
 }
 if (this.config.getAppID() == null || this.config.getAppID().trim().length() == 0) {
 throw new Exception("appid in config is empty");
 }
 if (this.config.getMchID() == null || this.config.getMchID().trim().length() == 0) {
 throw new Exception("appid in config is empty");
 }
 if (this.config.getCertStream() == null) {
 throw new Exception("cert stream in config is empty");
 }
 if (this.config.getWXPayDomain() == null){
 throw new Exception("config.getWXPayDomain() is null");
 }
 
 if (this.config.getHttpConnectTimeoutMs() < 10) {
 throw new Exception("http connect timeout is too small");
 }
 if (this.config.getHttpReadTimeoutMs() < 10) {
 throw new Exception("http read timeout is too small");
 }
 
 }
 
 /**
 * 向 Map 中添加 appid、mch_id、nonce_str、sign_type、sign 
 * 该函数适用于商户适用于统一下单等接口，不适用于红包、代金券接口
 *
 * @param reqData
 * @return
 * @throws Exception
 */
 public Map<String, String> fillRequestData(Map<String, String> reqData) throws Exception {
 reqData.put("appid", config.getAppID());
 reqData.put("mch_id", config.getMchID());
 reqData.put("nonce_str", WXPayUtil.generateNonceStr());
 if (SignType.MD5.equals(this.signType)) {
 reqData.put("sign_type", WXPayConstants.MD5);
 }
 else if (SignType.HMACSHA256.equals(this.signType)) {
 reqData.put("sign_type", WXPayConstants.HMACSHA256);
 }
 reqData.put("sign", WXPayUtil.generateSignature(reqData, config.getKey(), this.signType));
 return reqData;
 }
 
 /**
 * 判断xml数据的sign是否有效，必须包含sign字段，否则返回false。
 *
 * @param reqData 向wxpay post的请求数据
 * @return 签名是否有效
 * @throws Exception
 */
 public boolean isResponseSignatureValid(Map<String, String> reqData) throws Exception {
 // 返回数据的签名方式和请求中给定的签名方式是一致的
 return WXPayUtil.isSignatureValid(reqData, this.config.getKey(), this.signType);
 }
 
 /**
 * 判断支付结果通知中的sign是否有效
 *
 * @param reqData 向wxpay post的请求数据
 * @return 签名是否有效
 * @throws Exception
 */
 public boolean isPayResultNotifySignatureValid(Map<String, String> reqData) throws Exception {
 String signTypeInData = reqData.get(WXPayConstants.FIELD_SIGN_TYPE);
 SignType signType;
 if (signTypeInData == null) {
 signType = SignType.MD5;
 }
 else {
 signTypeInData = signTypeInData.trim();
 if (signTypeInData.length() == 0) {
 signType = SignType.MD5;
 }
 else if (WXPayConstants.MD5.equals(signTypeInData)) {
 signType = SignType.MD5;
 }
 else if (WXPayConstants.HMACSHA256.equals(signTypeInData)) {
 signType = SignType.HMACSHA256;
 }
 else {
 throw new Exception(String.format("Unsupported sign_type: %s", signTypeInData));
 }
 }
 return WXPayUtil.isSignatureValid(reqData, this.config.getKey(), signType);
 }
 
 
 /**
 * 不需要证书的请求
 * @param urlSuffix String
 * @param reqData 向wxpay post的请求数据
 * @param connectTimeoutMs 超时时间，单位是毫秒
 * @param readTimeoutMs 超时时间，单位是毫秒
 * @return API返回数据
 * @throws Exception
 */
 public String requestWithoutCert(String urlSuffix, Map<String, String> reqData,
 int connectTimeoutMs, int readTimeoutMs) throws Exception {
 String msgUUID = reqData.get("nonce_str");
 String reqBody = WXPayUtil.mapToXml(reqData);
 
 String resp = this.wxPayRequest.requestWithoutCert(urlSuffix, msgUUID, reqBody, connectTimeoutMs, readTimeoutMs, autoReport);
 return resp;
 }
 
 
 /**
 * 需要证书的请求
 * @param urlSuffix String
 * @param reqData 向wxpay post的请求数据 Map
 * @param connectTimeoutMs 超时时间，单位是毫秒
 * @param readTimeoutMs 超时时间，单位是毫秒
 * @return API返回数据
 * @throws Exception
 */
 public String requestWithCert(String urlSuffix, Map<String, String> reqData,
 int connectTimeoutMs, int readTimeoutMs) throws Exception {
 String msgUUID= reqData.get("nonce_str");
 String reqBody = WXPayUtil.mapToXml(reqData);
 
 String resp = this.wxPayRequest.requestWithCert(urlSuffix, msgUUID, reqBody, connectTimeoutMs, readTimeoutMs, this.autoReport);
 return resp;
 }
 
 /**
 * 处理 HTTPS API返回数据，转换成Map对象。return_code为SUCCESS时，验证签名。
 * @param xmlStr API返回的XML格式数据
 * @return Map类型数据
 * @throws Exception
 */
 public Map<String, String> processResponseXml(String xmlStr) throws Exception {
 String RETURN_CODE = "return_code";
 String return_code;
 Map<String, String> respData = WXPayUtil.xmlToMap(xmlStr);
 if (respData.containsKey(RETURN_CODE)) {
 return_code = respData.get(RETURN_CODE);
 }
 else {
 throw new Exception(String.format("No `return_code` in XML: %s", xmlStr));
 }
 
 if (return_code.equals(WXPayConstants.FAIL)) {
 return respData;
 }
 else if (return_code.equals(WXPayConstants.SUCCESS)) {
 if (this.isResponseSignatureValid(respData)) {
 return respData;
 }
 else {
 throw new Exception(String.format("Invalid sign value in XML: %s", xmlStr));
 }
 }
 else {
 throw new Exception(String.format("return_code value %s is invalid in XML: %s", return_code, xmlStr));
 }
 }
 
 /**
 * 作用：提交刷卡支付 
 * 场景：刷卡支付
 * @param reqData 向wxpay post的请求数据
 * @return API返回数据
 * @throws Exception
 */
 public Map<String, String> microPay(Map<String, String> reqData) throws Exception {
 return this.microPay(reqData, this.config.getHttpConnectTimeoutMs(), this.config.getHttpReadTimeoutMs());
 }
 
 
 /**
 * 作用：提交刷卡支付 
 * 场景：刷卡支付
 * @param reqData 向wxpay post的请求数据
 * @param connectTimeoutMs 连接超时时间，单位是毫秒
 * @param readTimeoutMs 读超时时间，单位是毫秒
 * @return API返回数据
 * @throws Exception
 */
 public Map<String, String> microPay(Map<String, String> reqData, int connectTimeoutMs, int readTimeoutMs) throws Exception {
 String url;
 if (this.useSandbox) {
 url = WXPayConstants.SANDBOX_MICROPAY_URL_SUFFIX;
 }
 else {
 url = WXPayConstants.MICROPAY_URL_SUFFIX;
 }
 String respXml = this.requestWithoutCert(url, this.fillRequestData(reqData), connectTimeoutMs, readTimeoutMs);
 return this.processResponseXml(respXml);
 }
 
 /**
 * 提交刷卡支付，针对软POS，尽可能做成功
 * 内置重试机制，最多60s
 * @param reqData
 * @return
 * @throws Exception
 */
 public Map<String, String> microPayWithPos(Map<String, String> reqData) throws Exception {
 return this.microPayWithPos(reqData, this.config.getHttpConnectTimeoutMs());
 }
 
 /**
 * 提交刷卡支付，针对软POS，尽可能做成功
 * 内置重试机制，最多60s
 * @param reqData
 * @param connectTimeoutMs
 * @return
 * @throws Exception
 */
 public Map<String, String> microPayWithPos(Map<String, String> reqData, int connectTimeoutMs) throws Exception {
 int remainingTimeMs = 60*1000;
 long startTimestampMs = 0;
 Map<String, String> lastResult = null;
 Exception lastException = null;
 
 while (true) {
 startTimestampMs = WXPayUtil.getCurrentTimestampMs();
 int readTimeoutMs = remainingTimeMs - connectTimeoutMs;
 if (readTimeoutMs > 1000) {
 try {
 lastResult = this.microPay(reqData, connectTimeoutMs, readTimeoutMs);
 String returnCode = lastResult.get("return_code");
 if (returnCode.equals("SUCCESS")) {
 String resultCode = lastResult.get("result_code");
 String errCode = lastResult.get("err_code");
 if (resultCode.equals("SUCCESS")) {
 break;
 }
 else {
 // 看错误码，若支付结果未知，则重试提交刷卡支付
 if (errCode.equals("SYSTEMERROR") || errCode.equals("BANKERROR") || errCode.equals("USERPAYING")) {
 remainingTimeMs = remainingTimeMs - (int)(WXPayUtil.getCurrentTimestampMs() - startTimestampMs);
 if (remainingTimeMs <= 100) {
 break;
 }
 else {
 WXPayUtil.getLogger().info("microPayWithPos: try micropay again");
 if (remainingTimeMs > 5*1000) {
 Thread.sleep(5*1000);
 }
 else {
 Thread.sleep(1*1000);
 }
 continue;
 }
 }
 else {
 break;
 }
 }
 }
 else {
 break;
 }
 }
 catch (Exception ex) {
 lastResult = null;
 lastException = ex;
 }
 }
 else {
 break;
 }
 }
 
 if (lastResult == null) {
 throw lastException;
 }
 else {
 return lastResult;
 }
 }
 
 
 
 /**
 * 作用：统一下单 
 * 场景：公共号支付、扫码支付、APP支付
 * @param reqData 向wxpay post的请求数据
 * @return API返回数据
 * @throws Exception
 */
 public Map<String, String> unifiedOrder(Map<String, String> reqData) throws Exception {
 return this.unifiedOrder(reqData, config.getHttpConnectTimeoutMs(), this.config.getHttpReadTimeoutMs());
 }
 
 
 /**
 * 作用：统一下单 
 * 场景：公共号支付、扫码支付、APP支付
 * @param reqData 向wxpay post的请求数据
 * @param connectTimeoutMs 连接超时时间，单位是毫秒
 * @param readTimeoutMs 读超时时间，单位是毫秒
 * @return API返回数据
 * @throws Exception
 */
 public Map<String, String> unifiedOrder(Map<String, String> reqData, int connectTimeoutMs, int readTimeoutMs) throws Exception {
 String url;
 if (this.useSandbox) {
 url = WXPayConstants.SANDBOX_UNIFIEDORDER_URL_SUFFIX;
 }
 else {
 url = WXPayConstants.UNIFIEDORDER_URL_SUFFIX;
 }
 if(this.notifyUrl != null) {
 reqData.put("notify_url", this.notifyUrl);
 }
 String respXml = this.requestWithoutCert(url, this.fillRequestData(reqData), connectTimeoutMs, readTimeoutMs);
 return this.processResponseXml(respXml);
 }
 
 
 /**
 * 作用：查询订单 
 * 场景：刷卡支付、公共号支付、扫码支付、APP支付
 * @param reqData 向wxpay post的请求数据
 * @return API返回数据
 * @throws Exception
 */
 public Map<String, String> orderQuery(Map<String, String> reqData) throws Exception {
 return this.orderQuery(reqData, config.getHttpConnectTimeoutMs(), this.config.getHttpReadTimeoutMs());
 }
 
 
 /**
 * 作用：查询订单 
 * 场景：刷卡支付、公共号支付、扫码支付、APP支付
 * @param reqData 向wxpay post的请求数据 int
 * @param connectTimeoutMs 连接超时时间，单位是毫秒
 * @param readTimeoutMs 读超时时间，单位是毫秒
 * @return API返回数据
 * @throws Exception
 */
 public Map<String, String> orderQuery(Map<String, String> reqData, int connectTimeoutMs, int readTimeoutMs) throws Exception {
 String url;
 if (this.useSandbox) {
 url = WXPayConstants.SANDBOX_ORDERQUERY_URL_SUFFIX;
 }
 else {
 url = WXPayConstants.ORDERQUERY_URL_SUFFIX;
 }
 String respXml = this.requestWithoutCert(url, this.fillRequestData(reqData), connectTimeoutMs, readTimeoutMs);
 return this.processResponseXml(respXml);
 }
 
 
 /**
 * 作用：撤销订单 
 * 场景：刷卡支付
 * @param reqData 向wxpay post的请求数据
 * @return API返回数据
 * @throws Exception
 */
 public Map<String, String> reverse(Map<String, String> reqData) throws Exception {
 return this.reverse(reqData, config.getHttpConnectTimeoutMs(), this.config.getHttpReadTimeoutMs());
 }
 
 
 /**
 * 作用：撤销订单 
 * 场景：刷卡支付 
 * 其他：需要证书
 * @param reqData 向wxpay post的请求数据
 * @param connectTimeoutMs 连接超时时间，单位是毫秒
 * @param readTimeoutMs 读超时时间，单位是毫秒
 * @return API返回数据
 * @throws Exception
 */
 public Map<String, String> reverse(Map<String, String> reqData, int connectTimeoutMs, int readTimeoutMs) throws Exception {
 String url;
 if (this.useSandbox) {
 url = WXPayConstants.SANDBOX_REVERSE_URL_SUFFIX;
 }
 else {
 url = WXPayConstants.REVERSE_URL_SUFFIX;
 }
 String respXml = this.requestWithCert(url, this.fillRequestData(reqData), connectTimeoutMs, readTimeoutMs);
 return this.processResponseXml(respXml);
 }
 
 
 /**
 * 作用：关闭订单 
 * 场景：公共号支付、扫码支付、APP支付
 * @param reqData 向wxpay post的请求数据
 * @return API返回数据
 * @throws Exception
 */
 public Map<String, String> closeOrder(Map<String, String> reqData) throws Exception {
 return this.closeOrder(reqData, config.getHttpConnectTimeoutMs(), this.config.getHttpReadTimeoutMs());
 }
 
 
 /**
 * 作用：关闭订单 
 * 场景：公共号支付、扫码支付、APP支付
 * @param reqData 向wxpay post的请求数据
 * @param connectTimeoutMs 连接超时时间，单位是毫秒
 * @param readTimeoutMs 读超时时间，单位是毫秒
 * @return API返回数据
 * @throws Exception
 */
 public Map<String, String> closeOrder(Map<String, String> reqData, int connectTimeoutMs, int readTimeoutMs) throws Exception {
 String url;
 if (this.useSandbox) {
 url = WXPayConstants.SANDBOX_CLOSEORDER_URL_SUFFIX;
 }
 else {
 url = WXPayConstants.CLOSEORDER_URL_SUFFIX;
 }
 String respXml = this.requestWithoutCert(url, this.fillRequestData(reqData), connectTimeoutMs, readTimeoutMs);
 return this.processResponseXml(respXml);
 }
 
 
 /**
 * 作用：申请退款 
 * 场景：刷卡支付、公共号支付、扫码支付、APP支付
 * @param reqData 向wxpay post的请求数据
 * @return API返回数据
 * @throws Exception
 */
 public Map<String, String> refund(Map<String, String> reqData) throws Exception {
 return this.refund(reqData, this.config.getHttpConnectTimeoutMs(), this.config.getHttpReadTimeoutMs());
 }
 
 
 /**
 * 作用：申请退款 
 * 场景：刷卡支付、公共号支付、扫码支付、APP支付 
 * 其他：需要证书
 * @param reqData 向wxpay post的请求数据
 * @param connectTimeoutMs 连接超时时间，单位是毫秒
 * @param readTimeoutMs 读超时时间，单位是毫秒
 * @return API返回数据
 * @throws Exception
 */
 public Map<String, String> refund(Map<String, String> reqData, int connectTimeoutMs, int readTimeoutMs) throws Exception {
 String url;
 if (this.useSandbox) {
 url = WXPayConstants.SANDBOX_REFUND_URL_SUFFIX;
 }
 else {
 url = WXPayConstants.REFUND_URL_SUFFIX;
 }
 String respXml = this.requestWithCert(url, this.fillRequestData(reqData), connectTimeoutMs, readTimeoutMs);
 return this.processResponseXml(respXml);
 }
 
 
 /**
 * 作用：退款查询 
 * 场景：刷卡支付、公共号支付、扫码支付、APP支付
 * @param reqData 向wxpay post的请求数据
 * @return API返回数据
 * @throws Exception
 */
 public Map<String, String> refundQuery(Map<String, String> reqData) throws Exception {
 return this.refundQuery(reqData, this.config.getHttpConnectTimeoutMs(), this.config.getHttpReadTimeoutMs());
 }
 
 
 /**
 * 作用：退款查询 
 * 场景：刷卡支付、公共号支付、扫码支付、APP支付
 * @param reqData 向wxpay post的请求数据
 * @param connectTimeoutMs 连接超时时间，单位是毫秒
 * @param readTimeoutMs 读超时时间，单位是毫秒
 * @return API返回数据
 * @throws Exception
 */
 public Map<String, String> refundQuery(Map<String, String> reqData, int connectTimeoutMs, int readTimeoutMs) throws Exception {
 String url;
 if (this.useSandbox) {
 url = WXPayConstants.SANDBOX_REFUNDQUERY_URL_SUFFIX;
 }
 else {
 url = WXPayConstants.REFUNDQUERY_URL_SUFFIX;
 }
 String respXml = this.requestWithoutCert(url, this.fillRequestData(reqData), connectTimeoutMs, readTimeoutMs);
 return this.processResponseXml(respXml);
 }
 
 
 /**
 * 作用：对账单下载（成功时返回对账单数据，失败时返回XML格式数据） 
 * 场景：刷卡支付、公共号支付、扫码支付、APP支付
 * @param reqData 向wxpay post的请求数据
 * @return API返回数据
 * @throws Exception
 */
 public Map<String, String> downloadBill(Map<String, String> reqData) throws Exception {
 return this.downloadBill(reqData, this.config.getHttpConnectTimeoutMs(), this.config.getHttpReadTimeoutMs());
 }
 
 
 /**
 * 作用：对账单下载 
 * 场景：刷卡支付、公共号支付、扫码支付、APP支付 
 * 其他：无论是否成功都返回Map。若成功，返回的Map中含有return_code、return_msg、data，
 * 其中return_code为`SUCCESS`，data为对账单数据。
 * @param reqData 向wxpay post的请求数据
 * @param connectTimeoutMs 连接超时时间，单位是毫秒
 * @param readTimeoutMs 读超时时间，单位是毫秒
 * @return 经过封装的API返回数据
 * @throws Exception
 */
 public Map<String, String> downloadBill(Map<String, String> reqData, int connectTimeoutMs, int readTimeoutMs) throws Exception {
 String url;
 if (this.useSandbox) {
 url = WXPayConstants.SANDBOX_DOWNLOADBILL_URL_SUFFIX;
 }
 else {
 url = WXPayConstants.DOWNLOADBILL_URL_SUFFIX;
 }
 String respStr = this.requestWithoutCert(url, this.fillRequestData(reqData), connectTimeoutMs, readTimeoutMs).trim();
 Map<String, String> ret;
 // 出现错误，返回XML数据
 if (respStr.indexOf("<") == 0) {
 ret = WXPayUtil.xmlToMap(respStr);
 }
 else {
 // 正常返回csv数据
 ret = new HashMap<String, String>();
 ret.put("return_code", WXPayConstants.SUCCESS);
 ret.put("return_msg", "ok");
 ret.put("data", respStr);
 }
 return ret;
 }
 
 
 /**
 * 作用：交易保障 
 * 场景：刷卡支付、公共号支付、扫码支付、APP支付
 * @param reqData 向wxpay post的请求数据
 * @return API返回数据
 * @throws Exception
 */
 public Map<String, String> report(Map<String, String> reqData) throws Exception {
 return this.report(reqData, this.config.getHttpConnectTimeoutMs(), this.config.getHttpReadTimeoutMs());
 }
 
 
 /**
 * 作用：交易保障 
 * 场景：刷卡支付、公共号支付、扫码支付、APP支付
 * @param reqData 向wxpay post的请求数据
 * @param connectTimeoutMs 连接超时时间，单位是毫秒
 * @param readTimeoutMs 读超时时间，单位是毫秒
 * @return API返回数据
 * @throws Exception
 */
 public Map<String, String> report(Map<String, String> reqData, int connectTimeoutMs, int readTimeoutMs) throws Exception {
 String url;
 if (this.useSandbox) {
 url = WXPayConstants.SANDBOX_REPORT_URL_SUFFIX;
 }
 else {
 url = WXPayConstants.REPORT_URL_SUFFIX;
 }
 String respXml = this.requestWithoutCert(url, this.fillRequestData(reqData), connectTimeoutMs, readTimeoutMs);
 return WXPayUtil.xmlToMap(respXml);
 }
 
 
 /**
 * 作用：转换短链接 
 * 场景：刷卡支付、扫码支付
 * @param reqData 向wxpay post的请求数据
 * @return API返回数据
 * @throws Exception
 */
 public Map<String, String> shortUrl(Map<String, String> reqData) throws Exception {
 return this.shortUrl(reqData, this.config.getHttpConnectTimeoutMs(), this.config.getHttpReadTimeoutMs());
 }
 
 
 /**
 * 作用：转换短链接 
 * 场景：刷卡支付、扫码支付
 * @param reqData 向wxpay post的请求数据
 * @return API返回数据
 * @throws Exception
 */
 public Map<String, String> shortUrl(Map<String, String> reqData, int connectTimeoutMs, int readTimeoutMs) throws Exception {
 String url;
 if (this.useSandbox) {
 url = WXPayConstants.SANDBOX_SHORTURL_URL_SUFFIX;
 }
 else {
 url = WXPayConstants.SHORTURL_URL_SUFFIX;
 }
 String respXml = this.requestWithoutCert(url, this.fillRequestData(reqData), connectTimeoutMs, readTimeoutMs);
 return this.processResponseXml(respXml);
 }
 
 
 /**
 * 作用：授权码查询OPENID接口 
 * 场景：刷卡支付
 * @param reqData 向wxpay post的请求数据
 * @return API返回数据
 * @throws Exception
 */
 public Map<String, String> authCodeToOpenid(Map<String, String> reqData) throws Exception {
 return this.authCodeToOpenid(reqData, this.config.getHttpConnectTimeoutMs(), this.config.getHttpReadTimeoutMs());
 }
 
 
 /**
 * 作用：授权码查询OPENID接口 
 * 场景：刷卡支付
 * @param reqData 向wxpay post的请求数据
 * @param connectTimeoutMs 连接超时时间，单位是毫秒
 * @param readTimeoutMs 读超时时间，单位是毫秒
 * @return API返回数据
 * @throws Exception
 */
 public Map<String, String> authCodeToOpenid(Map<String, String> reqData, int connectTimeoutMs, int readTimeoutMs) throws Exception {
 String url;
 if (this.useSandbox) {
 url = WXPayConstants.SANDBOX_AUTHCODETOOPENID_URL_SUFFIX;
 }
 else {
 url = WXPayConstants.AUTHCODETOOPENID_URL_SUFFIX;
 }
 String respXml = this.requestWithoutCert(url, this.fillRequestData(reqData), connectTimeoutMs, readTimeoutMs);
 return this.processResponseXml(respXml);
 }
 
 
 } // end class

6.WXPayConfig类：

import java.io.InputStream;
    
    public abstract class WXPayConfig {
    
    
    
        /**
         * 获取 App ID
         *
         * @return App ID
         */
        abstract String getAppID();
    
    
        /**
         * 获取 Mch ID
         *
         * @return Mch ID
         */
        abstract String getMchID();
    
    
        /**
         * 获取 API 密钥
         *
         * @return API密钥
         */
        abstract String getKey();
    
    
        /**
         * 获取商户证书内容
         *
         * @return 商户证书内容
         */
        abstract InputStream getCertStream();
    
        /**
         * HTTP(S) 连接超时时间，单位毫秒
         *
         * @return
         */
        public int getHttpConnectTimeoutMs() {
            return 6*1000;
        }
    
        /**
         * HTTP(S) 读数据超时时间，单位毫秒
         *
         * @return
         */
        public int getHttpReadTimeoutMs() {
            return 8*1000;
        }
    
        /**
         * 获取WXPayDomain, 用于多域名容灾自动切换
         * @return
         */
        abstract IWXPayDomain getWXPayDomain();
    
        /**
         * 是否自动上报。
         * 若要关闭自动上报，子类中实现该函数返回 false 即可。
         *
         * @return
         */
        public boolean shouldAutoReport() {
            return true;
        }
    
        /**
         * 进行健康上报的线程的数量
         *
         * @return
         */
        public int getReportWorkerNum() {
            return 6;
        }
    
    
        /**
         * 健康上报缓存消息的最大数量。会有线程去独立上报
         * 粗略计算：加入一条消息200B，10000消息占用空间 2000 KB，约为2MB，可以接受
         *
         * @return
         */
        public int getReportQueueMaxSize() {
            return 10000;
        }
    
        /**
         * 批量上报，一次最多上报多个数据
         *
         * @return
         */
        public int getReportBatchSize() {
            return 10;
        }
    
    }

7.WXPayRequest类：

import org.apache.http.HttpEntity;
 import org.apache.http.HttpResponse;
 import org.apache.http.client.HttpClient;
 import org.apache.http.client.config.RequestConfig;
 import org.apache.http.client.methods.HttpPost;
 import org.apache.http.config.RegistryBuilder;
 import org.apache.http.conn.ConnectTimeoutException;
 import org.apache.http.conn.socket.ConnectionSocketFactory;
 import org.apache.http.conn.socket.PlainConnectionSocketFactory;
 import org.apache.http.conn.ssl.DefaultHostnameVerifier;
 import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
 import org.apache.http.entity.StringEntity;
 import org.apache.http.impl.client.HttpClientBuilder;
 import org.apache.http.impl.conn.BasicHttpClientConnectionManager;
 import org.apache.http.util.EntityUtils;
 
 import javax.net.ssl.KeyManagerFactory;
 import javax.net.ssl.SSLContext;
 import java.io.InputStream;
 import java.net.SocketTimeoutException;
 import java.net.UnknownHostException;
 import java.security.KeyStore;
 import java.security.SecureRandom;
 
 import static com.ldkj.smms.util.wxtools.pay.WXPayConstants.USER_AGENT;
 
 public class WXPayRequest {
 private WXPayConfig config;
 public WXPayRequest(WXPayConfig config) throws Exception{
 
 this.config = config;
 }
 
 /**
 * 请求，只请求一次，不做重试
 * @param domain
 * @param urlSuffix
 * @param uuid
 * @param data
 * @param connectTimeoutMs
 * @param readTimeoutMs
 * @param useCert 是否使用证书，针对退款、撤销等操作
 * @return
 * @throws Exception
 */
 private String requestOnce(final String domain, String urlSuffix, String uuid, String data, int connectTimeoutMs, int readTimeoutMs, boolean useCert) throws Exception {
 BasicHttpClientConnectionManager connManager;
 if (useCert) {
 // 证书
 char[] password = config.getMchID().toCharArray();
 InputStream certStream = config.getCertStream();
 KeyStore ks = KeyStore.getInstance("PKCS12");
 ks.load(certStream, password);
 
 // 实例化密钥库 & 初始化密钥工厂
 KeyManagerFactory kmf = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
 kmf.init(ks, password);
 
 // 创建 SSLContext
 SSLContext sslContext = SSLContext.getInstance("TLS");
 sslContext.init(kmf.getKeyManagers(), null, new SecureRandom());
 
 SSLConnectionSocketFactory sslConnectionSocketFactory = new SSLConnectionSocketFactory(
 sslContext,
 new String[]{"TLSv1"},
 null,
 new DefaultHostnameVerifier());
 
 connManager = new BasicHttpClientConnectionManager(
 RegistryBuilder.<ConnectionSocketFactory>create()
 .register("http", PlainConnectionSocketFactory.getSocketFactory())
 .register("https", sslConnectionSocketFactory)
 .build(),
 null,
 null,
 null
 );
 }
 else {
 connManager = new BasicHttpClientConnectionManager(
 RegistryBuilder.<ConnectionSocketFactory>create()
 .register("http", PlainConnectionSocketFactory.getSocketFactory())
 .register("https", SSLConnectionSocketFactory.getSocketFactory())
 .build(),
 null,
 null,
 null
 );
 }
 
 HttpClient httpClient = HttpClientBuilder.create()
 .setConnectionManager(connManager)
 .build();
 
 String url = "https://" + domain + urlSuffix;
 HttpPost httpPost = new HttpPost(url);
 
 RequestConfig requestConfig = RequestConfig.custom().setSocketTimeout(readTimeoutMs).setConnectTimeout(connectTimeoutMs).build();
 httpPost.setConfig(requestConfig);
 
 StringEntity postEntity = new StringEntity(data, "UTF-8");
 httpPost.addHeader("Content-Type", "text/xml");
 httpPost.addHeader("User-Agent", USER_AGENT + " " + config.getMchID());
 httpPost.setEntity(postEntity);
 
 HttpResponse httpResponse = httpClient.execute(httpPost);
 HttpEntity httpEntity = httpResponse.getEntity();
 return EntityUtils.toString(httpEntity, "UTF-8");
 
 }
 
 
 private String request(String urlSuffix, String uuid, String data, int connectTimeoutMs, int readTimeoutMs, boolean useCert, boolean autoReport) throws Exception {
 Exception exception = null;
 long elapsedTimeMillis = 0;
 long startTimestampMs = WXPayUtil.getCurrentTimestampMs();
 boolean firstHasDnsErr = false;
 boolean firstHasConnectTimeout = false;
 boolean firstHasReadTimeout = false;
 IWXPayDomain.DomainInfo domainInfo = config.getWXPayDomain().getDomain(config);
 if(domainInfo == null){
 throw new Exception("WXPayConfig.getWXPayDomain().getDomain() is empty or null");
 }
 try {
 String result = requestOnce(domainInfo.domain, urlSuffix, uuid, data, connectTimeoutMs, readTimeoutMs, useCert);
 elapsedTimeMillis = WXPayUtil.getCurrentTimestampMs()-startTimestampMs;
 config.getWXPayDomain().report(domainInfo.domain, elapsedTimeMillis, null);
 WXPayReport.getInstance(config).report(
 uuid,
 elapsedTimeMillis,
 domainInfo.domain,
 domainInfo.primaryDomain,
 connectTimeoutMs,
 readTimeoutMs,
 firstHasDnsErr,
 firstHasConnectTimeout,
 firstHasReadTimeout);
 return result;
 }
 catch (UnknownHostException ex) { // dns 解析错误，或域名不存在
 exception = ex;
 firstHasDnsErr = true;
 elapsedTimeMillis = WXPayUtil.getCurrentTimestampMs()-startTimestampMs;
 WXPayUtil.getLogger().warn("UnknownHostException for domainInfo {}", domainInfo);
 WXPayReport.getInstance(config).report(
 uuid,
 elapsedTimeMillis,
 domainInfo.domain,
 domainInfo.primaryDomain,
 connectTimeoutMs,
 readTimeoutMs,
 firstHasDnsErr,
 firstHasConnectTimeout,
 firstHasReadTimeout
 );
 }
 catch (ConnectTimeoutException ex) {
 exception = ex;
 firstHasConnectTimeout = true;
 elapsedTimeMillis = WXPayUtil.getCurrentTimestampMs()-startTimestampMs;
 WXPayUtil.getLogger().warn("connect timeout happened for domainInfo {}", domainInfo);
 WXPayReport.getInstance(config).report(
 uuid,
 elapsedTimeMillis,
 domainInfo.domain,
 domainInfo.primaryDomain,
 connectTimeoutMs,
 readTimeoutMs,
 firstHasDnsErr,
 firstHasConnectTimeout,
 firstHasReadTimeout
 );
 }
 catch (SocketTimeoutException ex) {
 exception = ex;
 firstHasReadTimeout = true;
 elapsedTimeMillis = WXPayUtil.getCurrentTimestampMs()-startTimestampMs;
 WXPayUtil.getLogger().warn("timeout happened for domainInfo {}", domainInfo);
 WXPayReport.getInstance(config).report(
 uuid,
 elapsedTimeMillis,
 domainInfo.domain,
 domainInfo.primaryDomain,
 connectTimeoutMs,
 readTimeoutMs,
 firstHasDnsErr,
 firstHasConnectTimeout,
 firstHasReadTimeout);
 }
 catch (Exception ex) {
 exception = ex;
 elapsedTimeMillis = WXPayUtil.getCurrentTimestampMs()-startTimestampMs;
 WXPayReport.getInstance(config).report(
 uuid,
 elapsedTimeMillis,
 domainInfo.domain,
 domainInfo.primaryDomain,
 connectTimeoutMs,
 readTimeoutMs,
 firstHasDnsErr,
 firstHasConnectTimeout,
 firstHasReadTimeout);
 }
 config.getWXPayDomain().report(domainInfo.domain, elapsedTimeMillis, exception);
 throw exception;
 }
 
 
 /**
 * 可重试的，非双向认证的请求
 * @param urlSuffix
 * @param uuid
 * @param data
 * @return
 */
 public String requestWithoutCert(String urlSuffix, String uuid, String data, boolean autoReport) throws Exception {
 return this.request(urlSuffix, uuid, data, config.getHttpConnectTimeoutMs(), config.getHttpReadTimeoutMs(), false, autoReport);
 }
 
 /**
 * 可重试的，非双向认证的请求
 * @param urlSuffix
 * @param uuid
 * @param data
 * @param connectTimeoutMs
 * @param readTimeoutMs
 * @return
 */
 public String requestWithoutCert(String urlSuffix, String uuid, String data, int connectTimeoutMs, int readTimeoutMs, boolean autoReport) throws Exception {
 return this.request(urlSuffix, uuid, data, connectTimeoutMs, readTimeoutMs, false, autoReport);
 }
 
 /**
 * 可重试的，双向认证的请求
 * @param urlSuffix
 * @param uuid
 * @param data
 * @return
 */
 public String requestWithCert(String urlSuffix, String uuid, String data, boolean autoReport) throws Exception {
 return this.request(urlSuffix, uuid, data, config.getHttpConnectTimeoutMs(), config.getHttpReadTimeoutMs(), true, autoReport);
 }
 
 /**
 * 可重试的，双向认证的请求
 * @param urlSuffix
 * @param uuid
 * @param data
 * @param connectTimeoutMs
 * @param readTimeoutMs
 * @return
 */
 public String requestWithCert(String urlSuffix, String uuid, String data, int connectTimeoutMs, int readTimeoutMs, boolean autoReport) throws Exception {
 return this.request(urlSuffix, uuid, data, connectTimeoutMs, readTimeoutMs, true, autoReport);
 }
 }

8.HttpRequest类：

import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.io.OutputStream;
 import java.io.PrintWriter;
 import java.net.URL;
 import java.net.URLConnection;
 import java.util.List;
 import java.util.Map;
 
 import javax.net.ssl.HttpsURLConnection;
 
 public class HttpRequest {
 	/**
 	 * 向指定URL发送GET方法的请求
 	 * 
 	 * @param url
 	 * 发送请求的URL
 	 * @param param
 	 * 请求参数,请求参数应该是 name1=value1&name2=value2 的形式。
 	 * @return URL 所代表远程资源的响应结果
 	 */
 	public static String sendGet(String url, String param) {
 		String result = "";
 		BufferedReader in = null;
 		try {
 			String urlNameString = url + "?" + param;
 			System.out.println(urlNameString);
 			URL realUrl = new URL(urlNameString);
 			// 打开和URL之间的连接
 			URLConnection connection = realUrl.openConnection();
 			// 设置通用的请求属性
 			connection.setRequestProperty("accept", "*/*");
 			connection.setRequestProperty("connection", "Keep-Alive");
 			connection.setRequestProperty("user-agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)");
 			// 建立实际的连接
 			connection.connect();
 			// 获取所有响应头字段
 			Map<String, List<String>> map = connection.getHeaderFields();
 			// 遍历所有的响应头字段
 			for (String key : map.keySet()) {
 				System.out.println(key + "--->" + map.get(key));
 			}
 			// 定义 BufferedReader输入流来读取URL的响应
 			in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
 			String line;
 			while ((line = in.readLine()) != null) {
 				result += line;
 			}
 		} catch (Exception e) {
 			System.out.println("发送GET请求出现异常！" + e);
 			e.printStackTrace();
 		}
 		// 使用finally块来关闭输入流
 		finally {
 			try {
 				if (in != null) {
 					in.close();
 				}
 			} catch (Exception e2) {
 				e2.printStackTrace();
 			}
 		}
 		return result;
 	}
 
 	/**
 	 * 向指定 URL 发送POST方法的请求
 	 * 
 	 * @param url
 	 * 发送请求的 URL
 	 * @param param
 	 * 请求参数,请求参数应该是 name1=value1&name2=value2 的形式。
 	 * @return 所代表远程资源的响应结果
 	 */
 	public static String sendPost(String url, String param) {
 		PrintWriter out = null;
 		BufferedReader in = null;
 		String result = "";
 		try {
 			URL realUrl = new URL(url);
 			// 打开和URL之间的连接
 			URLConnection conn = realUrl.openConnection();
 			// 设置通用的请求属性
 			conn.setRequestProperty("accept", "*/*");
 			conn.setRequestProperty("connection", "Keep-Alive");
 			conn.setRequestProperty("user-agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)");
 			// 发送POST请求必须设置如下两行
 			conn.setDoOutput(true);
 			conn.setDoInput(true);
 			// 获取URLConnection对象对应的输出流
 			out = new PrintWriter(conn.getOutputStream());
 			// 发送请求参数
 			out.print(param);
 			// flush输出流的缓冲
 			out.flush();
 			// 定义BufferedReader输入流来读取URL的响应
 			in = new BufferedReader(new InputStreamReader(conn.getInputStream(), "UTF-8"));
 			String line;
 			while ((line = in.readLine()) != null) {
 				result += line;
 			}
 		} catch (Exception e) {
 			System.out.println("发送 POST 请求出现异常！" + e);
 			e.printStackTrace();
 		}
 		// 使用finally块来关闭输出流、输入流
 		finally {
 			try {
 				if (out != null) {
 					out.close();
 				}
 				if (in != null) {
 					in.close();
 				}
 			} catch (IOException ex) {
 				ex.printStackTrace();
 			}
 		}
 		return result;
 	}
 
 	/**
 	 * post请求并得到返回结果
 	 * 
 	 * @param requestUrl
 	 * @param requestMethod
 	 * @param output
 	 * @return
 	 */
 	public static String httpsRequest(String requestUrl, String requestMethod, String output) {
 		try { 
 			URL url = new URL(requestUrl);
 			HttpsURLConnection connection = (HttpsURLConnection) url.openConnection();
 			connection.setDoOutput(true);
 			connection.setDoInput(true);
 			connection.setUseCaches(false);
 			connection.setRequestMethod(requestMethod);
 			if (null != output) {
 				OutputStream outputStream = connection.getOutputStream();
 				outputStream.write(output.getBytes("UTF-8"));
 				outputStream.close();
 			}
 			// 从输入流读取返回内容
 			InputStream inputStream = connection.getInputStream();
 			InputStreamReader inputStreamReader = new InputStreamReader(inputStream, "utf-8");
 			BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
 			String str = null;
 			StringBuffer buffer = new StringBuffer();
 			while ((str = bufferedReader.readLine()) != null) {
 				buffer.append(str);
 			}
 			bufferedReader.close();
 			inputStreamReader.close();
 			inputStream.close();
 			inputStream = null;
 			connection.disconnect();
 			return buffer.toString();
 		} catch (Exception ex) {
 			ex.printStackTrace();
 		}
 
 		return "";
 	}
 }

9.IWXPayDomain类：

/**
     * 域名管理，实现主备域名自动切换
     */
    public abstract interface IWXPayDomain {
        /**
         * 上报域名网络状况
         * @param domain 域名。 比如：api.mch.weixin.qq.com
         * @param elapsedTimeMillis 耗时
         * @param ex 网络请求中出现的异常。
         *           null表示没有异常
         *           ConnectTimeoutException，表示建立网络连接异常
         *           UnknownHostException， 表示dns解析异常
         */
        abstract void report(final String domain, long elapsedTimeMillis, final Exception ex);
    
        /**
         * 获取域名
         * @param config 配置
         * @return 域名
         */
        abstract DomainInfo getDomain(final WXPayConfig config);
    
        static class DomainInfo{
            public String domain;       //域名
            public boolean primaryDomain;     //该域名是否为主域名。例如:api.mch.weixin.qq.com为主域名
            public DomainInfo(String domain, boolean primaryDomain) {
                this.domain = domain;
                this.primaryDomain = primaryDomain;
            }
    
            @Override
            public String toString() {
                return "DomainInfo{" +
                        "domain='" + domain + '\'' +
                        ", primaryDomain=" + primaryDomain +
                        '}';
            }
        }
    
    }

10.WXPayReport类：

import org.apache.http.HttpEntity;
 import org.apache.http.HttpResponse;
 import org.apache.http.client.HttpClient;
 import org.apache.http.client.config.RequestConfig;
 import org.apache.http.client.methods.HttpPost;
 import org.apache.http.config.RegistryBuilder;
 import org.apache.http.conn.socket.ConnectionSocketFactory;
 import org.apache.http.conn.socket.PlainConnectionSocketFactory;
 import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
 import org.apache.http.entity.StringEntity;
 import org.apache.http.impl.client.HttpClientBuilder;
 import org.apache.http.impl.conn.BasicHttpClientConnectionManager;
 import org.apache.http.util.EntityUtils;
 
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.LinkedBlockingQueue;
 import java.util.concurrent.ThreadFactory;
 
 /**
 * 交易保障
 */
 public class WXPayReport {
 
 public static class ReportInfo {
 
 /**
 * 布尔变量使用int。0为false， 1为true。
 */
 
 // 基本信息
 private String version = "v1";
 private String sdk = WXPayConstants.WXPAYSDK_VERSION;
 private String uuid; // 交易的标识
 private long timestamp; // 上报时的时间戳，单位秒
 private long elapsedTimeMillis; // 耗时，单位 毫秒
 
 // 针对主域名
 private String firstDomain; // 第1次请求的域名
 private boolean primaryDomain; //是否主域名
 private int firstConnectTimeoutMillis; // 第1次请求设置的连接超时时间，单位 毫秒
 private int firstReadTimeoutMillis; // 第1次请求设置的读写超时时间，单位 毫秒
 private int firstHasDnsError; // 第1次请求是否出现dns问题
 private int firstHasConnectTimeout; // 第1次请求是否出现连接超时
 private int firstHasReadTimeout; // 第1次请求是否出现连接超时
 
 public ReportInfo(String uuid, long timestamp, long elapsedTimeMillis, String firstDomain, boolean primaryDomain, int firstConnectTimeoutMillis, int firstReadTimeoutMillis, boolean firstHasDnsError, boolean firstHasConnectTimeout, boolean firstHasReadTimeout) {
 this.uuid = uuid;
 this.timestamp = timestamp;
 this.elapsedTimeMillis = elapsedTimeMillis;
 this.firstDomain = firstDomain;
 this.primaryDomain = primaryDomain;
 this.firstConnectTimeoutMillis = firstConnectTimeoutMillis;
 this.firstReadTimeoutMillis = firstReadTimeoutMillis;
 this.firstHasDnsError = firstHasDnsError?1:0;
 this.firstHasConnectTimeout = firstHasConnectTimeout?1:0;
 this.firstHasReadTimeout = firstHasReadTimeout?1:0;
 }
 
 @Override
 public String toString() {
 return "ReportInfo{" +
 "version='" + version + '\'' +
 ", sdk='" + sdk + '\'' +
 ", uuid='" + uuid + '\'' +
 ", timestamp=" + timestamp +
 ", elapsedTimeMillis=" + elapsedTimeMillis +
 ", firstDomain='" + firstDomain + '\'' +
 ", primaryDomain=" + primaryDomain +
 ", firstConnectTimeoutMillis=" + firstConnectTimeoutMillis +
 ", firstReadTimeoutMillis=" + firstReadTimeoutMillis +
 ", firstHasDnsError=" + firstHasDnsError +
 ", firstHasConnectTimeout=" + firstHasConnectTimeout +
 ", firstHasReadTimeout=" + firstHasReadTimeout +
 '}';
 }
 
 /**
 * 转换成 csv 格式
 *
 * @return
 */
 public String toLineString(String key) {
 String separator = ",";
 Object[] objects = new Object[] {
 version, sdk, uuid, timestamp, elapsedTimeMillis,
 firstDomain, primaryDomain, firstConnectTimeoutMillis, firstReadTimeoutMillis,
 firstHasDnsError, firstHasConnectTimeout, firstHasReadTimeout
 };
 StringBuffer sb = new StringBuffer();
 for(Object obj: objects) {
 sb.append(obj).append(separator);
 }
 try {
 String sign = WXPayUtil.HMACSHA256(sb.toString(), key);
 sb.append(sign);
 return sb.toString();
 }
 catch (Exception ex) {
 return null;
 }
 
 }
 
 }
 
 private static final String REPORT_URL = "http://report.mch.weixin.qq.com/wxpay/report/default";
 // private static final String REPORT_URL = "http://127.0.0.1:5000/test";
 
 
 private static final int DEFAULT_CONNECT_TIMEOUT_MS = 6*1000;
 private static final int DEFAULT_READ_TIMEOUT_MS = 8*1000;
 
 private LinkedBlockingQueue<String> reportMsgQueue = null;
 private WXPayConfig config;
 private ExecutorService executorService;
 
 private volatile static WXPayReport INSTANCE;
 
 private WXPayReport(final WXPayConfig config) {
 this.config = config;
 reportMsgQueue = new LinkedBlockingQueue<String>(config.getReportQueueMaxSize());
 
 // 添加处理线程
 executorService = Executors.newFixedThreadPool(config.getReportWorkerNum(), new ThreadFactory() {
 public Thread newThread(Runnable r) {
 Thread t = Executors.defaultThreadFactory().newThread(r);
 t.setDaemon(true);
 return t;
 }
 });
 
 if (config.shouldAutoReport()) {
 WXPayUtil.getLogger().info("report worker num: {}", config.getReportWorkerNum());
 for (int i = 0; i < config.getReportWorkerNum(); ++i) {
 executorService.execute(new Runnable() {
 public void run() {
 while (true) {
 // 先用 take 获取数据
 try {
 StringBuffer sb = new StringBuffer();
 String firstMsg = reportMsgQueue.take();
 WXPayUtil.getLogger().info("get first report msg: {}", firstMsg);
 String msg = null;
 sb.append(firstMsg); //会阻塞至有消息
 int remainNum = config.getReportBatchSize() - 1;
 for (int j=0; j<remainNum; ++j) {
 WXPayUtil.getLogger().info("try get remain report msg");
 // msg = reportMsgQueue.poll(); // 不阻塞了
 msg = reportMsgQueue.take();
 WXPayUtil.getLogger().info("get remain report msg: {}", msg);
 if (msg == null) {
 break;
 }
 else {
 sb.append("\n");
 sb.append(msg);
 }
 }
 // 上报
 WXPayReport.httpRequest(sb.toString(), DEFAULT_CONNECT_TIMEOUT_MS, DEFAULT_READ_TIMEOUT_MS);
 }
 catch (Exception ex) {
 WXPayUtil.getLogger().warn("report fail. reason: {}", ex.getMessage());
 }
 }
 }
 });
 }
 }
 
 }
 
 /**
 * 单例，双重校验，请在 JDK 1.5及更高版本中使用
 *
 * @param config
 * @return
 */
 public static WXPayReport getInstance(WXPayConfig config) {
 if (INSTANCE == null) {
 synchronized (WXPayReport.class) {
 if (INSTANCE == null) {
 INSTANCE = new WXPayReport(config);
 }
 }
 }
 return INSTANCE;
 }
 
 public void report(String uuid, long elapsedTimeMillis,
 String firstDomain, boolean primaryDomain, int firstConnectTimeoutMillis, int firstReadTimeoutMillis,
 boolean firstHasDnsError, boolean firstHasConnectTimeout, boolean firstHasReadTimeout) {
 long currentTimestamp = WXPayUtil.getCurrentTimestamp();
 ReportInfo reportInfo = new ReportInfo(uuid, currentTimestamp, elapsedTimeMillis,
 firstDomain, primaryDomain, firstConnectTimeoutMillis, firstReadTimeoutMillis,
 firstHasDnsError, firstHasConnectTimeout, firstHasReadTimeout);
 String data = reportInfo.toLineString(config.getKey());
 WXPayUtil.getLogger().info("report {}", data);
 if (data != null) {
 reportMsgQueue.offer(data);
 }
 }
 
 
 @SuppressWarnings("unused")
 	@Deprecated
 private void reportSync(final String data) throws Exception {
 httpRequest(data, DEFAULT_CONNECT_TIMEOUT_MS, DEFAULT_READ_TIMEOUT_MS);
 }
 
 @SuppressWarnings("unused")
 	@Deprecated
 private void reportAsync(final String data) throws Exception {
 new Thread(new Runnable() {
 public void run() {
 try {
 httpRequest(data, DEFAULT_CONNECT_TIMEOUT_MS, DEFAULT_READ_TIMEOUT_MS);
 }
 catch (Exception ex) {
 WXPayUtil.getLogger().warn("report fail. reason: {}", ex.getMessage());
 }
 }
 }).start();
 }
 
 /**
 * http 请求
 * @param data
 * @param connectTimeoutMs
 * @param readTimeoutMs
 * @return
 * @throws Exception
 */
 private static String httpRequest(String data, int connectTimeoutMs, int readTimeoutMs) throws Exception{
 BasicHttpClientConnectionManager connManager;
 connManager = new BasicHttpClientConnectionManager(
 RegistryBuilder.<ConnectionSocketFactory>create()
 .register("http", PlainConnectionSocketFactory.getSocketFactory())
 .register("https", SSLConnectionSocketFactory.getSocketFactory())
 .build(),
 null,
 null,
 null
 );
 HttpClient httpClient = HttpClientBuilder.create()
 .setConnectionManager(connManager)
 .build();
 
 HttpPost httpPost = new HttpPost(REPORT_URL);
 
 RequestConfig requestConfig = RequestConfig.custom().setSocketTimeout(readTimeoutMs).setConnectTimeout(connectTimeoutMs).build();
 httpPost.setConfig(requestConfig);
 
 StringEntity postEntity = new StringEntity(data, "UTF-8");
 httpPost.addHeader("Content-Type", "text/xml");
 httpPost.addHeader("User-Agent", WXPayConstants.USER_AGENT);
 httpPost.setEntity(postEntity);
 
 HttpResponse httpResponse = httpClient.execute(httpPost);
 HttpEntity httpEntity = httpResponse.getEntity();
 return EntityUtils.toString(httpEntity, "UTF-8");
 }
 
 }

11.WXPayXmlUtil类：

import org.w3c.dom.Document;
    
    import javax.xml.XMLConstants;
    import javax.xml.parsers.DocumentBuilder;
    import javax.xml.parsers.DocumentBuilderFactory;
    import javax.xml.parsers.ParserConfigurationException;
    
    /**
     * 2018/7/3
     */
    public final class WXPayXmlUtil {
        public static DocumentBuilder newDocumentBuilder() throws ParserConfigurationException {
            DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
            documentBuilderFactory.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
            documentBuilderFactory.setFeature("http://xml.org/sax/features/external-general-entities", false);
            documentBuilderFactory.setFeature("http://xml.org/sax/features/external-parameter-entities", false);
            documentBuilderFactory.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", false);
            documentBuilderFactory.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, true);
            documentBuilderFactory.setXIncludeAware(false);
            documentBuilderFactory.setExpandEntityReferences(false);
    
            return documentBuilderFactory.newDocumentBuilder();
        }
    
        public static Document newDocument() throws ParserConfigurationException {
            return newDocumentBuilder().newDocument();
        }
    }

12.WXSignUtils类：

import java.util.Iterator;
 import java.util.Map;
 import java.util.Set;
 
 import com.ldkj.smms.util.MD5Util;
 
 import java.util.Map.Entry;
 
 
 public class WXSignUtils {
 	
 public static String createSign(String characterEncoding, Map<Object, Object> parameters){
 	StringBuffer sb = new StringBuffer();
 		Set<Entry<Object, Object>> es = parameters.entrySet();
 		Iterator<Entry<Object, Object>> it = es.iterator();
 		while (it.hasNext()) {
 			Entry<Object, Object> entry = it.next();
 			String k = (String) entry.getKey();
 			Object v = entry.getValue();
 			if (null != v && !"".equals(v) && !"sign".equals(k) && !"key".equals(k)) {
 				sb.append(k + "=" + v + "&");
 			}
 		}
 		sb.append("key=" + WXPayConstants.PATERNERKEY);
 		String sign = MD5Util.MD5Encode(sb.toString(), characterEncoding).toUpperCase();
 		return sign;
 }
 }

二.遇到的问题

（1）NoClassDefFoundError:   
        Failed resolution of: org.apache.http.conn.ssl.DefaultHostnameVerifier 错误

解决方案：

添加依赖或者jar包：

<dependency>
             <groupId>org.apache.httpcomponents</groupId>
             <artifactId>httpclient</artifactId>
             <version>4.4.1</version>
         </dependency>

链接：https://pan.baidu.com/s/12yT-QNJX0ZYbjyXSnZnEPA   
提取码：lwx6

（2）签名不正确：

解决方案：当你用MD5加密时，应该修改官方代码的一个地方（WXPay类）下的一个地方，因为这个地方默认HMACSHA256

![20200228172429251.png][]

（3）记得在微信公众号的微信支付里添加支付域名、相关秘钥，以及一些证书

[https_pay.weixin.qq.com_wiki_doc_api_app_app.php_chapter_9_1]: https://pay.weixin.qq.com/wiki/doc/api/app/app.php?chapter=9_1
[20200228172429251.png]: https://img-blog.csdnimg.cn/20200228172429251.png