上篇我们记录了手机端的微信支付的大致流程，期间可能会遇到各种各样的错误，但这些问题没有得到官方的重视，所以我们只能一步步自己排查，要有足够的耐心。
这篇内容看标题已经很明确了，由于微信是用xml通讯的，所以这一点比较恶心，各位可能需要在项目里导入一些解析xml的包。
首先放出工具类（包含支付宝用到的工具类），因为现在csdn下载都是扣积分的，因为工具类代码会在文尾贴出。
工具类下载：点击这里
首先我在重新贴一下支付流程图吧，我再重复一遍，一定要认真看流程图，这样对你业务逻辑的处理有很大的提升。
知道了支付的大致流程，接下来就要分析如何支付了。在我的项目里，支付的流程是这样的：
首先，选择商品和数量等，点击下单，此时会在后台生成一张下单表，此表中的任何一条数据，有效期都在半小时内。半小时后该条下单数据就失效了。因此应该在半小时内完成支付。
下单后支付时，后台返回手机端预付单，此时调起微信完成支付。支付后的结果和支付宝一样，依然需要调用后台的数据以确保交易的正确性。虽然很繁琐，但是涉及到金钱的业务，一定要谨慎，作为程序员，我们也要对自己写的代码负责。
- 1
- 2
接下来，就从预付单开始说起吧，假设现在已经下了单，那么此时支付的话，需要后台返回给手机端预付单，那么代码就来了：（用到的工具类在文章开头或文末）
拉取微信预付单
/**
* 拉取微信预付单
*/
@ValidatePermission(value = PermissionValidateType.Validate)
@Override
public BaseResult<Orders> getWXPay(BaseRequest<Orders> baseRequest)
{
BaseResult<Orders> baseResult = new BaseResult<>();
LogUtil.debugLog(logger, baseRequest);
Orders orders = baseRequest.getData();
Double price = orders.getOrderAmount();
if (price <= 0) // 防止抓包修改订单金额造成损失
{
baseResult.setState(-999);
baseResult.setMsg("付款金额错误!");
baseResult.setSuccess(false);
return baseResult;
}
try
{
SortedMap<Object, Object> parameters = PayCommonUtil.getWXPrePayID(); // 获取预付单，此处已做封装，需要工具类
TravelFly travelFly = new TravelFly(); // 商品对象
travelFly.setId(orders.getProductId());
travelFly = travelFlyMapper.selectById(travelFly);
travelFly.setBusinesser(businesserMapper.selectByPrimaryKey(travelFly.getBusinesserId()));
orders.setTravelFly(travelFly);
parameters.put("body", "xxx产品-" + travelFly.getProductName());
parameters.put("spbill_create_ip", this.request.getRemoteAddr());
parameters.put("out_trade_no", orders.getId() + PayCommonUtil.getDateStr()); // 订单id这里我的订单id生成规则是订单id+时间
parameters.put("total_fee", "1"); // 测试时，每次支付一分钱，微信支付所传的金额是以分为单位的，因此实际开发中需要x100
// parameters.put("total_fee", orders.getOrderAmount()*100+""); // 上线后，将此代码放开
// 设置签名
String sign = PayCommonUtil.createSign("UTF-8", parameters);
parameters.put("sign", sign);
// 封装请求参数结束
String requestXML = PayCommonUtil.getRequestXml(parameters); // 获取xml结果
logger.debug("封装请求参数是：" + requestXML);
// 调用统一下单接口
String result = PayCommonUtil.httpsRequest(PropertyUtil.getInstance().getProperty("WxPay.payURL"), "POST",
requestXML);
logger.debug("调用统一下单接口：" + result);
SortedMap<Object, Object> parMap = PayCommonUtil.startWXPay(result);
logger.debug("最终的map是：" + parMap.toString());
if (parMap != null)
{
orders.setWxPayOrderString(JSON.toJSONString(parMap));
baseResult.setData(orders);
} else
{
baseResult.setState(-999);
baseResult.setMsg("支付出现异常，请稍后重试!");
baseResult.setSuccess(false);
}
} catch (Exception e)
{
e.printStackTrace();
baseResult.setState(-999);
baseResult.setMsg("程序异常!");
baseResult.setSuccess(false);
logger.error(e.getMessage());
}
return baseResult;
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
由于测试的时候一定会在外网测试，因为实际支付结果会通知给后台，所以这里为了调试方便，就将日志保存成了文本。
获取结果
/**
* 微信异步通知
*/
@SuppressWarnings("unchecked")
@ValidatePermission
@RequestMapping("/wx")
@ResponseBody
public void wxNotify(HttpServletRequest request, HttpServletResponse response) throws IOException, JDOMException
{
String result = PayCommonUtil.reciverWx(request); // 接收到异步的参数
Map<String, String> m = new HashMap<String, String>();// 解析xml成map
if (m != null && !"".equals(m))
{
m = XMLUtil.doXMLParse(result);
}
// 过滤空 设置 TreeMap
SortedMap<Object, Object> packageParams = new TreeMap<Object, Object>();
Iterator it = m.keySet().iterator();
while (it.hasNext())
{
String parameter = (String) it.next();
String parameterValue = m.get(parameter);
String v = "";
if (null != parameterValue)
{
v = parameterValue.trim();
}
packageParams.put(parameter, v);
}
// 判断签名是否正确
String resXml = "";
if (PayCommonUtil.isTenpaySign("UTF-8", packageParams))
{
if ("SUCCESS".equals((String) packageParams.get("return_code")))
{
// 如果返回成功
String mch_id = (String) packageParams.get("mch_id"); // 商户号
String out_trade_no = (String) packageParams.get("out_trade_no"); // 商户订单号
String total_fee = (String) packageParams.get("total_fee");
// String transaction_id = (String)
// packageParams.get("transaction_id"); // 微信支付订单号
// 查询订单 根据订单号查询订单
String orderId = out_trade_no.substring(0, out_trade_no.length() - PayCommonUtil.TIME.length());
Orders orders = ordersMapper.selectByPrimaryKey(Integer.parseInt(orderId));
// 验证商户ID 和 价格 以防止篡改金额
if (PropertyUtil.getInstance().getProperty("WxPay.mchid").equals(mch_id) && orders != null
// &&
// total_fee.trim().toString().equals(orders.getOrderAmount())
// // 实际项目中将此注释删掉，以保证支付金额相等
)
{
/** 这里是我项目里的消费状态
* 1.待付款=0 2.付款完成=1
* 3.消费成功=2
* 4.取消=-1
* 5.发起退款=-2
* 6.退款成功=-3
* 7.退款失败=3（由于商户拒绝退款或其他原因导致退款失败）
*/
insertWxNotice(packageParams);
orders.setPayWay("1"); // 变更支付方式为wx
orders.setOrderState("1"); // 订单状态为已付款
ordersMapper.updateByPrimaryKeySelective(orders); // 变更数据库中该订单状态
// ordersMapper.updatePayStatus(Integer.parseInt(orderId));
resXml = "<xml>" + "<return_code><![CDATA[SUCCESS]]></return_code>"
+ "<return_msg><![CDATA[OK]]></return_msg>" + "</xml> ";
} else
{
resXml = "<xml>" + "<return_code><![CDATA[FAIL]]></return_code>"
+ "<return_msg><![CDATA[参数错误]]></return_msg>" + "</xml> ";
}
} else // 如果微信返回支付失败，将错误信息返回给微信
{
resXml = "<xml>" + "<return_code><![CDATA[FAIL]]></return_code>"
+ "<return_msg><![CDATA[交易失败]]></return_msg>" + "</xml> ";
}
} else
{
resXml = "<xml>" + "<return_code><![CDATA[FAIL]]></return_code>"
+ "<return_msg><![CDATA[通知签名验证失败]]></return_msg>" + "</xml> ";
}
// 处理业务完毕，将业务结果通知给微信
// ------------------------------
BufferedOutputStream out = new BufferedOutputStream(response.getOutputStream());
out.write(resXml.getBytes());
out.flush();
out.close();
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 90
- 91
附：工具类代码：
package com.loveFly.utils;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.io.UnsupportedEncodingException;
import java.net.ConnectException;
import java.net.URL;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Iterator;
import java.util.Map;
import java.util.Random;
import java.util.Set;
import java.util.SortedMap;
import java.util.TreeMap;
import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSocketFactory;
import javax.net.ssl.TrustManager;
import javax.servlet.http.HttpServletRequest;
import com.alibaba.fastjson.JSONObject;
import com.alipay.api.AlipayClient;
import com.alipay.api.DefaultAlipayClient;
public class PayCommonUtil
{
public static final String TIME = "yyyyMMddHHmmss";
/**
* 创建支付宝交易对象
*/
public static AlipayClient getAliClient()
{
AlipayClient alipayClient = new DefaultAlipayClient(PropertyUtil.getInstance().getProperty("AliPay.payURL"),
PropertyUtil.getInstance().getProperty("AliPay.appId"),
PropertyUtil.getInstance().getProperty("AliPay.privateKey"), "json", "utf-8",
PropertyUtil.getInstance().getProperty("AliPay.publicKey"), "RSA2");
return alipayClient;
}
/**
* 创建微信交易对象
*/
public static SortedMap<Object, Object> getWXPrePayID()
{
SortedMap<Object, Object> parameters = new TreeMap<Object, Object>();
parameters.put("appid", PropertyUtil.getInstance().getProperty("WxPay.appid"));
parameters.put("mch_id", PropertyUtil.getInstance().getProperty("WxPay.mchid"));
parameters.put("nonce_str", PayCommonUtil.CreateNoncestr());
parameters.put("fee_type", "CNY");
parameters.put("notify_url", PropertyUtil.getInstance().getProperty("WxPay.notifyurl"));
parameters.put("trade_type", "APP");
return parameters;
}
/**
* 再次签名，支付
*/
public static SortedMap<Object, Object> startWXPay(String result)
{
try
{
Map<String, String> map = XMLUtil.doXMLParse(result);
SortedMap<Object, Object> parameterMap = new TreeMap<Object, Object>();
parameterMap.put("appid", PropertyUtil.getInstance().getProperty("WxPay.appid"));
parameterMap.put("partnerid", PropertyUtil.getInstance().getProperty("WxPay.mchid"));
parameterMap.put("prepayid", map.get("prepay_id"));
parameterMap.put("package", "Sign=WXPay");
parameterMap.put("noncestr", PayCommonUtil.CreateNoncestr());
// 本来生成的时间戳是13位，但是ios必须是10位，所以截取了一下
parameterMap.put("timestamp",
Long.parseLong(String.valueOf(System.currentTimeMillis()).toString().substring(0, 10)));
String sign = PayCommonUtil.createSign("UTF-8", parameterMap);
parameterMap.put("sign", sign);
return parameterMap;
} catch (Exception e)
{
e.printStackTrace();
}
return null;
}
/**
* 创建随机数
*
* @param length
* @return
*/
public static String CreateNoncestr()
{
String chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
String res = "";
for (int i = 0; i < 16; i++)
{
Random rd = new Random();
res += chars.charAt(rd.nextInt(chars.length() - 1));
}
return res;
}
/**
* 是否签名正确,规则是:按参数名称a-z排序,遇到空值的参数不参加签名。
*
* @return boolean
*/
public static boolean isTenpaySign(String characterEncoding, SortedMap<Object, Object> packageParams)
{
StringBuffer sb = new StringBuffer();
Set es = packageParams.entrySet();
Iterator it = es.iterator();
while (it.hasNext())
{
Map.Entry entry = (Map.Entry) it.next();
String k = (String) entry.getKey();
String v = (String) entry.getValue();
if (!"sign".equals(k) && null != v && !"".equals(v))
{
sb.append(k + "=" + v + "&");
}
}
sb.append("key=" + PropertyUtil.getInstance().getProperty("WxPay.key"));
// 算出摘要
String mysign = MD5Util.MD5Encode(sb.toString(), characterEncoding).toLowerCase();
String tenpaySign = ((String) packageParams.get("sign")).toLowerCase();
// System.out.println(tenpaySign + " " + mysign);
return tenpaySign.equals(mysign);
}
/**
* @Description：创建sign签名
* @param characterEncoding
* 编码格式
* @param parameters
* 请求参数
* @return
*/
public static String createSign(String characterEncoding, SortedMap<Object, Object> parameters)
{
StringBuffer sb = new StringBuffer();
Set es = parameters.entrySet();
Iterator it = es.iterator();
while (it.hasNext())
{
Map.Entry entry = (Map.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=" + PropertyUtil.getInstance().getProperty("WxPay.key"));
String sign = MD5Util.MD5Encode(sb.toString(), characterEncoding).toUpperCase();
return sign;
}
/**
* @Description：将请求参数转换为xml格式的string
* @param parameters
* 请求参数
* @return
*/
public static String getRequestXml(SortedMap<Object, Object> parameters)
{
StringBuffer sb = new StringBuffer();
sb.append("<xml>");
Set es = parameters.entrySet();
Iterator it = es.iterator();
while (it.hasNext())
{
Map.Entry entry = (Map.Entry) it.next();
String k = (String) entry.getKey();
String v = (String) entry.getValue();
if ("attach".equalsIgnoreCase(k) || "body".equalsIgnoreCase(k))
{
sb.append("<" + k + ">" + "<![CDATA[" + v + "]]></" + k + ">");
} else
{
sb.append("<" + k + ">" + v + "</" + k + ">");
}
}
sb.append("</xml>");
return sb.toString();
}
/**
* @Description：返回给微信的参数
* @param return_code
* 返回编码
* @param return_msg
* 返回信息
* @return
*/
public static String setXML(String return_code, String return_msg)
{
return "<xml><return_code><![CDATA[" + return_code + "]]></return_code><return_msg><![CDATA[" + return_msg
+ "]]></return_msg></xml>";
}
/**
* 发送https请求
*
* @param requestUrl
* 请求地址
* @param requestMethod
* 请求方式（GET、POST）
* @param outputStr
* 提交的数据
* @return 返回微信服务器响应的信息
*/
public static String httpsRequest(String requestUrl, String requestMethod, String outputStr)
{
try
{
// 创建SSLContext对象，并使用我们指定的信任管理器初始化
TrustManager[] tm =
{ new TrustManagerUtil() };
SSLContext sslContext = SSLContext.getInstance("SSL", "SunJSSE");
sslContext.init(null, tm, new java.security.SecureRandom());
// 从上述SSLContext对象中得到SSLSocketFactory对象
SSLSocketFactory ssf = sslContext.getSocketFactory();
URL url = new URL(requestUrl);
HttpsURLConnection conn = (HttpsURLConnection) url.openConnection();
// conn.setSSLSocketFactory(ssf);
conn.setDoOutput(true);
conn.setDoInput(true);
conn.setUseCaches(false);
// 设置请求方式（GET/POST）
conn.setRequestMethod(requestMethod);
conn.setRequestProperty("content-type", "application/x-www-form-urlencoded");
// 当outputStr不为null时向输出流写数据
if (null != outputStr)
{
OutputStream outputStream = conn.getOutputStream();
// 注意编码格式
outputStream.write(outputStr.getBytes("UTF-8"));
outputStream.close();
}
// 从输入流读取返回内容
InputStream inputStream = conn.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;
conn.disconnect();
return buffer.toString();
} catch (ConnectException ce)
{
// log.error("连接超时：{}", ce);
} catch (Exception e)
{
// log.error("https请求异常：{}", e);
}
return null;
}
/**
* 发送https请求
*
* @param requestUrl
* 请求地址
* @param requestMethod
* 请求方式（GET、POST）
* @param outputStr
* 提交的数据
* @return JSONObject(通过JSONObject.get(key)的方式获取json对象的属性值)
*/
public static JSONObject httpsRequest(String requestUrl, String requestMethod)
{
JSONObject jsonObject = null;
try
{
// 创建SSLContext对象，并使用我们指定的信任管理器初始化
TrustManager[] tm =
{ new TrustManagerUtil() };
SSLContext sslContext = SSLContext.getInstance("SSL", "SunJSSE");
sslContext.init(null, tm, new java.security.SecureRandom());
// 从上述SSLContext对象中得到SSLSocketFactory对象
SSLSocketFactory ssf = sslContext.getSocketFactory();
URL url = new URL(requestUrl);
HttpsURLConnection conn = (HttpsURLConnection) url.openConnection();
// conn.setSSLSocketFactory(ssf);
conn.setDoOutput(true);
conn.setDoInput(true);
conn.setUseCaches(false);
conn.setConnectTimeout(3000);
// 设置请求方式（GET/POST）
conn.setRequestMethod(requestMethod);
// conn.setRequestProperty("content-type",
// "application/x-www-form-urlencoded");
// 当outputStr不为null时向输出流写数据
// 从输入流读取返回内容
InputStream inputStream = conn.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;
conn.disconnect();
jsonObject = JSONObject.parseObject(buffer.toString());
} catch (ConnectException ce)
{
// log.error("连接超时：{}", ce);
} catch (Exception e)
{
System.out.println(e);
// log.error("https请求异常：{}", e);
}
return jsonObject;
}
public static String urlEncodeUTF8(String source)
{
String result = source;
try
{
result = java.net.URLEncoder.encode(source, "utf-8");
} catch (UnsupportedEncodingException e)
{
e.printStackTrace();
}
return result;
}
/**
* 接收微信的异步通知
*
* @throws IOException
*/
public static String reciverWx(HttpServletRequest request) throws IOException
{
InputStream inputStream;
StringBuffer sb = new StringBuffer();
inputStream = request.getInputStream();
String s;
BufferedReader in = new BufferedReader(new InputStreamReader(inputStream, "UTF-8"));
while ((s = in.readLine()) != null)
{
sb.append(s);
}
in.close();
inputStream.close();
return sb.toString();
}
/**
* 产生num位的随机数
*
* @return
*/
public static String getRandByNum(int num)
{
String length = "1";
for (int i = 0; i < num; i++)
{
length += "0";
}
Random rad = new Random();
String result = rad.nextInt(Integer.parseInt(length)) + "";
if (result.length() != num)
{
return getRandByNum(num);
}
return result;
}
/**
* 返回当前时间字符串
*
* @return yyyyMMddHHmmss
*/
public static String getDateStr()
{
SimpleDateFormat sdf = new SimpleDateFormat(TIME);
return sdf.format(new Date());
}
/**
* 将日志保存至指定路径
*
* @param path
* @param str
*/
public static void saveLog(String path, String str)
{
File file = new File(path);
FileOutputStream fos = null;
try
{
fos = new FileOutputStream(path);
fos.write(str.getBytes());
fos.close();
} catch (FileNotFoundException e)
{
e.printStackTrace();
} catch (IOException e)
{
e.printStackTrace();
}
}
public static void saveE(String path, Exception exception)
{
try {
int i = 1 / 0;
} catch (final Exception e) {
try {
new PrintWriter(new BufferedWriter(new FileWriter(
path, true)), true).println(new Object() {
public String toString() {
StringWriter stringWriter = new StringWriter();
PrintWriter writer = new PrintWriter(stringWriter);
e.printStackTrace(writer);
StringBuffer buffer = stringWriter.getBuffer();
return buffer.toString();
}
});
} catch (IOException e1) {
e1.printStackTrace();
}
}
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 90
- 91
- 92
- 93
- 94
- 95
- 96
- 97
- 98
- 99
- 100
- 101
- 102
- 103
- 104
- 105
- 106
- 107
- 108
- 109
- 110
- 111
- 112
- 113
- 114
- 115
- 116
- 117
- 118
- 119
- 120
- 121
- 122
- 123
- 124
- 125
- 126
- 127
- 128
- 129
- 130
- 131
- 132
- 133
- 134
- 135
- 136
- 137
- 138
- 139
- 140
- 141
- 142
- 143
- 144
- 145
- 146
- 147
- 148
- 149
- 150
- 151
- 152
- 153
- 154
- 155
- 156
- 157
- 158
- 159
- 160
- 161
- 162
- 163
- 164
- 165
- 166
- 167
- 168
- 169
- 170
- 171
- 172
- 173
- 174
- 175
- 176
- 177
- 178
- 179
- 180
- 181
- 182
- 183
- 184
- 185
- 186
- 187
- 188
- 189
- 190
- 191
- 192
- 193
- 194
- 195
- 196
- 197
- 198
- 199
- 200
- 201
- 202
- 203
- 204
- 205
- 206
- 207
- 208
- 209
- 210
- 211
- 212
- 213
- 214
- 215
- 216
- 217
- 218
- 219
- 220
- 221
- 222
- 223
- 224
- 225
- 226
- 227
- 228
- 229
- 230
- 231
- 232
- 233
- 234
- 235
- 236
- 237
- 238
- 239
- 240
- 241
- 242
- 243
- 244
- 245
- 246
- 247
- 248
- 249
- 250
- 251
- 252
- 253
- 254
- 255
- 256
- 257
- 258
- 259
- 260
- 261
- 262
- 263
- 264
- 265
- 266
- 267
- 268
- 269
- 270
- 271
- 272
- 273
- 274
- 275
- 276
- 277
- 278
- 279
- 280
- 281
- 282
- 283
- 284
- 285
- 286
- 287
- 288
- 289
- 290
- 291
- 292
- 293
- 294
- 295
- 296
- 297
- 298
- 299
- 300
- 301
- 302
- 303
- 304
- 305
- 306
- 307
- 308
- 309
- 310
- 311
- 312
- 313
- 314
- 315
- 316
- 317
- 318
- 319
- 320
- 321
- 322
- 323
- 324
- 325
- 326
- 327
- 328
- 329
- 330
- 331
- 332
- 333
- 334
- 335
- 336
- 337
- 338
- 339
- 340
- 341
- 342
- 343
- 344
- 345
- 346
- 347
- 348
- 349
- 350
- 351
- 352
- 353
- 354
- 355
- 356
- 357
- 358
- 359
- 360
- 361
- 362
- 363
- 364
- 365
- 366
- 367
- 368
- 369
- 370
- 371
- 372
- 373
- 374
- 375
- 376
- 377
- 378
- 379
- 380
- 381
- 382
- 383
- 384
- 385
- 386
- 387
- 388
- 389
- 390
- 391
- 392
- 393
- 394
- 395
- 396
- 397
- 398
- 399
- 400
- 401
- 402
- 403
- 404
- 405
- 406
- 407
- 408
- 409
- 410
- 411
- 412
- 413
- 414
- 415
- 416
- 417
- 418
- 419
- 420
- 421
- 422
- 423
- 424
- 425
- 426
- 427
- 428
- 429
- 430
- 431
- 432
- 433
- 434
- 435
- 436
- 437
- 438
- 439
- 440
- 441
- 442
- 443
- 444
- 445
- 446
- 447
- 448
- 449
- 450
- 451
- 452
- 453
- 454
至此，一套完整的支付流程就跑完了，。可以直接拷贝到项目里用，前提是公钥私钥AppId等都没有问题哦。
ok本系列第三方支付就到此为止，如果真的帮到你，那真的是太好了。
4649
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
