微信支付BUG注销再重新绑定继续撸微信支付游戏特权活动（vx支付注销）

25-02-18 24

以上就是给各位分享微信支付BUG注销再重新绑定继续撸微信支付游戏特权活动，其中也会对vx支付注销进行解释，同时本文还将给你拓展app微信支付（一）-微信支付基本业务流程解析、【java微信支付】微信支

以上就是给各位分享微信支付BUG注销再重新绑定继续撸微信支付游戏特权活动，其中也会对vx支付注销进行解释，同时本文还将给你拓展app微信支付（一） - 微信支付基本业务流程解析、【java微信支付】微信支付之扫码支付相关代码、【weixin】微信支付---PC网站微信支付、一篇文章讲明白微信支付，适合第一次接通微信支付的同学等相关知识，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

本文目录一览：

微信支付BUG注销再重新绑定继续撸微信支付游戏特权活动（vx支付注销）
app微信支付（一） - 微信支付基本业务流程解析
【java微信支付】微信支付之扫码支付相关代码
【weixin】微信支付---PC网站微信支付
一篇文章讲明白微信支付，适合第一次接通微信支付的同学

微信支付BUG注销再重新绑定继续撸微信支付游戏特权活动（vx支付注销）

微信支付BUG 注销后重新绑定可再次参加0.1元得20Q币一样，继续撸这次的微信支付游戏特权活动了。下面小编就为大家详细介绍一下啊

昨天上午发了微信支付游戏特权首次微信支付必拿Q币 Q钻等，下午官方又推送了福利第三波，支付0.01元赢蓝钻一个月。这都不是重点，重点是我们可以像上次微信支付BUG 注销后重新绑定可再次参加0.1元得20Q币一样，继续撸这次的微信支付游戏特权活动了。

软件名称：: 微信 V6.5.6 for Android 官方中文免费正式版
软件大小：: 40.3MB
更新时间：: 2017-03-17

软件名称：: 微信手机通信软件 V6.6.1 for iPhone 苹果版
软件大小：: 165MB
更新时间：: 2018-01-10立即下载

操作流程：

1、先把微信支付注销，不会的朋友可以参考https://www.html.cn/softjc/261481.html

2、昨天下午推送的蓝钻活动，和投递者“微信支付游戏特权”2个活动奖励。如下图：

3、支付交易记录截图（第一个活动是注销后参加的，第二个活动需要换个微信号了）。如下图：

经咨询投递者“腾爱 - 小闯”得出以下注意事项：

1、同时的两个活动（就像这次的上午/下午两个活动），注销只能参加一个，另一个要换微信号。

2、投递者试过好几回，同一微信号换别的银行卡还是捐（虽然说明有写，确实没有几个人去试过，不是么？）

3、投递者说明：上次注销的时间距离现在最多10几天时间，所以基本断定超过10天没注销操作过的速度撸吧！

提示：没想到现在这个方法还可以用，因为小编参加这两天活动得的微信红包（零钱）提现还没有完成，不然也继续撸给大家看了！

app微信支付（一） - 微信支付基本业务流程解析

想必微信支付是现在很多朋友离不开的一个功能，不论是扫描支付还是公众号支付或者app端支付，基本的思路都是一样的，之前做过支付宝支付以及中国移动支付接口，这几天花时间讲讲微信支付吧

先看一下微信支付的时序图，这图是官方提供的

看上去步骤很多，其实仔细划分后就是4个步骤：

<1> 生成预付单，用户点击支付后，需要经过自己的后台去调用微信后台生成一个预付单号，这个预付单号是用来跟随整个支付流程的，然后再展示确认支付页面

<2> 用户在确认支付页面看到相关的支付，点击确认支付按钮，然后手机端会调用微信sdk进行支付操作，这个步骤直接调用微信后台，不经过自己的后台

<3> 用户在微信中输入密码，然后是否成功会直接在微信上显示，而这个是否成功的结果状态，会通过一个异步的通知发送到自己的后台，自己的后台需要记录相关数据，保存在数据库中，这个就是所谓的并行操作

<4> 用户在手机端上的操作需要查询后台数据，就是说要成功支付后需要进行的操作，这个需要经过后台验证一下，虽然微信会回调我们的app通知支付成功，但是在进行下一步操作的时候，必须经过我们的后台去查询这个订单是否支付成功，一般情况下都是会成功的，不成功就不会继续，那么成功则进行下面的操作，发货的发货，充值的充值~

微信支付会分几次来讲，接下来会把大致的demo放出

【java微信支付】微信支付之扫码支付相关代码

最近开发网站过程，需要引入支付过程，第三方支付中最火的莫过于支付宝支付和微信支付，下边借助微信支付官网上的文档，写一下接入微信支付之扫码支付的流程

相对支付宝支付而言，微信支付的开发文档写的相当的low，demo写的一点都不简洁，下边写一下微信扫码支付的过程，这一过程中，需要注意的所涉及的实际业务是怎样的，根据实际情况结合业务进行引入，在进入正式开发之前，要申请微信支付的相关内容按照官网的操作进行即可，审核成功后，会得到appId，商户号，商户平台登录账号和密码

登录微信支付官网

https://pay.weixin.qq.com，照相开发文档入口，查看扫码支付，大致了解一下扫码支付的相关信息后，进入开发流程，这是官网上的模式二的业务流程，

（1）商户后台系统根据用户选购的商品生成订单。

（2）用户确认支付后调用微信支付【统一下单API】生成预支付交易；

（3）微信支付系统收到请求后生成预支付交易单，并返回交易会话的二维码链接code_url。

（4）商户后台系统根据返回的code_url生成二维码。

（5）用户打开微信“扫一扫”扫描二维码，微信客户端将扫码内容发送到微信支付系统。

（6）微信支付系统收到客户端请求，验证链接有效性后发起用户支付，要求用户授权。

（7）用户在微信客户端输入密码，确认支付后，微信客户端提交授权。

（8）微信支付系统根据用户授权完成支付交易。

（9）微信支付系统完成支付交易后给微信客户端返回交易结果，并将交易结果通过短信、微信消息提示用户。微信客户端展示支付交易结果页面。

（10）微信支付系统通过发送异步消息通知商户后台系统支付结果。商户后台系统需回复接收情况，通知微信后台系统不再发送该单的支付通知。

（11）未收到支付通知的情况，商户后台系统调用【查询订单API】。

（12）商户确认订单已支付后给用户发货。

开发的流程，首先根据自己的业务流程，生成订单保存到数据库当中，这一过程包含了商品的信息，需要支付的钱数，商品名称等，下边开始进入统一下单的方法，

这部分是微信统一下单入口（controller方法）

/**
* 微信扫码支付统一下单
*/
@RequestMapping(value = "/WxPayUnifiedorder", method = RequestMethod.GET)
@ResponseBody
public Object WxPayUnifiedorder(String out_trade_no) throws Exception{
HashMap<String,Object> map = new HashMap<String,Object>();
String codeUrl = wxPayService.weixin_pay(out_trade_no);
map.put("codeUrl",codeUrl);
return map;
}

下边是微信支付统一下单具体实现方法

[java]

/**
* 微信支付统一下单接口
* @param out_trade_no
* @return
* @throws Exception
*/
public String weixin_pay(String out_trade_no) throws Exception {
// 账号信息
String appid = PayConfigUtil.getAppid(); // appid
//String appsecret = PayConfigUtil.APP_SECRET; // appsecret
// 商业号
String mch_id = PayConfigUtil.getMchid();
// key
String key = PayConfigUtil.getKey();
String currTime = PayCommonUtil.getCurrTime();
String strTime = currTime.substring(8, currTime.length());
String strRandom = PayCommonUtil.buildRandom(4) + "";
//随机字符串
String nonce_str = strTime + strRandom;
// 价格注意：价格的单位是分
//String order_price = "1";
// 商品名称
//String body = "企嘉科技商品";
//查询订单数据表获取订单信息
PayOrder payOrder = payOrderDao.get(PayOrder.class,out_trade_no);
// 获取发起电脑 ip
String spbill_create_ip = PayConfigUtil.getIP();
// 回调接口
String notify_url = PayConfigUtil.NOTIFY_URL;
String trade_type = "NATIVE";
String time_start = new SimpleDateFormat("yyyyMMddHHmmss").format(new Date());
Calendar ca = Calendar.getInstance();
ca.setTime(new Date());
ca.add(Calendar.DATE, 1);
String time_expire = new SimpleDateFormat("yyyyMMddHHmmss").format(ca.getTime());
SortedMap<Object,Object> packageParams = new TreeMap<Object,Object>();
packageParams.put("appid", appid);
packageParams.put("mch_id", mch_id);
packageParams.put("nonce_str", nonce_str);
packageParams.put("body",payOrder.getBody());
packageParams.put("out_trade_no", out_trade_no);
//packageParams.put("total_fee", "1");
packageParams.put("total_fee", payOrder.getTotalFee());
packageParams.put("spbill_create_ip", spbill_create_ip);
packageParams.put("notify_url", notify_url);
packageParams.put("trade_type", trade_type);
packageParams.put("time_start", time_start);
packageParams.put("time_expire", time_expire);
String sign = PayCommonUtil.createSign("UTF-8", packageParams,key);
packageParams.put("sign", sign);
String requestXML = PayCommonUtil.getRequestXml(packageParams);
System.out.println("请求xml：：：："+requestXML);
String resXml = HttpUtil.postData(PayConfigUtil.PAY_API, requestXML);
System.out.println("返回xml：：：："+resXml);
Map map = XMLUtil.doXMLParse(resXml);
//String return_code = (String) map.get("return_code");
//String prepay_id = (String) map.get("prepay_id");
String urlCode = (String) map.get("code_url");
System.out.println("打印调用统一下单接口生成二维码url:::::"+urlCode);
return urlCode;
}

这一方法中，我们从工具类中获取微信官网提供的appId以及商户号，以及在商户平台上设置的支付密钥，处理一些统一下单接口需要携带的参数，回调链接（微信发起的本地调用，并返回成功或错误信息），totalFee的单位为分，官网的接口文档有说明，trade_type写死指定为NATIVE,另外的两个量time_start与time_expire是指定订单的有效期，

可以根据的自己的业务需求具体指定时间，（此处是24小时的订单有效期），如果无需指定，直接注释掉即可，sign是签名操作，借助工具类将packageParams转化为XML借助postData方法请求微信统一下单接口

[java]

public static String PAY_API = "https://api.mch.weixin.qq.com/pay/unifiedorder";

resXml作为调用统一下单的返回值，当然返回的也是xml文件，再借助xmlUtil将返回值转化为map，返回值中有生成二维码的code_url，接下来我们需要处理的是，解析二维码url在前端网页中生成二维码图片，在前端使用ajax调用统一下单接口方法，接收返回值code_url，接收返回值后在调用后台接口方法解析code_url

[javascript]

common.get("/*****/wxpay/WxPayUnifiedorder?out_trade_no="+orderId,function(data){
var codeUrl = data.codeUrl;
if(codeUrl!=null && codeUrl!=""){
$("#id_wxtwoCode").attr(''src'',"******/wxpay/qr_codeImg?code_url="+codeUrl);
}
});

html中img标签

[html]

<div >
<img id="id_wxtwoCode"src=""/>
<p>打开手机端微信<br>扫一扫继续支付</p>
</div>

下边是解析二维码过程

[java]

/**
* 生成二维码图片并直接以流的形式输出到页面
* @param code_url
* @param response
*/
@RequestMapping("qr_codeImg")
@ResponseBody
public void getQRCode(String code_url,HttpServletResponse response){
wxPayService.encodeQrcode(code_url, response);
}

[java]

/**
* 生成二维码图片不存储直接以流的形式输出到页面
* @param content
* @param response
*/
@SuppressWarnings({ "unchecked", "rawtypes" })
public static void encodeQrcode(String content,HttpServletResponse response){
if(content==null || "".equals(content))
return;
MultiFormatWriter multiFormatWriter = new MultiFormatWriter();
Map hints = new HashMap();
hints.put(EncodeHintType.CHARACTER_SET, "UTF-8"); //设置字符集编码类型
BitMatrix bitMatrix = null;
try {
bitMatrix = multiFormatWriter.encode(content, BarcodeFormat.QR_CODE, 300, 300,hints);
BufferedImage image = toBufferedImage(bitMatrix);
//输出二维码图片流
try {
ImageIO.write(image, "png", response.getOutputStream());
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} catch (WriterException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
}

这里的300,300确定了二维码图片的大小

二维码图片生成后，接下来的流程就是扫码进行支付操作，这里还存在一个问题，需要在扫码后支付成功，需要实现页面的跳转，这一过程需要添加js的定时器，定时查看订单的支付状态是否发生了改变是否为支付成功，成功即可跳转后续流程，失败跳转失败提示

[javascript]

//定时器，每隔1s查询订单支付状态，订单状态改变，清除页面定时器，页面跳转
function checkOrder(orderId) {
console.log("定时器方法"+orderId);
common.get("/*******/order/checkOrder?out_trade_no="+orderId,function(data){
var isorder = data.isorder;
var paystatus = data.paystatus;
if(isorder=="1"){
if(paystatus=="1"){
//支付成功跳转
window.location.href="******/order/wxpaySuccess?out_trade_no="+orderId;
clearInterval(time);
}else if(paystatus=="2"){
//支付失败
alert("支付失败！");
clearInterval(time);
}
}
});
}

isorder查看是否存在订单，存在订单时判断支付状态，进行后续流程

支付成功后，微信服务端开始回调方法，

[java]

@RequestMapping(value = "/weixinNotify", method = RequestMethod.POST)
@ResponseBody
public void weixinNotify(HttpServletRequest request,HttpServletResponse response) throws Exception{
System.out.println("支付回调方法开始！");
HashMap<String,Object> map = new HashMap<String,Object>();
wxPayService.weixin_notify(request, response);
System.out.println("支付回调方法结束！");
}

[java]

/**
* 微信支付回调方法
* @param request
* @param response
* @throws Exception
*/
public void weixin_notify(HttpServletRequest request,HttpServletResponse response) throws Exception{
//读取参数
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();
//解析xml成map
Map<String, String> m = new HashMap<String, String>();
m = XMLUtil.doXMLParse(sb.toString());
//过滤空设置 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 key = PayConfigUtil.getKey(); // key
String out_trade_no = (String)packageParams.get("out_trade_no");
//logger.info(packageParams);
//判断签名是否正确
if(PayCommonUtil.isTenpaySign("UTF-8", packageParams,key)) {
//------------------------------
//处理业务开始
//------------------------------
String resXml = "";
if("SUCCESS".equals((String)packageParams.get("result_code"))){
// 这里是支付成功
//////////执行自己的业务逻辑////////////////
String mch_id = (String)packageParams.get("mch_id");
String openid = (String)packageParams.get("openid");
String is_subscribe = (String)packageParams.get("is_subscribe");
String bank_type = (String)packageParams.get("bank_type");
String total_fee = (String)packageParams.get("total_fee");
String transaction_id = (String)packageParams.get("transaction_id");
System.out.println("mch_id:"+mch_id);
System.out.println("openid:"+openid);
System.out.println("is_subscribe:"+is_subscribe);
System.out.println("out_trade_no:"+out_trade_no);
System.out.println("total_fee:"+total_fee);
System.out.println("bank_type:"+bank_type);
System.out.println("transaction_id:"+transaction_id);
//成功回调后需要处理预生成订单的状态和一些支付信息

[java]

//查询数据库中订单，首先判定订单中金额与返回的金额是否相等，不等金额被纂改

[java]

//判定订单是否已经被支付，不可重复支付

[java]

//正常处理相关业务逻辑

[java]

} else {
System.out.println("支付失败,错误信息：" + packageParams.get("err_code")+
"-----订单号：：："+out_trade_no+"*******支付失败时间：：：："
+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
String err_code = (String)packageParams.get("err_code");
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();
} else{
System.out.println("通知签名验证失败---时间::::"+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
}

至此，微信支付流程完毕

下边是相关工具类

[java]

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.URL;
import java.net.URLConnection;
import com.entplus.log.entity.Log;
public class HttpUtil {
//private static final Log logger = Logs.get();
private final static int CONNECT_TIMEOUT = 5000; // in milliseconds
private final static String DEFAULT_ENCODING = "UTF-8";
public static String postData(String urlStr, String data){
return postData(urlStr, data, null);
}
public static String postData(String urlStr, String data, String contentType){
BufferedReader reader = null;
try {
URL url = new URL(urlStr);
URLConnection conn = url.openConnection();
conn.setDoOutput(true);
conn.setConnectTimeout(CONNECT_TIMEOUT);
conn.setReadTimeout(CONNECT_TIMEOUT);
if(contentType != null)
conn.setRequestProperty("content-type", contentType);
OutputStreamWriter writer = new OutputStreamWriter(conn.getOutputStream(), DEFAULT_ENCODING);
if(data == null)
data = "";
writer.write(data);
writer.flush();
writer.close();
reader = new BufferedReader(new InputStreamReader(conn.getInputStream(), DEFAULT_ENCODING));
StringBuilder sb = new StringBuilder();
String line = null;
while ((line = reader.readLine()) != null) {
sb.append(line);
sb.append("\r\n");
}
return sb.toString();
} catch (IOException e) {
//logger.error("Error connecting to " + urlStr + ": " + e.getMessage());
System.out.println("Error connecting to " + urlStr + ": " + e.getMessage());
} finally {
try {
if (reader != null)
reader.close();
} catch (IOException e) {
}
}
return null;
}
}

[java]

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.SortedMap;
public class PayCommonUtil {
/**
* 是否签名正确,规则是:按参数名称a-z排序,遇到空值的参数不参加签名。
* @return boolean
*/
public static boolean isTenpaySign(String characterEncoding, SortedMap<Object, Object> packageParams, String API_KEY) {
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=" + API_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);
}
/**
* @author
* @date 2016-4-22
* @Description：sign签名
* @param characterEncoding
* 编码格式
* @param parameters
* 请求参数
* @return
*/
public static String createSign(String characterEncoding, SortedMap<Object, Object> packageParams, String API_KEY) {
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 (null != v && !"".equals(v) && !"sign".equals(k) && !"key".equals(k)) {
sb.append(k + "=" + v + "&");
}
}
sb.append("key=" + API_KEY);
String sign = MD5Util.MD5Encode(sb.toString(), characterEncoding).toUpperCase();
return sign;
}
/**
* @author
* @date 2016-4-22
* @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) || "sign".equalsIgnoreCase(k)) {
sb.append("<" + k + ">" + "<![CDATA[" + v + "]]></" + k + ">");
} else {
sb.append("<" + k + ">" + v + "</" + k + ">");
}
}
sb.append("</xml>");
return sb.toString();
}
/**
* 取出一个指定长度大小的随机正整数.
*
* @param length
* int 设定所取出随机数的长度。length小于11
* @return int 返回生成的随机数。
*/
public static int buildRandom(int length) {
int num = 1;
double random = Math.random();
if (random < 0.1) {
random = random + 0.1;
}
for (int i = 0; i < length; i++) {
num = num * 10;
}
return (int) ((random * num));
}
/**
* 获取当前时间 yyyyMMddHHmmss
*
* @return String
*/
public static String getCurrTime() {
Date now = new Date();
SimpleDateFormat outFormat = new SimpleDateFormat("yyyyMMddHHmmss");
String s = outFormat.format(now);
return s;
}
}

[java]

package com.entplus.wxpay.util;
public class PayConfigUtil {
//这个就是自己要保管好的私有Key了（切记只能放在自己的后台代码里，不能放在任何可能被看到源代码的客户端程序中）
// 每次自己Post数据给API的时候都要用这个key来对所有字段进行签名，生成的签名会放在Sign这个字段，API收到Post数据的时候也会用同样的签名算法对Post过来的数据进行签名和验证
// 收到API的返回的时候也要用这个key来对返回的数据算下签名，跟API的Sign数据进行比较，如果值不一致，有可能数据被第三方给篡改
private static String key = "";
//微信分配的公众号ID（开通公众号之后可以获取到）
private static String appID = "";
//微信支付分配的商户号ID（开通公众号的微信支付功能之后可以获取到）
private static String mchID = "";
//机器IP
private static String ip = "";
//以下是几个API的路径：
//1）被扫支付API
//public static String PAY_API = "https://api.mch.weixin.qq.com/pay/micropay";
public static String PAY_API = "https://api.mch.weixin.qq.com/pay/unifiedorder";
//2）被扫支付查询API
public static String PAY_QUERY_API = "https://api.mch.weixin.qq.com/pay/orderquery";
//3）退款API
public static String REFUND_API = "https://api.mch.weixin.qq.com/secapi/pay/refund";
//4）退款查询API
public static String REFUND_QUERY_API = "https://api.mch.weixin.qq.com/pay/refundquery";
//5）撤销API
public static String REVERSE_API = "https://api.mch.weixin.qq.com/secapi/pay/reverse";
//6）下载对账单API
public static String DOWNLOAD_BILL_API = "https://api.mch.weixin.qq.com/pay/downloadbill";
//7) 统计上报API
public static String REPORT_API = "https://api.mch.weixin.qq.com/payitil/report";
//回调地址
//public static String NOTIFY_URL = ""; //测试
public static String HttpsRequestClassName = "com.entplus.wxpay.util.HttpsRequest";
public static void setKey(String key) {
PayConfigUtil.key = key;
}
public static void setAppID(String appID) {
PayConfigUtil.appID = appID;
}
public static void setMchID(String mchID) {
PayConfigUtil.mchID = mchID;
}
public static void setIp(String ip) {
PayConfigUtil.ip = ip;
}
public static String getKey(){
return key;
}
public static String getAppid(){
return appID;
}
public static String getMchid(){
return mchID;
}
public static String getIP(){
return ip;
}
public static void setHttpsRequestClassName(String name){
HttpsRequestClassName = name;
}
}

[java]

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.jdom.Document;
import org.jdom.Element;
import org.jdom.JDOMException;
import org.jdom.input.SAXBuilder;
public class XMLUtil {
/**
* 解析xml,返回第一级元素键值对。如果第一级元素有子节点，则此节点的值是子节点的xml数据。
* @param strxml
* @return
* @throws JDOMException
* @throws IOException
*/
public static Map doXMLParse(String strxml) throws JDOMException, IOException {
strxml = strxml.replaceFirst("encoding=\".*\"", "encoding=\"UTF-8\"");
if(null == strxml || "".equals(strxml)) {
return null;
}
Map m = new HashMap();
InputStream in = new ByteArrayInputStream(strxml.getBytes("UTF-8"));
SAXBuilder builder = new SAXBuilder();
Document doc = builder.build(in);
Element root = doc.getRootElement();
List list = root.getChildren();
Iterator it = list.iterator();
while(it.hasNext()) {
Element e = (Element) it.next();
String k = e.getName();
String v = "";
List children = e.getChildren();
if(children.isEmpty()) {
v = e.getTextNormalize();
} else {
v = XMLUtil.getChildrenText(children);
}
m.put(k, v);
}
//关闭流
in.close();
return m;
}
/**
* 获取子结点的xml
* @param children
* @return String
*/
public static String getChildrenText(List children) {
StringBuffer sb = new StringBuffer();
if(!children.isEmpty()) {
Iterator it = children.iterator();
while(it.hasNext()) {
Element e = (Element) it.next();
String name = e.getName();
String value = e.getTextNormalize();
List list = e.getChildren();
sb.append("<" + name + ">");
if(!list.isEmpty()) {
sb.append(XMLUtil.getChildrenText(list));
}
sb.append(value);
sb.append("</" + name + ">");
}
}
return sb.toString();
}
}

[java]

import java.security.MessageDigest;
public class MD5Util {
private static String byteArrayToHexString(byte b[]) {
StringBuffer resultSb = new StringBuffer();
for (int i = 0; i < b.length; i++)
resultSb.append(byteToHexString(b[i]));
return resultSb.toString();
}
private static String byteToHexString(byte b) {
int n = b;
if (n < 0)
n += 256;
int d1 = n / 16;
int d2 = n % 16;
return hexDigits[d1] + hexDigits[d2];
}
public static String MD5Encode(String origin, String charsetname) {
String resultString = null;
try {
resultString = new String(origin);
MessageDigest md = MessageDigest.getInstance("MD5");
if (charsetname == null || "".equals(charsetname))
resultString = byteArrayToHexString(md.digest(resultString
.getBytes()));
else
resultString = byteArrayToHexString(md.digest(resultString
.getBytes(charsetname)));
} catch (Exception exception) {
}
return resultString;
}
private static final String hexDigits[] = { "0", "1", "2", "3", "4", "5",
"6", "7", "8", "9", "a", "b", "c", "d", "e", "f" };
}

开发过程中借助了网络资料，欢迎大家指正。

【weixin】微信支付---PC网站微信支付

一、PC网站支付

微信支付支持完成域名ICP备案的网站接入支付功能。
PC网站接入支付后，可以通过JSAPI支付或Native支付，自行开发生成二维码，用户使用微信“扫一扫”来完成支付。

二、支付产品介绍

JSAPI支付：商家张贴收款码物料，用户打开扫一扫，扫码后输入金额，完成付款；开发文档

Native支付：商家在系统中按微信支付协议生成支付二维码，用户扫码拉起微信收银台，确认并完成付款。开发文档（PC端支付用的是此）

JSAPI支付流程图：

Native支付流程图：

三、扫码支付介绍

1、链接

　　　　https://pay.weixin.qq.com/wiki/doc/api/native.php?chapter=6_2

2、使用场景介绍

用户扫描商户展示在各种场景的二维码进行支付。

步骤1：商户根据微信支付的规则，为不同商品生成不同的二维码（如图6.1），展示在各种场景，用于用户扫描购买。

步骤2：用户使用微信“扫一扫”（如图6.2）扫描二维码后，获取商品支付信息，引导用户完成支付（如图6.3）。

步骤3：用户确认支付，输入支付密码（如图6.4）。

步骤4：支付完成后会提示用户支付成功（如图6.5），商户后台得到支付成功的通知，然后进行发货处理。

3、Native支付可分为两种模式

模式一：

商户后台系统根据微信支付规则链接生成二维码，链接中带固定参数productid（可定义为产品标识或订单号）。
用户扫码后，微信支付系统将productid和用户唯一标识(openid)回调商户后台系统(需要设置支付回调URL)，
商户后台系统根据productid生成支付交易，最后微信支付系统发起用户支付流程。

详细步骤：https://www.cnblogs.com/websmile/p/11115045.html

模式二：(采用的此模式)

商户后台系统调用微信支付【统一下单API】生成预付交易，将接口返回的链接生成二维码，用户扫码后输入密码完成支付交易。
注意：该模式的预付单有效期为2小时，过期后无法支付

详细步骤：https://www.cnblogs.com/websmile/p/11115600.html　　　　　

四、支付成功后如何通知前端（PC端）页面进行刷新/跳转

生成二维码之后设置定时器去查询下订单。订单支付成功之后。跳转window.location.href="回调成功的url,支付成功页面";

相关资料

https://pay.weixin.qq.com/static/applyment_guide/applyment_detail_website.shtml
https://lzqustc.iteye.com/blog/2396674
https://lzqustc.iteye.com/blog/2364688
https://www.baidu.com/link?url=ws6cxNIhWmVA1gbrUgFMRtACQhCMdYvcwZtLWOZfWZ2tO0oBW-YtCOmTJsTqsPnY9SzpJ3RjFQsgfV66616OMhHY7XPykYlO1aU-t5N3sAC&wd=&eqid=d7a66c6e0030e722000000025d19661f
https://blog.csdn.net/qq_29058883/article/details/79193612
https://www.cnblogs.com/guanjunhui/p/9070659.html
https://www.baidu.com/link?url=57aywD0Q6WTnl7XKbIHuE7lcWGXh50Vy3z1lItKlmd4OJre3dLQnWbn8s4nBPmV1q3dU6Y8A68dybv-wlO9GW96qiIBTGfwQg97O_af1WDC&wd=&eqid=d7a66c6e0030e722000000025d19661f

一篇文章讲明白微信支付，适合第一次接通微信支付的同学

微信的支付文档，看似很全，实际则特别分散，可能在公司里经常微信支付的工具类有和相关参数已经有人告知并且写好了，大部分同学尽管调用就可以了，但是对于刚上手想0-1接通微信支付，还是有很多困难的。这篇文章一次性讲清v3版本的API支付

1.maven依赖

<dependency>
     <groupId>com.github.wechatpay-apiv3</groupId>
     <artifactId>wechatpay-java</artifactId>
     <version>0.2.6</version>
</dependency>  
复制代码

2.微信支付基本参数解释

1.MACHID:微信支付商户号，参数经常也表示为merchantId

2.privateKeyPath：商户API证书的路径(文章下面会细讲API证书)

3.API_SERIAL_NO：也被称作merchantSerialNumber，是API证书的序列号（下面会细讲怎么获得）

4.certPath：wechatPayCertificatesFromPath()方法需要的参数,可以理解为微信支付平台证书，这个和API证书是不一样的

5.callback_url：微信支付回调咱们系统的接口地址，回调接口会返回用户的支付结果，具体看微信的回调接口文档

6.APPID:这个指微信公众号或者小程序的appid，微信支付必须要有公众号或者小程序(目前必须是这样的)

简单介绍完这些参数后，开始详细解释这些参数是从哪里获取的

1.MACHID

2.privateKeyPath:管理证书，根据提示操作即可，具体参考：微信API证书及其密钥

根据上述操作生成证书，下载到本地是一个证书压缩包，解压后，压缩包里面的内容是这样的:

public static final String privateKeyPath = "/Users/camel/cert/1610157505_20230310_cert/apiclient_key.pem";//API证书密钥路径，指的就是这个证书里的apiclient_key.pem路径
复制代码

3.商户证书序列号的获取

public static final String API_SERIAL_NO = "xxxxxxxxxxC9203xxxxxx6C632";
复制代码

账户中心--->API安全--->管理证书页，可以看到证书的序列号，或者访问证书解析网站:https://myssl.com/cert_decode.html ,上传文件选择图3中的apiclient_cert.pem证书

4.微信平台证书生成

 public static final String certPath = "/Users/camel/cert/1610157505_20230310_cert/file/wechatpay_5A4BE90F6551D7F8CD853CB65016E005237849E9.pem";
复制代码

•下载微信支付平台证书方法微信支付平台证书下载工具微信支付平台证书下载工具说明：在这里下载 CertificateDownloader.jar 文件，按照里面的文档操作即可

•注意：我的操作说明，我是把下载好的 CertificateDownloader.jar 文件，放在了解压证书的目录里(图3)。这样我取mchPrivateKeyFilePath这个值的时候就可以直接写证书文件名，不用写路径了。

官方完整命令如：

java -jar CertificateDownloader.jar -k ${apiV3key} -m ${mchId} -f ${mchPrivateKeyFilePath} -s ${mchSerialNo} -o ${outputFilePath} -c ${wechatpayCertificateFilePath}
复制代码

我的实际操作命令如下：就会生成图3中多出来的file文件夹，/Users/camel/cert/1610157505_20230310_cert/file/wechatpay_5A4BE90F6551D7F8CD853CB65016E005237849E9.pem，wechatpay_5A4BE90F6551D7F8CD853CB65016E005237849E9.pem就是微信支付平台证书，也是程序真正需要的

java -jar CertificateDownloader.jar -k YUCONG12340924834535984954958948 -m 1610157505 -f apiclient_key.pem -s 6217F9226ABFACF3B183E6C9203475E3A446C632 -o file
复制代码

5.callback_url，微信支付结果的回调地址配置地方：

至此，微信支付的相关底层参数介绍完毕

6.以二维码支付为例，测试demo如下

  //下面的静态参数要仔细看下面的解释，否则只会调用别人写好的方法，压根学不会0-1接入微信支付
    public static final String MACHID = "1610xxxx";
    public static final String APPID = "wx9aa9xxx7fxxxxxx";
    public static final String API_SERIAL_NO = "xxxxxxxxxxC9203xxxxxx6C632";
    public static final String privateKeyPath = "/Users/camel/cert/1610157505_20230310_cert/apiclient_key.pem";
    public static final String certPath = "/Users/camel/cert/1610157505_20230310_cert/file/wechatpay_5A4BE90F6551D7F8CD853CB65016E005237849E9.pem";
    public static final String callback_url = "https://xxxxxx.com/wx/callback";

public static void main(String[] args) {
        try {
            // 初始化商户配置，在实际业务中，config最好全局变量创建一次就好，频繁创建config会报异常
            RSAConfig config = new RSAConfig.Builder()
                    .merchantId(MACHID)
                    // 使用 com.wechat.pay.java.core.util 中的函数从本地文件中加载商户私钥，商户私钥会用来生成请求的签名
                    .privateKeyFromPath(privateKeyPath)
                    .merchantSerialNumber(API_SERIAL_NO)
                    .wechatPayCertificatesFromPath(certPath)
                    .build();
            // 初始化服务
            NativePayService service = new NativePayService.Builder().config(config).build();
            String orderNumber = IdGeneratorUtils.genDateUniqueId("MA", 16);
            log.info("orderNumber={}", orderNumber);
            PrepayRequest request = new PrepayRequest();
            Amount amount = new Amount();
            amount.setCurrency("CNY");
            amount.setTotal(1);
            request.setAmount(amount);
            request.setDescription("测试下单001");
            request.setOutTradeNo(orderNumber);
            request.setNotifyUrl(callback_url);
            request.setAppid(APPID);
            request.setMchid(MACHID);
            PrepayResponse response=service.prepay(request);
            log.info("result={}", JsonTools.object2Json(response));
        } catch (HttpException e) { // 发送HTTP请求失败
            log.error("1111111={}", e);
            // 调用e.getHttpRequest()获取请求打印日志或上报监控，更多方法见HttpException定义
        } catch (ServiceException e) { // 服务返回状态小于200或大于等于300，例如500
            log.error("222222222={}", e.getResponseBody());
            // 调用e.getResponseBody()获取返回体打印日志或上报监控，更多方法见ServiceException定义
        } catch (MalformedMessageException e) { // 服务返回成功，返回体类型不合法，或者解析返回体失败
            log.error("3333333333={}", e);
            
            // 调用e.getMessage()获取信息打印日志或上报监控，更多方法见MalformedMessageException定义
        } catch (Exception e) {
            log.error("未知异常：{}", e);
        }


    }
复制代码

上述简单的代码，就可以实现微信的预下单，response会返回二维码的微信链接（咱们需要用第三方二维码工具，将微信链接转成二维码），response返回结果如下：

{
  "code_url": "weixin://wxpay/bizpayurl?pr=AQAsbYzzz"
}
//需要用第三方二维码生成工具weixin://wxpay/bizpayurl?pr=AQAsbYzzz生成二维码，在此不做赘述，生成的二维码文件返回给前端，或者前端根据code_url生成二维码展示到页面上，然后就可以扫码支付了
复制代码

更多丰富的支付逻辑基本都和这个差不多，可以参考下边demo

微信支付SDK DEMO

至此，微信支付结束，希望能帮到大家

今天关于微信支付BUG注销再重新绑定继续撸微信支付游戏特权活动和vx支付注销的讲解已经结束，谢谢您的阅读，如果想了解更多关于app微信支付（一） - 微信支付基本业务流程解析、【java微信支付】微信支付之扫码支付相关代码、【weixin】微信支付---PC网站微信支付、一篇文章讲明白微信支付，适合第一次接通微信支付的同学的相关知识，请在本站搜索。

本文标签：