1.1 开发文档

微信支付接口调用的整体思路：

按API要求组装参数，以XML方式发送（POST）给微信支付接口（URL）,微信支付接口也是以XML方式给予响应。程序根据返回的结果（其中包括支付URL）生成二维码或判断订单状态。
在线微信支付开发文档：
https://pay.weixin.qq.com/wiki/doc/api/index.html

本次测试用到 ：统一下单”和”查询订单”两组API

1. appid：微信公众账号或开放平台APP的唯一标识
2. mch_id：商户号  (配置文件中的partner)
3. partnerkey：商户密钥
4. sign:数字签名, 根据微信官方提供的密钥和一套算法生成的一个加密信息, 就是为了保证交易的安全性

1.2 微信支付模式回顾

业务流程说明：

1.商户后台系统根据用户选购的商品生成订单。
2.用户确认支付后调用微信支付【统一下单API】生成预支付交易；
3.微信支付系统收到请求后生成预支付交易单，并返回交易会话的二维码链接code_url。
4.商户后台系统根据返回的code_url生成二维码。
5.用户打开微信“扫一扫”扫描二维码，微信客户端将扫码内容发送到微信支付系统。
6.微信支付系统收到客户端请求，验证链接有效性后发起用户支付，要求用户授权。
7.用户在微信客户端输入密码，确认支付后，微信客户端提交授权。
8.微信支付系统根据用户授权完成支付交易。
9.微信支付系统完成支付交易后给微信客户端返回交易结果，并将交易结果通过短信、微信消息提示用户。微信客户端展示支付交易结果页面。
10.微信支付系统通过发送异步消息通知商户后台系统支付结果。商户后台系统需回复接收情况，通知微信后台系统不再发送该单的支付通知。
11.未收到支付通知的情况，商户后台系统调用【查询订单API】。
12.商户确认订单已支付后给用户发货。

1.3 微信支付SDK
微信支付提供了SDK, 大家下载后打开源码，install到本地仓库。

使用微信支付SDK,在maven工程中引入依赖

<!--微信支付-->
<dependency>
    <groupId>com.github.wxpay</groupId>
    <artifactId>wxpay-sdk</artifactId>
    <version>0.0.3</version>
</dependency>

我们主要会用到微信支付SDK的以下功能：
获取随机字符串

WXPayUtil.generateNonceStr()

MAP转换为XML字符串（自动添加签名）

 WXPayUtil.generateSignedXml(param, partnerkey)

XML字符串转换为MAP

WXPayUtil.xmlToMap(result)

1.4 HttpClient工具类

HttpClient是Apache Jakarta Common下的子项目，用来提供高效的、最新的、功能丰富的支持HTTP协议的客户端编程工具包，并且它支持HTTP协议最新的版本和建议。HttpClient已经应用在很多的项目中，比如Apache Jakarta上很著名的另外两个开源项目Cactus和HTMLUnit都使用了HttpClient。

HttpClient通俗的讲就是模拟了浏览器的行为，如果我们需要在后端向某一地址提交数据获取结果，就可以使用HttpClient.

package entity;

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;
    }
}

1.5 支付微服务搭建
项目结构；

（2）创建controller

package com.changgou.pay.controller;

import com.alibaba.fastjson.JSON;
import com.changgou.pay.service.WeiXinPayService;
import com.github.wxpay.sdk.WXPayUtil;
import entity.Result;
import entity.StatusCode;

import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.env.Environment;
import org.springframework.web.bind.annotation.*;

import javax.servlet.ServletInputStream;
import javax.servlet.http.HttpServletRequest;
import java.io.ByteArrayOutputStream;
import java.util.Map;


@RestController
@RequestMapping("/weixin/pay")
@CrossOrigin
public class WeiXinPayController {

    @Autowired(required = false)
    private WeiXinPayService weiXinPayService;

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Autowired
    private Environment env;



    @GetMapping("/closePay/{orderId}")
    public Result closePay(@PathVariable("orderId") Long orderId){
        Map<String, String> map = weiXinPayService.closePay(orderId);
        return new Result(true, StatusCode.OK,"关闭微信支付成功",map);
    }



    /**
     * 获取微信的回调信息(回调,获取支付信息)
     * @return
     */
    @RequestMapping("/notify/url")
    public Map<String, String> notifyUrl(HttpServletRequest request) throws Exception{
        // 获取微信回调信息
        ServletInputStream inputStream = request.getInputStream();
        // 网络传输的字节流操作（内存操作）
        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        // 定义缓冲去
        byte[] buffer = new byte[1024];
        int len = 0;
        while ((len=inputStream.read(buffer))!=-1){
            byteArrayOutputStream.write(buffer, 0, len);
        }
        byteArrayOutputStream.flush();
        byteArrayOutputStream.close();
        inputStream.close();
        // 获取数据
        String strXML = new String(byteArrayOutputStream.toByteArray(), "UTF-8");
        System.out.println(strXML);
        Map<String, String> map = WXPayUtil.xmlToMap(strXML);
        System.out.println("回调数据:" + map);
        // 将map转JSON
        String jsonString = JSON.toJSONString(map);
        // 将参数发送到mq
        rabbitTemplate.convertAndSend("exchange.order","queue.order",jsonString);
        System.out.println("------------------------------------");
        return map;
    }

    /**
     * 生成支付的二维码
     * @param parames : 封装数据（订单，金额，用户名，交换机，路由）
     * @return
     */
    @RequestMapping("/create/native")
    public Result createNavite(@RequestParam Map<String ,String> parames){
        Map<String, String> map = weiXinPayService.createNative(parames);
        return new Result(true, StatusCode.OK,"创建支付二维码成功",map);
    }


    /**
     * 查询支付状态
     * @param outtradeno
     * @return
     */
    @RequestMapping("/status/query")
    public Result queryStatus(String outtradeno){
        Map<String, String> map = weiXinPayService.queryStatus(outtradeno);
        return new Result(true, StatusCode.OK,"查询支付状态成功",map);
    }
}

(3)创建service

package com.changgou.pay.service;

import java.util.Map;


public interface WeiXinPayService {

    /**
     * 关闭支付
     * @param orderId
     * @return
     * @throws Exception
     */
    Map<String,String> closePay(Long orderId) ;


    /**
     * 创建二维码参数
     * @param params
     * @return
     */
    Map<String ,String> createNative(Map<String, String> params);

    /**
     * 查询订单的支付状态
     * @param out_trade_no
     * @return
     */
    Map<String ,String> queryStatus(String out_trade_no);

}
///impl--------------
@Service
public class WeiXinPayServiceImpl implements WeiXinPayService {

    // 微信公众账号或开放平台APP的唯一标识
    @Value("${weixin.appid}")
    private String appid;
    // 商户号
    @Value("${weixin.partner}")
    private String partner;
    // 商户密钥
    @Value("${weixin.partnerkey}")
    private String partnerkey;
    // 回调地址
    @Value("${weixin.notifyurl}")
    private String notifyurl;


    /**
     * 关闭微信支付
     * @param orderId
     * @return
     * @throws Exception
     */
    @Override
    public Map<String, String> closePay(Long orderId) {
        try {
            // 统一下单的url
            String url = "https://api.mch.weixin.qq.com/pay/closeorder";
            // 封装支付接口调用需要的参数
            Map<String,String> data = new HashMap<>();
            // 微信支付分配的公众账号ID（企业号corpid即为此appId）
            data.put("appid",appid);
            // 微信支付分配的商户号
            data.put("mch_id",partner);
            // 随机字符串，长度要求在32位以内。推荐随机数生成算法
            data.put("nonce_str", WXPayUtil.generateNonceStr());
            //订单编号
            data.put("out_trade_no",String.valueOf(orderId));

            String signedXml = WXPayUtil.generateSignedXml(data, partnerkey);
            // 发送请求
            HttpClient httpClient = new HttpClient(url);
            httpClient.setHttps(true);
            httpClient.setXmlParam(signedXml);
            httpClient.post();
            // 获得返回数据
            String strXML = httpClient.getContent();
            Map<String, String> map = WXPayUtil.xmlToMap(strXML);
            return map;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 生成二维码所需要的数据，生成二维码
     * @param params :需要传入商户订单号 需要传入支付金额 用户名
     * @return
     */
    @Override
    public Map<String, String> createNative(Map<String,String> params) {
        try {
            // 统一下单的url
            String url = "https://api.mch.weixin.qq.com/pay/unifiedorder";
            // 封装支付接口调用需要的参数
            Map<String,String> data = new HashMap<>();
            // 微信支付分配的公众账号ID（企业号corpid即为此appId）
            data.put("appid",appid);
            // 微信支付分配的商户号
            data.put("mch_id",partner);
            // 随机字符串，长度要求在32位以内。推荐随机数生成算法
            data.put("nonce_str", WXPayUtil.generateNonceStr());
            // 通过签名算法计算得出的签名值，详见签名生成算法
            // data.put("sign",);
            // 商品简单描述，该字段请按照规范传递，具体请见参数规定
            data.put("body","畅购商城");
            // 商户订单号
            data.put("out_trade_no",params.get("outtradeno"));
            // 支付金额 单位是分
            data.put("total_fee",params.get("totalfee"));
            // 支持IPV4和IPV6两种格式的IP地址。用户的客户端IP
            data.put("spbill_create_ip","127.0.0.1");
            // 异步接收微信支付结果通知的回调地址，通知url必须为外网可访问的url，不能携带参数。
            data.put("notify_url",notifyurl);
            // (支付类型)JSAPI -JSAPI支付 NATIVE -Native支付 APP -APP支付 说明详见参数规定
            data.put("trade_type","NATIVE");



            // 接口需要将参数装拆XML类型数据(通过商户秘钥解析)
            String signedXml = WXPayUtil.generateSignedXml(data,partnerkey);
            // 创建HttpClient进行调用(统一下单的url)
            HttpClient httpClient = new HttpClient(url);
            httpClient.setHttps(true);          // 设置是否发以Https发送请求,可选择发送http
            httpClient.setXmlParam(signedXml);  // 发送请求所需的XML数据
            httpClient.post();                  // post请求
            // 发松请求
            String strXML = httpClient.getContent();
            // 处理响应数据键xml数据转成map 生成二维码的数据格式为: key : value
            Map<String, String> map = WXPayUtil.xmlToMap(strXML);
            return map;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 查询订单的状态
     * @param out_trade_no
     * @return
     */
    @Override
    public Map<String, String> queryStatus(String out_trade_no) {
        try {
            // 指定接口地址,查询订单的api
            String url = "https://api.mch.weixin.qq.com/pay/orderquery";
            // 构建接口需要的map
            Map<String, String> data = new HashMap<>();
            data.put("appid",appid);
            data.put("mch_id",partner);
            data.put("out_trade_no",out_trade_no);
            data.put("nonce_str",WXPayUtil.generateNonceStr());
            // 将数据转成xml
            String signedXml = WXPayUtil.generateSignedXml(data, partnerkey);
            // 创建HttpClient调用
            HttpClient httpClient = new HttpClient(url);
            httpClient.setHttps(true);
            httpClient.setXmlParam(signedXml);
            httpClient.post();
            String strXML = httpClient.getContent();
            // 处理响应数据
            Map<String, String> map = WXPayUtil.xmlToMap(strXML);
            return map;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}

(4)配置文件

server:
  port: 18091
spring:
  application:
    name: pay
  main:
    allow-bean-definition-overriding: true
  rabbitmq:
    host: 129.211.164.41
    port: 5672
    username: user
    password: 123456
eureka:
  client:
    service-url:
      defaultZone: http://127.0.0.1:7001/eureka
  instance:
    prefer-ip-address: true
feign:
  hystrix:
    enabled: true
#hystrix 配置
hystrix:
  command:
    default:
      execution:
        timeout:
          #如果enabled设置为false，则请求超时交给ribbon控制
          enabled: true
        isolation:
          strategy: SEMAPHORE

#微信支付信息配置
weixin:
  appid: wx8397f8696b538317
  partner: 1473426802
  partnerkey: T6m9iK73b0kn9g5v426MKfHQH7X8rKwb
  notifyurl:  http://3563l0682w.zicp.vip:33540/weixin/pay/notify/url #内网穿透支付回调

#配置连接mq

#配置支付交换机和队列
mq:
  pay:
    exchange:
      order: exchange.order
 
    queue:
      order: queue.order
    
    routing:
      key: queue.order
   

appid： 微信公众账号或开放平台APP的唯一标识
partner：财付通平台的商户账号
partnerkey：财付通平台的商户密钥
notifyurl: 回调地址
（5）依赖；

		<!--加入ampq 监听消息使用-->
 		<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
		  <!--微信支付-->
        <dependency>
            <groupId>com.github.wxpay</groupId>
            <artifactId>wxpay-sdk</artifactId>
            <version>0.0.3</version>
        </dependency>
        <!--httpclient支持-->
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
        </dependency>

2 微信支付二维码生成

2.1请求微信创建二维码，标红是返回的二维码地址 

2.2 页面生成二维码 ，上面标红位置code_url 返回的地址
链接：https://pan.baidu.com/s/1Qbl_1ktJCqh1Q6qDPD2WRQ
提取码：wxpa
复制这段内容后打开百度网盘手机App，操作更方便哦

2.3根据订单号查询订单状态

项目源码
git 地址；https://github.com/lkzgit/springcloud_oauth2.0_changgou