devbox
小桥流水78
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

JAVA 微信APPV3支付(保姆级)_java微信支付

作者：小桥流水78 | 2024-08-14 19:56:39

赞

踩

java微信支付

2024.05.07更新方法

更新WXPaySignatureCertificateUtil.java 工具类 详细看3.1

许多人对AutoUpdateCertificatesVerifier验证有疑问 

所以此次更新使用Verifier验证

这里有两种验证证书方式

AutoUpdateCertificatesVerifier和Verifier

两者自选使用

2024.02.05更新方法

去掉了重复代码 更新以下

更新验证签名方法

更新回调验签方法

更新随机字符串使用

小程序去下面

java微信小程序v3支付（保姆级）

java微信商户转账（保姆级）

现在Java微信支付文章五花八门 看不懂 看的懵 掺杂业务逻辑不知名的返回封装 爆红一片 不妨看看这篇

 由于微信更新了0.4.9版本 部分使用微信支付会解析报错 原因是微信内置了Jackson2.13.xxx依赖会与springboot这个Jackson产生冲突 可能会无法升级依赖 因为升级了也会使用老版本依赖

解决方法需要把微信支付解析 验签等方法分离重写 目前没时间写文章 无法自行解决的请私信

1.加入Maven依赖

  1.         <!-- 微信支付V3 目前新版本-->
  2.         <dependency>
  3.             <groupId>com.github.wechatpay-apiv3</groupId>
  4.             <artifactId>wechatpay-apache-httpclient</artifactId>
  5.             <version>0.4.9</version>
  6.         </dependency>

2.更新创建WxV3PayConfig.java配置类 

  1. /**
  2.  * implements WXPayConfig
  3.  */
  4. @Data
  5. public class WxV3PayConfig {
  6.  
  7.     //平台证书序列号
  8.     public static String mchSerialNo = "xxxxxxxxxxxxxx";
  9.  
  10.     //appID
  11.     public static String APP_ID = "xxxxxxxxxxxxxx";
  12.  
  13.     //商户id
  14.     public static String Mch_ID = "xxxxxxxxxxxxxx";
  15.  
  16.     // API V3密钥
  17.     public static String apiV3Key = "xxxxxxxxxxxxxx";
  18.  
  19.   
  20.  
  21.     }

3.创建WXPaySignatureCertificateUtil.java 工具类

使用AutoUpdateCertificatesVerifier验证

复制粘贴即可

  1. /***
  2. *
  3. *包都在这
  4. *
  5. *
  6. *
  7. */
  8. import com.wechat.pay.contrib.apache.httpclient.WechatPayHttpClientBuilder;
  9. import com.wechat.pay.contrib.apache.httpclient.auth.AutoUpdateCertificatesVerifier;
  10. import com.wechat.pay.contrib.apache.httpclient.auth.PrivateKeySigner;
  11. import com.wechat.pay.contrib.apache.httpclient.auth.WechatPay2Credentials;
  12. import com.wechat.pay.contrib.apache.httpclient.auth.WechatPay2Validator;
  13. import com.wechat.pay.contrib.apache.httpclient.util.PemUtil;
  14. import lombok.SneakyThrows;
  15. import org.apache.http.impl.client.CloseableHttpClient;
  16. import javax.servlet.http.HttpServletRequest;
  17. import java.io.ByteArrayInputStream;
  18. import java.io.IOException;
  19. import java.io.UnsupportedEncodingException;
  20. import java.nio.charset.StandardCharsets;
  21. import java.nio.file.Files;
  22. import java.nio.file.Paths;
  23. import java.security.*;
  24. import java.security.spec.InvalidKeySpecException;
  25. import java.security.spec.PKCS8EncodedKeySpec;
  26. import java.util.Base64;
  27. import java.util.concurrent.ConcurrentHashMap;
  28. import java.util.stream.Collectors;
  29. import java.util.stream.Stream;
  30.  
  31. public class WXPaySignatureCertificateUtil {
  32.  
  33.  
  34.  
  35.  
  36.     /**
  37.      * 证书验证
  38.      * 自动更新的签名验证器
  39.      */
  40.     public static CloseableHttpClient checkSign() throws IOException {
  41.         //验签
  42.         CloseableHttpClient httpClient = null;
  43.         PrivateKey merchantPrivateKey = WXPaySignatureCertificateUtil.getPrivateKey();
  44.         httpClient = WechatPayHttpClientBuilder.create()
  45.                 .withMerchant(WxV3PayConfig.Mch_ID, WxV3PayConfig.mchSerialNo, merchantPrivateKey)
  46.                 .withValidator(new WechatPay2Validator(WXPaySignatureCertificateUtil.getVerifier(WxV3PayConfig.mchSerialNo)))
  47.                 .build();
  48.  
  49.         return httpClient;
  50.     }
  51.  
  52.  
  53.  
  54.  
  55.     /**
  56.      * 保存微信平台证书
  57.      */
  58.     private static final ConcurrentHashMap<String, AutoUpdateCertificatesVerifier> verifierMap = new ConcurrentHashMap<>();
  59.  
  60.     /**
  61.      * 功能描述:获取平台证书，自动更新
  62.      * 注意：这个方法内置了平台证书的获取和返回值解密
  63.      */
  64.     static AutoUpdateCertificatesVerifier getVerifier() {
  65.         String mchSerialNo = WxV3PayConfig.mchSerialNo;
  66.         AutoUpdateCertificatesVerifier verifier = null;
  67.         if (verifierMap.isEmpty() || !verifierMap.containsKey(mchSerialNo)) {
  68.             verifierMap.clear();
  69.             try {
  70.                  //传入证书
  71.                  PrivateKey privateKey = getPrivateKey();
  72.                 //刷新
  73.                 PrivateKeySigner signer = new PrivateKeySigner(mchSerialNo, privateKey);
  74.                 WechatPay2Credentials credentials = new WechatPay2Credentials(WxV3PayConfig.Mch_ID, signer);
  75.                 verifier = new AutoUpdateCertificatesVerifier(credentials
  76.                         , WxV3PayConfig.apiV3Key.getBytes("utf-8"));
  77.                 verifierMap.put(verifier.getValidCertificate().getSerialNumber()+"", verifier);
  78.             } catch (UnsupportedEncodingException e) {
  79.                 e.printStackTrace();
  80.             }
  81.         } else {
  82.             verifier = verifierMap.get(mchSerialNo);
  83.         }
  84.         return verifier;
  85.     }
  86.  
  87.  
  88.  
  89.     /**
  90.      * app生成带签名支付信息
  91.      *
  92.      * @param timestamp 时间戳
  93.      * @param nonceStr  随机数
  94.      * @param prepayId  预付单
  95.      * @return 支付信息
  96.      * @throws Exception
  97.      */
  98.     public static String appPaySign(String timestamp, String nonceStr, String prepayId) throws Exception {
  99.         //上传私钥
  100.         PrivateKey privateKey = getPrivateKey();
  101.         String signatureStr = Stream.of(WxV3PayConfig.APP_ID, timestamp, nonceStr, prepayId)
  102.                 .collect(Collectors.joining("\n", "", "\n"));
  103.         Signature sign = Signature.getInstance("SHA256withRSA");
  104.         sign.initSign(privateKey);
  105.         sign.update(signatureStr.getBytes(StandardCharsets.UTF_8));
  106.         return Base64.getEncoder().encodeToString(sign.sign());
  107.     }
  108.  
  109.     /**
  110.      * 小程序及其它支付生成带签名支付信息
  111.      *
  112.      * @param timestamp 时间戳
  113.      * @param nonceStr  随机数
  114.      * @param prepayId  预付单
  115.      * @return 支付信息
  116.      * @throws Exception
  117.      */
  118.     public static String jsApiPaySign(String timestamp, String nonceStr, String prepayId) throws Exception {
  119.         //上传私钥
  120.         PrivateKey privateKey = getPrivateKey();
  121.         String signatureStr = Stream.of(WxV3PayConfig.APP_ID, timestamp, nonceStr, "prepay_id="+prepayId)
  122.                 .collect(Collectors.joining("\n", "", "\n"));
  123.         Signature sign = Signature.getInstance("SHA256withRSA");
  124.         sign.initSign(privateKey);
  125.         sign.update(signatureStr.getBytes(StandardCharsets.UTF_8));
  126.         return Base64.getEncoder().encodeToString(sign.sign());
  127.     }
  128.  
  129.  
  130.     /**
  131.      * 获取私钥。
  132.      * 证书路径 本地使用如： D:\\微信平台证书工具\\7.9\\apiclient_key.pem
  133.      * 证书路径 线上使用如： /usr/apiclient_key.pem
  134.      * String filename 私钥文件路径  (required)
  135.      * @return 私钥对象
  136.      */
  137.     public static PrivateKey getPrivateKey() throws IOException {
  138.         String content = new String(Files.readAllBytes(Paths.get("D:\\微信平台证书工具\\7.9\\apiclient_key.pem")), "utf-8");
  139.         try {
  140.             String privateKey = content.replace("-----BEGIN PRIVATE KEY-----", "")
  141.                     .replace("-----END PRIVATE KEY-----", "")
  142.                     .replaceAll("\\s+", "");
  143.  
  144.             KeyFactory kf = KeyFactory.getInstance("RSA");
  145.             return kf.generatePrivate(
  146.                     new PKCS8EncodedKeySpec(Base64.getDecoder().decode(privateKey)));
  147.         } catch (NoSuchAlgorithmException e) {
  148.             throw new RuntimeException("当前Java环境不支持RSA", e);
  149.         } catch (InvalidKeySpecException e) {
  150.             throw new RuntimeException("无效的密钥格式");
  151.         }
  152.     }
  153.  
  154. }

3.1.更新创建WXPaySignatureCertificateUtil.java 工具类

使用Verifier验证

复制粘贴即可

  1. /***
  2. *
  3. *包都在这
  4. *
  5. *
  6. *
  7. */
  8. import com.wechat.pay.contrib.apache.httpclient.WechatPayHttpClientBuilder;
  9. import com.wechat.pay.contrib.apache.httpclient.auth.AutoUpdateCertificatesVerifier;
  10. import com.wechat.pay.contrib.apache.httpclient.auth.PrivateKeySigner;
  11. import com.wechat.pay.contrib.apache.httpclient.auth.WechatPay2Credentials;
  12. import com.wechat.pay.contrib.apache.httpclient.auth.WechatPay2Validator;
  13. import com.wechat.pay.contrib.apache.httpclient.util.PemUtil;
  14. import lombok.SneakyThrows;
  15. import org.apache.http.impl.client.CloseableHttpClient;
  16. import javax.servlet.http.HttpServletRequest;
  17. import java.io.ByteArrayInputStream;
  18. import java.io.IOException;
  19. import java.io.UnsupportedEncodingException;
  20. import java.nio.charset.StandardCharsets;
  21. import java.nio.file.Files;
  22. import java.nio.file.Paths;
  23. import java.security.*;
  24. import java.security.spec.InvalidKeySpecException;
  25. import java.security.spec.PKCS8EncodedKeySpec;
  26. import java.util.Base64;
  27. import java.util.concurrent.ConcurrentHashMap;
  28. import java.util.stream.Collectors;
  29. import java.util.stream.Stream;
  30.  
  31. public class WXPaySignatureCertificateUtil {
  32.  
  33.  
  34.  
  35.  
  36.     private static final ConcurrentHashMap<String, Verifier> verifierMaps = new ConcurrentHashMap<>();
  37.  
  38.  
  39.    /**
  40.      * 证书验证
  41.      * 自动更新的签名验证器
  42.      */
  43.     public static CloseableHttpClient checkSign() throws IOException {
  44.         //验签
  45.         CloseableHttpClient httpClient = null;
  46.         PrivateKey merchantPrivateKey = WXPaySignatureCertificateUtil.getPrivateKey();
  47.         httpClient = WechatPayHttpClientBuilder.create()
  48.                 .withMerchant(WxV3PayConfig.Mch_ID, WxV3PayConfig.mchSerialNo, merchantPrivateKey)
  49.                 .withValidator(new WechatPay2Validator(WXPaySignatureCertificateUtil.getVerifier(WxV3PayConfig.mchSerialNo)))
  50.                 .build();
  51.  
  52.         return httpClient;
  53.     }
  54.         
  55.  
  56.  
  57.     /**
  58.      * 功能描述:获取平台证书，自动更新
  59.      * 注意：这个方法内置了平台证书的获取和返回值解密
  60.      */
  61.     public static Verifier getVerifiers(String mchSerialNo) {
  62.         Verifier verifier = null;
  63.         if (verifierMaps.isEmpty() || !verifierMaps.containsKey(mchSerialNo)) {
  64.             verifierMaps.clear();
  65.             try {
  66.                 PrivateKey privateKey = getPrivateKey();
  67.                 //刷新
  68.                 PrivateKeySigner signer = new PrivateKeySigner(mchSerialNo, privateKey);
  69.                 WechatPay2Credentials credentials = new WechatPay2Credentials(WxV3PayConfig.Mch_ID, signer);
  70.                 verifier = new AutoUpdateCertificatesVerifier(credentials
  71.                         , apiV3Key.getBytes("utf-8"));
  72.                 verifierMaps.put(verifier.getValidCertificate().getSerialNumber()+"", verifier);
  73.             } catch (UnsupportedEncodingException e) {
  74.                 e.printStackTrace();
  75.             } catch (IOException e) {
  76.                 throw new RuntimeException(e);
  77.             }
  78.         } else {
  79.             verifier = verifierMaps.get(mchSerialNo);
  80.         }
  81.         return verifier;
  82.     }
  83.  
  84.  
  85.     /**
  86.      * app生成带签名支付信息
  87.      *
  88.      * @param timestamp 时间戳
  89.      * @param nonceStr  随机数
  90.      * @param prepayId  预付单
  91.      * @return 支付信息
  92.      * @throws Exception
  93.      */
  94.     public static String appPaySign(String timestamp, String nonceStr, String prepayId) throws Exception {
  95.         //上传私钥
  96.         PrivateKey privateKey = getPrivateKey();
  97.         String signatureStr = Stream.of(WxV3PayConfig.APP_ID, timestamp, nonceStr, prepayId)
  98.                 .collect(Collectors.joining("\n", "", "\n"));
  99.         Signature sign = Signature.getInstance("SHA256withRSA");
  100.         sign.initSign(privateKey);
  101.         sign.update(signatureStr.getBytes(StandardCharsets.UTF_8));
  102.         return Base64.getEncoder().encodeToString(sign.sign());
  103.     }
  104.  
  105.     /**
  106.      * 小程序及其它支付生成带签名支付信息
  107.      *
  108.      * @param timestamp 时间戳
  109.      * @param nonceStr  随机数
  110.      * @param prepayId  预付单
  111.      * @return 支付信息
  112.      * @throws Exception
  113.      */
  114.     public static String jsApiPaySign(String timestamp, String nonceStr, String prepayId) throws Exception {
  115.         //上传私钥
  116.         PrivateKey privateKey = getPrivateKey();
  117.         String signatureStr = Stream.of(WxV3PayConfig.APP_ID, timestamp, nonceStr, "prepay_id="+prepayId)
  118.                 .collect(Collectors.joining("\n", "", "\n"));
  119.         Signature sign = Signature.getInstance("SHA256withRSA");
  120.         sign.initSign(privateKey);
  121.         sign.update(signatureStr.getBytes(StandardCharsets.UTF_8));
  122.         return Base64.getEncoder().encodeToString(sign.sign());
  123.     }
  124.  
  125.  
  126.     /**
  127.      * 获取私钥。
  128.      * 证书路径 本地使用如： D:\\微信平台证书工具\\7.9\\apiclient_key.pem
  129.      * 证书路径 线上使用如： /usr/apiclient_key.pem
  130.      * String filename 私钥文件路径  (required)
  131.      * @return 私钥对象
  132.      */
  133.     public static PrivateKey getPrivateKey() throws IOException {
  134.         String content = new String(Files.readAllBytes(Paths.get("D:\\微信平台证书工具\\7.9\\apiclient_key.pem")), "utf-8");
  135.         try {
  136.             String privateKey = content.replace("-----BEGIN PRIVATE KEY-----", "")
  137.                     .replace("-----END PRIVATE KEY-----", "")
  138.                     .replaceAll("\\s+", "");
  139.  
  140.             KeyFactory kf = KeyFactory.getInstance("RSA");
  141.             return kf.generatePrivate(
  142.                     new PKCS8EncodedKeySpec(Base64.getDecoder().decode(privateKey)));
  143.         } catch (NoSuchAlgorithmException e) {
  144.             throw new RuntimeException("当前Java环境不支持RSA", e);
  145.         } catch (InvalidKeySpecException e) {
  146.             throw new RuntimeException("无效的密钥格式");
  147.         }
  148.     }
  149.  
  150. }

创建WXPayConstants.java类

  1.  
  2. /**
  3.  * 常量
  4.  */
  5. public class WXPayConstants {
  6.  
  7.     public static final String DOMAIN_API = "https://api.mch.weixin.qq.com/v3";
  8.  
  9.     //app下单
  10.     public static final String PAY_TRANSACTIONS_APP = "/pay/transactions/app";
  11.     
  12.  
  13.     //微信支付回调
  14.     public static final String WECHAT_PAY_NOTIFY_URL =         
  15.     "https://xxx.xxxx.com/deal/api/appPayment/weChatPayNotify";
  16.  
  17.  
  18.     //申请退款
  19.     public static final String REFUND_DOMESTIC_REFUNDS      = "/refund/domestic/refunds";
  20.  
  21.     //微信退款回调
  22.     public static final String WECHAT_REFUNDS_NOTIFY_URL = "https://xxx.xxxx.com/api/appPayment/weChatPayRefundsNotify";
  23.  
  24.     //关闭订单
  25.     public static final String PAY_TRANSACTIONS_OUT_TRADE_NO   = "/pay/transactions/out-trade-no/{}/close";
  26.  
  27.    
  28.  
  29.  
  30. }
  31.

这里以APP支付和退款为例

创建WechatPaymentService.java

  1. /**
  2.  * @author 影子
  3.  */
  4. public interface WechatPaymentService
  5. {
  6.  
  7.  
  8.     /**
  9.      * 微信商品支付
  10.      * @param payParam
  11.      * @return
  12.      */
  13.     public Map<String, Object>weChatDoUnifiedOrder() throws Exception;
  14.  
  15.  
  16.  
  17.  
  18.     /**
  19.      * 微信支付回调通知
  20.      * @param
  21.      * @return
  22.      */
  23.     public Map<String, Object> weChatNotificationHandler(HttpServletRequest request, HttpServletResponse response);
  24.  
  25.   /**
  26.      *微信关闭订单
  27.      * @param outTradeNo
  28.      * @return
  29.      */
  30.     public Map<String, Object> closeOrder(String outTradeNo);
  31.  
  32.  
  33.  
  34.  
  35.     /**
  36.      * 申请退款
  37.      * @param
  38.      * @return
  39.      */
  40.     public Map<String, Object> weChatPayRefundsNotify(HttpServletRequest request);
  41.  
  42.  
  43.  
  44.  
  45.     /**
  46.      * 微信退款
  47.      * @param outTradeNo 订单号
  48.      * @return
  49.      */
  50.     public Map<String, Object> weChatRefunds(String outTradeNo);
  51. }

创建WeChatPaymentServiceImpl.java

  1. /*
  2. *
  3. *改了七八遍 照顾找包困难的朋友吧
  4. *
  5. */
  6. import com.alibaba.fastjson.JSONObject;
  7. import com.alipay.api.internal.util.file.ByteArrayOutputStream;
  8. import com.fasterxml.jackson.databind.ObjectMapper;
  9. import com.fasterxml.jackson.databind.node.ObjectNode;
  10. import com.github.wxpay.sdk.WXPayUtil;
  11. import com.wechat.pay.contrib.apache.httpclient.notification.Notification;
  12. import com.wechat.pay.contrib.apache.httpclient.notification.NotificationHandler;
  13. import com.wechat.pay.contrib.apache.httpclient.notification.NotificationRequest;
  14. import org.apache.http.client.methods.CloseableHttpResponse;
  15. import org.apache.http.client.methods.HttpPost;
  16. import org.apache.http.entity.StringEntity;
  17. import org.apache.http.impl.client.CloseableHttpClient;
  18. import org.apache.http.util.EntityUtils;
  19.  
  20. public class WeChatPaymentServiceImpl implements WechatPaymentService {
  21.  
  22.  
  23.  
  24.  /**
  25.      * V3微信支付统一下单
  26.      *
  27.      * @param payParam
  28.      * @return
  29.      * 
  30.      */
  31.     @Override
  32.     public Map<String, Object>weChatDoUnifiedOrder() {
  33.         Map<String,Object> map =new HashMap<>();
  34.         //支付总金额
  35.         BigDecimal totalPrice = BigDecimal.ZERO;
  36.         totalPrice = totalPrice.add(BigDecimal.valueOf(600));
  37.         //转换金额保留两位小数点
  38.         Integer money=new BigDecimal(String.valueOf(totalPrice)).movePointRight(2).intValue();
  39.             try {
  40.                 //验证证书
  41.                 CloseableHttpClient httpClient = WXPaySignatureCertificateUtil.checkSign();
  42.                 //app下单
  43.                 HttpPost httpPost = new HttpPost(WXPayConstants.DOMAIN_API+WXPayConstants.PAY_TRANSACTIONS_APP);
  44.                 httpPost.addHeader("Accept", "application/json");
  45.                 httpPost.addHeader("Content-type", "application/json; charset=utf-8");
  46.                 ByteArrayOutputStream bos = new ByteArrayOutputStream();
  47.                 ObjectMapper objectMapper = new ObjectMapper();
  48.                 ObjectNode rootNode = objectMapper.createObjectNode();
  49.                 rootNode.put("mchid", "商户id")
  50.                         .put("appid", "APPID")
  51.                         .put("description","描述")
  52.                         .put("notify_url", WXPayConstants.WECHAT_PAY_NOTIFY_URL)//回调
  53.                         .put("out_trade_no", "订单号");
  54.                 rootNode.putObject("amount")
  55.                         .put("total","总金额");
  56.                 objectMapper.writeValue(bos, rootNode);
  57.                 httpPost.setEntity(new StringEntity(bos.toString("UTF-8"), "UTF-8"));
  58.                 //完成签名并执行请求
  59.                 CloseableHttpResponse response = httpClient.execute(httpPost);
  60.                 //获取返回状态
  61.                 int statusCode = response.getStatusLine().getStatusCode();
  62.                 if (statusCode == 200) { //处理成功
  63.                     String result = EntityUtils.toString(response.getEntity(), "UTF-8");
  64.                     JSONObject object = JSONObject.parseObject(result);
  65.                     //获取预付单
  66.                     String prepayId = object.getString("prepay_id");
  67.                     //生成签名
  68.                     Long timestamp = System.currentTimeMillis() / 1000;
  69.                     //随机字符串 这个是微信支付maven自带的 也可以用其它的
  70.                     //这个是v2支付依赖自带的工具包 可以去掉了
  71.                     //String nonceStr = WXPayUtil.generateNonceStr();
  72.                     //该方法org.apache.commons.lang3.RandomStringUtils依赖自带随机生成字符串 RandomStringUtils.randomAlphanumeric(32) 代表生成32位
  73.                     String nonceStr = RandomStringUtils.randomAlphanumeric(32);
  74.                     //生成带签名支付信息
  75.                     String paySign = WXPaySignatureCertificateUtil.appPaySign(String.valueOf(timestamp), nonceStr, prepayId);
  76.                     Map<String, String> param = new HashMap<>();
  77.                     param.put("appid", WxV3PayConfig.APP_ID);
  78.                     param.put("partnerid", WxV3PayConfig.Mch_ID);
  79.                     param.put("prepayid", prepayId);
  80.                     param.put("package", "Sign=WXPay");
  81.                     param.put("noncestr", nonceStr);
  82.                     param.put("timestamp", String.valueOf(timestamp));
  83.                     param.put("sign", paySign);
  84.                     map.put("code",200);
  85.                     map.put("message", "下单成功");
  86.                     map.put("data", param);
  87.                     return map;
  88.                 }
  89.                     map.put("code",200);
  90.                     map.put("message", "下单失败");
  91.                     map.put("data", response);
  92.                     return map;
  93.             } catch (Exception e) {
  94.                 e.printStackTrace();
  95.             }
  96.     }
  97.  
  98.  
  99.     /**
  100.      * 微信支付回调通知
  101.      * @return
  102.      */
  103.     @Override
  104.     public Map<String, Object> weChatNotificationHandler(HttpServletRequest request, HttpServletResponse response){
  105.         Map<String,Object> map = new HashMap<>();
  106.         try {
  107.             BufferedReader br = request.getReader();
  108.             String str = null;
  109.             StringBuilder sb = new StringBuilder();
  110.             while ((str = br.readLine())!=null) {
  111.                 sb.append(str);
  112.             }
  113.             // 构建request，传入必要参数
  114.             NotificationRequest requests = new NotificationRequest.Builder()
  115.                     .withSerialNumber(request.getHeader("Wechatpay-Serial"))
  116.                     .withNonce(request.getHeader("Wechatpay-Nonce"))
  117.                     .withTimestamp(request.getHeader("Wechatpay-Timestamp"))
  118.                     .withSignature(request.getHeader("Wechatpay-Signature"))
  119.                     .withBody(String.valueOf(sb))
  120.                     .build();
  121.             //验签
  122.             NotificationHandler handler = new NotificationHandler(WXPaySignatureCertificateUtil.getVerifier(), WxV3PayConfig.apiV3Key.getBytes(StandardCharsets.UTF_8));
  123.             //解析请求体
  124.             Notification notification = handler.parse(requests);
  125.             String decryptData = notification.getDecryptData();
  126.             //解析
  127.             JSONObject jsonObject = JSONObject.parseObject(decryptData);
  128.             //支付状态交易状态，枚举值： SUCCESS：支付成功 REFUND：转入退款 NOTPAY：未支付 CLOSED：已关闭 REVOKED：已撤销（付款码支付）
  129.             // USERPAYING：用户支付中（付款码支付） PAYERROR：支付失败(其他原因，如银行返回失败)
  130.             String trade_state = String.valueOf(jsonObject.get("trade_state"));
  131.             if (trade_state.equals("SUCCESS")) {
  132.                 //订单号
  133.                 String orderNumber = String.valueOf(jsonObject.get("out_trade_no"));
  134.                 //微信支付微信生成的订单号
  135.                 String transactionId = String.valueOf(jsonObject.get("transaction_id"));
  136.                 //省略查询订单
  137.                 //此处处理业务
  138.                     map.put("code","SUCCESS");
  139.                     map.put("message","成功");
  140.                     //消息推送成功
  141.                     return map;
  142.                 }
  143.                 map.put("code","RESOURCE_NOT_EXISTS");
  144.                 map.put("message", "订单不存在");
  145.                 return map;
  146.             }catch (Exception e) {
  147.             e.printStackTrace();
  148.         }
  149.         map.put("code","FAIL");
  150.         map.put("message", "失败");
  151.         return map;
  152.     }
  153. /**
  154.      * 关闭订单
  155.      * @param outTradeNo 订单号
  156.      * @return
  157.      */
  158.     @Override
  159.     public Map<String, Object> closeOrder(String outTradeNo) {
  160.         Map<String,Object> map = new HashMap<>();
  161.         try {
  162.             //验证证书
  163.                 CloseableHttpClient httpClient = WXPaySignatureCertificateUtil.checkSign();
  164.             //关闭订单
  165.             String url = StrFormatter.format(WXPayConstants.DOMAIN_API+WXPayConstants.PAY_TRANSACTIONS_OUT_TRADE_NO, outTradeNo);
  166.             HttpPost httpPost = new HttpPost(url);
  167.             httpPost.addHeader("Accept", "application/json");
  168.             httpPost.addHeader("Content-type", "application/json; charset=utf-8");
  169.             ByteArrayOutputStream bos = new ByteArrayOutputStream();
  170.             //2.添加商户id
  171.             ObjectMapper objectMapper = new ObjectMapper();
  172.             ObjectNode rootNode = objectMapper.createObjectNode();
  173.             rootNode.put("mchid", WxV3PayConfig.Mch_ID);
  174.             objectMapper.writeValue(bos, rootNode);
  175.             //3.调起微信关单接口
  176.             httpPost.setEntity(new StringEntity(bos.toString("UTF-8"), "UTF-8"));
  177.             //完成签名并执行请求
  178.             CloseableHttpResponse response = httpClient.execute(httpPost);
  179.             System.out.println(response.getStatusLine().getStatusCode() == 204);
  180.             //无数据（Http状态码为204） 微信返回结果无数据 状态码为204 成功
  181.             if (response.getStatusLine().getStatusCode() == 204) {
  182.                 
  183.                 //code 退款码请前往微信支付文档查询
  184.                 map.put("code",200);
  185.                 map.put("message", "关闭订单成功！");
  186.                 return map;
  187.             }
  188.         } catch (Exception e) {
  189.             log.error("关单失败:" + outTradeNo + e);
  190.         }
  191.         return null;
  192.     }
  193.  
  194.  /**
  195.      * 微信退款
  196.      * @param outTradeNo 订单号
  197.      * @return
  198.      */
  199.     @Override
  200.     public Map<String, Object> weChatRefunds(String outTradeNo) {
  201.         Map<String,Object> map = new HashMap<>();
  202.         //退款总金额
  203.         BigDecimal totalPrice = BigDecimal.ZERO;
  204.         totalPrice = totalPrice.add(BigDecimal.valueOf(600));
  205.         //转换金额
  206.         Integer money=new BigDecimal(String.valueOf(totalPrice)).movePointRight(2).intValue();
  207.         
  208.         try {
  209.             //验证证书
  210.              CloseableHttpClient httpClient = WXPaySignatureCertificateUtil.checkSign();
  211.             //申请退款接口
  212.             HttpPost httpPost = new HttpPost(WXPayConstants.DOMAIN_API+WXPayConstants.REFUND_DOMESTIC_REFUNDS);
  213.             httpPost.addHeader("Accept", "application/json");
  214.             httpPost.addHeader("Content-type","application/json; charset=utf-8");
  215.             ByteArrayOutputStream bos = new ByteArrayOutputStream();
  216.             ObjectMapper objectMapper = new ObjectMapper();
  217.             ObjectNode rootNode = objectMapper.createObjectNode();
  218.             //微信支付订单号
  219.             rootNode.put("transaction_id", "微信支付订单号")
  220.                     //退款订单号
  221.                     .put("out_refund_no","生成退款订单号")
  222.                     .put("notify_url","退款回调");
  223.                     //退款金额
  224.             rootNode.putObject("amount")
  225.                     .put("refund", "100.00")
  226.                     //原订单金额
  227.                     .put("total", "100.00")
  228.                     .put("currency","CNY");
  229.             objectMapper.writeValue(bos, rootNode);
  230.             httpPost.setEntity(new StringEntity(bos.toString("UTF-8"), "UTF-8"));
  231.             CloseableHttpResponse response = httpClient.execute(httpPost);
  232.             //退款成功返回消息
  233.             String bodyAsString = EntityUtils.toString(response.getEntity());
  234.             JSONObject jsonObject = JSONObject.parseObject(bodyAsString);
  235.             if (jsonObject.get("status").equals("SUCCESS") || jsonObject.get("status").equals("PROCESSING")) {
  236.                 //code返回
  237.                 map.put("code",200);
  238.                 map.put("message", "退款成功");
  239.                 return map;
  240.             }
  241.         }catch (Exception e) {
  242.             e.printStackTrace();
  243.         }
  244.         map.put("code",500);
  245.         map.put("message", "申请退款失败！");
  246.         map.put("data", jsonObject);
  247.         return map;
  248.     }
  249.  
  250.     /**
  251.      * 申请退款回调
  252.      * @param request
  253.      * @return
  254.      */
  255.     @Override
  256.     public Map<String,Object> weChatPayRefundsNotify(HttpServletRequest request) {
  257.         Map<String,Object> map = new HashMap<>();
  258.         try {
  259.             BufferedReader br = request.getReader();
  260.             String str = null;
  261.             StringBuilder sb = new StringBuilder();
  262.             while ((str = br.readLine())!=null) {
  263.                 sb.append(str);
  264.             }
  265.             // 构建request，传入必要参数
  266.             NotificationRequest requests = new NotificationRequest.Builder()
  267.                     .withSerialNumber(request.getHeader("Wechatpay-Serial"))
  268.                     .withNonce(request.getHeader("Wechatpay-Nonce"))
  269.                     .withTimestamp(request.getHeader("Wechatpay-Timestamp"))
  270.                     .withSignature(request.getHeader("Wechatpay-Signature"))
  271.                     .withBody(String.valueOf(sb))
  272.                     .build();
  273.             //验签
  274.             NotificationHandler handler = new NotificationHandler(WXPaySignatureCertificateUtil.getVerifier(), WxV3PayConfig.apiV3Key.getBytes(StandardCharsets.UTF_8));
  275.             //解析请求体
  276.             Notification notification = handler.parse(requests);
  277.             String decryptData = notification.getDecryptData();
  278.             //解析
  279.             JSONObject jsonObject = JSONObject.parseObject(decryptData);
  280.             String refund_status = String.valueOf(jsonObject.get("refund_status"));
  281.             if (refund_status.equals("SUCCESS")) {
  282.                 //订单号
  283.                 String orderNumber = String.valueOf(jsonObject.get("out_trade_no"));
  284.                 //微信支付订单号
  285.                 String transactionId = String.valueOf(jsonObject.get("transaction_id"));
  286.  
  287.                 //这里是处理业务逻辑
  288.                 
  289.                 
  290.                 //code 退款码请前往微信支付文档查询
  291.                 map.put("code","RESOURCE_NOT_EXISTS");
  292.                 map.put("message", "订单不存在");
  293.                 return map;
  294.             }
  295.         }catch (Exception e) {
  296.             e.printStackTrace();
  297.         }
  298.         map.put("code","USER_ACCOUNT_ABNORMAL");
  299.         map.put("message", "退款请求失败");
  300.         return map;
  301.     }
  302.  
  303. }

代码可复制粘贴使用 无业务逻辑代码 支付代码简洁

如果更换支付类型如：APP、二维码支付、扫码支付、JSAPI支付

请看以下示例二维码支付代码

 HttpPost httpPost = new HttpPost("https://api.mch.weixin.qq.com/v3"+"/pay/transactions/native");

 HttpPost httpPost = new HttpPost（"这里更换"）

整体不变只需要微信返回正确状态码内处理即可 如以下返回为 二维码支付参数

  1.             //完成签名并执行请求
  2.                 CloseableHttpResponse response = httpClient.execute(httpPost);
  3.                 //获取返回状态
  4.                 int statusCode = response.getStatusLine().getStatusCode();
  5.            if (statusCode == 200) { //处理成功
  6.               String result = EntityUtils.toString(response.getEntity(), "UTF-8");
  7.               JSONObject object = JSONObject.parseObject(result);
  8.                  map.put("code",200);
  9.                  map.put("message", "下单成功");
  10.                  map.put("data", object);
  11.                  return map;
  12.            }
  13.                  map.put("code",500);
  14.                  map.put("message", "下单失败");
  15.                  map.put("data", response);
  16.                  return map;

修改方式 根据官方文档返回参数类型为准

你学废了吗?

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小桥流水78/article/detail/980559
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号