SpringBoot 搭建微信小程序支付（JSAPI）纯后端

最新推荐文章于 2024-09-19 11:10:42 发布

xixililicm

最新推荐文章于 2024-09-19 11:10:42 发布

阅读量1.8k

点赞数 5

文章标签： java

本文链接：https://blog.csdn.net/aSmart_Q/article/details/109244081

版权

一、支付流程

PS:做这个之前，先去下载官方的SDK吧 https://pay.weixin.qq.com/wiki/doc/api/jsapi.php?chapter=11_1

1.首先要拿到appid,key,AppSecret, mch_id (商户号) 。这几个参数由你或者是你公司去申请

2.前端需要给后端的（统一下单接口）传递code(登录凭证)，标题body(自定义，比如游戏充值)和支付金额。

3.后端需要有统一下单的接口和一个支付成功后的回调接口

4.统一下单接口在收到这三个参数后，先根据code去获取openid（JSAPI必传openid），

官网放出的获取openid的请求地址需要appid ，secret， code， grant_type的值写成固定的->authorization_code

GET https://api.weixin.qq.com/sns/jscode2session?appid=APPID&secret=SECRET&js_code=JSCODE&grant_type=authorization_code

5.然后把各种参数封装为一个map 再根据secret和map进行MD5加密返回一个签名，再把这个签名封装到map中

最后发送请求并返回结果

6.获取到第一次签名请求的结果后，再对返回的数据进行第二次签名，最后返回给前端一系列的参数

7.前端在收到返回的参数后，如果为success ，就调起微信支付页面，付款成功后微信会自动调用我们定义的回调函数，在回调函数中需要响应结果给微信系统，表示我们已经支付完成，不然微信会调用我们的回调函数8次。

8.回调函数会返回结果，如果为success就表示此次支付成功完成

官网放出的获取openid的请求地址需要appid , secret,code,grant_type写成固定的->authorization_code

具体代码:

统一下单，回调函数，查询订单--具体代码:

注意：这里面的地址我都不是用的localhost ，需要弄成外网的样子所以这里我做了一个内网穿透不然回调函数无法执行

内网穿透我用的是ngrok,官网下载后启动执行ngrok http 端口号。然后就会生成一行地址，你把你接口的地址加在生成的地址后面就可以访问了

package com.github.wxpay.sdk.wxpaydemo.controller;


import com.github.wxpay.sdk.wxpaydemo.config.WXPay;
import com.github.wxpay.sdk.wxpaydemo.config.WXPayConstants;
import com.github.wxpay.sdk.wxpaydemo.config.WXPayUtil;
import com.github.wxpay.sdk.wxpaydemo.domain.OrderQueryReturnDomain;
import com.github.wxpay.sdk.wxpaydemo.domain.OrderReturnDomain;
import com.github.wxpay.sdk.wxpaydemo.domain.PayDomain;
import com.github.wxpay.sdk.wxpaydemo.util.PayUtil;
import com.github.wxpay.sdk.wxpaydemo.util.RandomStringGenerator;
import com.github.wxpay.sdk.wxpaydemo.util.WxPayGobal;
import com.thoughtworks.xstream.annotations.XStreamAlias;
import com.thoughtworks.xstream.XStream;
import org.springframework.web.bind.annotation.*;

import javax.servlet.ServletInputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.InetAddress;
import java.util.HashMap;
import java.util.Map;

/**
 * 微信小程序支付接口
 */

@RestController
@RequestMapping("/pay")
public class wxpay {

    //JSAPI和APP 统一下单请求地址 （固定的）
    private static  final String JSAPI_URL="https://api.mch.weixin.qq.com/pay/unifiedorder";



    //支付回调地址（你自己的请求地址，可以自己随意配置啦，写在这方便你理解）
    private static final String  NOTIFY_URL = "http://04a3af668030.ngrok.io/pay/back/wxNotify";

    //支付订单查询地址 （固定的）
    private static  final String ORDER_URL="https://api.mch.weixin.qq.com/pay/orderquery";

    //交易类型（这里是公众号支付）
    private static final String TRADE_TYPE = "JSAPI";


    /**
     * JSAPI 统一下单接口
     *
     * @param code  登录凭证
     * @param body  标题
     * @param money 支付金额
     * @return 返回交易类型和预支付会话标识
     * @throws Exception
     */
    @PostMapping("/wxJSApiPay")
    public Map<String, Object> wxJSApiPay(String code, String body, String money) throws Exception {
        String orderNumber = WxPayGobal.orderNumber();

        Map<String, String> data = new HashMap<String, String>();
        Map<String, Object> map = new HashMap<String, Object>();
        data.put("appid", PayDomain.getAppid());   //appid
        data.put("mch_id", PayDomain.getMch_id()); //商户id
        data.put("body", body);                            //标题
        data.put("out_trade_no", orderNumber);//订单号
        data.put("total_fee", money);                      //金额  单位为分
        data.put("spbill_create_ip", InetAddress.getLocalHost().getHostAddress());//终端IP
        data.put("notify_url", NOTIFY_URL);                                       //回调地址
        data.put("trade_type", TRADE_TYPE);                                       // 交易类型
        data.put("openid", WxPayGobal.getOpenId(code));                           //用户标识
        data.put("nonce_str", RandomStringGenerator.getRandomStringByLength(32)); //随机字符串

        System.out.println(data);
        String result = WxPayGobal.wxPay(data,JSAPI_URL);                                   //传递参数发送请求并返回结果


        XStream xStream = new XStream();
        //出于安全考虑，这里必须限制类型，不然会报错
        xStream.allowTypes(new Class[]{OrderReturnDomain.class});
        xStream.alias("xml", OrderReturnDomain.class);
        OrderReturnDomain s = (OrderReturnDomain) xStream.fromXML(result);        //返回结果转换为实体


        //当请求返回结果为success时  进行二次签名
        if ("SUCCESS".equals(s.getReturn_code()) && s.getReturn_code().equals(s.getResult_code())) {
            //生成签名（官方给出来的签名方法）
            Map<String, String> map2 = new HashMap<String, String>();
            long time = System.currentTimeMillis() / 1000;
            map2.put("appId", PayDomain.getAppid());
            map2.put("timeStamp", String.valueOf(time));
            //这边的随机字符串必须是第一次生成sign时，微信返回的随机字符串，不然小程序支付时会报签名错误
            map2.put("nonceStr", s.getNonce_str());
            map2.put("package", "prepay_id=" + s.getPrepay_id());
            map2.put("signType", "MD5");

            String sign2 = WXPayUtil.generateSignature(map2, PayDomain.getKey(), WXPayConstants.SignType.MD5);
            System.out.println("二次签名的sign2----->" + sign2);


            Map<String, Object> payInfo = new HashMap<String, Object>();
            payInfo.put("timeStamp", String.valueOf(time));
            payInfo.put("nonceStr", s.getNonce_str());
            payInfo.put("package", "prepay_id="+s.getPrepay_id());
            payInfo.put("signType", "MD5");
            payInfo.put("paySign", sign2);
            payInfo.put("orderNumber",orderNumber);
            map.put("status", 200);
            map.put("msg", "success");
            map.put("data", payInfo);
            //此处写逻辑代码实现
            /**
             * --
             * --
             */

        } else {
            return null;
        }
        return map;
    }

  

    /**
     *
     * @param request
     * @param response
     * @param orderNumber  下单成功后的订单号
     * @param sign  下单成功后的签名
     * @return
     * @throws Exception
     */

    @PostMapping(value = "/orderQuery")
    public static OrderQueryReturnDomain orderQuery(HttpServletRequest request, HttpServletResponse response,String orderNumber,String sign) throws Exception {
        Map<String, String> data = new HashMap<String, String>();
        data.put("appid", PayDomain.getAppid());
        data.put("mch_id", PayDomain.getMch_id());
        data.put("out_trade_no", orderNumber);//订单号
        data.put("nonce_str", RandomStringGenerator.getRandomStringByLength(32)); //随机字符串
        data.put("sign",sign);                                                    //签名
        System.out.println(data);
        String s = WxPayGobal.wxPay(data,ORDER_URL);                                   //传递参数发送请求并返回结果
        XStream xStream = new XStream();
        OrderQueryReturnDomain result = (OrderQueryReturnDomain) xStream.fromXML(s);
        return result;
    }



    /**
     * 微信小程序支付成功回调函数
     *
     * @param request
     * @param response
     * @throws Exception
     */
    @RequestMapping(value = "/callback/wxNotify")
    public static void wxNotify(HttpServletRequest request, HttpServletResponse response) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader((ServletInputStream) request.getInputStream()));
        String line = null;
        StringBuilder sb = new StringBuilder();
        while ((line = br.readLine()) != null) {
            sb.append(line);
        }
        br.close();
        //sb为微信返回的xml
        String notityXml = sb.toString();
        String resXml = "";
        System.out.println("接收到的报文：" + notityXml);
        @SuppressWarnings("unchecked")
        Map<String, String> map = PayUtil.doXMLParse(notityXml);

        String returnCode = (String) map.get("return_code");
        if ("SUCCESS".equals(returnCode)) {
            //验证签名是否正确
            Map<String, String> validParams = PayUtil.paraFilter(map);  //回调验签时需要去除sign和空值参数
            String validStr = PayUtil.createLinkString(validParams);//把数组所有元素，按照“参数=参数值”的模式用“&”字符拼接成字符串
            String sign = PayUtil.sign(validStr, PayDomain.getKey(), "utf-8").toUpperCase();//拼装生成服务器端验证的签名
            // 因为微信回调会有八次之多,所以当第一次回调成功了,那么我们就不再执行逻辑了

            //根据微信官网的介绍，此处不仅对回调的参数进行验签，还需要对返回的金额与系统订单的金额进行比对等
            if (sign.equals(map.get("sign"))) {
                /**此处添加自己的业务逻辑代码start**/
                // bla bla bla....
                /**此处添加自己的业务逻辑代码end**/
                //通知微信服务器已经支付成功
                resXml = "<xml>" + "<return_code><![CDATA[SUCCESS]]></return_code>"
                        + "<return_msg><![CDATA[OK]]></return_msg>" + "</xml> ";
            } else {
                System.out.println("微信支付回调失败!签名不一致");
            }
        } else {
            resXml = "<xml>" + "<return_code><![CDATA[FAIL]]></return_code>"
                    + "<return_msg><![CDATA[报文为空]]></return_msg>" + "</xml> ";
        }
        System.out.println(resXml);
        System.out.println("微信支付回调数据结束");
        BufferedOutputStream out = new BufferedOutputStream(
                response.getOutputStream());
        out.write(resXml.getBytes());
        out.flush();
        out.close();
    }


}

2.工具类用于发送请求获取openid 生成订单号（具体的订单号生成规则需要修改，我这里只是演示，不能用于上线）

package com.github.wxpay.sdk.wxpaydemo.util;


import com.github.wxpay.sdk.wxpaydemo.config.WXPayUtil;
import com.github.wxpay.sdk.wxpaydemo.domain.PayDomain;
import org.apache.http.HttpEntity;
import org.apache.http.HttpRequest;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
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 org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

import java.io.IOException;

import java.time.LocalDateTime;
import java.util.Map;

import com.alibaba.fastjson.JSONObject;

/**
 * 小程序支付工具类
 */

@Component
public class WxPayGobal {

    /**
     * 请求地址  （用于获取openid）
     */
    private final static String url = "https://api.weixin.qq.com/sns/jscode2session";

    private static Logger logger = LoggerFactory.getLogger(WxPayGobal.class);

    public static String wxPay(Map<String, String> data,String url) {

        //生成签名
        String sign = null;
        try {
            sign = WXPayUtil.generateSignature(data, PayDomain.getKey());
        } catch (Exception e) {
            e.printStackTrace();
        }
        data.put("sign", sign);
        String s = null;
        try {
            s = WXPayUtil.mapToXml(data);
        } catch (Exception e) {
            e.printStackTrace();
        }
        //发生请求并返回请求结果
        String s1 = doPostXml(url, s);
        System.out.println(s1);
        return s1;
    }

    /**
     * 发送请求
     *
     * @param url            请求地址
     * @param requestDataXml 请求的xml类型的字符串
     * @return
     */
    public static String doPostXml(String url, String requestDataXml) {
        CloseableHttpClient httpClient = null;
        CloseableHttpResponse httpResponse = null;
        httpClient = HttpClients.createDefault();
        HttpPost httpPost = new HttpPost(url);
        RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(15000)
                .setConnectionRequestTimeout(60000)
                .setSocketTimeout(60000)
                .build();
        httpPost.setConfig(requestConfig);
        httpPost.setEntity(new StringEntity(requestDataXml, "UTF-8"));
        httpPost.addHeader("Content-Type", "text/xml");

        String result = "";
        try {
            httpResponse = httpClient.execute(httpPost);
            HttpEntity entity = httpResponse.getEntity();
            result = EntityUtils.toString(entity, "UTF-8");
        } catch (Exception e) {
            e.printStackTrace();
        }

        return result;

    }

    /**
     * 获取openId
     * @param code 登录凭证
     * @return
     */
    public static String getOpenId(String code) {

        //请求参数
        String params = url + "?appid=" + PayDomain.getAppid() + "&secret=" + PayDomain.getSecret() + "&js_code=" + code + "&grant_type=" + "authorization_code";
        logger.info("请求地址:"+params);
        //发送请求
        HttpGet httpGet = new HttpGet(params);
        CloseableHttpClient httpClients = HttpClients.createDefault();
        String result = null;
        try {
            CloseableHttpResponse execute = httpClients.execute(httpGet);
            HttpEntity entity = execute.getEntity();
            result = EntityUtils.toString(entity);
            System.out.println(result+"...");
        } catch (IOException e) {
            e.printStackTrace();
        }
        JSONObject jsonObject = JSONObject.parseObject(result);
        logger.info("获取openid" + jsonObject.getString("openid"));
        if (null!=jsonObject.getString("openid")) {
            String openid = jsonObject.getString("openid");
            return openid;
        }
        return null;
    }

    /**
     * 订单号生成    当前日期+随机数字+商户ID
     */
    public static String orderNumber(){
        LocalDateTime now = LocalDateTime.now();
        String str=now.getYear()+""+now.getMonthValue()+now.getDayOfMonth()+"";//当前年月日

        String randomNumber=""; //随机数字
        for (int i = 0; i < 6; i++) {
            int max=9,min=0;
            int ran2 = (int) (Math.random()*(max-min)+min);

            randomNumber=ran2+randomNumber;
        }
        System.out.println(str+randomNumber);
        return str+randomNumber;
    }


}

实体类：

package com.github.wxpay.sdk.wxpaydemo.domain;

import lombok.Data;

/**
 * 接收统一下单调用微信接口返回的参数
 * @author Administrator
 *   */
@Data
public class OrderReturnDomain {

    /**
     * 返回状态码 （SUCCESS或 fail）
     */
    private String return_code;

    /**
     * 返回信息
     */
    private String return_msg;

    /**
     * 返回的结果状态码
     */
    private String result_code;

    /**
     * 返回的appid
     */
    private String appid;

    /**
     * 返回的商户号
     */
    private String mch_id;
    /**
     * 返回的随机字符串
     */
    private String nonce_str;

    /**
     * 返回的签名
     */
    private String sign;
    /**
     *微信生成的预支付会话标识，用于后续接口调用中使用，该值有效期为2小时
     */
    private String prepay_id;

    /**
     * 返回的交易类型 （JSAPI,APP,NATIVE）
     */
    private String trade_type;

    /**
     * 返回的错误码
     */
    private String err_code;

    /**
     * 返回的错误信息描述
     */
    private String err_code_des;
}

package com.github.wxpay.sdk.wxpaydemo.domain;

import lombok.Data;

/**
 * 封装订单支付成功后的返回结果
 */

@Data
public class OrderQueryReturnDomain {
    private String return_code;     //返回返回状态码
    private String return_msg;      //返回信息
    private String appid;           //公众账号ID
    private String mch_id;          //商户号
    private String nonce_str;       //随机字符串
    private String sign;            //签名
    private String result_code;     //业务结果
    private String openid;          //用户标识
    private String is_subscribe;    //是否关注公众账号
    private String trade_type;      //交易类型
    private String bank_type;       //付款银行
    private String total_fee;       //标价金额
    private String fee_type;        //标价币种
    private String transaction_id;  //微信支付订单号
    private String out_trade_no;    //商户订单号
    private String time_end;        //支付完成时间
    private String trade_state;     //交易状态
    private String cash_fee;        //现金支付金额
    private String trade_state_desc;//交易状态描述
    private String cash_fee_type;   //现金支付币种

}

package com.github.wxpay.sdk.wxpaydemo.domain;

import com.github.wxpay.sdk.wxpaydemo.config.WXPayConfig;
import lombok.Data;
import lombok.Getter;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;


@Component
public class PayDomain  {


    /**
     * 密钥key
     */
    private static  String key;



    /**
     * 应用ID
     */
    private static  String appid;


    /**
     * 商户号
     */
    private static  String mch_id;


    /**
     * 密钥
     * @param key
     */
    private static  String secret;

    @Value("${com.wx.wxpay.key}")
    public void setKey(String key) {
        this.key = key;
    }
    @Value("${com.wx.wxpay.appid}")
    public void setAppid(String appid) {
        this.appid = appid;
    }
    @Value("${com.wx.wxpay.mch_id}")
    public void setMch_id(String mch_id) {
        this.mch_id = mch_id;
    }

    @Value("${com.wx.wxpay.secret}")
    public  void setSecret(String secret) {
        PayDomain.secret = secret;
    }

    public static String getSecret() {
        return secret;
    }

    public static  String getKey() {
        return key;
    }

    public static  String getAppid() {
        return appid;
    }

    public static  String getMch_id() {
        return mch_id;
    }

}

pom:


 

    <dependencies>
<!--        map和xml之间的转换器-->
        <dependency>
            <groupId>com.thoughtworks.xstream</groupId>
            <artifactId>xstream</artifactId>
            <version>1.4.9</version>
        </dependency>
<!--        操作xml标签-->
        <dependency>
            <groupId>org.jdom</groupId>
            <artifactId>jdom</artifactId>
            <version>2.0.2</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.4</version>
        </dependency>
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
            <version>4.5.3</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.16.18</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>