微信支付：Native 模式 + 二维码生成技术！+ XML＜＞ Map转换

短命女 2022-11-12 02:59 916阅读 0赞

# 微信支付 `环境准备` #

# 二维码创建： #

*  微信支付，扫码支付 **首先前提是要有码！**
 *  可以利用 **qrious二维码插件** 生成一个简单的 `二维码`

## qrious ##

*  qrious是一款基于HTML5 Canvas的纯JS二维码生成插件。
 *  通过qrious.js可以快速生成各种二维码。  
    你可以控制二维码的尺寸颜色，还可以将生成的二维码进行Base64编码。

**本章掌握基本属性，使用了解即可！** `qrious.js二维码插件的可用配置参数如下`

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NTQyMzgw_size_16_color_FFFFFF_t_70]

## 实例 ##

**下面的代码即可生成一张二维码**  
`pay.html`

<html>
    <head>
    <title>二维码入门小demo</title>
    
    <script src="qrious.js"> </script>
    </head>
    <body>
    
    	<img id="myqrious" >
    
    </body>
    	<script> var qrious = new QRious({ element:document.getElementById("myqrious"),// 指定的是图片所在的DOM对象 size:250, //指定图片的像素大小 level:'H', //指定二维码的容错级别(H:可以恢复30%的数据) value:'https://blog.csdn.net/qq_45542380?spm=1011.2124.3001.5343' //指定二维码图片代表的真正的值,这里我设置了我的blog地址... }) </script>
    </html>

## 测试： ##

**微信扫码跳转页面！** `看到这儿点个赞吧~！！`  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NTQyMzgw_size_16_color_FFFFFF_t_70 1]

## **`注意`** ##

*  别忘了要，引入依赖，`可以自己下载或者私聊...`
 *  value 不一定非得是连接, 变量值也可以接受！或一个图片地址…搞怪;
 *  **总之还不错后面应该可以恶搞一下！**

--------------------

# Ngrok 内网穿透： #

*  **和上面相比这个更牛~** 因为微信，需要我们给其提供一个**回调接口执行：**  
    `支付成功之后，微信服务器会　回调这个api接口，而对本机的项目来说，本地的api方法只有自己可以访问，无法直接通过外网访问！`
 *  这就不好了，但通过 **Ngrok** 可以直接将本机，定义为一个服务器，对外网暴漏接口！ip 端口 给微信进行回调！
 *  **话不多说，搞起来看效果！**

## Ngrok ##

*  ngrok 是一个反向代理，通过在公共的端点和本地运行的 Web 服务器之间建立一个安全的通道。
 *  ngrok 可捕获和分析所有通道上的流量，便于后期分析和重放.

**简单来说就是：**

*  在PC上完美运行，想在手机端访问，只能让手机电脑处于同一局域网内
 *  但是这个技术可以把你的本地IP和端口（例如：localhost:8080）转换为www.baidu.com一样的万网
 *  这样，即使电脑与手机不是在同一局域网内也可以无缝访问，（厉害吧！）。

## 干！ ##

**Ngrok 官网：** [https://www.ngrok.cc/user.html][https_www.ngrok.cc_user.html]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NTQyMzgw_size_16_color_FFFFFF_t_70 2]

*  **登录注册一个之后，可以进入主页了！**
 *  直接开门见山，买一个免费的的服务器！设置ok之后，**绑定映射你的本地端口！`确认/添加 | 开通！`** 恭喜你有了一个自己的服务器了！  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NTQyMzgw_size_16_color_FFFFFF_t_70 3]
 *  **查看 `隧道管理:` 发现它默认生成了一个你的，`域名`**
 *  **下载一个 Ngrok 启动客户端，启动就可以通过这个域名来访问到你本机的服务了！`有点意思！`**

## 下载 Ngrok 客户端 + 启动： ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NTQyMzgw_size_16_color_FFFFFF_t_70 4]

*  双击启动程序 `Sunny-Ngrok启动工具.bat`
 *  按照要求，输入对应的开启隧道的 id… 就可以看到右图信息就是开头成功了！
 *  这个时候在访问直接访问，`http://wsm.free.idcfengye.com` **就等于访问你本机的 127.0.0.1:7008 的端口了**

## 测试： ##

*  **修改映射的端口！`7007`** 并启动微服！  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NTQyMzgw_size_16_color_FFFFFF_t_70 5]
 *  手机访问：`http://wsm.free.idcfengye.com/items/10000000616300.html` 效果一样！**重点不在一个局域网！！！**
 *  太强了！直接找一个不用的电脑，运行一个微服工程，暴漏网关！**基本等于一个: `永久服务器好吧！`**
 *  爱了爱了！

--------------------

# **微信支付** `Native模式` #

*  **我想不用解释了吧,** 就是付钱的！
 *  可以说是当前，比较流行和方便的一个技术，出门玩一个手机搞定一切！`太发达了！`
 *  **下面就让我们深入了解一下微信的支付的开发流程…**

## 支付流程分析 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NTQyMzgw_size_16_color_FFFFFF_t_70 6]

*  1.用户下单后`订单数据会存入到数据库中...` **且** 进入支付页面
 *  2.支付页面调用支付系统，从微信支付获取二维码数据 **并在页面生成支付二维码。**
 *  3.用户扫码支付后，微信支付服务器会调用`预留的回调地址`，**并携带支付状态信息**
 *  4.支付系统接到支付状态信息后，将支付状态信息发送给**RabbitMQ`消息队列`**  
    因为支付是一个 高并发且非常重要的操作！  
    为了提高程序的性能和安全，不可能在支付方面做限流！`哪有地方不想要钱的！`  
    对于高并发的，订单采用消息队列进行存储… 信息，有序缓慢逐一进行数据更新！
 *  5.订单系统监听RabbitMQ中的消息获取支付状态，并根据支付状态修改订单状态
 *  6.为了防止网络问题导致notifyurl没有接到对应数据，延迟队列，定时更新对应状态  
    支付成功后， `微信24小时，时间递增不停向商家进行响应` **支付状态，直到商家接收并执行响应`才会停止！`**

## 微信扫码支付简介 ##

**官方文档：** [ https://pay.weixin.qq.com/wiki/doc/api/index.html][https_pay.weixin.qq.com_wiki_doc_api_index.html]

*  **Native支付**  
    Native支付是指商户系统按微信支付协议生成支付二维码，
 *  用户再用微信“扫一扫”完成支付的模式。该模式适用于PC网站、实体店单品或订单、媒体广告支付等场景。  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NTQyMzgw_size_16_color_FFFFFF_t_70 7]

### 微信扫码支付申请 ###

*  **第一步：注册公众号（类型须为：服务号）**  
    请根据营业执照类型选择以下主体注册：个体工商户| 企业/公司| 政府| 媒体| 其他类型。
 *  **第二步：认证公众号**  
    公众号认证后才可申请微信支付，认证费：300元/次。
 *  **第三步：提交资料申请微信支付**  
    登录公众平台，点击左侧菜单【微信支付】，开始填写资料等待审核，审核时间为1-5个工作日内。
 *  **第四步：开户成功，登录商户平台进行验证**  
    资料审核通过后，请登录联系人邮箱查收商户号和密码，并登录商户平台填写财付通备付金打的小额资金数额，完成账户验证。
 *  **第五步：在线签署协议**
 *  **以上完成开始开发！！** `这里就自己使用自己的` **`微信商户了...`**

## 微信支付模式介绍 ##

*  **微信支付用户：** 扫码付钱的人
 *  **微信客户端：** 手机上的微信，可以扫码的
 *  **商户后端：** 支付的商家公众号！
 *  **微信支付系统：** 微信的支付后端服务器

### 模式 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NTQyMzgw_size_16_color_FFFFFF_t_70 8]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NTQyMzgw_size_16_color_FFFFFF_t_70 9]

# 微信支付: Demo开发 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NTQyMzgw_size_16_color_FFFFFF_t_70 10]

## 依赖组件： ##

**微信支付提供了SDK** `或直接使用Maven 依赖`

**微信支付SDK的以下功能：**

*  **获取随机字符串** `WXPayUtil.generateNonceStr()`
 *  **MAP转换为XML字符串（自动添加签名）** `WXPayUtil.generateSignedXml(param, partnerkey)`
 *  **XML字符串转换为MAP** `WXPayUtil.xmlToMap(result)`

**微信认证，之间通信api 参数：**

*  `以XML方式发送（POST）给微信支付接口（URL）,微信支付接口也是以XML方式给予响应。`
 *  程序根据返回的结果（其中包括支付URL）生成二维码或判断订单状态。  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NTQyMzgw_size_16_color_FFFFFF_t_70 11]

**HttpClient**

*  HttpClient是Apache Jakarta Common下的子项  
    用来提供高效的、最新的、功能丰富的支持HTTP协议的客户端编程工具包 `它支持HTTP协议最新的版本和建议`
 *  **HttpClient通俗的讲就是模拟了浏览器的行为**  
    如果我们需要在后端向某一地址提交数据获取结果，就可以使用HttpClient

### pom.xml ###

<dependency>
        <groupId>com.github.wxpay</groupId>
        <artifactId>wxpay-sdk</artifactId>
        <version>0.0.3</version>
    </dependency>
    
    <dependency>
        <groupId>org.apache.httpcomponents</groupId>
        <artifactId>httpclient</artifactId>
    </dependency>

## HttpClient工具类代码 ##

**上图并没有展示，因为通过，Maven父工程集成了！** `一般建立在 util包下！`  
`HttpClient.Java`

package com.zb.util;
    
    import org.apache.http.Consts;
    import org.apache.http.HttpEntity;
    import org.apache.http.NameValuePair;
    import org.apache.http.ParseException;
    import org.apache.http.client.ClientProtocolException;
    import org.apache.http.client.entity.UrlEncodedFormEntity;
    import org.apache.http.client.methods.*;
    import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
    import org.apache.http.conn.ssl.TrustStrategy;
    import org.apache.http.entity.StringEntity;
    import org.apache.http.impl.client.CloseableHttpClient;
    import org.apache.http.impl.client.HttpClients;
    import org.apache.http.message.BasicNameValuePair;
    import org.apache.http.ssl.SSLContextBuilder;
    import org.apache.http.util.EntityUtils;
    
    import javax.net.ssl.SSLContext;
    import java.io.IOException;
    import java.security.cert.CertificateException;
    import java.security.cert.X509Certificate;
    import java.util.HashMap;
    import java.util.LinkedList;
    import java.util.List;
    import java.util.Map;
    
    public class HttpClient { 
        private String url;
        private Map<String, String> param;
        private int statusCode;
        private String content;
        private String xmlParam;
        private boolean isHttps;
    
        public boolean isHttps() { 
            return isHttps;
        }
    
        public void setHttps(boolean isHttps) { 
            this.isHttps = isHttps;
        }
    
        public String getXmlParam() { 
            return xmlParam;
        }
    
        public void setXmlParam(String xmlParam) { 
            this.xmlParam = xmlParam;
        }
    
        public HttpClient(String url, Map<String, String> param) { 
            this.url = url;
            this.param = param;
        }
    
        public HttpClient(String url) { 
            this.url = url;
        }
    
        public void setParameter(Map<String, String> map) { 
            param = map;
        }
    
        public void addParameter(String key, String value) { 
            if (param == null)
                param = new HashMap<String, String>();
            param.put(key, value);
        }
    
        public void post() throws ClientProtocolException, IOException { 
            HttpPost http = new HttpPost(url);
            setEntity(http);
            execute(http);
        }
    
        public void put() throws ClientProtocolException, IOException { 
            HttpPut http = new HttpPut(url);
            setEntity(http);
            execute(http);
        }
    
        public void get() throws ClientProtocolException, IOException { 
            if (param != null) { 
                StringBuilder url = new StringBuilder(this.url);
                boolean isFirst = true;
                for (String key : param.keySet()) { 
                    if (isFirst) { 
                        url.append("?");
                    }else { 
                        url.append("&");
                    }
                    url.append(key).append("=").append(param.get(key));
                }
                this.url = url.toString();
            }
            HttpGet http = new HttpGet(url);
            execute(http);
        }
    
        /** * set http post,put param */
        private void setEntity(HttpEntityEnclosingRequestBase http) { 
            if (param != null) { 
                List<NameValuePair> nvps = new LinkedList<NameValuePair>();
                for (String key : param.keySet()) { 
                    nvps.add(new BasicNameValuePair(key, param.get(key))); // 参数
                }
                http.setEntity(new UrlEncodedFormEntity(nvps, Consts.UTF_8)); // 设置参数
            }
            if (xmlParam != null) { 
                http.setEntity(new StringEntity(xmlParam, Consts.UTF_8));
            }
        }
    
        private void execute(HttpUriRequest http) throws ClientProtocolException,
                IOException { 
            CloseableHttpClient httpClient = null;
            try { 
                if (isHttps) { 
                    SSLContext sslContext = new SSLContextBuilder()
                            .loadTrustMaterial(null, new TrustStrategy() { 
                                // 信任所有
                                @Override
                                public boolean isTrusted(X509Certificate[] chain,
                                                         String authType)
                                        throws CertificateException { 
                                    return true;
                                }
                            }).build();
                    SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(
                            sslContext);
                    httpClient = HttpClients.custom().setSSLSocketFactory(sslsf)
                            .build();
                } else { 
                    httpClient = HttpClients.createDefault();
                }
                CloseableHttpResponse response = httpClient.execute(http);
                try { 
                    if (response != null) { 
                        if (response.getStatusLine() != null) { 
                            statusCode = response.getStatusLine().getStatusCode();
                        }
                        HttpEntity entity = response.getEntity();
                        // 响应内容
                        content = EntityUtils.toString(entity, Consts.UTF_8);
                    }
                } finally { 
                    response.close();
                }
            } catch (Exception e) { 
                e.printStackTrace();
            } finally { 
                httpClient.close();
            }
        }
    
        public int getStatusCode() { 
            return statusCode;
        }
    
        public String getContent() throws ParseException, IOException { 
            return content;
        }
    }

## .yml 配置： ##

`application.yml`

server:
      port: 7008
    spring:
      application:
        name: pay-server
      main:
        allow-bean-definition-overriding: true
    eureka:
      client:
        service-url:
          defaultZone: http://localhost:7001/eureka/
      instance:
        prefer-ip-address: true
        instance-id: ${ spring.cloud.client.ip-address}:${ server.port}
    feign:
      httpclient:
        connection-timeout: 10000
      client:
        config:
          default: # 指定feignclients对应的名称 如果指定的是default 表示全局所有的client 的超时时间设置
            connectTimeout: 10000
            readTimeout: 10000
            loggerLevel: basic
            
    #微信支付信息配置: 这里请填写自己的id....
    weixin:
      appid: wwwwwwwwwwwwwww		#商家微信公众账号或开放平台APP的唯一标识 这里是我随便写的...(实际开发用自己的即可)
      partner: 11473623 #商家财付通平台的商户账号
      partnerkey: 2ab9071b06b9f739b950ddb41db2690d		#商家财付通平台的商户密钥
      notifyurl: http://wsm.free.idcfengye.com/weixin/notifyurl	#回调地址后,微信服务器根据这个地址给 商户24小时的返回,支付的结果数据！

## 统一下单 ##

**调用微信api 输入：`唯一订单号` `订单金额` `回调函数` `商家参数...`**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NTQyMzgw_size_16_color_FFFFFF_t_70 12]

### 业务逻辑： ###

`PayService.Java`

@Service
    public class PayService { 
        //从yml 中读取对应的... yml配置属性！
        @Value("${weixin.appid}")
        private String appid;
        @Value("${weixin.partner}")
        private String partner;
        @Value("${weixin.partnerkey}")
        private String partnerkey;
        @Value("${weixin.notifyurl}")
        private String notifyurl;
    
        //唯一订单号 交易金额单位: 分
        public Map<String, String> pay(String out_trade_no, String total_fee) throws Exception { 
            //设置统一下单: 请求参数;
            Map<String, String> param = new HashMap<>();
            param.put("appid", appid);                              //应用ID
            param.put("mch_id", partner);                           //商户ID号
            param.put("nonce_str", WXPayUtil.generateNonceStr());   //随机数
            param.put("body", "My商场");                             //订单描述
            param.put("out_trade_no", out_trade_no);                //商户订单号: 这是唯一的,会在微信存储！
            param.put("total_fee", total_fee);                      //交易金额:
            param.put("spbill_create_ip", "127.0.0.1");             //终端IP
            param.put("notify_url", notifyurl);                     //回调地址: 是后面需要进行商户暴漏的回调接口！
            param.put("trade_type", "NATIVE");                      //交易类型,NATIVE
    
            String xml = WXPayUtil.generateSignedXml(param, partnerkey);    //将map 转换成 xml 并传入签名
            String url = "https://api.mch.weixin.qq.com/pay/unifiedorder";  //统一下单的: api!
            //获取HttpClient 请求对象！
            HttpClient httpClient = new HttpClient(url);
            //传入参数,执行请求post
            httpClient.setXmlParam(xml);
            httpClient.setHttps(true);
            httpClient.post();
    
            //获取返回结果！ 打印！
            String content = httpClient.getContent();
            System.out.println(content);
    
            //将返回xml 转换成Map 方便展示输出！
            Map<String, String> stringStringMap = WXPayUtil.xmlToMap(content);
            //输出: 订单号 金额 支付url(将这个绑定至上面的,二维码中扫码就可以,看到信息进行支付了！！)
            Map<String, String> result = new HashMap<>();
            result.put("out_trade_no", out_trade_no);
            result.put("total_fee", total_fee);
            result.put("code_url", stringStringMap.get("code_url"));
            //打印！
            System.out.println(stringStringMap.get("code_url"));
            return result;
        }
    }

### 控制器层： ###

**`回调函数`**

`PayController.Java`

@RestController
    @RequestMapping("/weixin")
    public class PayController { 
    
        @Autowired
        private PayService payService;
    
        @GetMapping("/pay")
        public Dto pay(String out_trade_no, String total_fee) throws Exception { 
            //调用:统一下单！
            Map<String, String> pay = payService.pay(out_trade_no, total_fee);
            return DtoUtil.returnSuccess("获取二维码成功！", pay);
        }
    
        //回调函数
        //必须得是post 的方式,这里查看yml: http://wsm.free.idcfengye.com/weixin/notifyurl /weixin/notifyurl 绑定的回调就是这个方法!
        @PostMapping("/notifyurl")
        public String notifyurl(HttpServletRequest request) { 
        	System.out.println("支付后回调---------------------------");
            InputStream is = null;
            ByteArrayOutputStream baos = null;
            try { 
                is = request.getInputStream();
                baos = new ByteArrayOutputStream();
                byte[] bytes = new byte[1024];
                int len = 0;
                while ((len = is.read(bytes)) != -1) { 
                    baos.write(bytes, 0, len);
                }
                String str = new String(baos.toByteArray(), "UTF-8");
                System.out.println(str);
    
                //响应数据,如果不写, 商户就不会接受微信的回调,微信就会24小时内频繁进行响应...
                Map respMap = new HashMap();
                respMap.put("return_code", "SUCCESS");
                respMap.put("return_msg", "OK");
                return WXPayUtil.mapToXml(respMap);
    
            //处理异常,最终关闭资源！
            } catch (Exception e) { 
                e.printStackTrace();
            } finally { 
                try { 
                    baos.close();
                    is.close();
                } catch (IOException e) { 
                    e.printStackTrace();
                }
            }
            return "";
        }
    }

*  **回调函数协助控制器中，主要是因为 `它不是商户服务调用的，是微信支付服务，在用户支付成功后，不停的调用的一个方法！`**
 *  只有不返回 null 或 24小时后，微信服务器才会停止调用：
 *  **当然它也不蠢一直调你，浪费资源：**  
    `支付结果通知回调频率调整为15s/15s/30s/3m/10m/20m/30m/30m/30m/60m/3h/3h/3h/6h/6h - 总计 24h4m`

### 主程序测试： ###

`MyPayApp.Java`

import com.zb.service.PayService;
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
    import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
    import org.springframework.context.ConfigurableApplicationContext;
    
    @SpringBootApplication(exclude = { DataSourceAutoConfiguration.class})   //父工程中存在,访问数据库依赖防止报错,禁用调！
    @EnableEurekaClient
    public class MyPayApp { 
        public static void main(String[] args) throws Exception { 
            ConfigurableApplicationContext context = SpringApplication.run(MyPayApp.class, args);
            PayService bean = context.getBean(PayService.class);
            System.out.println("模拟一个假订单1分钱！---------------------------");
            bean.pay("5400", "1");
        }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NTQyMzgw_size_16_color_FFFFFF_t_70 13]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NTQyMzgw_size_16_color_FFFFFF_t_70 14]  
**支付后 `回调！`**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NTQyMzgw_size_16_color_FFFFFF_t_70 15]

## 查询订单 ##

**结合文档学习：**

*  该接口提供所有微信支付订单的查询，商户可以通过查询订单接口主动查询订单状态，完成下一步的业务逻辑。  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NTQyMzgw_size_16_color_FFFFFF_t_70 16]

### 业务逻辑代码： + ###

`PayService.Java`

//查询订单: 参数: 要查询的订单号！
        public Map<String,String> queryStatus(String out_trade_no)throws Exception{ 
            //设置统一下单: 请求参数;
            Map<String, String> param = new HashMap<>();
            param.put("appid", appid);                              
            param.put("mch_id", partner);                           
            param.put("out_trade_no", out_trade_no);
            param.put("nonce_str", WXPayUtil.generateNonceStr());
            String xml = WXPayUtil.generateSignedXml(param, partnerkey);
            //统一下单的: api! 获取HttpClient 请求对象！传入参数,执行请求post
            String url = "https://api.mch.weixin.qq.com/pay/orderquery";
            HttpClient client =new HttpClient(url);
            client.setXmlParam(xml);
            client.setHttps(true);
            client.post();
    
            //获取返回结果！ 打印！
            String content = client.getContent();
            System.out.println(content);
            Map<String, String> stringStringMap = WXPayUtil.xmlToMap(content);
            Map<String, String> result = new HashMap<>();
            result.put("out_trade_no", out_trade_no);
            result.put("trade_state_desc",stringStringMap.get("trade_state_desc"));
            return result;
        }

### 主测试： ###

`MyPayApp.Java`

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NTQyMzgw_size_16_color_FFFFFF_t_70 17]

*  **ok. 这就欧克了, 当然还有很多操作，就不一一展示了！**

## 关闭订单 ##

*  **以下情况需要调用关单接口：**  
    商户订单支付失败需要生成新单号重新发起支付，要对原订单号调用关单，避免重复支付；系统下单后，用户支付超时，系统退出不再受理，避免用户继续，请调用关单接口。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NTQyMzgw_size_16_color_FFFFFF_t_70 18]

### 业务逻辑代码： + ###

`PayService.Java`

//关闭订单:
        public Map<String,String> stopStatus(String out_trade_no)throws Exception{ 
            Map<String, String> param = new HashMap<>();
            param.put("appid", appid);                              //应用ID
            param.put("mch_id", partner);
            param.put("out_trade_no", out_trade_no);
            param.put("nonce_str", WXPayUtil.generateNonceStr());
            String xml = WXPayUtil.generateSignedXml(param, partnerkey);
    
            String url = "https://api.mch.weixin.qq.com/pay/closeorder";
            HttpClient client =new HttpClient(url);
            client.setXmlParam(xml);
            client.setHttps(true);
            client.post();
            String content = client.getContent();
            System.out.println(content);
            Map<String, String> stringStringMap = WXPayUtil.xmlToMap(content);
            Map<String, String> result = new HashMap<>();
            result.put("out_trade_no", out_trade_no);
            result.put("trade_state_desc",stringStringMap.get("trade_state_desc"));
            return result;
        }

**牛皮**。。。。。。。

## 注意： ##

**这里设置的金额不要乱输入，这不是支付宝，还提供沙盒测试…这里的钱是，白花花的银子！！**

## 多类型订单微信支付处理… ##

### **前言** ###

*  ok, 目前为止，我们已经了解了微信支付的大致一个流程…
 *  **而，** 正常情况下， 一个项目的支付类型会有很多, `美团会员充值` `外卖下单` `电影票购买...`
 *  对于这么多种类型的订单，**当然都需要调用 `微信支付模块！`** 而 对于这种多种支付的类型，却一般都需要一个 **回调函数！**`如何处理？`

**解决方案：**

*  当然这种问题，是有可能发生的，解决方案也不是单一的…**本人介绍一种通过`RabbitMQ 来实现！`**
 *  会员充值 外卖下单 都需要经过支付模块，向微信服务器发送请求，产生支付连接…
 *  用户支付成功之后，微信服务器调用**支付模块中的`回调方法`** 对成功的订单进行处理！  
    **更改用户状态`会员续费`** / **发起商家接单服务！**
 *  对于这种场景，不同的支付场景来对应不同的 **交换机/队列/Routingkey**  
    不同的请求**支付成功之后**，微信服务器回调时候，**给不同的`交换机/队列` 发送请求** , 不同的模块，不同的队列**监听！**
 *  会员下单，支付成功，给会员交换机发送消息，会员支付队列监听到数据进行处理！  
    外卖下单，支付成功，给外卖交换机发送消息，外卖支付队列监听到数据进行处理！
 *  **两者，来自一个`支付回调`** 却互不干涉！

**如何，指定回调时候，要发送的`交换机/队列？`**

*  **微信下单，时候可以指定一个参数属性 `attach`**
    
     *  改属性不是必须的，却可以用于传递附加的数据，在**统一下单时候在 attach属性中传入！对应的`交换机/队列！`**
     *  支付成功，微信回调时候，**从 attach属性中获得 `交换机/队列信息....`**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NTQyMzgw_size_16_color_FFFFFF_t_70 19]

### 注意： ###

*  **可能因为网络原因，支付成功后，调用回调，没有反应…**
 *  微信多次调用！往队列中多次发送消息…要谨慎处理…

### 实现： ###

**支付模块同一下单方法：**

public Map<String, String> pay(String out_trade_no, String total_fee,String exchange,String routingKey,String username) throws Exception { 
            Map<String, String> param = new HashMap<>();
            param.put("appid", appid);                              //应用ID
            param.put("mch_id", partner);                           //商户ID号
            param.put("nonce_str", WXPayUtil.generateNonceStr());   //随机数
            param.put("body", "My商场");                             //订单描述
            param.put("out_trade_no", out_trade_no);                 //商户订单号
            param.put("total_fee", total_fee);                      //交易金额
            param.put("spbill_create_ip", "127.0.0.1");           //终端IP
            param.put("notify_url", notifyurl);                    //回调地址
            param.put("trade_type", "NATIVE");                     //交易类型
    
    
            
            Map<String,String> attach = new HashMap<>();            //附加数据， 用户回调时，区分不同的订单队列
            attach.put("exchange",exchange);
            attach.put("routingKey",routingKey);
            attach.put("username",username);
            param.put("attach",JSON.toJSONString(attach));			//String类型... Map转换成JSON字符！
    		
    		//发送请求....
            String xml = WXPayUtil.generateSignedXml(param, partnerkey);
            String url = "https://api.mch.weixin.qq.com/pay/unifiedorder";
            HttpClient httpClient = new HttpClient(url);
            httpClient.setXmlParam(xml);
            httpClient.setHttps(true);
            httpClient.post();
            String content = httpClient.getContent();
            System.out.println(content);
            Map<String, String> stringStringMap = WXPayUtil.xmlToMap(content);
            Map<String, String> result = new HashMap<>();
            result.put("out_trade_no", out_trade_no);
            result.put("total_fee", total_fee);
            result.put("code_url", stringStringMap.get("code_url"));
            return result;
        }

**微服服务器，提供的Post 回调方法：**

@PostMapping("/notifyurl")
        public String notifyurl(HttpServletRequest request) { 
    			//省略代码....
    
    		    //获取attach 附加属性,JSON字符...
    		    String str = new String(baos.toByteArray(), "UTF-8");
                System.out.println(str);
                Map<String, String> stringStringMap = WXPayUtil.xmlToMap(str);
                String id = stringStringMap.get("out_trade_no");
                String attachStr= stringStringMap.get("attach");
                Map<String,String> mqMap = JSON.parseObject(attachStr,Map.class);
                String exchange = mqMap.get("exchange");
                String routingKey = mqMap.get("routingKey");
                String username = mqMap.get("username");
                //给指定交换机,队列,发送数据...
                payService.updateStatus(id,exchange,routingKey,username);
    			//省略代码....支付成功回调,表示成功.... 详情代码参考上面！
    			Map respMap = new HashMap();
                respMap.put("return_code", "SUCCESS");
                respMap.put("return_msg", "OK");
                return WXPayUtil.mapToXml(respMap);
    	}

*  **注意处理，网络导致回调失败，多次MQ发送消息！**

**接下来，不同的模块在开启对应`交换机/队列的监听，并进行对应的处理操作即可！`**

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NTQyMzgw_size_16_color_FFFFFF_t_70]: /images/20221022/7c443654f98e4a9a81f50ea3438420fc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NTQyMzgw_size_16_color_FFFFFF_t_70 1]: /images/20221022/ee17925beb834ccd8c4bee513be17035.png
[https_www.ngrok.cc_user.html]: https://www.ngrok.cc/user.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NTQyMzgw_size_16_color_FFFFFF_t_70 2]: /images/20221022/4cc7a30ef04142e5a77c94885c50aaa8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NTQyMzgw_size_16_color_FFFFFF_t_70 3]: /images/20221022/2884a8e452f94368a4b153b97c7e5e3c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NTQyMzgw_size_16_color_FFFFFF_t_70 4]: /images/20221022/f7cd9980c67443989879ec7d3065d52a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NTQyMzgw_size_16_color_FFFFFF_t_70 5]: /images/20221022/2a30ee3ee86e4559b245bd7e429ffbb9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NTQyMzgw_size_16_color_FFFFFF_t_70 6]: /images/20221022/05b949079735425eaaa99bcd0bf45fbf.png
[https_pay.weixin.qq.com_wiki_doc_api_index.html]: https://pay.weixin.qq.com/wiki/doc/api/index.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NTQyMzgw_size_16_color_FFFFFF_t_70 7]: /images/20221022/cdbcbf7e85234adba9c1777b7fe07667.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NTQyMzgw_size_16_color_FFFFFF_t_70 8]: /images/20221022/754ccb5480ec4681a3f2edf1cb32eca4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NTQyMzgw_size_16_color_FFFFFF_t_70 9]: /images/20221022/2a2c557dde6043e2826f07247dd365b6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NTQyMzgw_size_16_color_FFFFFF_t_70 10]: /images/20221022/9df7232a0033481e81b8ff10d258272e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NTQyMzgw_size_16_color_FFFFFF_t_70 11]: /images/20221022/030869de7ff845dbad7f4450569f8238.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NTQyMzgw_size_16_color_FFFFFF_t_70 12]: /images/20221022/f997edeb304f4826ac60713d18db8882.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NTQyMzgw_size_16_color_FFFFFF_t_70 13]: /images/20221022/96c9e9a630e64f3ab212306130c4aab6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NTQyMzgw_size_16_color_FFFFFF_t_70 14]: /images/20221022/e844935949744d9da5786a5fb1333959.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NTQyMzgw_size_16_color_FFFFFF_t_70 15]: /images/20221022/e36c383b6f9442a5872413e5f56035fd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NTQyMzgw_size_16_color_FFFFFF_t_70 16]: /images/20221022/e97b5df754584736915b2beeb5e44223.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NTQyMzgw_size_16_color_FFFFFF_t_70 17]: /images/20221022/5f86d295804a4abda496bcb55540ce90.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NTQyMzgw_size_16_color_FFFFFF_t_70 18]: /images/20221022/b21dc688311e4a00aeba5ec63ef1d328.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NTQyMzgw_size_16_color_FFFFFF_t_70 19]: /images/20221022/4a85e3ac4f644575829595f257c2051b.png