微信小程序支付
最近做小程序，涉及到微信支付，看了看微信小程序开发文档，尽管之前做过微信支付，还是有点懵逼，不过好在之前研究过，不然真的是无从下手。对比了一下发现，其实小程序中做支付比公众号支付要省事很多，因为不需要支付授权目录，也不需要授权域名，但是支付流程却比公众号多了一步，就是统一下单是预支付，然后需要对预支付的结果再次签名之后，才调起支付。
前期准备：
1.开通了微信支付，并且小程序绑定了微信支付；
2.准备好小程序的appid，微信支付的商户号，支付秘钥。
商户系统和微信支付系统主要交互：
1、小程序内调用登录接口，获取到用户的openid
此步骤在小程序内完成，也很简单，方法见：【小程序登录API】
2、调用商户服务器支付统一下单接口，进行预支付
/**
* 预支付请求接口(POST)
* @param string $openid openid
* @param string $body 商品简单描述
* @param string $order_sn 订单编号
* @param string $total_fee 金额
* @return json的数据
*/
public function prepay(){
$config = $this->config;
$openid = I('post.openid');
$body = I('post.body');
$order_sn = I('post.order_sn');
$total_fee = I('post.total_fee');
//统一下单参数构造
$unifiedorder = array(
'appid' => $config['appid'],
'mch_id' => $config['pay_mchid'],
'nonce_str' => self::getNonceStr(),
'body' => $body,
'out_trade_no' => $order_sn,
'total_fee' => $total_fee * 100,
'spbill_create_ip' => get_client_ip(),
'notify_url' => 'https://'.$_SERVER['HTTP_HOST'].'/Api/Wxpay/notify',
'trade_type' => 'JSAPI',
'openid' => $openid
);
$unifiedorder['sign'] = self::makeSign($unifiedorder);
//请求数据
$xmldata = self::array2xml($unifiedorder);
$url = 'https://api.mch.weixin.qq.com/pay/unifiedorder';
$res = self::curl_post_ssl($url, $xmldata);
if(!$res){
self::return_err("Can't connect the server");
}
// 这句file_put_contents是用来查看服务器返回的结果 测试完可以删除了
//file_put_contents(APP_ROOT.'/Statics/log1.txt',$res,FILE_APPEND);
$content = self::xml2array($res);
if(strval($content['result_code']) == 'FAIL'){
self::return_err(strval($content['err_code_des']));
}
if(strval($content['return_code']) == 'FAIL'){
self::return_err(strval($content['return_msg']));
}
self::return_data(array('data'=>$content));
//$this->ajaxReturn($content);
}
3、调用商户服务器再次签名接口，返回支付数据
/**
* 进行支付接口(POST)
* @param string $prepay_id 预支付ID(调用prepay()方法之后的返回数据中获取)
* @return json的数据
*/
public function pay(){
$config = $this->config;
$prepay_id = I('post.prepay_id');
$data = array(
'appId' => $config['appid'],
'timeStamp' => time(),
'nonceStr' => self::getNonceStr(),
'package' => 'prepay_id='.$prepay_id,
'signType' => 'MD5'
);
$data['paySign'] = self::makeSign($data);
$this->ajaxReturn($data);
}
4、小程序内完成支付，商户服务器接收支付回调通知，小程序加密方式一定是MD5
小程序端代码:
wx.requestPayment({
'timeStamp': '',
'nonceStr': '',
'package': '',
'signType': 'MD5',
'paySign': '',
'success':function(res){
},
'fail':function(res){
}
})
服务器回调通知:
//微信支付回调验证
public function notify(){
$xml = $GLOBALS['HTTP_RAW_POST_DATA'];
// 这句file_put_contents是用来查看服务器返回的XML数据 测试完可以删除了
//file_put_contents(APP_ROOT.'/Statics/log2.txt',$res,FILE_APPEND);
//将服务器返回的XML数据转化为数组
$data = self::xml2array($xml);
// 保存微信服务器返回的签名sign
$data_sign = $data['sign'];
// sign不参与签名算法
unset($data['sign']);
$sign = self::makeSign($data);
// 判断签名是否正确 判断支付状态
if ( ($sign===$data_sign) && ($data['return_code']=='SUCCESS') && ($data['result_code']=='SUCCESS') ) {
$result = $data;
//获取服务器返回的数据
$order_sn = $data['out_trade_no']; //订单单号
$openid = $data['openid']; //付款人openID
$total_fee = $data['total_fee']; //付款金额
$transaction_id = $data['transaction_id']; //微信支付流水号
//更新数据库
$this->updateDB($order_sn,$openid,$total_fee,$transaction_id);
}else{
$result = false;
}
// 返回状态给微信服务器
if ($result) {
$str='小程序端完整代码如下:
/**
* 支付函数
* @param {[type]} _payInfo [description]
* @return {[type]} [description]
*/
pay:function(_payInfo,success,fail){
var payInfo = {
body:'',
total_fee:0,
order_sn:''
}
Object.assign(payInfo, _payInfo);
if(payInfo.body.length==0){
wx.showToast({
title:'支付信息描述错误'
})
return false;
}
if(payInfo.total_fee==0){
wx.showToast({
title:'支付金额不能0'
})
return false;
}
if(payInfo.order_sn.length==0){
wx.showToast({
title:'订单号不能为空'
})
return false;
}
var This = this;
This.getOpenid(function(openid){
payInfo.openid=openid;
This.request({
url:'api/pay/prepay',
data:payInfo,
success:function(res){
var data = res.data;
console.log(data);
if(!data.status){
wx.showToast({
title:data['errmsg']
})
return false;
}
This.request({
url:'api/pay/pay',
data:{prepay_id:data.data.data.prepay_id},
success:function(_payResult){
var payResult = _payResult.data;
console.log(payResult);
wx.requestPayment({
'timeStamp': payResult.timeStamp.toString(),
'nonceStr': payResult.nonceStr,
'package': payResult.package,
'signType': payResult.signType,
'paySign': payResult.paySign,
'success': function (succ) {
success&&success(succ);
},
'fail': function (err) {
fail&&fail(err);
},
'complete': function (comp) {
}
})
}
})
}
})
})
}
有前端不管后端不是很合适 所以简单的贴一点 各位自行脑补哈：
package com.taozugong.service.wechat.weixinpay;
import com.taozugong.service.wechat.weixinpay.WXPayConstants.SignType;
import java.util.HashMap;
import java.util.Map;
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 {
this.signType = SignType.HMACSHA256;
}
this.wxPayRequest = new WXPayRequest(config);
}
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.getPrimaryDomain() == null || this.config.getPrimaryDomain().trim().length() == 0) {
// throw new Exception("primary domain in config is empty");
// }
//
// // todo 海外就填两个相同的？ 下面的逻辑待考虑
// if (this.config.getAlternateDomain() == null || this.config.getAlternateDomain().trim().length() == 0) {
// throw new Exception("alternate domain 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 fillRequestData(Map reqData) throws Exception {
//小程序jsapi支付二次传入appid,i需要大写 appId
reqData.put("appid", config.getAppID());
reqData.put("mch_id", config.getMchID());
reqData.put("nonce_str", WXPayUtil.generateUUID());
reqData.put("sign_type", WXPayConstants.MD5);
reqData.put("sign", WXPayUtil.generateSignature(reqData, config.getKey(), SignType.MD5));
System.out.println(WXPayUtil.generateSignature(reqData, config.getKey(), SignType.MD5) + ":" + "签名");
return reqData;
}
/**
* 判断xml数据的sign是否有效，必须包含sign字段，否则返回false。
*
* @param reqData 向wxpay post的请求数据
* @return 签名是否有效
* @throws Exception
*/
public boolean isResponseSignatureValid(Map reqData) throws Exception {
// 返回数据的签名方式和请求中给定的签名方式是一致的
return WXPayUtil.isSignatureValid(reqData, this.config.getKey(), this.signType);
}
/**
* 判断支付结果通知中的sign是否有效
*
* @param reqData 向wxpay post的请求数据
* @return 签名是否有效
* @throws Exception
*/
public boolean isPayResultNotifySignatureValid(Map 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 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 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 processResponseXml(String xmlStr) throws Exception {
String RETURN_CODE = "return_code";
String return_code;
Map 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));
}
}
public Map processResponseXml2(String xmlStr) throws Exception {
String RETURN_CODE = "return_code";
String return_code;
Map 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 (true) {
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 microPay(Map 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 microPay(Map 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 microPayWithPos(Map reqData) throws Exception {
return this.microPayWithPos(reqData, this.config.getHttpConnectTimeoutMs());
}
/**
* 提交刷卡支付，针对软POS，尽可能做成功
* 内置重试机制，最多60s
*
* @param reqData
* @param connectTimeoutMs
* @return
* @throws Exception
*/
public Map microPayWithPos(Map reqData, int connectTimeoutMs) throws Exception {
int remainingTimeMs = 60 * 1000;
long startTimestampMs = 0;
Map 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 unifiedOrder(Map 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 unifiedOrder(Map 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);
Map result = this.processResponseXml(respXml);
result.put("respXml", respXml);
return result;
}
/**
* 作用：查询订单
* 场景：刷卡支付、公共号支付、扫码支付、APP支付
*
* @param reqData 向wxpay post的请求数据
* @return API返回数据
* @throws Exception
*/
public Map orderQuery(Map 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 orderQuery(Map 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 reverse(Map 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 reverse(Map 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 closeOrder(Map 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 closeOrder(Map 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 refund(Map 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 refund(Map 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);
Map map = this.processResponseXml2(respXml);
map.put("respXml", respXml);
return map;
}
/**
* 作用：退款查询
* 场景：刷卡支付、公共号支付、扫码支付、APP支付
*
* @param reqData 向wxpay post的请求数据
* @return API返回数据
* @throws Exception
*/
public Map refundQuery(Map 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 refundQuery(Map 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 downloadBill(Map 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 downloadBill(Map 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 ret;
// 出现错误，返回XML数据
if (respStr.indexOf("<") == 0) {
ret = WXPayUtil.xmlToMap(respStr);
} else {
// 正常返回csv数据
ret = new HashMap();
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 report(Map 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 report(Map 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 shortUrl(Map reqData) throws Exception {
return this.shortUrl(reqData, this.config.getHttpConnectTimeoutMs(), this.config.getHttpReadTimeoutMs());
}
/**
* 作用：转换短链接
* 场景：刷卡支付、扫码支付
*
* @param reqData 向wxpay post的请求数据
* @return API返回数据
* @throws Exception
*/
public Map shortUrl(Map 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 authCodeToOpenid(Map 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 authCodeToOpenid(Map 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
package com.taozugong.service.wechat.weixinpay;
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;
}
/**
* x
* 健康上报缓存消息的最大数量。会有线程去独立上报
* 粗略计算：加入一条消息200B，10000消息占用空间 2000 KB，约为2MB，可以接受
*
* @return
*/
public int getReportQueueMaxSize() {
return 10000;
}
/**
* 批量上报，一次最多上报多个数据
*
* @return
*/
public int getReportBatchSize() {
return 10;
}
}
package com.taozugong.service.wechat.weixinpay;
import java.io.ByteArrayInputStream;
import java.io.InputStream;
public class WXPayConfigImpl extends WXPayConfig {
private byte[] certData;
private static WXPayConfigImpl INSTANCE;
// private WXPayConfigImpl() throws Exception{
// String certPath = "/tmp/apiclient_cert.p12";
// File file = new File(certPath);
// InputStream certStream = new FileInputStream(file);
// this.certData = new byte[(int) file.length()];
// certStream.read(this.certData);
// certStream.close();
// }
public static WXPayConfigImpl getInstance() throws Exception {
if (INSTANCE == null) {
synchronized (WXPayConfigImpl.class) {
if (INSTANCE == null) {
INSTANCE = new WXPayConfigImpl();
}
}
}
return INSTANCE;
}
// public String getAppID() {
// return "wxd9266709896ddbf1";
// }
//
// public String getMchID() {
// return "1507891911";
// }
//
//
// public String getKey() {
// return "magicshop20180619bujiangkejishop";
// //return "b0e73c8fd78d2b7eec7e8a9ff07001d6";
// }
public String getAppID() {
return "nideid";
}
public String getMchID() {
return "nideid";
}
public String getKey() {
return "nideshanghuhao";
}
public InputStream getCertStream() {
ByteArrayInputStream certBis;
certBis = new ByteArrayInputStream(this.certData);
return certBis;
}
public int getHttpConnectTimeoutMs() {
return 2000;
}
public int getHttpReadTimeoutMs() {
return 10000;
}
IWXPayDomain getWXPayDomain() {
return WXPayDomainSimpleImpl.instance();
}
public String getPrimaryDomain() {
return "api.mch.weixin.qq.com";
}
public String getAlternateDomain() {
return "api2.mch.weixin.qq.com";
}
@Override
public int getReportWorkerNum() {
return 1;
}
@Override
public int getReportBatchSize() {
return 2;
}
}
package com.taozugong.service.wechat.weixinpay;
/**
* 常量
*/
public class WXPayConstants {
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 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";
}
太多我就不一一贴了 直接给链接大家去下载吧 下载地址下载地址