实战APP微信支付服务商模式(一个APP多个商户收款)

GuiSu97

已于 2022-06-17 15:27:23 修改

阅读量9.1k

点赞数 6

分类专栏：微信支付文章标签： java 接口 spring boot

于 2020-10-26 17:45:10 首次发布

本文链接：https://blog.csdn.net/GuiSu97/article/details/109262783

版权

微信支付专栏收录该内容

1 篇文章 0 订阅

订阅专栏

由于项目需要对接微信支付功能，需求是：一个APP实现不同商户进行收款，花时间去研究了下官方文档，决定采用微信支付APP服务商模式进行实现，开发时也踩了不少坑(参数顺序及大小写、签名的加密方式等)，这里记录下来，方便之后也许还能用到，也希望能帮助到需要的人，官方文档写的不那么容易快速理解，但认真研读官方给出的文档，还是能解决大部分的问题，附上官方文档。

本文为原创文章，转载请注明来源。

1、开发前准备
在开始开发时，需要提供如下参数：

对这些参数获取方式不清楚的，我这里也有整理一个申请流程文档，大家可根据需要下载阅读。

2、正式开发，引入Maven：

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

3、编写微信配置类：

package com.testwx.stylefeng.util;


import com.github.wxpay.sdk.WXPayConfig;

import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;

public class WxConfigUtil implements WXPayConfig {
    private byte[] certData;
    public static final String APP_ID = ""; //服务商的APPID(公众平台服务号)
    public static final String MCH_ID = ""; //商户号
    public static final String KEY = ""; //服务商密钥

    public WxConfigUtil() throws Exception {
        String certPath = DocUtil.createFtlFileByFtlArray()+"apiclient_cert.p12";//从微信商户平台下载的安全证书存放的路径
        File file = new File(certPath);
        InputStream certStream = new FileInputStream(file);
        this.certData = new byte[(int) file.length()];
        certStream.read(this.certData);
        certStream.close();
    }

    @Override
    public String getAppID() {
        return APP_ID;
    }

    @Override
    public String getMchID() {
        return MCH_ID;
    }

    @Override
    public String getKey() {
        return KEY;
    }

    @Override
    public InputStream getCertStream() {
        ByteArrayInputStream certBis = new ByteArrayInputStream(this.certData);
        return certBis;
    }

    @Override
    public int getHttpConnectTimeoutMs() {
        return 8000;
    }

    @Override
    public int getHttpReadTimeoutMs() {
        return 10000;
    }
}

注：由于博主的这个项目最终是要打包成jar，部署到服务器上，在读取证书资源文件目录时，jar方式可能会找不到，这里提供一个工具类，用于项目打成jar包后也可访问具体的资源文件，如果项目是war包方式，这里certPath不需要这么麻烦，直接填写证书资源文件路径即可。

工具类(防止打成jar包时，访问不到资源文件)：

        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>2.7</version>
        </dependency>

import org.apache.commons.compress.utils.IOUtils;

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import org.apache.commons.io.FileUtils;

public class DocUtil {
    public static String sourceWxCertPath;
    public static String[] ftlArray = {"apiclient_cert.p12"};

    static {
        sourceWxCertPath = createFtlFileByFtlArray();
    }

    public static String createFtlFileByFtlArray() {
        String ftlPath = "wx/";
        String path = "";
        for (int i = 0; i < ftlArray.length; i++) {
            path = createFtlFile(ftlPath, ftlArray[i]);
            if (null == path) {

            }
        }
        return path;
    }

    public static String createFtlFile(String ftlPath, String ftlName) {
        try {
            //获取当前项目所在的绝对路径
            String proFilePath = System.getProperty("user.dir");
            //获取模板下的路径　
            String newFilePath = proFilePath + File.separator + "src" + File.separator + "main" + File.separator + "resources" + File.separator + ftlPath;
            newFilePath = newFilePath.replace("/", File.separator);
            //检查项目运行时的src下的对应路径
            File newFile = new File(newFilePath + ftlName);
            if (newFile.isFile() && newFile.exists()) {
                return newFilePath;
            }

            // 当项目打成jar包会运行下面的代码，并且复制一份到src路径下
            InputStream certStream = Thread.currentThread().getContextClassLoader().getResourceAsStream(ftlPath + ftlName);
            byte[] certData = IOUtils.toByteArray(certStream);
            FileUtils.writeByteArrayToFile(newFile, certData);
            return newFilePath;
        } catch (IOException e) {
            System.out.println("复制失败");
        } return null;
    }
}

3、Controller(统一下单、微信回调、查询订单)

业务流程官方文档有提供具体的流程图，还是比较简单，这里简单说下大概流程就是，APP端调用服务端统一下单接口向微信发起统一下单，微信生成预付订单，APP根据统一下单接口返回的参数调起微信支付，用户支付完成，微信会调用服务端接口，微信回调接口需给微信返回(xml格式)是否成功接收，APP再调用服务端查询订单接口，获取支付结果，返回相应界面。

package com.AppWxPayService.web.api;

import com.testwx.stylefeng.core.Result;
import com.testwx.stylefeng.core.ResultGenerator;
import com.testwx.stylefeng.service.AppWxPayService;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.Map;

@RestController
@RequestMapping("/api/wxPay")
@Validated
public class AppWxPayController {
    @Resource
    public AppWxPayService appWxPayService;

    @PostMapping("/appPay")
    @ApiOperation(value = "app微信缴费")
    @ApiImplicitParams({
            @ApiImplicitParam(paramType = "query", dataType = "Long", name = "userId", value = "用户id"),
            @ApiImplicitParam(paramType = "query", dataType = "String", name = "totalFee", value = "总价"),
            @ApiImplicitParam(paramType = "query", dataType = "Long", name = "orderId", value = "订单id"),
            @ApiImplicitParam(paramType = "query", dataType = "String", name = "orderName", value = "订单名称"),
    })
    public Result wxAppPay(Long userId, String totalFee , Long orderId, String orderName){
        try {
            Map map = appWxPayService.wxAppPay(userId, totalFee, orderId, orderName);
            return ResultGenerator.genSuccessResult(map);
        }catch (Exception e){
            return ResultGenerator.genFailResult(e.getMessage());
        }
    }

    /**
     * 支付异步结果通知
     */
    @PostMapping(value = "/notify")
    public String wxPayNotify(HttpServletRequest request) {
        System.out.println("======================微信支付异步结果通知开始=================================");
        String resXml = "";
        try {
            InputStream inputStream = request.getInputStream();
            //将InputStream转换成xmlString
            BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
            StringBuilder sb = new StringBuilder();
            String line = null;
            try {
                while ((line = reader.readLine()) != null) {
                    sb.append(line + "\n");
                }
            } catch (IOException e) {
                System.out.println(e.getMessage());
            } finally {
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            resXml = sb.toString();
            String result = appWxPayService.payBack(resXml);
            return result;
        } catch (Exception e) {
            System.out.println("微信手机支付失败:" + e.getMessage());
            String result = "<xml>" + "<return_code><![CDATA[FAIL]]></return_code>" + "<return_msg><![CDATA[报文为空]]></return_msg>" + "</xml> ";
            return result;
        }
    }


    @PostMapping("/findWxPay")
    @ApiOperation(value = "查询支付结果")
    @ApiImplicitParams({
            @ApiImplicitParam(paramType = "query", dataType = "Long", name = "outTradeNo", value = "订单id"),
            @ApiImplicitParam(paramType = "query", dataType = "String", name = "subMchId", value = "子商户号"),
    })
    public Result findWxPay(Long outTradeNo,String subMchId){
        return appWxPayService.findWxPay(outTradeNo,subMchId);
    }
}

4、Service

package com.testwx.stylefeng.service;


import com.testwx.stylefeng.core.Result;

import java.util.Map;

public interface AppWxPayService {
    Map wxAppPay(Long userId, String totalFee, Long orderId,String orderName) throws Exception;

    String payBack(String resXml);

    Result findWxPay(Long outTradeNo, String subMchId);
}

5、ServiceImpl

package com.testwx.stylefeng.service.impl;

import com.testwx.stylefeng.core.Result;
import com.testwx.stylefeng.core.ResultGenerator;
import com.testwx.stylefeng.dao.WxAppPayOrderMapper;
import com.testwx.stylefeng.model.WxAppPayOrder;
import com.testwx.stylefeng.service.AppWxPayService;
import com.testwx.stylefeng.util.Utils;
import com.testwx.stylefeng.util.WxConfigUtil;
import com.github.wxpay.sdk.WXPay;
import com.github.wxpay.sdk.WXPayConstants;
import com.github.wxpay.sdk.WXPayUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;

@Service
@Transactional
public class AppWxPayServiceImpl implements AppWxPayService{
    @Autowired
    public HttpServletRequest request;
    @Resource
    public WxAppPayOrderMapper wxAppPayOrderMapper;

    public static final String NOTIFY_URL = "http://j682cq.natappfree.cc/api/wxPay/notify"; //回调地址
    public static final String TRADE_TYPE_APP = "APP"; //交易类型
    public static final String SUB_APPID = ""; //子商户应用ID

    /**
    * 调用官方SDK 获取预支付订单等参数
    * 统一下单
    */
    @Override
    public Map wxAppPay(Long userId, String totalFee, Long orderId,String orderName) throws Exception {
        WxAppPayOrder wxAppPayOrder = wxAppPayOrderMapper.selectByPrimaryKey(orderId);
        if (wxAppPayOrder == null){
            throw  new Exception("该订单不存在或已被删除");
        }
        if (wxAppPayOrder.getOrderState()==2){
            throw  new Exception("付款失败，该订单已支付");
        }
        try {
            float cardprice1 = Float.parseFloat(totalFee) * 100;//微信的支付单位是分所以要转换一些单位
            int cardmoney = (int) cardprice1;
            String totalproce = String.valueOf(cardmoney);
            System.out.println("支付："+totalFee + "元=" + totalproce + "分");
            WxConfigUtil configUtil = new WxConfigUtil();
            WXPay wxPay = new WXPay(configUtil);
            Map<String, String> data = new HashMap<>();

            //查询获得订单id
            String orderid = orderId+"";
            System.out.println("商户订单号------------" + orderid);

            data.put("appid", configUtil.getAppID()); //服务商的APPID
            data.put("mch_id", configUtil.getMchID()); //商户号
            data.put("sub_appid", SUB_APPID); //子商户应用ID
            //这里是关键，根据你具体业务，查询出不同的子商户号，从而实现不同商户收款
			//===========代码==========
            data.put("sub_mch_id", ""); //子商户号
            data.put("nonce_str", WXPayUtil.generateNonceStr());//随机字符串
            data.put("body","测试微信支付");//商品描述
            data.put("out_trade_no", orderid); //商品订单号
            data.put("total_fee", totalproce);  // 总金额
            data.put("spbill_create_ip", Utils.getIpAddress(request));//终端IP
            data.put("notify_url", NOTIFY_URL);//回调地址
            data.put("trade_type", TRADE_TYPE_APP);//交易类型
            //附加数据，在查询API和支付通知中原样返回，该字段主要用于商户携带订单的自定义数据
            data.put("attach", userId+"");
            String sign = WXPayUtil.generateSignature(data, configUtil.getKey(), WXPayConstants.SignType.MD5);
            data.put("sign", sign); //生成签名
            String str = WXPayUtil.mapToXml(data);
            System.out.println("map转xml" + str);
            System.out.println("我给的数据是" + data);
            System.out.println("第一次签名------------------" + sign);
            //使用官方API请求预付订单
            Map<String, String> response = wxPay.unifiedOrder(data);
            String returnCode = response.get("return_code");    //获取返回码
            Map<String, String> param = new LinkedHashMap<>();
            //判断返回状态码是否成功
            if (returnCode.equals("SUCCESS")) {
                //成功后接受微信返回的参数
                String resultCode = response.get("result_code");
                System.out.println("获取返回码" + resultCode);
                System.out.println("获取返回码错误代码---" + response.get("err_code") + "---获取返回码错误代码描述---" + response.get("err_code_des"));
                param.put("appid", response.get("sub_appid"));//子商户应用id
                param.put("partnerid", response.get("sub_mch_id"));//子商户号
                param.put("package", "Sign=WXPay");
                param.put("noncestr", WXPayUtil.generateNonceStr());//随机字符串
                param.put("timestamp", String.valueOf(System.currentTimeMillis() / 1000));     //时间戳
                if (resultCode.equals("SUCCESS")) {
                    param.put("prepayid", response.get("prepay_id"));//预支付交易会话ID
                    String retutnSign = WXPayUtil.generateSignature(param, configUtil.getKey(), WXPayConstants.SignType.MD5);
                    System.out.println("第二次签名------------------" + retutnSign);
                    param.put("sign", retutnSign);
                    String str1 = WXPayUtil.mapToXml(param);
                    System.out.println("map转xml" + str1);
                    param.put("packages","Sign=WXPay");
                    return param;
                } else {
                    //此时返回没有预付订单的数据
                    System.out.println("没有预付订单的数据");
                    throw new Exception("没有预付订单的数据");
                }
            } else {
                System.out.println("没有返回我接受到的微信参数");
                throw new Exception("没有返回我接受到的微信参数");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        throw new Exception("下单失败");
    }

 /**
 * @param resXml 异步通知后的XML数据
 */
 @Override
    public String payBack(String resXml) {
     System.out.println("======================微信支付异步结果逻辑处理开始=================================");
     WxConfigUtil config = null;
     try {
         config = new WxConfigUtil();
     } catch (Exception e) {
         e.printStackTrace();
     }
     WXPay wxpay = new WXPay(config);
     String xmlBack = "";
     Map<String, String> notifyMap = null;
     try {
         notifyMap = WXPayUtil.xmlToMap(resXml);// 调用官方SDK转换成map类型数据
         System.out.println("返回的map----------------" + notifyMap);
         System.out.println("返回的错误代码--------" + notifyMap.get("err_code") + "返回的错误信息--------" + notifyMap.get("err_code_des"));
         if (wxpay.isPayResultNotifySignatureValid(notifyMap)) {//验证签名是否有效，有效则进一步处理
             String return_code = notifyMap.get("return_code");//状态
             if (return_code.equals("SUCCESS")) {
                 String out_trade_no = notifyMap.get("out_trade_no");//商户订单号
                 //String userId = notifyMap.get("attach");
                 if (out_trade_no != null) {
                     //更新缴费状态
                     Long outTradeNo = Long.valueOf(out_trade_no);
                     paymentRecordMapper.updateState(outTradeNo);
                     System.out.println("-------------------------------支付成功----------------------");
                     System.out.println("微信手机支付回调成功订单号:"+out_trade_no);
                     xmlBack = "<xml>" + "<return_code><![CDATA[SUCCESS]]></return_code>" + "<return_msg><![CDATA[OK]]></return_msg>" + "</xml> ";
                 } else {
                     System.out.println("微信手机支付回调失败订单号为空");
                     xmlBack = "<xml>" + "<return_code><![CDATA[FAIL]]></return_code>" + "<return_msg><![CDATA[报文为空]]></return_msg>" + "</xml> ";
                 }
             }
             return xmlBack;
         } else {
             // 签名错误，如果数据里没有sign字段，也认为是签名错误
             //失败的数据要不要存储？
             System.out.println("手机支付回调通知签名错误");
             xmlBack = "<xml>" + "<return_code><![CDATA[FAIL]]></return_code>" + "<return_msg><![CDATA[报文为空]]></return_msg>" + "</xml> ";
             return xmlBack;
         }
     } catch (Exception e) {
         System.out.println("手机支付回调通知失败:"+ e);
         xmlBack = "<xml>" + "<return_code><![CDATA[FAIL]]></return_code>" + "<return_msg><![CDATA[报文为空]]></return_msg>" + "</xml> ";
     }
     return xmlBack;
 }

 /**
 * 查询订单
 */
 @Override
 public Result findWxPay(Long outTradeNo, String subMchId){
     try {
         WxConfigUtil configUtil = new WxConfigUtil();
         WXPay wxPay = new WXPay(configUtil);
         Map<String, String> data = new HashMap<>();
         data.put("appid", configUtil.getAppID()); //服务商的APPID
         data.put("mch_id", configUtil.getMchID()); //商户号
         //根据当前用户小区id查所属子商户应用ID与子商户号
         data.put("sub_appid", SUB_APPID); //子商户应用ID
         data.put("sub_mch_id", subMchId); //子商户号
         data.put("out_trade_no", outTradeNo+""); //商户订单号
         data.put("nonce_str", WXPayUtil.generateNonceStr());//随机字符串
         String sign = WXPayUtil.generateSignature(data, configUtil.getKey(), WXPayConstants.SignType.MD5);
         data.put("sign", sign); //生成签名
         //使用官方API查询订单
         Map<String, String> response = wxPay.orderQuery(data);
         String returnCode = response.get("return_code");    //获取返回码
         Map<String, String> param = new LinkedHashMap<>();
         //判断返回状态码是否成功
         if (returnCode.equals("SUCCESS")) {
             String resultCode = response.get("result_code");
             if (resultCode.equals("SUCCESS")) {
                String tradeState = response.get("trade_state");
                String cashFee = response.get("cash_fee");
                //SUCCESS—支付成功REFUND—转入退款NOTPAY—未支付CLOSED—已关闭REVOKED—已撤销（刷卡支付)USERPAYING--用户支付中PAYERROR--支付失败(其他原因，如银行返回失败)
                 return ResultGenerator.genSuccessResult("交易状态："+tradeState+"现金支付金额："+cashFee);
             }else {
                String errCodeDes = response.get("err_code_des");
                return ResultGenerator.genFailResult("错误代码描述："+errCodeDes);
             }
         }else {
            return ResultGenerator.genFailResult("查询失败");
         }
     } catch (Exception e) {
         e.printStackTrace();
     }
     return null;
 }

}

注：上面统一下单代码中子商户号根据个人具体业务，数据库查询获取得到不同的子商户号，这样即可实现不同服务商收款。

6、结束

好了，微信支付APP服务商模式就已实现完成，多仔细阅读几遍官方文档，其实流程还是挺简单的，可能比较麻烦的就是申请微信支付所需的这些参数。

GuiSu97

关注

6
点赞
踩
28

收藏

觉得还不错? 一键收藏
9
评论
实战APP微信支付服务商模式(一个APP多个商户收款)

引入Maven： <dependency> <groupId>com.github.wxpay</groupId> <artifactId>wxpay-sdk</artifactId> <version>0.0.3</version> </dependency>微信配置类：package co..
复制链接

扫一扫

专栏目录