微信支付开发V2版本 springboot详细版

矫情吗；* 2024-02-18 12:53 39阅读 0赞

### 一、配置 ###

#### 1、开发文档链接 ####

v2版本官方链接：[https://pay.weixin.qq.com/wiki/doc/api/jsapi.php?chapter=7\_1][https_pay.weixin.qq.com_wiki_doc_api_jsapi.php_chapter_7_1]

#### 2、公众号后台配置 ####

1、![564e847ae9f3452c81da58f7b2b6fe13.png][]

2、![3743814f0e3449d98340e253be5c8c66.png][]

3、![27998c0ffe59458aa46cbd56f28f4525.png][]

### 二、流程 ###

![48692ea4df4642eeb0af79585652ed01.png][]

商户系统和微信支付系统主要交互：

1、商户server调用统一下单接口请求订单，api参见公共api【[统一下单API][API]】

2、商户server可通过【[JSAPI调起支付API][JSAPI_API]】调起微信支付，发起支付请求。

3、商户server接收支付通知，api参见公共api【[支付结果通知API][API 1]】

4、商户server查询支付结果，api参见公共api【[查询订单API][API 2]】（查单实现可参考：[支付回调和查单实现指引][Link 1]）

### 三、代码 ###

v2版本代码可以直接复制使用

#### 1、添加Maven ####

<dependency>
                <groupId>com.github.wxpay</groupId>
                <artifactId>wxpay-sdk</artifactId>
                <version>0.0.3</version>
            </dependency>

#### 2、统一下单接口 ####

@GetMapping("/place")
        public AjaxResult place(PayVo payVo) {
            System.out.println("money:"+money.toString());
            System.out.println("openid:"+payVo.getOpenid());
            Map<String,String> weChatPayMap = new HashMap<>();
            String wechat_appid = payConfig.getAppid();//小程序appid 或者 公众号appid, 必须与商户绑定
            String wechat_mchid = payConfig.getMch_id(); //商户号id
            String wechat_seckey = payConfig.getApi_key();//商户秘钥
            String out_trade_no = UUIDUtils.getUUID36(); //订单号
            String ip = payConfig.getIp();
            String openid = payVo.getOpenid();
            String trade_type = "JSAPI";
            Double d = new Double(money.toString());
            Double a=d*100;
            String total_fee =a.intValue()+"";
            try {
    //            YmyXlyAct ymyXlyAct = new YmyXlyAct();
    //            List<YmyXlyAct> list = ymyXlyActService.selectYmyXlyActList(ymyXlyAct);
    //            String body = qishu;
                String product_id = actId;
                YmyXlyDingdan XlyDingdan=new YmyXlyDingdan();
                XlyDingdan.setOpenid(openid);
                XlyDingdan.setMoney(money.toString());
                XlyDingdan.setPayType("未支付");
                XlyDingdan.setProductId(product_id);
                List<YmyXlyDingdan> dingdans= ymyXlyDingdanService.selectYmyXlyDingdanList(XlyDingdan);
                if (StringUtils.isNotEmpty(dingdans)){
    //                JSONObject jsonObject = JSON.parseObject(dingdans.get(0).getParam());
                    /*JSON对象转map常用*/
                    Map<String,Object> jsonToMap =  JSONObject.parseObject(dingdans.get(0).getParam());
                  return AjaxResult.success(jsonToMap);
    
                }
                //微信统一下单
                Map<String, String> paraMap = new HashMap<String, String>();
                paraMap.put("appid", wechat_appid);
                paraMap.put("mch_id", wechat_mchid);
                String new_body=new String(body.getBytes(),"utf-8");
                paraMap.put("body", body);//商品描述
                paraMap.put("product_id", product_id);//商品id
                paraMap.put("nonce_str", UUIDUtils.getUUID36());
                paraMap.put("out_trade_no", out_trade_no);//订单号
                paraMap.put("spbill_create_ip", ip);
                paraMap.put("total_fee", total_fee);
                paraMap.put("trade_type", trade_type);//交易类型   JSAPI支付
                paraMap.put("notify_url", WeChatConstants.NOTIFY_URL);// 此路径是微信服务器调用支付结果通知路径随意写，---回调地址
                //生成签名, 统一下单
    
                if (StringUtils.equals(WeChatConstants.TRADE_TYPE_JSAPI, trade_type)) {
                    paraMap.put("openid", openid);//trade_type=JSAPI时（即JSAPI支付），此参数必传
                    weChatPayMap = WXPayUtil.unifiedorderJSAPI(paraMap, wechat_appid, wechat_seckey, out_trade_no);
                    System.out.println(weChatPayMap);
    
                    if ("200".equals(weChatPayMap.get("paycode"))){
                        YmyXlyDingdan ymyXlyDingdan=new YmyXlyDingdan();
                        ymyXlyDingdan.setOpenid(openid);
                        ymyXlyDingdan.setOutTradeNo(out_trade_no);
                        ymyXlyDingdan.setPayType("待支付");
                        ymyXlyDingdan.setMoney(money.toString());
                        ymyXlyDingdan.setProductId(product_id);
                        ymyXlyDingdan.setBody(body);
                        JSONObject JSONObj = JSONObject.parseObject(JSON.toJSONString(weChatPayMap));
                        ymyXlyDingdan.setParam(String.valueOf(weChatPayMap));
                        String str = JSONObj.toString();
                        ymyXlyDingdan.setParam(str);
                        ymyXlyDingdanService.insertYmyXlyDingdan(ymyXlyDingdan);
                    }
                    return AjaxResult.success(weChatPayMap);
                }
    
    
            } catch (Exception e) {
    
                e.printStackTrace();
            }
    
            return AjaxResult.success(weChatPayMap);
        }

#### 3、查询订单 ####

/**
         * 订单支付状态查询
         *
         * @param wechat_appid
         * @param wechat_mchid
         * @param wechat_seckey
         * @param out_trade_no
         * @return
         * @throws Exception
         */
        @GetMapping("/orderquery")
        public Map<String, String> orderquery(String wechat_appid, String wechat_mchid, String wechat_seckey, String out_trade_no) throws Exception {
            //拼接 参数
            Map<String, String> paraMap = new HashMap<String, String>();
            paraMap.put("appid", wechat_appid);
            paraMap.put("mch_id", wechat_mchid);
            paraMap.put("nonce_str", UUIDUtils.getUUID36());
            paraMap.put("out_trade_no", out_trade_no);//订单号
            String sign = WXPayUtil.generateSignature(paraMap, wechat_seckey);
            paraMap.put("sign", sign);
            String xml = WXPayUtil.mapToXml(paraMap);//将所有参数(map)转xml格式
            String xmlStr = HttpUtils.sendPost(WeChatConstants.ORDERQUERY_URL, xml);//发送post请求"统一下单接口"返回预支付id:prepay_id
            Map<String, String> map = WXPayUtil.xmlToMap(xmlStr);
            if(map!=null && "SUCCESS".equalsIgnoreCase(map.get("trade_state"))){
                //支付成功
                //2.修改订单状态为“待发货/已支付”
                String orderId = out_trade_no;
    //            String orderId = map.get("out_trade_no");
    //            int i =1;
                YmyXlyDingdan ymyXlyDingdan = new YmyXlyDingdan();
                ymyXlyDingdan.setOutTradeNo(orderId);
                ymyXlyDingdan.setPayType("已支付");
                ymyXlyDingdanService.updateYmyXlyDingdan(ymyXlyDingdan);
    
                List<YmyXlyDingdan> list = ymyXlyDingdanService.selectYmyXlyDingdanList(ymyXlyDingdan);
                String[] actIds=list.get(0).getProductId().split(",");
                for (String actId:actIds){
                    YmyXly ymyXly = new YmyXly();
                    ymyXly.setOpenid(list.get(0).getOpenid());
                    ymyXly.setActId(Long.valueOf(actId));
                    ymyXly.setMoney(list.get(0).getMoney());
                    List<YmyXly> ymyXlies = ymyXlyService.selectYmyXlyList(ymyXly);
                    YmyXly xly=new YmyXly();
                    BeanUtils.copyBeanProp(xly,ymyXlies.get(0));
                    xly.setIsPay("已付款");
                    ymyXlyService.updateYmyXly(xly);
                }
    
                //3.响应微信支付平台
    
    
            }
            return map;
        }

#### 4、下单回调接口 ####

/**
         * 1.接收微信支付平台传递的数据（使用request的输入流接收）
         */
        @PostMapping("/callback")
        public String success(HttpServletRequest request) throws Exception {
            System.out.println("进入回调----------------------------------------------------");
            ServletInputStream is = request.getInputStream();
            byte[] bs = new byte[1024];
            int len = -1;
            StringBuilder builder = new StringBuilder();
            while ((len = is.read(bs)) != -1) {
                builder.append(new String(bs, 0, len));
            }
            String s = builder.toString();
            System.out.println("s="+s);
            //使用帮助类将xml接口的字符串转换成map
            Map<String, String> map = WXPayUtil.xmlToMap(s);
    System.out.println("map:"+map);
            if(map!=null && "SUCCESS".equalsIgnoreCase(map.get("return_code"))){
                //支付成功
                //2.修改订单状态为“待发货/已支付”
                String orderId = map.get("out_trade_no");
    //            int i =1;
                try {
                    YmyXlyDingdan ymyXlyDingdan = new YmyXlyDingdan();
                    ymyXlyDingdan.setOutTradeNo(orderId);
                    ymyXlyDingdan.setPayType("已支付");
                    int i = ymyXlyDingdanService.updateYmyXlyDingdan(ymyXlyDingdan);
    
                    List<YmyXlyDingdan> list = ymyXlyDingdanService.selectYmyXlyDingdanList(ymyXlyDingdan);
                    String[] actIds=list.get(0).getProductId().split(",");
                    for (String actId:actIds){
                        YmyXly ymyXly = new YmyXly();
                        ymyXly.setOpenid(list.get(0).getOpenid());
                        ymyXly.setActId(Long.valueOf(actId));
                        ymyXly.setMoney(list.get(0).getMoney());
                        List<YmyXly> ymyXlies = ymyXlyService.selectYmyXlyList(ymyXly);
                        YmyXly xly=new YmyXly();
                        BeanUtils.copyBeanProp(xly,ymyXlies.get(0));
                        xly.setIsPay("已付款");
                        ymyXlyService.updateYmyXly(xly);
                    }
    
    
    
                    System.out.println("--orderId:" + orderId);
                    //3.响应微信支付平台
                    if (i > 0) {
                        HashMap<String, String> resp = new HashMap<>();
                        resp.put("return_code", "success");
                        resp.put("return_msg", "OK");
                        resp.put("appid", map.get("appid"));
                        resp.put("result_code", "success");
                        return WXPayUtil.mapToXml(resp);
                    }
                }catch (Exception e){
                    e.printStackTrace();
                }
    
            }
            //支付失败
            return null;
        }

#### 5、工具类util ####

##### 1、HttpUtils #####

import com.alibaba.fastjson2.JSONObject;
    import org.apache.http.HttpEntity;
    import org.apache.http.client.methods.CloseableHttpResponse;
    import org.apache.http.client.methods.HttpPost;
    import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
    import org.apache.http.conn.ssl.SSLContexts;
    import org.apache.http.entity.StringEntity;
    import org.apache.http.impl.client.CloseableHttpClient;
    import org.apache.http.impl.client.HttpClients;
    import org.apache.http.util.EntityUtils;
    
    import javax.net.ssl.HttpsURLConnection;
    import javax.net.ssl.SSLContext;
    import javax.net.ssl.SSLSocketFactory;
    import javax.net.ssl.TrustManager;
    import java.io.*;
    import java.net.ConnectException;
    import java.net.URL;
    import java.net.URLConnection;
    import java.security.KeyStore;
    
    public class HttpUtils {
    
    
        public static JSONObject httpRequest(String requestUrl, String requestMethod, String outputStr) {
            JSONObject jsonObject = null;
            StringBuffer buffer = new StringBuffer();
            try {
                // 创建SSLContext对象，并使用我们指定的信任管理器初始化
                TrustManager[] tm = { new MyX509TrustManager() };
                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 httpUrlConn = (HttpsURLConnection) url.openConnection();
                httpUrlConn.setSSLSocketFactory(ssf);
    
                httpUrlConn.setDoOutput(true);
                httpUrlConn.setDoInput(true);
                httpUrlConn.setUseCaches(false);
                // 设置请求方式（GET/POST）
                httpUrlConn.setRequestMethod(requestMethod);
    
                if ("GET".equalsIgnoreCase(requestMethod))
                    httpUrlConn.connect();
    
                // 当有数据需要提交时
                if (null != outputStr) {
                    OutputStream outputStream = httpUrlConn.getOutputStream();
                    // 注意编码格式，防止中文乱码
                    outputStream.write(outputStr.getBytes("UTF-8"));
                    outputStream.close();
                }
    
                // 将返回的输入流转换成字符串
                InputStream inputStream = httpUrlConn.getInputStream();
                InputStreamReader inputStreamReader = new InputStreamReader(inputStream, "utf-8");
                BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
    
                String str = null;
                while ((str = bufferedReader.readLine()) != null) {
                    buffer.append(str);
                }
                bufferedReader.close();
                inputStreamReader.close();
                // 释放资源
                inputStream.close();
                inputStream = null;
                httpUrlConn.disconnect();
                jsonObject = JSONObject.parseObject(buffer.toString());
                return jsonObject;
            } catch (ConnectException ce) {
                System.out.println("Weixin server connection timed out.");
            } catch (Exception e) {
                System.out.println("error."+ e.getMessage());
            }
            return jsonObject;
        }
    
        /**
         * 向指定 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("Charsert", "UTF-8");
                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()));
                String line;
                while ((line = in.readLine()) != null) {
                    result += line;
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
            // 使用finally块来关闭输出流、输入流
            finally {
                try {
                    if (out != null) {
                        out.close();
                    }
                    if (in != null) {
                        in.close();
                    }
                } catch (IOException ex) {
                    ex.printStackTrace();
                }
            }
            return result;
        }
    
        /**
         * 需要使用证书请求接口
         */
        public static String requestWithCert(String url,String pay_cert,String mchid, String data) throws Exception {
    
            KeyStore keyStore = KeyStore.getInstance("PKCS12");
            FileInputStream is = new FileInputStream(new File(pay_cert));
            try {
                keyStore.load(is, mchid.toCharArray());// 这里写密码..默认是你的MCHID
            } finally {
                is.close();
            }
            // Trust own CA and all self-signed certs
            SSLContext sslcontext = SSLContexts.custom().loadKeyMaterial(keyStore, mchid.toCharArray())// 这里也是写密码的
                    .build();
            // Allow TLSv1 protocol only
            SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(sslcontext, new String[] { "TLSv1" }, null,
                    SSLConnectionSocketFactory.BROWSER_COMPATIBLE_HOSTNAME_VERIFIER);
            CloseableHttpClient httpclient = HttpClients.custom().setSSLSocketFactory(sslsf).build();
            try {
                HttpPost httpost = new HttpPost(url); // 设置响应头信息
                httpost.addHeader("Connection", "keep-alive");
                httpost.addHeader("Accept", "*/*");
                httpost.addHeader("Content-Type", "application/x-www-form-urlencoded; charset=UTF-8");
                httpost.addHeader("Host", "api.mch.weixin.qq.com");
                httpost.addHeader("X-Requested-With", "XMLHttpRequest");
                httpost.addHeader("Cache-Control", "max-age=0");
                httpost.addHeader("User-Agent", "Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 6.0) ");
                httpost.setEntity(new StringEntity(data, "UTF-8"));
                CloseableHttpResponse response = httpclient.execute(httpost);
                try {
                    HttpEntity entity = response.getEntity();
    
                    String jsonStr = EntityUtils.toString(response.getEntity(), "UTF-8");
                    EntityUtils.consume(entity);
                    return jsonStr;
                } finally {
                    response.close();
                }
            } finally {
                httpclient.close();
            }
        }
    }

##### 2、WeChatConstants #####

/**
     * 常量
     * @author voayc
     *
     */
    public class WeChatConstants {
    
    	public enum SignType {
    		MD5, HMACSHA256
    	}
    
    	public static final String FIELD_SIGN = "sign";
    
    	/** 支付成功回调地址 */
    	public static String NOTIFY_URL= "http://8.142.116.233:8001/pay/wxpay/callback";微信支付回调地址
    
    
    	/** 支付证书路径 */
    	public static String PAY_CERT_LOC = "C:\\CTO\\java\\apache-tomcat-8.0.50\\wxcert\\";
    
    	/** 微信 trade_type 参数  */
    	public static final String TRADE_TYPE_JSAPI = "JSAPI";//JSAPI支付  例如 : 直接调用微信支付
    	public static final String TRADE_TYPE_NATIVE = "NATIVE";//Native支付  例如 : 扫码支付
    
    	/**
    	 * 统一下单
    	 */
    	public static String UNIFIEDORDER_URL = "https://api.mch.weixin.qq.com/pay/unifiedorder";
    	/**
    	 * 订单支付状态查询
    	 */
    	public static String ORDERQUERY_URL = "https://api.mch.weixin.qq.com/pay/orderquery";
    	/**
    	 * 退款
    	 */
    	public static String REFUND_URL = "https://api.mch.weixin.qq.com/secapi/pay/refund";
    	/**
    	 * 提现
    	 */
    	public static String TRANSFERS_URL = "https://api.mch.weixin.qq.com/mmpaymkttransfers/promotion/transfers";
    
    }

##### 3、WXPayUtil #####

import com.alibaba.fastjson2.JSONObject;
    import com.ruoyi.common.utils.sign.Md5Utils;
    import com.ruoyi.garden.controller.wxpay.constants.WeChatConstants;
    import com.ruoyi.garden.controller.wxpay.dto.*;
    import org.apache.commons.collections.MapUtils;
    import org.apache.commons.lang3.StringUtils;
    import org.w3c.dom.Document;
    import org.w3c.dom.Element;
    import org.w3c.dom.Node;
    import org.w3c.dom.NodeList;
    
    import javax.crypto.Mac;
    import javax.crypto.spec.SecretKeySpec;
    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 java.io.ByteArrayInputStream;
    import java.io.InputStream;
    import java.io.StringWriter;
    import java.math.BigDecimal;
    import java.security.MessageDigest;
    import java.security.SecureRandom;
    import java.util.*;
    
    
    
    public class WXPayUtil {
    
        private static final String SYMBOLS = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
    
        private static final Random RANDOM = new SecureRandom();
        /**
         * JSAPI 下单
         * @Title: unifiedorderJSAPI
         * @param paraMap
         * @param wechat_seckey
         * @return
         * @author: voayc
         * @date:  2020年3月17日 上午10:00:49
         */
        public static Map<String,String> unifiedorderJSAPI(Map<String, String> paraMap, String wechat_appid, String wechat_seckey, String out_trade_no) throws Exception {
            Map<String,String> weChatPayMap = new HashMap<>();
        	//生成签名, 统一下单
            System.out.println("paraMap------------"+paraMap);
    		String sign = WXPayUtil.generateSignature(paraMap, wechat_seckey);
    		System.out.println("sign:"+sign);
    		paraMap.put("sign", sign);
    		String xml = WXPayUtil.mapToXml(paraMap);//将所有参数(map)转xml格式
            String new_xml=new String(xml.getBytes("utf-8"));
    
            System.out.println("xml:"+new_xml);
    		String xmlStr = HttpUtils.sendPost(WeChatConstants.UNIFIEDORDER_URL, new_xml);//发送post请求"统一下单接口"返回预支付id:prepay_id
            System.out.println("xmlStr:"+xmlStr);
    
            Map<String, String> map = WXPayUtil.xmlToMap(xmlStr);
    
    		//以下内容是返回前端页面的json数据
    		if (xmlStr.indexOf("SUCCESS") == -1) {
                weChatPayMap.put("message",CommonText.UNIFIEDORDER_ERR+":"+map + ",paraMap:"+paraMap +",return_msg" + map.get("return_msg") +",err_code_des" + map.get("err_code_des"));
    //			b.setDefultFailInfo();
    //			b.setMessage(CommonText.UNIFIEDORDER_ERR+":"+map + ",paraMap:"+paraMap +",return_msg" + map.get("return_msg") +",err_code_des" + map.get("err_code_des"));
    //
    		return weChatPayMap;
    		}
    
    		//返回前台参数
    		Map<String,String> payMap = new HashMap<>();
    		String prepay_id = MapUtils.getString(map, "prepay_id");
    		if (StringUtils.isBlank(prepay_id)) {
                weChatPayMap.put("message",CommonText.UNIFIEDORDER_ERR_PREPAY_ID_NOT_FIND + "," + map.get("err_code_des"));
    
    //			b.setDefultFailInfo();
    //			b.setMessage(CommonText.UNIFIEDORDER_ERR_PREPAY_ID_NOT_FIND + "," + map.get("err_code_des"));
    			return weChatPayMap;
    		}
            weChatPayMap.put("appId", wechat_appid);
            weChatPayMap.put("timeStamp", WXPayUtil.getCurrentTimestamp()+"");
            weChatPayMap.put("nonceStr", WXPayUtil.generateNonceStr());
            weChatPayMap.put("signType", "MD5");
            weChatPayMap.put("package", "prepay_id=" + prepay_id);
    
    		String paySign = WXPayUtil.generateSignature(weChatPayMap, wechat_seckey);
            weChatPayMap.put("paySign", paySign);
            weChatPayMap.put("out_trade_no", out_trade_no);
            weChatPayMap.put("paycode", "200");
    //		b.put("data",payMap);
    
    		return weChatPayMap;
    	}
    
        /**
         * NATIVE 下单
         * @Title: unifiedorderJSAPI
         * @param paraMap
         * @param wechat_seckey
         * @return
         * @author: voayc
         * @date:  2020年3月17日 上午10:00:49
         */
        public static BasicResponse unifiedorderNATIVE(Map<String, String> paraMap,String wechat_appid, String wechat_seckey,String out_trade_no) throws Exception {
        	BasicResponse b = new BasicResponse<>();
        	//生成签名, 统一下单
        	String sign = WXPayUtil.generateSignature(paraMap, wechat_seckey);
        	paraMap.put("sign", sign);
        	String xml = WXPayUtil.mapToXml(paraMap);//将所有参数(map)转xml格式
        	String xmlStr = HttpUtils.sendPost(WeChatConstants.UNIFIEDORDER_URL, xml);//发送post请求"统一下单接口"返回预支付id:prepay_id
        	Map<String, String> map = WXPayUtil.xmlToMap(xmlStr);
    
        	//以下内容是返回前端页面的json数据
    		if (xmlStr.indexOf("SUCCESS") == -1) {
    			b.setDefultFailInfo();
    			b.setMessage(CommonText.UNIFIEDORDER_ERR+":"+map + ",paraMap:"+paraMap +",return_msg" + map.get("return_msg"));
    			return b;
    		}
    
    		//将未支付状态 放入redis缓存, 用于前端循环查询, 扫码支付是否成功
    		//RedisClientUtils.save(SystemConstant.WECHAT_PAY_NATIVE_STATE+out_trade_no, "0",SystemConstant.WECHAT_PAY_NATIVE_STATE_EXPIRE);
    
    		Map<String,String> resultMap = new HashMap<>();
    		resultMap.put("code_url", MapUtils.getString(map, "code_url"));
    		resultMap.put("out_trade_no", out_trade_no);
        	b.setObject(resultMap);
        	b.setMessage(map.get("err_code_des"));
    
        	return b;
        }
    
        /**
    	 * 微信退款
    	 * @Title: wxRefund
    	 * @param wechat_appid  	公众号/小程序  appid
    	 * @param wechat_mchid		微信支付商户号
    	 * @param wechat_seckey		微信支付商户号
    	 * @param wechat_pay_cert	微信支付商户号证书路径
    	 * @param out_trade_no		订单编码
    	 * @param service_code		售后编码
    	 * @param total_price		订单总金额
    	 * @param refund_fee 		退款金额
    	 * @author: voayc
    	 * @throws Exception
    	 * @date:  2020年4月18日 下午4:53:58
    	 */
    	public static BasicResponse wxRefund(String wechat_appid, String wechat_mchid, String wechat_seckey, String wechat_pay_cert, String out_trade_no, String service_code, BigDecimal total_price, BigDecimal refund_fee) throws Exception {
    		BasicResponse b = new BasicResponse();
    		//拼接 退款 参数
    		Map<String, String> paraMap = new HashMap<String, String>();
    		paraMap.put("appid", wechat_appid);
    		paraMap.put("mch_id", wechat_mchid);
    		paraMap.put("nonce_str", UUIDUtils.getUUID36());
    		paraMap.put("out_trade_no", out_trade_no);//订单号
    		paraMap.put("out_refund_no", service_code);//商户退款单号, 必须为不同, 相同的话, 只会退一笔
    		paraMap.put("total_fee",total_price.multiply(new BigDecimal("100")).setScale(0).toString());//单位为分
    		paraMap.put("refund_fee",refund_fee.multiply(new BigDecimal("100")).setScale(0).toString());//单位为分
    		String sign = WXPayUtil.generateSignature(paraMap, wechat_seckey);
    		paraMap.put("sign", sign);
    		String xml = WXPayUtil.mapToXml(paraMap);//将所有参数(map)转xml格式
    
    		//退款
    		String xmlStr = HttpUtils.requestWithCert(WeChatConstants.REFUND_URL,(WeChatConstants.PAY_CERT_LOC+wechat_pay_cert),wechat_mchid, xml);
    		Map<String, String> map = WXPayUtil.xmlToMap(xmlStr);
    		if (xmlStr.indexOf("SUCCESS") == -1) {
    			b.setDefultFailInfo();
    			b.setMessage(CommonText.UNIFIEDORDER_ERR+":"+map + ",paraMap:"+paraMap +",return_msg" + map.get("return_msg"));
    			return b;
    		}
    		return b;
    	}
    
    	/**
    	 * 微信提现
    	 * @Title: wxTransfers
    	 * @param wechat_appid  	公众号/小程序  appid
    	 * @param wechat_mchid		微信支付商户号
    	 * @param wechat_seckey		微信支付商户号
    	 * @param wechat_pay_cert	微信支付商户号证书路径
    	 * @param out_trade_no		订单编码
    	 * @param openid			openid
    	 * @param transfers_price	提现金额
    	 * @author: voayc
    	 * @throws Exception
    	 * @date:  2020年4月18日 下午4:53:58
    	 */
    	public static BasicResponse wxTransfers(String wechat_appid, String wechat_mchid, String wechat_seckey, String wechat_pay_cert, String out_trade_no, String openid, BigDecimal transfers_price) throws Exception {
    		BasicResponse b = new BasicResponse();
    		//拼接 退款 参数
    		Map<String, String> paraMap = new HashMap<String, String>();
    		paraMap.put("mch_appid", wechat_appid);
    		paraMap.put("mchid", wechat_mchid);
    		paraMap.put("nonce_str", UUIDUtils.getUUID36());
    		paraMap.put("partner_trade_no", out_trade_no);//订单号
    		paraMap.put("openid", openid);//退款会员id
    		paraMap.put("check_name", "NO_CHECK");//NO_CHECK：不校验真实姓名
    		paraMap.put("desc", "提现");//企业付款备注，必填
    		paraMap.put("amount",transfers_price.multiply(new BigDecimal("100")).setScale(0).toString());//单位为分
    		String sign = WXPayUtil.generateSignature(paraMap, wechat_seckey);
    		paraMap.put("sign", sign);
    		String xml = WXPayUtil.mapToXml(paraMap);//将所有参数(map)转xml格式
    
    		//提现
    		String xmlStr = HttpUtils.requestWithCert(WeChatConstants.TRANSFERS_URL,(WeChatConstants.PAY_CERT_LOC+wechat_pay_cert),wechat_mchid, xml);
    
    		Map<String, String> map = WXPayUtil.xmlToMap(xmlStr);
    		String return_code = MapUtils.getString(map, "return_code");
    		String result_code = MapUtils.getString(map, "result_code");
    		if ( !(StringUtils.equals("SUCCESS", return_code) && StringUtils.equals("SUCCESS", result_code)) ) {
    			b.setDefultFailInfo();
    			b.setMessage(CommonText.UNIFIEDORDER_ERR+":"+map + ",paraMap:"+paraMap +",return_msg" + map.get("return_msg"));
    			return b;
    		}
    		return b;
    	}
    
    	 /**
         * 订单支付状态查询
         * @param wechat_appid
         * @param wechat_mchid
         * @param wechat_seckey
         * @param out_trade_no
         * @return
         * @throws Exception
         */
        public static Map<String, String> orderquery(String wechat_appid, String wechat_mchid, String wechat_seckey, String out_trade_no) throws Exception {
        	//拼接 参数
    		Map<String, String> paraMap = new HashMap<String, String>();
    		paraMap.put("appid", wechat_appid);
    		paraMap.put("mch_id", wechat_mchid);
    		paraMap.put("nonce_str", UUIDUtils.getUUID36());
    		paraMap.put("out_trade_no", out_trade_no);//订单号
        	String sign = WXPayUtil.generateSignature(paraMap, wechat_seckey);
        	paraMap.put("sign", sign);
        	String xml = WXPayUtil.mapToXml(paraMap);//将所有参数(map)转xml格式
        	String xmlStr = HttpUtils.sendPost(WeChatConstants.ORDERQUERY_URL, xml);//发送post请求"统一下单接口"返回预支付id:prepay_id
        	Map<String, String> map = WXPayUtil.xmlToMap(xmlStr);
        	return map;
        }
    
    	/**
         * XML格式字符串转换为Map
         *
         * @param strXML XML字符串
         * @return XML数据转换后的Map
         * @throws Exception
         */
        public static Map<String, String> xmlToMap(String strXML) throws Exception {
            try {
                Map<String, String> data = new HashMap<String, String>();
                DocumentBuilder documentBuilder = WXPayXmlUtil.newDocumentBuilder();
    //            InputStream stream = new ByteArrayInputStream(strXML.getBytes("UTF-8"));
                InputStream stream = new ByteArrayInputStream(strXML.getBytes("GBK"));
                Document doc = documentBuilder.parse(stream);
                doc.getDocumentElement().normalize();
                NodeList nodeList = doc.getDocumentElement().getChildNodes();
                for (int idx = 0; idx < nodeList.getLength(); ++idx) {
                    Node node = nodeList.item(idx);
                    if (node.getNodeType() == Node.ELEMENT_NODE) {
                        Element element = (Element) node;
                        data.put(element.getNodeName(), element.getTextContent());
                    }
                }
                try {
                    stream.close();
                } catch (Exception ex) {
                    // do nothing
                }
                return data;
            } catch (Exception ex) {
                throw ex;
            }
    
        }
    
    
        /**
         * 将Map转换为XML格式的字符串
         *
         * @param data Map类型数据
         * @return XML格式的字符串
         * @throws Exception
         */
        public static String mapToXml(Map<String, String> data) throws Exception {
            Document document = WXPayXmlUtil.newDocument();
            Element root = document.createElement("xml");
            document.appendChild(root);
            for (String key: data.keySet()) {
                String value = data.get(key);
                if (value == null) {
                    value = "";
                }
                value = value.trim();
                Element filed = document.createElement(key);
                filed.appendChild(document.createTextNode(value));
                root.appendChild(filed);
            }
            TransformerFactory tf = TransformerFactory.newInstance();
            Transformer transformer = tf.newTransformer();
            DOMSource source = new DOMSource(document);
            transformer.setOutputProperty(OutputKeys.ENCODING, "GBK");
    //        transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
            transformer.setOutputProperty(OutputKeys.INDENT, "yes");
            StringWriter writer = new StringWriter();
            StreamResult result = new StreamResult(writer);
            transformer.transform(source, result);
            String output = writer.getBuffer().toString(); //.replaceAll("\n|\r", "");
            try {
                writer.close();
            }
            catch (Exception ex) {
            }
            return output;
        }
    
    
        /**
         * 生成带有 sign 的 XML 格式字符串
         *
         * @param data Map类型数据
         * @param key API密钥
         * @return 含有sign字段的XML
         */
        public static String generateSignedXml(final Map<String, String> data, String key) throws Exception {
            return generateSignedXml(data, key, WeChatConstants.SignType.MD5);
        }
    
        /**
         * 生成带有 sign 的 XML 格式字符串
         *
         * @param data Map类型数据
         * @param key API密钥
         * @param signType 签名类型
         * @return 含有sign字段的XML
         */
        public static String generateSignedXml(final Map<String, String> data, String key, WeChatConstants.SignType signType) throws Exception {
            String sign = generateSignature(data, key, signType);
            data.put(WeChatConstants.FIELD_SIGN, sign);
            return mapToXml(data);
        }
    
    
        /**
         * 判断签名是否正确
         *
         * @param xmlStr XML格式数据
         * @param key API密钥
         * @return 签名是否正确
         * @throws Exception
         */
        public static boolean isSignatureValid(String xmlStr, String key) throws Exception {
            Map<String, String> data = xmlToMap(xmlStr);
            if (!data.containsKey(WeChatConstants.FIELD_SIGN) ) {
                return false;
            }
            String sign = data.get(WeChatConstants.FIELD_SIGN);
            return generateSignature(data, key).equals(sign);
        }
    
        /**
         * 判断签名是否正确，必须包含sign字段，否则返回false。使用MD5签名。
         *
         * @param data Map类型数据
         * @param key API密钥
         * @return 签名是否正确
         * @throws Exception
         */
        public static boolean isSignatureValid(Map<String, String> data, String key) throws Exception {
            return isSignatureValid(data, key, WeChatConstants.SignType.MD5);
        }
    
        /**
         * 判断签名是否正确，必须包含sign字段，否则返回false。
         *
         * @param data Map类型数据
         * @param key API密钥
         * @param signType 签名方式
         * @return 签名是否正确
         * @throws Exception
         */
        public static boolean isSignatureValid(Map<String, String> data, String key, WeChatConstants.SignType signType) throws Exception {
            if (!data.containsKey(WeChatConstants.FIELD_SIGN) ) {
                return false;
            }
            String sign = data.get(WeChatConstants.FIELD_SIGN);
            return generateSignature(data, key, signType).equals(sign);
        }
    
        /**
         * 生成签名
         *
         * @param data 待签名数据
         * @param key API密钥
         * @return 签名
         */
        public static String generateSignature(final Map<String, String> data, String key) throws Exception {
            return generateSignature(data, key, WeChatConstants.SignType.MD5);
        }
    
        /**
         * 生成签名. 注意，若含有sign_type字段，必须和signType参数保持一致。
         *
         * @param data 待签名数据
         * @param key API密钥
         * @param signType 签名方式
         * @return 签名
         */
        public static String generateSignature(final Map<String, String> data, String key, WeChatConstants.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(WeChatConstants.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 (WeChatConstants.SignType.MD5.equals(signType)) {
    //            return Md5Utils.hash(sb.toString());
                return MD5(sb.toString()).toUpperCase();
            }
            else if (WeChatConstants.SignType.HMACSHA256.equals(signType)) {
                return HMACSHA256(sb.toString(), key);
            }
            else {
                throw new Exception(String.format("Invalid sign_type: %s", signType));
            }
        }
    
    
        /**
         * 获取随机字符串 Nonce Str
         *
         * @return String 随机字符串
         */
        public static String generateNonceStr() {
            char[] nonceChars = new char[32];
            for (int index = 0; index < nonceChars.length; ++index) {
                nonceChars[index] = SYMBOLS.charAt(RANDOM.nextInt(SYMBOLS.length()));
            }
            return new String(nonceChars);
        }
    
    
        /**
         * 生成 MD5
         *
         * @param data 待处理数据
         * @return MD5结果
         */
        public static String MD5(String data) throws Exception {
            MessageDigest md = MessageDigest.getInstance("MD5");
            byte[] array = md.digest(data.getBytes("UTF-8"));
            StringBuilder sb = new StringBuilder();
            for (byte item : array) {
                sb.append(Integer.toHexString((item & 0xFF) | 0x100).substring(1, 3));
            }
            return sb.toString().toUpperCase();
        }
    
        /**
         * 生成 HMACSHA256
         * @param data 待处理数据
         * @param key 密钥
         * @return 加密结果
         * @throws Exception
         */
        public static String HMACSHA256(String data, String key) throws Exception {
            Mac sha256_HMAC = Mac.getInstance("HmacSHA256");
            SecretKeySpec secret_key = new SecretKeySpec(key.getBytes("UTF-8"), "HmacSHA256");
            sha256_HMAC.init(secret_key);
            byte[] array = sha256_HMAC.doFinal(data.getBytes("UTF-8"));
            StringBuilder sb = new StringBuilder();
            for (byte item : array) {
                sb.append(Integer.toHexString((item & 0xFF) | 0x100).substring(1, 3));
            }
            return sb.toString().toUpperCase();
        }
    
        /**
         * 获取当前时间戳，单位秒
         * @return
         */
        public static long getCurrentTimestamp() {
            return System.currentTimeMillis()/1000;
        }
    
    }

##### 4、WXPayXmlUtil #####

package com.ruoyi.garden.controller.wxpay.dto;
    
    import org.w3c.dom.Document;
    
    import javax.xml.XMLConstants;
    import javax.xml.parsers.DocumentBuilder;
    import javax.xml.parsers.DocumentBuilderFactory;
    import javax.xml.parsers.ParserConfigurationException;
    
    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();
        }
    }

##### 5、MyX509TrustManager #####

package com.ruoyi.garden.controller.wxpay.dto;
    
    import javax.net.ssl.X509TrustManager;
    import java.security.cert.CertificateException;
    import java.security.cert.X509Certificate;
    
    /**
     * 对于https请求，我们需要一个证书信任管理器，这个管理器类需要自己定义，但需要实现X509TrustManager接口
     * 证书信任管理器（用于https请求）
     * 这个证书管理器的作用就是让它信任我们指定的证书，上面的代码意味着信任所有证书，不管是否权威机构颁发。
     *
     * @author jiangyin
     */
    public class MyX509TrustManager implements X509TrustManager {
    
        public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {
        }
    
        public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {
        }
    
        public X509Certificate[] getAcceptedIssuers() {
            return null;
        }
    }

##### 6、BasicResponse #####

import org.apache.commons.lang3.StringUtils;
    
    import java.io.Serializable;
    import java.text.SimpleDateFormat;
    import java.util.Date;
    import java.util.HashMap;
    
    
    /**
     * 功能描述：基础交互对象
    */
    public class BasicResponse<T> implements Serializable{
    
    
    		/**  描述   (@author: yangxg) */
    
    	private static final long serialVersionUID = 1L;
    
    	private static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    
    	private boolean success = true;
    
    	private T object;
    
    	private String message = "";
    
    	private String code = "200";
    
    	private String remark = "";
    
    	private String time;//服务器返回时间
    
    	private String addition = "";//附加信息
    
    	//系统状态码
    	public static final String STATUS_CODE_FAIL_300 = "300";//token失效
    	public static final String STATUS_CODE_FAIL_301 = "301";//未上传sys_amdin_id
    	public static final String STATUS_CODE_FAIL_400 = "400";//错误请求，如语法错误
    	public static final String STATUS_CODE_FAIL_401 = "401";//未登录
    	public static final String STATUS_CODE_FAIL_404 = "404";//没有发现文件、查询或URl
    	public static final String STATUS_CODE_FAIL_500 = "500";//服务器产生内部错误
    	public static final String STATUS_CODE_FAIL_501 = "501";//服务器不支持请求的函数
    
    	public static final String SUCCESS = "success";
    
    	public static final String MESSAGE = "message";
    
    	public static final String REMARK = "remark";
    
    	public static final String ADDITION = "addition";
    
    	public static final String TIME = "time";
    
    	public static final String CODE = "code";
    
    	@SuppressWarnings("unchecked")
    	public BasicResponse() {
    		this.success = true;
    		this.object = (T)new HashMap<String,Object>();
    		this.time = sdf.format(new Date());
    	}
    
    	public boolean isSuccess() {
    		return success;
    	}
    
    	public void setSuccess(boolean success) {
    		this.success = success;
    	}
    
    	public T getObject() {
    		return object;
    	}
    
    	public BasicResponse setObject(T object) {
    		this.object = object;
    		return this;
    	}
    
    	public String getMessage() {
    		return message;
    	}
    
    	public BasicResponse setMessage(String message) {
    		this.message = message;
    		return this;
    	}
    
    	public String getCode() {
    		return code;
    	}
    
    	public void setCode(String code) {
    		this.code = code;
    	}
    
    	public void setDefultSuccesInfo() {
    		this.message = "OPT SUCCESS！";
    		this.code = "200";
    		this.success = true;
    	}
    	public BasicResponse setDefultFailInfo() {
    		return this.setDefultFailInfo(StringUtils.EMPTY);
    	}
    	public BasicResponse setDefultFailInfo(String msg) {
    		this.message = StringUtils.isBlank(msg)?"OPT FAILED！" : msg;
    		this.code = BasicResponse.STATUS_CODE_FAIL_400;
    		this.success = false;
    		return this;
    	}
    	public void setFailInfo501() {
    		this.message = "user not exist！";
    		this.code = BasicResponse.STATUS_CODE_FAIL_501;
    		this.success = false;
    	}
    	public void SETUseNotlogin() {
    		this.message = "user not login！";
    		this.code = BasicResponse.STATUS_CODE_FAIL_401;
    		this.success = false;
    	}
    
    	public String getRemark() {
    		return remark;
    	}
    
    	public void setRemark(String remark) {
    		this.remark = remark;
    	}
    
    	@SuppressWarnings("unchecked")
    	public void setDefultObject() {
    		this.object = (T) new HashMap<String,Object>();
    	}
    
    	public String getAddition() {
    		return addition;
    	}
    
    	public void setAddition(String addition) {
    		this.addition = addition;
    	}
    
    	@Override
    	public String toString() {
    		return "BasicResponse [success=" + success + ", object=" + object
    				+ ", message=" + message + ", code=" + code + ", remark="
    				+ remark + ", time=" + time + ", addition=" + addition + "]";
    	}
    
    	public static String getNowTime() {
    		String time = sdf.format(new Date());
    		return time;
    	}
    
    	public String getTime() {
    		return time;
    	}
    
    	public void setTime(String time) {
    		this.time = time;
    	}
    
    	public static BasicResponse  buildNew(){
    		return new BasicResponse();
    	}
    }

##### 7、CommonText #####

/**
     * 功能描述：系统提示 使用方法： create by voayc 
     */
    public class CommonText {
    
    	public static final String DATA_NOT_EXIST = "数据不存在";
    
    	/** 微信公众号*/
    	public static final String WECHAT_CONFIG_DOES_NOT_EXIST = "未配置公司微信公众号的相关信息";
    	public static final String WECHAT_PAY_CONFIG_DOES_NOT_EXIST = "未配置公司微信支付的相关信息";
    	public static final String OPENID_DOES_NOT_EXIST = "请上传微信用户openid";
    	public static final String WECHAT_TRADE_TYPE_DOES_NOT_EXIST = "请上传微信支付交易类型";
    	public static final String OPENID_ALREADY_BIND = "该微信号已被其他账号绑定！";
    	public static final String ADMIN_OPENID_DOES_NOT_EXIST = "请上传管理员openid";
    	public static final String OPENID_DOES_NOT_FIND = "未获取到对应微信用户openid";
    	public static final String WECHAT_CODE_DOES_NOT_EXIST = "请上传微信用户code";
    	public static final String WECHAT_USER_TOKEN_DOES_ERR = "获取微信用户token失败";
    	public static final String UNIFIEDORDER_ERR = "统一下单失败";
    	public static final String UNIFIEDORDER_ERR_PREPAY_ID_NOT_FIND = "统一下单失败,未生成PREPAY_ID";
    
    	/** 微信小程序*/
    	public static final String MINI_OPENID_DOES_NOT_EXIST = "请上传小程序用户openid";
    	public static final String WECHAT_MINI_CONFIG_DOES_NOT_EXIST = "未配置公司微信小程序的相关信息";
    	public static final String WECHAT_MINI_PARAM_NOT_EXIST = "缺少所需小程序参数!";
    	public static final String WECHAT_MINI_IV_NOT_EXIST = "请上传iv参数";
    	public static final String WECHAT_MINI_SESSION_KEY_DOES_NOT_EXIST = "请上传session_key参数";
    	public static final String WECHAT_MINI_ENCRYPTED_DATA_DOES_NOT_EXIST = "请上传encrypted_data参数";
    	public static final String WECHAT_MINI_ENCRYPTED_DATA_PARSE_ERR = "encrypted_data解析失败";
    	public static final String WECHAT_MINI_ENCRYPTED_DATA_NOT_HAVE_PHONE_NUM = "encrypted_data中未解析出电话号码";
    
    	/** 支付相关 */
    	public static final String ORDER_PAY_TYPE_NOT_EXIST = "请上传支付方式！";
    
    }

##### 8、UUIDUtils #####

import java.util.UUID;
    
    /**
     * 功能描述：uuid工具类
     * 使用方法：
    */
    public class UUIDUtils {
    
    	/**
    	 * 功能描述：获取uuid不带"-"
    	 * 使用方法：
    	 * 使用约束：
    	 * 逻辑：
    	 * @return
    	 * create voayc 2017年9月4日 下午6:34:44
    	*/
    	public static String getUUID36() {
    		return UUID.randomUUID().toString().replace("-", "");
    	}
    
    	/**
    	 * 功能描述：获取原始uuid
    	 * 使用方法：
    	 * 使用约束：
    	 * 逻辑：
    	 * @return
    	 * create voayc 2017年9月4日 下午6:34:34
    	*/
    	public static String getUUID36OLD() {
    		return UUID.randomUUID().toString();
    	}
    
    }

[https_pay.weixin.qq.com_wiki_doc_api_jsapi.php_chapter_7_1]: https://pay.weixin.qq.com/wiki/doc/api/jsapi.php?chapter=7_1
[564e847ae9f3452c81da58f7b2b6fe13.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/77397e3517704e249d5238a4f937f62c.png
[3743814f0e3449d98340e253be5c8c66.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/10c7648484df47d8a8018cebda9c5efe.png
[27998c0ffe59458aa46cbd56f28f4525.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/85d2a390ce9d4b8993e0051cef3acf24.png
[48692ea4df4642eeb0af79585652ed01.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/01e8992a768544c0b444e45ca466390f.png
[API]: https://pay.weixin.qq.com/wiki/doc/api/jsapi.php?chapter=9_1
[JSAPI_API]: https://pay.weixin.qq.com/wiki/doc/api/jsapi.php?chapter=7_7&index=6
[API 1]: https://pay.weixin.qq.com/wiki/doc/api/jsapi.php?chapter=9_7
[API 2]: https://pay.weixin.qq.com/wiki/doc/api/jsapi.php?chapter=9_2
[Link 1]: https://pay.weixin.qq.com/wiki/doc/api/jsapi.php?chapter=23_9&index=1