java接入微信支付的Native方式

整体思路

生成支付二维码

查询支付状态

实现支付日志的生成与订单状态的修改、删除订单

支付状态回查

业务流程：

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

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

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

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

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

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

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

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

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

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

11.未收到支付通知的情况，商户后台系统调用【查询订单API】。 12.商户确认订单已支付后给用户发货。

1.开发准备

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

按API要求组装参数，以XML方式发送（POST）给微信支付接口（URL）,微信支付接口也是以XML方式给予响应。程序根据返回的结果（其中包括支付URL）生成二维码或判断订单状态。

在线微信支付开发文档：

https://pay.weixin.qq.com/wiki/doc/api/index.html

 2.导入依赖

         <!--微信支付-->
        <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>

        可以把map数据和xml数据来回转换

3.先导入工具类（HttpClient）

        用于可以请求https网络请求

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

4.配置yml文件

server:
  port: 9060
spring:
  application:
    name: pay-server
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848
weixin:
  appid: wxab8ac  #公众账号ID
  partner: 114  #商户号
  partnerkey: 2ab9071b06b9f7  #商户密钥
  notifyurl: http://8de92n.natappfree.cc/pay/info #回调地址

5.service实现

package com.zb.service.impl;

import com.github.wxpay.sdk.WXPayUtil;
import com.zb.service.PayService;
import com.zb.util.HttpClient;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

import java.util.HashMap;
import java.util.Map;
@Service
public class PayServiceImpl implements PayService {
    //获取yml中的公众账号ID
    @Value("${weixin.appid}")
    private String appid;
    //获取yml中的商户号
    @Value("${weixin.partner}")
    private String partner;
    @Value("${weixin.partnerkey}")
    private String partnerkey;
    @Value("${weixin.notifyurl}")
    private String notifyurl;

    @Override
    public Map<String, String> createUrl(String orderId, Integer price) {
        //orderId:订单的id，price：需要支付的金额（默认单位为 分 ）
        try {
            Map<String, String> param = new HashMap<>();
            param.put("appid", appid);
            param.put("mch_id", partner);
            param.put("nonce_str", WXPayUtil.generateNonceStr());
            param.put("body", "我的购物车");
            param.put("out_trade_no", orderId);
            param.put("total_fee",price.toString());
            param.put("spbill_create_ip", "127.0.0.1");
            param.put("notify_url", notifyurl);
            param.put("trade_type", "NATIVE");
            //调取微信支付的接口
            String url = "https://api.mch.weixin.qq.com/pay/unifiedorder";
            //将map数据转换为xml格式
            String xml = WXPayUtil.generateSignedXml(param, partnerkey);
            //创建网络链接
            HttpClient httpClient = new HttpClient(url);
            httpClient.setXmlParam(xml);
            httpClient.setHttps(true);
            httpClient.post();
            String content = httpClient.getContent();
            return WXPayUtil.xmlToMap(content);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}

6.回调方法（将返回的xml数据存入rabbitmq中）

 @RequestMapping("/info")
    public String info(HttpServletRequest httpServletRequest){
        try {
            //读取支付回调数据
            InputStream inputStream = httpServletRequest.getInputStream();
            ByteArrayOutputStream byteArrayOutputStream=new ByteArrayOutputStream();
            byte[] bytes=new byte[1024];
            int len=0;
            while ((len=inputStream.read(bytes))!=-1){
                byteArrayOutputStream.write(bytes,0,len);
            }
            byteArrayOutputStream.close();
            inputStream.close();
            String res = new String(byteArrayOutputStream.toByteArray(), "UTF-8");
            System.out.println(res);
            //返回格式必须是这样
            Map<String,String> map=new HashMap<>();
            map.put("return_code", "SUCCESS");
            map.put("return_msg", "OK");
            System.out.println("发送成功！");
            return WXPayUtil.mapToXml(map);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return "";
    }