JAVA整合微信公众平台，实现微信支付功能

不念不忘少年蓝@ 2023-10-15 08:07 162阅读 0赞

## 一、准备工作 ##

### 1. 支付信息配置类 ###

import com.wechat.pay.contrib.apache.httpclient.WechatPayHttpClientBuilder;
    import com.wechat.pay.contrib.apache.httpclient.auth.PrivateKeySigner;
    import com.wechat.pay.contrib.apache.httpclient.auth.ScheduledUpdateCertificatesVerifier;
    import com.wechat.pay.contrib.apache.httpclient.auth.WechatPay2Credentials;
    import com.wechat.pay.contrib.apache.httpclient.auth.WechatPay2Validator;
    import com.wechat.pay.contrib.apache.httpclient.util.PemUtil;
    import lombok.Data;
    import lombok.extern.slf4j.Slf4j;
    import org.apache.http.impl.client.CloseableHttpClient;
    import org.springframework.boot.context.properties.ConfigurationProperties;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.nio.charset.StandardCharsets;
    import java.security.PrivateKey;
    
    @Configuration
    //@ConfigurationProperties(prefix = "wxpay") //读取wxpay节点
    @Data //使用set方法将wxpay节点中的值填充到当前类的属性中
    @Slf4j
    public class WxPayConfig {
    
        // 商户号
        private String mchId = "自己公众号的商户号";
    
        // 商户API证书序列号
        private String mchSerialNo = "自己公众号的商户API证书序列号";
    
        // 商户私钥文件
        private String privateKeyPath = "apiclient_key.pem";
    
        // APIv3密钥
        private String apiV3Key = "自己公众号的APIv3密钥";
    
        // APPID
        private String appid = "自己公众号的APPID";
    
        // 微信服务器地址
        private String domain = "https://api.mch.weixin.qq.com";
    
        // 接收结果通知地址
        private String notifyDomain = "自己公众号设置的接收结果通知地址";
    
    /**
         * 获取商户的私钥文件
         *
         * @param filename
         * @return*/
    
    
        public PrivateKey getPrivateKey(String filename) {
    
            try {
                //return PemUtil.loadPrivateKey(new FileInputStream(filename));
                return PemUtil.loadPrivateKey(getClass().getClassLoader().getResourceAsStream(filename));
            } catch (Exception e) {
                throw new RuntimeException("私钥文件不存在", e);
            }
        }
    
    /**
         * 获取签名验证器
         *
         * @return
    */
    
    
        @Bean
        public ScheduledUpdateCertificatesVerifier getVerifier() {
    
            log.info("获取签名验证器");
    
            //获取商户私钥
            PrivateKey privateKey = getPrivateKey(privateKeyPath);
    
            //私钥签名对象
            PrivateKeySigner privateKeySigner = new PrivateKeySigner(mchSerialNo, privateKey);
    
            //身份认证对象
            WechatPay2Credentials wechatPay2Credentials = new WechatPay2Credentials(mchId, privateKeySigner);
    
            // 使用定时更新的签名验证器，不需要传入证书
            ScheduledUpdateCertificatesVerifier verifier = new ScheduledUpdateCertificatesVerifier(
                    wechatPay2Credentials,
                    apiV3Key.getBytes(StandardCharsets.UTF_8));
    
            return verifier;
        }
    
    /**
         * 获取http请求对象
         *
         * @param verifier
         * @return*/
    
    
        @Bean(name = "wxPayClient")
        public CloseableHttpClient getWxPayClient(ScheduledUpdateCertificatesVerifier verifier) {
    
            log.info("获取httpClient");
    
            //获取商户私钥
            PrivateKey privateKey = getPrivateKey(privateKeyPath);
    
            WechatPayHttpClientBuilder builder = WechatPayHttpClientBuilder.create()
                    .withMerchant(mchId, mchSerialNo, privateKey)
                    .withValidator(new WechatPay2Validator(verifier));
            // ... 接下来，你仍然可以通过builder设置各种参数，来配置你的HttpClient
    
            // 通过WechatPayHttpClientBuilder构造的HttpClient，会自动的处理签名和验签，并进行证书自动更新
            CloseableHttpClient httpClient = builder.build();
    
            return httpClient;
        }
    
    /** 获取HttpClient，无需进行应答签名验证，跳过验签的流程*/
    
        @Bean(name = "wxPayNoSignClient")
        public CloseableHttpClient getWxPayNoSignClient() {
    
            //获取商户私钥
            PrivateKey privateKey = getPrivateKey(privateKeyPath);
    
            //用于构造HttpClient
            WechatPayHttpClientBuilder builder = WechatPayHttpClientBuilder.create()
                    //设置商户信息
                    .withMerchant(mchId, mchSerialNo, privateKey)
                    //无需进行签名验证、通过withValidator((response) -> true)实现
                    .withValidator((response) -> true);
    
            // 通过WechatPayHttpClientBuilder构造的HttpClient，会自动的处理签名和验签，并进行证书自动更新
            CloseableHttpClient httpClient = builder.build();
    
            log.info("== getWxPayNoSignClient END ==");
    
            return httpClient;
        }
    
    }

**说明：**

将以上代码中的信息改成自己公众号中申请的信息。

（1）其中商户私钥文件要下载下来，放在resources文件夹下

![9fbd36a4668d4caba2b142a539f33c6b.png][]

（2）支付接收结果通知地址，需要在微信公众平台设置成功

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMzc0NjQz_size_16_color_FFFFFF_t_70]

**在保存设置时，微信公众平台会向设置的地址发送验证请求，只有地址能被正常调用，且验证通过才能保存成功（此处有点坑）**

**需要注意：**

**a. 该回调接口要能被外网访问到,若想在本地调试，需要做代理转发，我是直接部署到线上了**

**b. 回调地址验证代码（接口名称改成自己的就可以）**

@RequestMapping(value = "/notify",method = RequestMethod.GET)
        @ResponseBody
        public String validate(HttpServletRequest request,HttpServletResponse response) {
            System.out.println("支付回调验证接口");
            Gson gson = new Gson();
            String timestamp = request.getParameter("timestamp");
            String nonce = request.getParameter("nonce");
            String signature = request.getParameter("signature");
            String echostr = request.getParameter("echostr");
            String[] arr = new String[]{"helloworld", timestamp, nonce};//helloworld为设置的token令牌
            System.out.println("回调验证arr"+arr);
    
            //排序
            Arrays.sort(arr);
            //生成字符串
            StringBuffer content = new StringBuffer();
            for (int i = 0; i < arr.length; i++) {
                content.append(arr[i]);//拼接字符串
            }
            String mySignature = CheckUtil.shal(content.toString());
            System.out.println("mySignature:"+mySignature);
            if (!"".equals(signature) && !"".equals(mySignature) && signature.equals(mySignature)) {
                System.out.println("-----签名校验通过-----");
                return echostr;//验证通过将echostr原封返回
            } else {
                System.out.println("-----校验签名失败-----");
                return "error";
            }
        }

### 2. 统一管理微信支付地址 ###

package com.zlhy.business.utils.wxpay;
    
    import lombok.AllArgsConstructor;
    import lombok.Getter;
    
    @AllArgsConstructor
    @Getter
    public enum WxApiType {
    
        /**
         * Native下单
         */
        NATIVE_PAY("/v3/pay/transactions/native"),
    
        /**
         * JSAPI下单
         */
        JSAPI_PAY("/v3/pay/transactions/jsapi"),
    
        /**
         * 查询订单
         */
        ORDER_QUERY_BY_NO("/v3/pay/transactions/out-trade-no/%s"),
    
        /**
         * 关闭订单
         */
        CLOSE_ORDER_BY_NO("/v3/pay/transactions/out-trade-no/%s/close"),
    
        /**
         * 支付通知
         */
        NATIVE_NOTIFY("api/business/wxPay/notifyOrder");
    
        /**
         * 类型
         */
        private final String type;
    }

## 二、实现JSAPI下单 ##

### 1. 接口，主要参数—openid ###

@ApiOperation(value = "JSAPI微信支付下单",notes = "调起微信支付")
        @GetMapping("/jsapi")
        public JsonResult jsapiPay(@RequestParam("productId") Integer productId,
                                   @RequestParam("openId") String openId,
                                   @RequestParam("amount") BigDecimal amount,
                                   HttpServletRequest request) {
            return wxPayService.jsapiPay(productId,openId,amount,request);
        }

### 2. 下单处理 ###

@Transactional(rollbackFor = Exception.class)
        @Override
        @SneakyThrows
        public JsonResult jsapiPay(Integer productId, String openId,BigDecimal amount,HttpServletRequest request) {
    
            System.out.println("发起JSAPI支付请求");
            HttpPost httpPost = new HttpPost(wxPayConfig.getDomain().concat(WxApiType.JSAPI_PAY.getType()));
            Map<String, String> resultMap = wxPayExecute(productId,openId,amount, httpPost,request);//此处为业务代码
            if (!resultMap.isEmpty()) {
                String prepayId = resultMap.get("prepay_id");
                Map<String, Object> resultMap2 = this.pay(prepayId);
                return JsonResult.success(resultMap2);
            }
            return JsonResult.failure("支付失败");
        }

### 3.下单业务代码 ###

// 封装统一下单方法
        private Map<String, String> wxPayExecute(Integer productId,String openId,BigDecimal amount,HttpPost httpPost,HttpServletRequest request) throws Exception {
            Map<String, String> resultMap = new HashMap<>();
             // 获取产品相关信息
            BusinessVipProductEntity vipProductEntity = vipProductService.getById(productId);
            if (null == vipProductEntity) {
                throw new Exception("vip产品不存在");
            }
            JSONObject classConfig = vipProductEntity.getClassConfig();
            if (null == classConfig) {
                throw new Exception("vip产品配置不存在");
            }
    
            // 从登录信息中获取用户信息
            UserEntity user = sessionUtil.getUserFromCookieAndSession(request);
            Long userId = user.getId();
    
            // 请求body参数
            Gson gson = new Gson();
            Map<String,Object> paramsMap = new HashMap<>();
            paramsMap.put("appid", wxPayConfig.getAppid());
            paramsMap.put("mchid", wxPayConfig.getMchId());
            paramsMap.put("description", vipProductEntity.getName());
            String orderNum = WxPayUtil.generateOrderNumber(userId.intValue(),productId);
            paramsMap.put("out_trade_no", orderNum); //订单号
            paramsMap.put("notify_url", wxPayConfig.getNotifyDomain().concat(WxApiType.NATIVE_NOTIFY.getType()));
    
            Map<String,Object> amountMap = new HashMap<>();
            JSONObject attachJson = new JSONObject();
            if (amount != null) {
                //由单位：元 转换为单位：分，并由Bigdecimal转换为整型
                BigDecimal total = amount.multiply(new BigDecimal(100));
                amountMap.put("total", total.intValue());
                attachJson.put("total",total);
            }
            amountMap.put("currency", "CNY");
            paramsMap.put("amount", amountMap);
    
            // 判断是Navicat下单还是JSAPI下单 JSAPI需要传OPENID
            if (StringUtils.isNotBlank(openId)) {
                Map<String,Object> payerMap = new HashMap<>();
                payerMap.put("openid",openId);
                paramsMap.put("payer",payerMap);
            }
    
            attachJson.put("productId",productId);
            attachJson.put("userId",userId);
            paramsMap.put("attach",attachJson.toJSONString());
            //将参数转换成json字符串
            String jsonParams = gson.toJson(paramsMap);
            System.out.println("请求参数 ===>"+jsonParams);
    
            //生成支付
            StringEntity entity = new StringEntity(jsonParams, "utf-8");
            entity.setContentType("application/json");
            httpPost.setEntity(entity);
            httpPost.setHeader("Accept", "application/json");
            //完成签名并执行请求
            CloseableHttpResponse response = wxPayClient.execute(httpPost);
    
            try {
                String bodyAsString = EntityUtils.toString(response.getEntity());//响应体
                int statusCode = response.getStatusLine().getStatusCode();//响应状态码
                if (statusCode == 200) { //处理成功
                    System.out.println("成功, 返回结果 = " + bodyAsString);
                } else if (statusCode == 204) { //处理成功，无返回Body
                    System.out.println("成功");
                } else {
                    System.out.println("JSAPI下单失败,响应码 = " + statusCode + ",返回结果 = " + bodyAsString);
                    throw new IOException("request failed");
                }
    
                Gson gson2 = new Gson();
    
                //响应结果
                resultMap = gson2.fromJson(bodyAsString, HashMap.class);
    
                //处理订单
                if (!resultMap.isEmpty()){
                    BusinessProductOrderEntity productOrder = new BusinessProductOrderEntity();
                    productOrder.setUserId(userId);
                    productOrder.setProductId(productId);
                    productOrder.setProductName(vipProductEntity.getName());
                    productOrder.setAmount(amount);
                    productOrder.setOrderNum(orderNum);
                    productOrder.setStatus(0);//初始化订单
                    productOrder.setCreateTime(new Date());
                    productOrder.setUpdateTime(new Date());
                    productOrderService.save(productOrder);
                }
            }finally {
                response.close();
            }
           return resultMap;
        }

**业务代码部分根据自身业务需要修改**

**注意此处的notify\_url，为支付回调地址，可以与之前设置的回调地址不同，之前设置的回调地址只是一个验证地址，真正的回调地址可以另外设置**

## **三、支付回调** ##

### 1. 接口（接口要与支付时的**notify\_url保持一致**） ###

/**
         * 支付通知
         * 微信支付通过支付通知接口将用户支付成功消息通知给商户*/
        @ApiOperation(value = "支付回调接口", notes = "微信支付回调")
        @PostMapping("/notifyOrder")
        public String payNotify(HttpServletRequest request,HttpServletResponse response) {
            return wxPayService.payNotify(request,response);
        }

### 2. 代码实现 ###

/**
         * 支付通知
         * @return*/
    
    
        @Override
        @Transactional
        public String payNotify(HttpServletRequest request,HttpServletResponse response){
            Gson gson = new Gson();
            try {
                //处理通知参数
                String body = WxPayUtil.readData(request);
                Map<String, Object> bodyMap = gson.fromJson(body, HashMap.class);
                String requestId = (String) bodyMap.get("id");
    
                //签名的验证
                WechatPay2ValidatorForRequest wechatPay2ValidatorForRequest
                        = new WechatPay2ValidatorForRequest(verifier, requestId, body);
    
                if (! wechatPay2ValidatorForRequest.validate(request)) {
                    response.setStatus(500);
                    final HashMap<String, Object> map = new HashMap<>();
                    map.put("code", "ERROR");
                    map.put("message", "通知验签失败");
                    System.out.println("通知验签失败");
                    return gson.toJson(map);
                }
    
                System.out.println("通知验签成功");
                //处理订单，此处为业务代码
                return processOrder(bodyMap,response);
            } catch (Exception e) {
                e.printStackTrace();
                response.setStatus(500);
                final HashMap<String, Object> map = new HashMap<>();
                map.put("code", "ERROR");
                map.put("message", "通知失败");
                return gson.toJson(map);
            }
        }

### 3. 订单业务代码 ###

/**
         * 处理订单
         *
         * @param bodyMap*/
    
        @Transactional
        @SneakyThrows
        public String processOrder(Map<String, Object> bodyMap,HttpServletResponse response){
            System.out.println("处理订单");
            //解密报文
            String plainText = decryptFromResource(bodyMap);
    
            //将明文转换成map
            Gson gson = new Gson();
            HashMap plainTextMap = gson.fromJson(plainText, HashMap.class);
            String orderNo = (String) plainTextMap.get("out_trade_no");
            String attach = (String) plainTextMap.get("attach");
            JSONObject attachJson = JSONObject.parseObject(attach);
            Integer packageId = attachJson.getInteger("packageId");
            Integer userId = attachJson.getInteger("userId");
            Integer total = attachJson.getInteger("total");
            /*
            在对业务数据进行状态检查和处理之前，
                    要采用数据锁进行并发控制，
                    以避免函数重入造成的数据混乱*/
            //尝试获取锁：
            // 成功获取则立即返回true，获取失败则立即返回false。不必一直等待锁的释放
            if (lock.tryLock()) {
                try {
    
                    System.out.println("plainText="+plainText);
    
                    //处理重复的通知
                    //接口调用的幂等性：无论接口被调用多少次，产生的结果是一致的。
                    BusinessProductOrderEntity productOrder = productOrderService.getByOoderNum(orderNo);
                    if (productOrder != null){
                        if (1 == productOrder.getStatus()) {
                            response.setStatus(200);
                            final HashMap<String, Object> resultMap = new HashMap<>();
                            resultMap.put("code", "SUCCESS");
                            resultMap.put("message", "成功");
                            return gson.toJson(resultMap);
                        }
                        // TODO 修改订单状态、添加支付记录等
                        //处理订单，处理自身业码
                        if (productOrder != null) {
                            productOrder.setStatus(1);
                            productOrder.setUpdateTime(new Date());
                            productOrderService.updateById(productOrder);
                        }
                    }
                    response.setStatus(200);
                    final HashMap<String, Object> resultMap = new HashMap<>();
                    resultMap.put("code", "SUCCESS");
                    resultMap.put("message", "成功");
                    return gson.toJson(resultMap);
                } finally {
                    //要主动释放锁
                    lock.unlock();
                }
            }
            response.setStatus(500);
            final HashMap<String, Object> map = new HashMap<>();
            map.put("code", "ERROR");
            map.put("message", "通知失败");
            return gson.toJson(map);
        }
    
    /**
         * 对称解密
         *
         * @param bodyMap
         * @return*/
    
    
    
        @SneakyThrows
        private String decryptFromResource(Map<String, Object> bodyMap) {
    
            System.out.println("密文解密");
    
            //通知数据
            Map<String, String> resourceMap = (Map) bodyMap.get("resource");
            //数据密文
            String ciphertext = resourceMap.get("ciphertext");
            //随机串
            String nonce = resourceMap.get("nonce");
            //附加数据
            String associatedData = resourceMap.get("associated_data");
    
            AesUtil aesUtil = new AesUtil(wxPayConfig.getApiV3Key().getBytes(StandardCharsets.UTF_8));
            //数据明文
            String plainText = aesUtil.decryptToString(associatedData.getBytes(StandardCharsets.UTF_8),
                    nonce.getBytes(StandardCharsets.UTF_8),
                    ciphertext);
    
            return plainText;
        }

**需处理微信的重复调用，若未处理则会给用户发多条消息，此处要根据自身订单状态判断处理。**

[9fbd36a4668d4caba2b142a539f33c6b.png]: https://img-blog.csdnimg.cn/9fbd36a4668d4caba2b142a539f33c6b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMzc0NjQz_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20210123165450152.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMzc0NjQz,size_16,color_FFFFFF,t_70