Java 开发微信支付 SDK3.0.9（最新版本SDK与DEMO）

原创朱雀 2020-06-24 03:03 3436阅读 5赞

# Java 开发微信支付 SDK3.0.9（最新版本SDK与DEMO）

> 在开发之前还是希望大家多看看官方的开发文档，SDK3.0.9这个版本的Demo已经相当成熟了。很多支付相关的功能都已经封装好了。当然需要注意的是这个Demo需要自己引入到项目当中。不像0.0.3以及0.01版本的可以通过依赖直接引入。当然0.03版本的SDK开发网上的教程也比较多，问题的解决也比较详细。咱们今天主要讲解3.0.9微信最新的支付SDK。

## 准备工作

开发之前先登录微信支付开发文档

地址：`https://pay.weixin.qq.com/wiki/doc/api/jsapi.php?chapter=7_1`

![](/images/1592967427114.png)

然后下载官方的SDK与DEMO，下载完成之后用IDEA打开

![](/images/1592967476693.png)

打开之后项目结构是这个样子的。

![](/images/1592967499435.png)

这里我有个大坑就是WXPayConfig是个抽象类直接继承无法实现它的抽象方法。所以我的解决方法直接改为接口。

```java
package com.github.wxpay.sdk;

import java.io.InputStream;

public interface WXPayConfig {

/**
     * 获取 App ID
     *
     * @return App ID
     */
    String getAppID();

/**
     * 获取 Mch ID
     *
     * @return Mch ID
     */
    String getMchID();

/**
     * 获取 API 密钥
     *
     * @return API密钥
     */
    String getKey();

/**
     * 获取商户证书内容
     *
     * @return 商户证书内容
     */
    InputStream getCertStream();

/**
     * HTTP(S) 连接超时时间，单位毫秒
     *
     * @return
     */
    int getHttpConnectTimeoutMs();

/**
     * HTTP(S) 读数据超时时间，单位毫秒
     *
     * @return
     */
    int getHttpReadTimeoutMs();

/**
     * 获取WXPayDomain, 用于多域名容灾自动切换
     *
     * @return
     */
    IWXPayDomain getWXPayDomain();

/**
     * 是否自动上报。
     * 若要关闭自动上报，子类中实现该函数返回 false 即可。
     *
     * @return
     */
    boolean shouldAutoReport();

/**
     * 进行健康上报的线程的数量
     *
     * @return
     */
    int getReportWorkerNum();

/**
     * 健康上报缓存消息的最大数量。会有线程去独立上报
     * 粗略计算：加入一条消息200B，10000消息占用空间 2000 KB，约为2MB，可以接受
     *
     * @return
     */
    int getReportQueueMaxSize();

/**
     * 批量上报，一次最多上报多个数据
     *
     * @return
     */
    int getReportBatchSize();

}

```

然后打包，因为网络下载的问题  我这里修改一下打包方式。

![](/images/1592967611611.png)

修改为：

![](/images/1592967539254.png)

然后在自己的项目中引入依赖
![](/images/1592967522409.png)

打包依赖时一定要选择install（或者手动安装依赖）

![](/images/1592967650308.png)

## 创建微信支付配置类

```java
import com.github.wxpay.sdk.IWXPayDomain;
import com.github.wxpay.sdk.WXPayConfig;
import com.github.wxpay.sdk.WXPayConstants;
import java.io.ByteArrayInputStream;
import java.io.InputStream;
import org.apache.commons.io.IOUtils;

public class MyWXPayConfig implements WXPayConfig {
    /**
     * 获取 App ID
     *
     * @return App ID
     */
    public String getAppID() {
        return "App ID";
    }
    /**
     * 获取 Mch ID
     *
     * @return Mch ID
     */
    public String getMchID() {
        return "Mch ID";
    }
    /**
     * 获取 API 密钥
     *
     * @return API密钥
     */
    public String getKey() {
        return "API密钥";
    }
    /**
     * 获取商户证书内容
     *
     * @return 商户证书内容
     */
    public InputStream getCertStream() {
        ByteArrayInputStream certBis = new ByteArrayInputStream(this.certData);
        return certBis;
    }
    /**
     * HTTP(S) 连接超时时间，单位毫秒
     *
     * @return
     */
    public int getHttpConnectTimeoutMs() {
        return 6*1000;
    }
    /**
     * HTTP(S) 读数据超时时间，单位毫秒
     *
     * @return
     */
    public int getHttpReadTimeoutMs() {
        return 8*1000;
    }

/**
     * 获取WXPayDomain, 用于多域名容灾自动切换
     * @return
     */
    @Override
    public IWXPayDomain getWXPayDomain() { // 这个方法需要这样实现, 否则无法正常初始化WXPay
        IWXPayDomain iwxPayDomain = new IWXPayDomain() {
            @Override
            public void report(String domain, long elapsedTimeMillis, Exception ex) {

}
            @Override
            public DomainInfo getDomain(WXPayConfig config) {
                return new IWXPayDomain.DomainInfo(WXPayConstants.DOMAIN_API, true);
            }
        };
        return iwxPayDomain;
    }

/**
     * 是否自动上报。
     * 若要关闭自动上报，子类中实现该函数返回 false 即可。
     *
     * @return
     */
    public boolean shouldAutoReport() {
        return true;
    }

/**
     * 进行健康上报的线程的数量
     *
     * @return
     */
    public int getReportWorkerNum() {
        return 6;
    }

/**
     * 健康上报缓存消息的最大数量。会有线程去独立上报
     * 粗略计算：加入一条消息200B，10000消息占用空间 2000 KB，约为2MB，可以接受
     *
     * @return
     */
    public int getReportQueueMaxSize() {
        return 10000;
    }
    /**
     * 批量上报，一次最多上报多个数据
     *
     * @return
     */
    public int getReportBatchSize()  {
        return 10;
    }

private byte[] certData;

public MyWXPayConfig() throws Exception {
        InputStream certStream = Thread.currentThread().getContextClassLoader().getResourceAsStream("cert/wxpay/apiclient_cert.p12");
        this.certData = IOUtils.toByteArray(certStream);
        certStream.read(this.certData);
        certStream.close();
    }
}

```

将配置信息换成自己的商户配置信息。

证书是需要去商户申请，根据官方文档申请证书然后存放到resources的cert/wxpay目录下

![](/images/1592967742947.png)

## 创建微信统一下单接口以及回调接口

```java
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.math.BigDecimal;
import java.util.HashMap;
import java.util.Map;

import static com.github.wxpay.sdk.WXPayConstants.SUCCESS;

@Controller
@RequestMapping("/")
public class WXPayApi {

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

/**
     * 发起微信支付
     *
     * @param request
     * @return
     * @throws Exception
     */
    @GetMapping("/wxpay")
    @ResponseBody
    public Map<String, String> WXPay(HttpServletRequest request, @RequestParam Map<String, String> map) throws Exception {
        // 订单信息
        String body = map.get("body");
        // 订单总金额
        String totalFee = map.get("totalFee");
        MyWXPayConfig wxPayConfig = new MyWXPayConfig();
        // 发起微信支付
        WXPay wxpay = null;
        Map<String, String> result = new HashMap<>();
        try {

// 注入自己实现的微信配置类, 创建WXPay核心类, WXPay 包括统一下单接口
            wxpay = new WXPay(wxPayConfig);
            Map<String, String> data = new HashMap<String, String>();
            data.put("body", body);
            // 订单唯一编号, 不允许重复
            data.put("out_trade_no", WXPayUtil.generateNonceStr());
            data.put("total_fee", String.valueOf(new BigDecimal(totalFee).multiply(new BigDecimal(100)).intValue())); // 订单金额, 单位分
            // 下单ip
            data.put("spbill_create_ip", HttpUrlUtil.getIpAddr(request));
            // 微信公众号统一标示openid
            // String openId = "omQHOjo2HH4tYV-NPBvYhvfUcJhg";
            // 获取用户OpenId
            String openId = this.getOpenId(request);
            if (StringUtils.isNotEmpty(openId)){
                data.put("openid", openId);
            }else {
                logger.info("获取OpenId失败, request={}", data);
                return null;
            }
            // OpenId
            data.put("openid", openId);
            // 订单结果通知, 微信主动回调此接口（微信支付回调接口）
            data.put("notify_url", "http://dandelioncloud.cn/payCallback");
            // 固定填写
            data.put("trade_type", "JSAPI");
            logger.info("发起微信支付下单接口, request={}", data);
            // 微信sdk集成方法, 统一下单接口unifiedOrder, 此处请求   MD5加密   加密方式
            Map<String, String> response = wxpay.unifiedOrder(data);
            logger.info("微信支付下单成功, 返回值 response={}", response);
            String returnCode = response.get("return_code");
            if (!SUCCESS.equals(returnCode)) {
                logger.info("获取returnCode失败, request={}", data);
                return null;
            }
            String resultCode = response.get("result_code");
            if (!SUCCESS.equals(resultCode)) {
                logger.info("获取resultCode失败, request={}", data);
                return null;
            }
            String prepay_id = response.get("prepay_id");
            if (prepay_id == null) {
                logger.info("获取预付款prepay_id失败, request={}", data);
                return null;
            }

// 前端调起微信支付必要参数
            String packages = "prepay_id=" + prepay_id;
            Map<String, String> wxPayMap = new HashMap<String, String>();
            // 微信公共号AppId
            wxPayMap.put("appId", wxPayConfig.getAppID());
            // 时间戳
            wxPayMap.put("timeStamp", DateUtil.getTimeStamp());
            // 随机数
            wxPayMap.put("nonceStr", WXPayUtil.generateNonceStr());
            // 拼接好的预付款id
            wxPayMap.put("package", packages);
            // 生成签证的格式
            wxPayMap.put("signType", "MD5");//这里需要注意，签名类型，默认为MD5，支持HMAC-SHA256和MD5。注意此处需与统一下单的签名类型一致（签名不正确就要考虑到这一块了）
            // 加密串中包括 appId timeStamp nonceStr package signType 5个参数, 通过sdk WXPayUtil类加密, 注意, 此处使用  MD5加密  方式
            String sign = WXPayUtil.generateSignature(wxPayMap, wxPayConfig.getKey());

// 返回给前端调起微信支付的必要参数
            result.put("prepay_id", prepay_id);
            // 签证
            result.put("paySign", sign);
            result.putAll(wxPayMap);
        } catch (Exception e) {
            e.getMessage();
        }
        logger.info("完成发起请求, request={}", result);
        return result;
    }

/**
     * 微信支付回调接口
     * @param request
     * @param response
     * @return
     */
    @PostMapping("/payCallback")
    @ResponseBody
    public String payCallback(HttpServletRequest request, HttpServletResponse response) {
        logger.info("进入微信支付异步通知");
        String resXml = "";
        try {
            //
            InputStream is = request.getInputStream();
            //将InputStream转换成String
            BufferedReader reader = new BufferedReader(new InputStreamReader(is));
            StringBuilder sb = new StringBuilder();
            String line = null;
            try {
                while ((line = reader.readLine()) != null) {
                    sb.append(line + "\n");
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            resXml = sb.toString();
            logger.info("微信支付异步通知请求包: {}", resXml);
            return this.payBack(resXml);
        } catch (Exception e) {
            logger.error("微信支付回调通知失败", e);
            String result = "<xml>" + "<return_code><![CDATA[FAIL]]></return_code>" + "<return_msg><![CDATA[报文为空]]></return_msg>" + "</xml> ";
            return result;
        }
    }

public String payBack(String notifyData) throws Exception {
        MyWXPayConfig wxPayConfig = new MyWXPayConfig();
        logger.info("payBack() start, notifyData={}", notifyData);
        String xmlBack = "";
        Map<String, String> notifyMap = null;
        try {
            WXPay wxpay = new WXPay(wxPayConfig);

notifyMap = WXPayUtil.xmlToMap(notifyData);         // 转换成map
            if (wxpay.isPayResultNotifySignatureValid(notifyMap)) {
                // 签名正确
                // 进行处理。
                // 注意特殊情况：订单已经退款，但收到了支付结果成功的通知，不应把商户侧订单状态从退款改成支付成功
                String return_code = notifyMap.get("return_code");//状态
                String out_trade_no = notifyMap.get("out_trade_no");//订单号

if (out_trade_no == null) {
                    logger.info("微信支付回调失败订单号: {}", notifyMap);
                    xmlBack = "<xml>" + "<return_code><![CDATA[FAIL]]></return_code>" + "<return_msg><![CDATA[报文为空]]></return_msg>" + "</xml> ";
                    return xmlBack;
                }

// 业务逻辑处理 ****************************
                logger.info("微信支付回调成功订单号: {}", notifyMap);
                xmlBack = "<xml>" + "<return_code><![CDATA[SUCCESS]]></return_code>" + "<return_msg><![CDATA[SUCCESS]]></return_msg>" + "</xml> ";
                logger.info("完成微信支付回调返回信息: {}", xmlBack);
                return xmlBack;
            } else {
                logger.error("微信支付回调通知签名错误");
                xmlBack = "<xml>" + "<return_code><![CDATA[FAIL]]></return_code>" + "<return_msg><![CDATA[报文为空]]></return_msg>" + "</xml> ";
                return xmlBack;
            }
        } catch (Exception e) {
            logger.error("微信支付回调通知失败", e);
            xmlBack = "<xml>" + "<return_code><![CDATA[FAIL]]></return_code>" + "<return_msg><![CDATA[报文为空]]></return_msg>" + "</xml> ";
        }
        return xmlBack;
    }

```

## 微信内H5调起支付

![](/images/1592967713275.png)

调起html这个就相当简单了，跟着官方文档跑就行了。

官方的唤醒微信支付的js示例:

```js
function onBridgeReady(){
   WeixinJSBridge.invoke(
      'getBrandWCPayRequest', {
         "appId":"wx2421b1c4370ec43b",     //公众号名称，由商户传入     
         "timeStamp":"1395712654",         //时间戳，自1970年以来的秒数     
         "nonceStr":"e61463f8efa94090b1f366cccfbbb444", //随机串     
         "package":"prepay_id=u802345jgfjsdfgsdg888",     
         "signType":"MD5",         //微信签名方式：     
         "paySign":"70EA570631E4BB79628FBCA90534C63FF7FADD89" //微信签名 
      },
      function(res){
      if(res.err_msg == "get_brand_wcpay_request:ok" ){
      // 使用以上方式判断前端返回,微信团队郑重提示：
            //res.err_msg将在用户支付成功后返回ok，但并不保证它绝对可靠。
      } 
   }); 
}
if (typeof WeixinJSBridge == "undefined"){
   if( document.addEventListener ){
       document.addEventListener('WeixinJSBridgeReady', onBridgeReady, false);
   }else if (document.attachEvent){
       document.attachEvent('WeixinJSBridgeReady', onBridgeReady); 
       document.attachEvent('onWeixinJSBridgeReady', onBridgeReady);
   }
}else{
   onBridgeReady();
}
```

总结：多看文档，多看参数，一切操作最好都在线上开发。不推荐使用沙箱开发。那样会带来更多的困扰。如果出现问题多看日志。log日志自己可以在tomcat下提取info的日志。日志标记我也写的很详细。不然怀疑代码有问题。代码不会有问题，有问题的是人。