描述

微信支付可分为V2版本与V3版本，项目需要使用V3版本微信支付，简述java如何实现微信支付V3版本

支付流程

概要流程：

1、小程序，传递微信支付需要参数，如商品价格等，调用后端的支付订单接口
2、后端调用微信支付系统后生成6个必要参数返回给前端。
后台调用微信支付系统需要组装必要的参数：
{
    
	"amount": {
    
		"total": 100 //支付金额 这个是分单位 100分=1元
	},
	"mchid": "1621239178", //商户号
	"description": "充值支付",//支付描述
	"notify_url": "http://127.0.0.1/pay/payNotify",//支付后回调接收地址
	"payer": {
    
		"openid": "o4GgauInH_RCEdvrrNGrntXDuXXX" //当前用户的openID
	},
	"out_trade_no": "3_6318816544250929333",//支付的订单号，支付后回调信息会将这个订单号带回来
	"appid": "wx1d0b55c33e1e0e333" //小程序的APPID
}
6个必要参数用于小程序能否成功唤起微信支付
如下：
订单号、金额、openid等去请求微信下单接口，微信返回预支付交易会话标识prepay_id
后端给appid、timestamp、nonceStr、prepayId签名，并将签名、timestamp、nonceStr、prepay_id返回给小程序
{
    
	"appId": "wx1d0b55c33e1e0e333",//小程序的APPID
	"timeStamp": "16279901923",//时间戳
	"nonceStr": "asd1231asdas",//随机串，保证唯一
	"package": "sdgscvb",
	"signType": "RSA",//签名类型
	"paySign": "zzzghhxcvsdfs2q3412sdfsdf" //签名信息
}
3、小程序调用wx.requestPayment拉起微信支付
4、用户支付后，微信支付系统会回调信息，后端接收，做对应的业务逻辑处理

微信支付前必要准备

1、微信官方文档–小程序支付接口文档描述（最终是组成概要流程中的参数形式）：
https://pay.weixin.qq.com/wiki/doc/apiv3/apis/chapter3_5_1.shtml
2、微信官方文档–商户号及微信V3证书下载
https://pay.weixin.qq.com/wiki/doc/apiv3/open/pay/chapter2_8_1.shtml
V3证书下载成功后文件（共3个）如下图：
apiclient_key.pem，apiclient_cert.pem，apiclient_cert.p12

maven导包

<dependency>
    <groupId>com.github.javen205</groupId>
    <artifactId>IJPay-WxPay</artifactId>
</dependency>

文件配置

wxpay_v3.properties（微信支付配置，有appId，商户id，API密钥，证书地址，回调地址，
该文件在resource根目录）
文件地址等信息根据自己项目情况自行配置

java代码

微信V3证书支付需要根据下载的3个证书文件（微信支付前必要准备第2点的）生成第四个证书文件（重要、重要、重要），
微信支付前，必须先生成这个文件，不然V3版本的支付无法唤醒，
调用这个接口生成即可：http://127.0.0.1:8080/项目名称/v1/wx/pay/createPlatformCert
后续会说明如何生成
废话不多说，直接上代码

Controller

import com.core.def.vo.renew.IWxPayParamVO;
import com.wechat.service.WXPayNewService;
import lombok.RequiredArgsConstructor;
import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.List;
import java.util.Map;

/**
 * 微信支付
 * @author 夕四
 **/
@RequiredArgsConstructor
@RestController
@RequestMapping(value = "/v1/wx/pay")
public class WXPayController {
    
    private final WXPayNewService wxPayNewService;

    /**
     * 微信统一下单接口
     * @param iWxPayParamVO 业务需要的参数
     * @return
     */
    @PostMapping("/doUnifiedOrder")
    public Map doUnifiedOrder(@RequestBody IWxPayParamVO iWxPayParamVO) throws Exception {
    
        return wxPayNewService.doUnifiedOrder(iWxPayParamVO);
    }

    /**
     * 微信支付的回调接收接口
     * @param request
     * @param response
     */
    @RequestMapping(value = "/payNotify", method = {
    org.springframework.web.bind.annotation.RequestMethod.POST, org.springframework.web.bind.annotation.RequestMethod.GET})
    public void callBack(HttpServletRequest request, HttpServletResponse response) {
    
        wxPayNewService.callBack(request, response);
    }

    /**
     * 生成v3证书
     *
     */
    @RequestMapping("/createPlatformCert")
    @ResponseBody
    public String createPlatformCert() throws IOException {
    
        return wxPayNewService.createPlatformCert();
    }
}

Service

import com.core.def.vo.renew.IWxPayParamVO;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.List;
import java.util.Map;

/**
 * 小程序微信支付
 *
 * @author 夕四
 **/
public interface WXPayNewService {
    
    /**
     * 微信统一下单接口
     *
     * @param iWxPayParamVO
     * @return
     * @throws Exception
     */
    Map doUnifiedOrder(IWxPayParamVO iWxPayParamVO) throws Exception;

    /**
     * 获取v3的证书
     *
     * @return
     * @throws IOException
     */
    String createPlatformCert() throws IOException;

    /**
     * 微信支付回调接口
     *
     * @param request
     * @param response
     */
    void callBack(HttpServletRequest request, HttpServletResponse response);
}

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.date.DateUnit;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.io.FileUtil;
import cn.hutool.core.util.RandomUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.http.ContentType;
import cn.hutool.json.JSONArray;
import cn.hutool.json.JSONObject;
import cn.hutool.json.JSONUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.vo.renew.IWxPayParamVO;
import com.config.WxPayParameterConfig;
import com.wechat.service.WXPayNewService;
import com.ijpay.core.IJPayHttpResponse;
import com.ijpay.core.enums.RequestMethod;
import com.ijpay.core.kit.AesUtil;
import com.ijpay.core.kit.HttpKit;
import com.ijpay.core.kit.PayKit;
import com.ijpay.core.kit.WxPayKit;
import com.ijpay.core.utils.DateTimeZoneUtil;
import com.ijpay.wxpay.WxPayApi;
import com.ijpay.wxpay.enums.WxApiType;
import com.ijpay.wxpay.enums.WxDomain;
import lombok.RequiredArgsConstructor;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.math.BigDecimal;
import java.nio.charset.StandardCharsets;
import java.security.cert.X509Certificate;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.Instant;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.util.*;

/**
 * @author 夕四
 **/
@RequiredArgsConstructor
@Slf4j
@Service
public class WXPayNewServiceImpl implements WXPayNewService {
    

	@Override
    public Map doUnifiedOrder(IWxPayParamVO iWxPayParamVO) throws Exception {
    
        //先写死1， 1就是1分钱，100=1元
        Integer price = 1;
        //商户订单号(随机字符串),这个回调的时候会给回
        String orderSn = generateNonceStr();
        //微信用户openId
        String openid = iWxPayParamVO.getOpenId();
        //这个是微信小程序的appid
        String appid = iWxPayParamVO.getAppId();
        //商户号ID
        String mchId = iWxPayParamVO.getMchId();
        //设置下支付的超时时间
        String timeExpire = DateTimeZoneUtil.dateToTimeZone(System.currentTimeMillis() + 1000 * 60 * 3);
        Map<String, Object> data = requestWxPayParam(mchId,orderSn, openid, price, appid, timeExpire);
        log.info("统一下单参数 {}", JSONUtil.toJsonStr(data));
        //这个是证书文件，先写死，后续调整成读取证书文件的服务器存放地址
        String privateKeyPath = "D:\\MyTools\\WXWork\\WxPayFile\\apiclient_key.pem";
        //请求下单
        IJPayHttpResponse response = WxPayApi.v3(
                RequestMethod.POST,
                WxDomain.CHINA.toString(),
                WxApiType.JS_API_PAY.toString(),
                // 商户号
                mchId,
                // 获取证书序列号
                getSerialNumber(),
                null,
                // 私钥
                privateKeyPath,
                // 请求参数
                JSONUtil.toJsonStr(data)
        );
        log.info("统一下单响应 {}", response);
        //这个就是小程序唤醒微信支付必要的那6个参数了
        Map<String, String> map =new HashMap<>();
        if (response.getStatus() == 200) {
    
            //这个是证书文件，先写死，后续调整成读取证书文件的服务器存放地址
            // 根据证书序列号查询对应的证书来验证签名结果
            String platformCertPath = "D:\\MyTools\\WXWork\\WxPayFile\\cert.pem";
            //平台证书
            boolean verifySignature = WxPayKit.verifySignature(response, platformCertPath);
            log.info("verifySignature: {}", verifySignature);
            if (verifySignature) {
    
                String body = response.getBody();
                JSONObject jsonObject = JSONUtil.parseObj(body);
                String prepayId = jsonObject.getStr("prepay_id");
                // 私钥
                map = WxPayKit.jsApiCreateSign(appid, prepayId,privateKeyPath);
                log.info("唤起支付参数:{}", map);
            }
        }
        //todo 微信预支付的订单新入库，为了业务查询记录

        return map;
    }

    @Override
    public void callBack(HttpServletRequest request, HttpServletResponse response) {
    
        log.info("收到微信支付回调");
        Map<String, String> map = new HashMap<>(12);
        try {
    
            String timestamp = request.getHeader("Wechatpay-Timestamp");
            String nonce = request.getHeader("Wechatpay-Nonce");
            String serialNo = request.getHeader("Wechatpay-Serial");
            String signature = request.getHeader("Wechatpay-Signature");

            log.info("timestamp:{} nonce:{} serialNo:{} signature:{}", timestamp, nonce, serialNo, signature);
            String result = HttpKit.readData(request);
            log.info("支付通知密文 {}", result);
            // 根据证书序列号查询对应的证书来验证签名结果
            String platformCertPath = "D:\\MyTools\\WXWork\\WxPayFile\\cert.pem";
            //这个商户号对应的那个V3秘钥
            String mckKey="cjajsrtasdqw21523asdf1";
            //需要通过证书序列号查找对应的证书，verifyNotify 中有验证证书的序列号
            String plainText = WxPayKit.verifyNotify(serialNo, result, signature, nonce, timestamp,mckKey, platformCertPath);
            log.info("支付通知明文 {}", plainText);
            //这个就是具体的业务情况
            savePayPlainText(plainText);
            //回复微信
            if (StrUtil.isNotEmpty(plainText)) {
    
                response.setStatus(200);
                map.put("code", "SUCCESS");
                map.put("message", "SUCCESS");
            } else {
    
                response.setStatus(500);
                map.put("code", "ERROR");
                map.put("message", "签名错误");
            }
            response.setHeader("Content-type", ContentType.JSON.toString());
            response.getOutputStream().write(JSONUtil.toJsonStr(map).getBytes(StandardCharsets.UTF_8));
            response.flushBuffer();
        } catch (Exception e) {
    
            e.printStackTrace();
        }
    }

    @Override
    public String createPlatformCert() {
    
        //商户号ID
        String mchId = "6382395623";
        //这个商户号对应的那个V3秘钥
        String mckKey="cjajsrtasdqw21523asdf1";
        // 获取平台证书列表
        try {
    
            //这个是证书文件，先写死，后续调整成读取证书文件的服务器存放地址
            String privateKeyPath = "D:\\MyTools\\WXWork\\WxPayFile\\apiclient_key.pem";
            IJPayHttpResponse response = WxPayApi.v3(
                    RequestMethod.GET,
                    WxDomain.CHINA.toString(),
                    WxApiType.GET_CERTIFICATES.toString(),
                    mchId,
                    getSerialNumber(),
                    null,
                    privateKeyPath,
                    ""
            );

            String timestamp = response.getHeader("Wechatpay-Timestamp");
            String nonceStr = response.getHeader("Wechatpay-Nonce");
            String serialNumber = response.getHeader("Wechatpay-Serial");
            String signature = response.getHeader("Wechatpay-Signature");

            String body = response.getBody();
            int status = response.getStatus();

            log.info("serialNumber: {}", serialNumber);
            log.info("status: {}", status);
            log.info("body: {}", body);
            int isOk = 200;
            // 根据证书序列号查询对应的证书来验证签名结果
            String platformCertPath = "D:\\MyTools\\WXWork\\WxPayFile\\cert.pem";
            if (status == isOk) {
    
                JSONObject jsonObject = JSONUtil.parseObj(body);
                JSONArray dataArray = jsonObject.getJSONArray("data");
                // 默认认为只有一个平台证书
                JSONObject encryptObject = dataArray.getJSONObject(0);
                JSONObject encryptCertificate = encryptObject.getJSONObject("encrypt_certificate");
                String associatedData = encryptCertificate.getStr("associated_data");
                String cipherText = encryptCertificate.getStr("ciphertext");
                String nonce = encryptCertificate.getStr("nonce");
                String serialNo = encryptObject.getStr("serial_no");
                //生成第四个证书文件
                final String platSerialNo = savePlatformCert(associatedData,mckKey, nonce, cipherText, platformCertPath);
                log.info("平台证书序列号: {} serialNo: {}", platSerialNo, serialNo);
            }
            // 根据证书序列号查询对应的证书来验证签名结果
            boolean verifySignature = WxPayKit.verifySignature(response, platformCertPath);
            log.info("verifySignature:{}" + verifySignature);
            return body;
        } catch (Exception e) {
    
            e.printStackTrace();
            return null;
        }
    }
    
    private String savePlatformCert(String associatedData, String apiKey3, String nonce, String cipherText, String certPath) {
    
        try {
    
            AesUtil aesUtil = new AesUtil(apiKey3.getBytes(StandardCharsets.UTF_8));
            // 平台证书密文解密
            // encrypt_certificate 中的  associated_data nonce  ciphertext
            String publicKey = aesUtil.decryptToString(
                    associatedData.getBytes(StandardCharsets.UTF_8),
                    nonce.getBytes(StandardCharsets.UTF_8),
                    cipherText
            );
            log.info("获取证书key：{},保存路径platformCert:{}", publicKey, certPath);
            //将生成的证书写入指定路径，文件名为：cert.pem
            FileOutputStream fos = new FileOutputStream(certPath);
            fos.write(publicKey.getBytes());
            fos.close();

            // 获取平台证书序列号
            X509Certificate certificate = PayKit.getCertificate(new ByteArrayInputStream(publicKey.getBytes()));
            return certificate.getSerialNumber().toString(16).toUpperCase();
        } catch (Exception e) {
    
            log.error("写入证书错误:{}", e);
            return e.getMessage();
        }
    }

    /**
     * 保存订单的支付通知明文
     *
     * @param plainText
     */
    private void savePayPlainText(String plainText) {
    
        JSONObject jsonObject = JSONUtil.parseObj(plainText);
        //这个就是发起订单时的那个订单号
        String outTradeNo = jsonObject.getStr("out_trade_no");
        //todo 把微信支付回调的明文消息存进数据库，方便后续校验查看

        //todo 把微信支付后需要处理的具体业务处理了
    }

    /**
     * 直连支付组装参数
     *
     * @return
     */
    private Map<String, Object> requestWxPayParam(String mchId,String orderSn, String openid, Integer price,String appid, String timeExpire) {
    
        Map<String, Object> data = new HashMap<String, Object>();
        Map<String, String> user = new HashMap<>();
        user.put("openid", openid);
        Map<String, Object> fee = new HashMap<>();
        fee.put("total", price);
        //APPID
        data.put("appid", appid);
        //商户ID
        data.put("mchid", mchId);
        //生成的随机字符串
        data.put("description", "*****支付");
        data.put("out_trade_no", orderSn);
        //支付金额，单位分,1是1分钱
        data.put("amount", fee);
        data.put("time_expire", timeExpire);
        //通知地址，用户支付成功之后，微信访问的接口
        data.put("notify_url", "填上你自己的微信回调接收地址");
        data.put("payer", user);
        return data;
    }

    /**
     * 获取证书序列号
     *
     * @return
     */
    private String getSerialNumber() throws IOException {
    
        //这个是证书文件，先写死，后续调整成读取证书文件的服务器存放地址
        String certPath = "D:\\MyTools\\WXWork\\WxPayFile\\apiclient_cert.pem";
        log.info("path:{}", certPath);
        // 获取证书序列号
        X509Certificate certificate = PayKit.getCertificate(FileUtil.getInputStream(certPath));
        String serialNo = certificate.getSerialNumber().toString(16).toUpperCase();
        log.info("获取证书序列号：{},", serialNo);
        return serialNo;
    }

    /**
     * 获取随机字符串 Nonce Str
     *
     * @return String 随机字符串
     */
    public String generateNonceStr() {
    
        StringBuffer stringBuffer = new StringBuffer();
        int prefix = RandomUtil.randomInt(10000, 99999);
        int suffix = RandomUtil.randomInt(10000, 99999);
        Long time = System.currentTimeMillis();
        return stringBuffer.append(prefix).append(time).append(suffix).toString();
    }
}

到此，微信支付对接业务逻辑处理完成