devbox
凡人多烦事01
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

微信支付：springboot企业付款到个人银行卡_springboot 对公账户给微信用户转账

作者：凡人多烦事01 | 2024-03-06 19:35:41

赞

踩

springboot 对公账户给微信用户转账

第一次做这个功能，坑有点多（官方坑也有），最终完全了付款到银行卡功能，一一为大家踩坑。文章只讲解关于转账至银行卡的业务逻辑，需要用到的工具类，还有具体做法都会贴，适合第一次开发此功能的人看。

官方文档：

【微信支付】付款开发者文档

一、准备

1.证书

按照文档操作，得到apiclient_cert.p12文件，将他放到项目内的resources/static内，如果要部署jar到云服务器的，可以把证书放在项目同文件。后面访问时需要证书路径。

2.rsa公钥文件

看文档内获取rsa公钥的文档，准备好请求参数，直接用postman请求，参数中随机值（自己生产也好，随便敲也好，跟示例参数一样多位的随机值就行），sign参数（用签名工具类把几个参数签下名）

签名方式和支付功能一样，可以直接用之前开发支付用的工具类，啥？之前没做支付，没有工具类？

那我贴一下吧：

  1. import org.slf4j.Logger;
  2. import org.slf4j.LoggerFactory;
  3. import org.w3c.dom.Node;
  4. import org.w3c.dom.NodeList;
  5. import org.w3c.dom.Document;
  6. import org.w3c.dom.Element;
  7.  
  8. import javax.xml.parsers.DocumentBuilder;
  9. import javax.xml.transform.OutputKeys;
  10. import javax.xml.transform.Transformer;
  11. import javax.xml.transform.TransformerFactory;
  12. import javax.xml.transform.dom.DOMSource;
  13. import javax.xml.transform.stream.StreamResult;
  14. import java.io.ByteArrayInputStream;
  15. import java.io.InputStream;
  16. import java.io.StringWriter;
  17. import java.util.*;
  18.  
  19. /**
  20.  * 微信支付要用到的：xml解析工具类
  21.  */
  22. public class WXPayUtils {
  23.     /**
  24.      * XML格式字符串转换为Map
  25.      *
  26.      * @param strXML XML字符串
  27.      * @return XML数据转换后的Map
  28.      * @throws Exception
  29.      */
  30.     public static Map<String, String> xmlToMap(String strXML) throws Exception {
  31.         try {
  32.             Map<String, String> data = new HashMap<String, String>();
  33.             DocumentBuilder documentBuilder = WXPayXmlUtil.newDocumentBuilder();
  34.             InputStream stream = new ByteArrayInputStream(strXML.getBytes("UTF-8"));
  35.             org.w3c.dom.Document doc = documentBuilder.parse(stream);
  36.             doc.getDocumentElement().normalize();
  37.             NodeList nodeList = doc.getDocumentElement().getChildNodes();
  38.             for (int idx = 0; idx < nodeList.getLength(); ++idx) {
  39.                 Node node = nodeList.item(idx);
  40.                 if (node.getNodeType() == Node.ELEMENT_NODE) {
  41.                     org.w3c.dom.Element element = (org.w3c.dom.Element) node;
  42.                     data.put(element.getNodeName(), element.getTextContent());
  43.                 }
  44.             }
  45.             try {
  46.                 stream.close();
  47.             } catch (Exception ex) {
  48.                 // do nothing
  49.             }
  50.             return data;
  51.         } catch (Exception ex) {
  52.             WXPayUtils.getLogger().warn("Invalid XML, can not convert to map. Error message: {}. XML content: {}", ex.getMessage(), strXML);
  53.             throw ex;
  54.         }
  55.  
  56.     }
  57.  
  58.     /**
  59.      * 将Map转换为XML格式的字符串
  60.      *
  61.      * @param data Map类型数据
  62.      * @return XML格式的字符串
  63.      * @throws Exception
  64.      */
  65.     public static String mapToXml(Map<String, String> data) throws Exception {
  66.         Document document = WXPayXmlUtil.newDocument();
  67.         Element root = document.createElement("xml");
  68.         document.appendChild(root);
  69.         for (String key: data.keySet()) {
  70.             String value = data.get(key);
  71.             if (value == null) {
  72.                 value = "";
  73.             }
  74.             value = value.trim();
  75.             Element filed = document.createElement(key);
  76.             filed.appendChild(document.createTextNode(value));
  77.             root.appendChild(filed);
  78.         }
  79.         TransformerFactory tf = TransformerFactory.newInstance();
  80.         Transformer transformer = tf.newTransformer();
  81.         DOMSource source = new DOMSource(document);
  82.         transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
  83.         transformer.setOutputProperty(OutputKeys.INDENT, "yes");
  84.         StringWriter writer = new StringWriter();
  85.         StreamResult result = new StreamResult(writer);
  86.         transformer.transform(source, result);
  87.         String output = writer.getBuffer().toString(); //.replaceAll("\n|\r", "");
  88.         try {
  89.             writer.close();
  90.         }
  91.         catch (Exception ex) {
  92.         }
  93.         return output;
  94.     }
  95.  
  96.     /**
  97.      * 生成微信支付sign
  98.      */
  99.     public static String createSign(SortedMap<String, String> params, String key){
  100.         StringBuilder sb = new StringBuilder();
  101.         Set<Map.Entry<String, String>> es = params.entrySet();
  102.         Iterator<Map.Entry<String, String>> it = es.iterator();
  103.         while(it.hasNext()){
  104.             Map.Entry<String, String> entry = it.next();
  105.             String k = entry.getKey();
  106.             String v = entry.getValue();
  107.             if(null != v && !"".equals(v) && !"sign".equals(k) && !"key".equals(k)){
  108.                 sb.append(k + "=" + v + "&");
  109.             }
  110.         }
  111.         sb.append("key=").append(key);
  112.         String sign = CommonUtils.MD5(sb.toString()).toUpperCase();
  113.  
  114.         return sign;
  115.     }
  116.  
  117.     /**
  118.      * 校验签名
  119.      * @param params
  120.      * @param key
  121.      * @return
  122.      */
  123.     public static Boolean isCorrectSign(SortedMap<String, String> params, String key){
  124.         String sign = createSign(params, key);
  125.         String wxPaySign = params.get("sign").toUpperCase();
  126.  
  127.         return  wxPaySign.equals(sign);
  128.     }
  129.     /**
  130.      * 获取有序map
  131.      * @param map
  132.      */
  133.     public static SortedMap<String, String> getSortedMap(Map<String, String> map){
  134.         SortedMap<String, String> sortedMap = new TreeMap<>();
  135.         Iterator<String> it = map.keySet().iterator();
  136.         while(it.hasNext()){
  137.             String key = it.next();
  138.             String value = map.get(key);
  139.             String temp = "";
  140.             if(null != value){
  141.                 temp = value.trim();
  142.             }
  143.             sortedMap.put(key, value);
  144.         }
  145.         return sortedMap;
  146.     }
  147.  
  148.     /**
  149.      * 日志
  150.      * @return
  151.      */
  152.     public static Logger getLogger() {
  153.         Logger logger = LoggerFactory.getLogger("wxpay java sdk");
  154.         return logger;
  155.     }
  156.  
  157.     /**
  158.      * 获取当前时间戳，单位秒
  159.      * @return
  160.      */
  161.     public static long getCurrentTimestamp() {
  162.         return System.currentTimeMillis()/1000;
  163.     }
  164.  
  165.     /**
  166.      * 获取当前时间戳，单位毫秒
  167.      * @return
  168.      */
  169.     public static long getCurrentTimestampMs() {
  170.         return System.currentTimeMillis();
  171.     }
  172.     /**
  173.      * 生成UUID(用来表示一笔订单)
  174.      * @return
  175.      */
  176.     public static String generateUUID(){
  177.         String uuid = UUID.randomUUID().toString()
  178.                 .replaceAll("-","")
  179.                 .substring(0,32);
  180.         return uuid;
  181.     }
  182. }

——签好名就请求获取rsa公钥接口，拿到了RSA公钥字符串。

——不要高兴得太早，请把这个字符串复制进txt，名字随意英文，然后改后缀名.pem，因为你是Java你需要转pkcs#8

文档内有互转的方法：

openssl rsa -RSAPublicKey_in -in <filename> -pubout

——如果没有openssl，你需要安装并配置openssl，这个可以百度。安装好后配置环境变量，然后在bin路径输入cmd，再跑上面的代码，成功之后，转换结果会直接显示在命令行，请复制这些密钥字符串。

——接下来，删除首尾：-----BEGIN PUBLIC KEY-----和-----END PUBLIC KEY-----

——然后将剩下的字符串放进txt，该后缀名pem，再放进项目的resources/static内。

——截止目前，我们便得到了rsa公钥文件：rsa.pem

3.银行卡开户行代号（付款至银行卡需要微信自己的参数）

这个我觉得不用说那么详细了，我自己用的方式都很业余。我是从百度找到了一个阿里的开发性api，用于获取银行卡开户行，然后再把微信的代号填到对照表里。再整理成工具类，把银行卡号做参数就可以得出代号（有几个小银行没有在对照表里），从优化的角度来看，这种方式需要跨域请求，最好是用一种可以直接识别银行卡号开户行的工具类，然后把微信开户行代号表和工具类的银行名称对齐一下。这里就默认你已经获取了银行卡开户行代号。

二、入参准备

——商户号：自行获取

——商户订单号：在请求这个接口前，你需要先新增一个你目前系统的订单，就是在订单表里插入一条订单，这个订单号就是商户订单号。

——随机值：直接调用我上方的工具类，有个generateUUID()函数直接获取。

——银行卡号：这个就需要用rsa公钥加密了。你已经有了公钥文件，但需要转成PublicKey类才能使用我的加密工具类。下面分步叙述流程（结果将得到PublicKey文件）：

1.获取公钥文件的字节输入流

InputStream rsaStream = getClass().getClassLoader().getResourceAsStream(RSA公钥文件的路径字符串);

2.用下面这个工具类转成字符串

  1. import java.io.ByteArrayOutputStream;
  2. import java.io.InputStream;
  3.  
  4. /*IO流工具类*/
  5. public class StreamUtil {
  6.     /**
  7.      * 读取 InputStream 到 String字符串中
  8.      */
  9.     public static String readStream(InputStream in) {
  10.         try {
  11.             //<1>创建字节数组输出流，用来输出读取到的内容
  12.             ByteArrayOutputStream baos = new ByteArrayOutputStream();
  13.             //<2>创建缓存大小
  14.             byte[] buffer = new byte[1024]; // 1KB
  15.             //每次读取到内容的长度
  16.             int len = -1;
  17.             //<3>开始读取输入流中的内容
  18.             while ((len = in.read(buffer)) != -1) { //当等于-1说明没有数据可以读取了
  19.                 baos.write(buffer, 0, len);   //把读取到的内容写到输出流中
  20.             }
  21.             //<4> 把字节数组转换为字符串
  22.             String content = baos.toString();
  23.             //<5>关闭输入流和输出流
  24.             in.close();
  25.             baos.close();
  26.             //<6>返回字符串结果
  27.             return content;
  28.         } catch (Exception e) {
  29.             e.printStackTrace();
  30.             return  e.getMessage();
  31.         }
  32.     }
  33. }

3.再用下面这个工具类getPublicKey(String key)函数将公钥字符串转为PublicKey类（该工具类包含RSA加密方法）

  1. import java.io.BufferedReader;
  2. import java.io.ByteArrayOutputStream;
  3. import java.io.FileInputStream;
  4. import java.io.IOException;
  5. import java.io.InputStream;
  6. import java.io.InputStreamReader;
  7. import java.lang.reflect.Method;
  8. import java.security.KeyFactory;
  9. import java.security.PrivateKey;
  10. import java.security.PublicKey;
  11. import java.security.spec.PKCS8EncodedKeySpec;
  12. import java.security.spec.X509EncodedKeySpec;
  13.  
  14. import javax.crypto.Cipher;
  15. import sun.misc.BASE64Decoder;
  16.  
  17. public class RSAwxUtil {
  18.  
  19.     public static byte[] decrypt(byte[] encryptedBytes, PrivateKey privateKey, int keyLength, int reserveSize, String cipherAlgorithm) throws Exception {
  20.         int keyByteSize = keyLength / 8;
  21.         int decryptBlockSize = keyByteSize - reserveSize;
  22.         int nBlock = encryptedBytes.length / keyByteSize;
  23.         ByteArrayOutputStream outbuf = null;
  24.         try {
  25.             Cipher cipher = Cipher.getInstance(cipherAlgorithm);
  26.             cipher.init(Cipher.DECRYPT_MODE, privateKey);
  27.  
  28.             outbuf = new ByteArrayOutputStream(nBlock * decryptBlockSize);
  29.             for (int offset = 0; offset < encryptedBytes.length; offset += keyByteSize) {
  30.                 int inputLen = encryptedBytes.length - offset;
  31.                 if (inputLen > keyByteSize) {
  32.                     inputLen = keyByteSize;
  33.                 }
  34.                 byte[] decryptedBlock = cipher.doFinal(encryptedBytes, offset, inputLen);
  35.                 outbuf.write(decryptedBlock);
  36.             }
  37.             outbuf.flush();
  38.             return outbuf.toByteArray();
  39.         } catch (Exception e) {
  40.             throw new Exception("DEENCRYPT ERROR:", e);
  41.         } finally {
  42.             try{
  43.                 if(outbuf != null){
  44.                     outbuf.close();
  45.                 }
  46.             }catch (Exception e){
  47.                 outbuf = null;
  48.                 throw new Exception("CLOSE ByteArrayOutputStream ERROR:", e);
  49.             }
  50.         }
  51.     }
  52.     public static byte[] encrypt(byte[] plainBytes, PublicKey publicKey, int keyLength, int reserveSize, String cipherAlgorithm) throws Exception {
  53.         int keyByteSize = keyLength / 8;
  54.         int encryptBlockSize = keyByteSize - reserveSize;
  55.         int nBlock = plainBytes.length / encryptBlockSize;
  56.         if ((plainBytes.length % encryptBlockSize) != 0) {
  57.             nBlock += 1;
  58.         }
  59.         ByteArrayOutputStream outbuf = null;
  60.         try {
  61.             Cipher cipher = Cipher.getInstance(cipherAlgorithm);
  62.             cipher.init(Cipher.ENCRYPT_MODE, publicKey);
  63.  
  64.             outbuf = new ByteArrayOutputStream(nBlock * keyByteSize);
  65.             for (int offset = 0; offset < plainBytes.length; offset += encryptBlockSize) {
  66.                 int inputLen = plainBytes.length - offset;
  67.                 if (inputLen > encryptBlockSize) {
  68.                     inputLen = encryptBlockSize;
  69.                 }
  70.                 byte[] encryptedBlock = cipher.doFinal(plainBytes, offset, inputLen);
  71.                 outbuf.write(encryptedBlock);
  72.             }
  73.             outbuf.flush();
  74.             return outbuf.toByteArray();
  75.         } catch (Exception e) {
  76.             throw new Exception("ENCRYPT ERROR:", e);
  77.         } finally {
  78.             try{
  79.                 if(outbuf != null){
  80.                     outbuf.close();
  81.                 }
  82.             }catch (Exception e){
  83.                 outbuf = null;
  84.                 throw new Exception("CLOSE ByteArrayOutputStream ERROR:", e);
  85.             }
  86.         }
  87.     }
  88.     public static PrivateKey getPriKey(String privateKeyPath,String keyAlgorithm){
  89.         PrivateKey privateKey = null;
  90.         InputStream inputStream = null;
  91.         try {
  92.             if(inputStream==null){
  93.                 System.out.println("hahhah1!");
  94.             }
  95.  
  96.             inputStream = new FileInputStream(privateKeyPath);
  97.             System.out.println("hahhah2!");
  98.             privateKey = getPrivateKey(inputStream,keyAlgorithm);
  99.             System.out.println("hahhah3!");
  100.         } catch (Exception e) {
  101.             System.out.println("加载私钥出错!");
  102.         } finally {
  103.             if (inputStream != null){
  104.                 try {
  105.                     inputStream.close();
  106.                 }catch (Exception e){
  107.                     System.out.println("加载私钥,关闭流时出错!");
  108.                 }
  109.             }
  110.         }
  111.         return privateKey;
  112.     }
  113.     public static PublicKey getPubKey(String publicKeyPath,String keyAlgorithm){
  114.         PublicKey publicKey = null;
  115.         InputStream inputStream = null;
  116.         try
  117.         {
  118.             System.out.println("getPubkey 1......");
  119.  
  120.             inputStream = new FileInputStream(publicKeyPath);
  121.             System.out.println("getPubkey 2......");
  122.  
  123.             publicKey = getPublicKey(inputStream,keyAlgorithm);
  124.             System.out.println("getPubkey 3......");
  125.  
  126.         } catch (Exception e) {
  127.  
  128.             e.printStackTrace();//EAD PUBLIC KEY ERROR
  129.             System.out.println("加载公钥出错!");
  130.         } finally {
  131.             if (inputStream != null){
  132.                 try {
  133.                     inputStream.close();
  134.                 }catch (Exception e){
  135.                     System.out.println("加载公钥,关闭流时出错!");
  136.                 }
  137.             }
  138.         }
  139.         return publicKey;
  140.     }
  141.     public static PublicKey getPublicKey(InputStream inputStream, String keyAlgorithm) throws Exception {
  142.         try
  143.         {
  144.             System.out.println("b1.........");
  145.             BufferedReader br = new BufferedReader(new InputStreamReader(inputStream));
  146.             System.out.println("b2.........");
  147.             StringBuilder sb = new StringBuilder();
  148.             String readLine = null;
  149.             System.out.println("b3.........");
  150.             while ((readLine = br.readLine()) != null) {
  151.                 if (readLine.charAt(0) == '-') {
  152.                     continue;
  153.                 } else {
  154.                     sb.append(readLine);
  155.                     sb.append('\r');
  156.                 }
  157.             }
  158.             System.out.println("b4.........");
  159.             X509EncodedKeySpec pubX509 = new X509EncodedKeySpec(decodeBase64(sb.toString()));
  160.             System.out.println("b5.........");
  161.             KeyFactory keyFactory = KeyFactory.getInstance(keyAlgorithm);
  162.             System.out.println("b6.........");
  163.             //下行出错  java.security.spec.InvalidKeySpecException: java.security.InvalidKeyException: IOException: DerInputStream.getLength(): lengthTag=127, too big.
  164.             PublicKey publicKey = keyFactory.generatePublic(pubX509);
  165.             System.out.println("b7.........");
  166.             return publicKey;
  167.         } catch (Exception e) {
  168.             e.printStackTrace();
  169.             System.out.println("b8.........");
  170.             throw new Exception("1这里报异常了："+e.getMessage(), e);
  171.         } finally {
  172.             try {
  173.                 if (inputStream != null) {
  174.                     inputStream.close();
  175.                 }
  176.             } catch (IOException e) {
  177.                 inputStream = null;
  178.                 throw new Exception("INPUT STREAM CLOSE ERROR:", e);
  179.             }
  180.         }
  181.     }
  182.     public static PrivateKey getPrivateKey(InputStream inputStream, String keyAlgorithm) throws Exception {
  183.         try {
  184.             BufferedReader br = new BufferedReader(new InputStreamReader(inputStream));
  185.             StringBuilder sb = new StringBuilder();
  186.             String readLine = null;
  187.             while ((readLine = br.readLine()) != null) {
  188.                 if (readLine.charAt(0) == '-') {
  189.                     continue;
  190.                 } else {
  191.                     sb.append(readLine);
  192.                     sb.append('\r');
  193.                 }
  194.             }
  195.             System.out.println("hahhah4!"+decodeBase64(sb.toString()));
  196.             PKCS8EncodedKeySpec priPKCS8 = new PKCS8EncodedKeySpec(decodeBase64(sb.toString()));
  197.             System.out.println("hahhah5!");
  198.             KeyFactory keyFactory = KeyFactory.getInstance(keyAlgorithm);
  199.             System.out.println("hahhah6!");
  200.             PrivateKey privateKey = keyFactory.generatePrivate(priPKCS8);
  201.             System.out.println("hahhah7!");
  202.             return privateKey;
  203.         } catch (Exception e) {
  204.             throw new Exception("READ PRIVATE KEY ERROR:" ,e);
  205.         }  finally {
  206.             try {
  207.                 if (inputStream != null) {
  208.                     inputStream.close();
  209.                 }
  210.             } catch (IOException e) {
  211.                 inputStream = null;
  212.                 throw new Exception("INPUT STREAM CLOSE ERROR:", e);
  213.             }
  214.         }
  215.     }
  216.     //一下面是base64的编码和解码
  217.     public static String encodeBase64(byte[]input) throws Exception{
  218.         Class clazz=Class.forName("com.sun.org.apache.xerces.internal.impl.dv.util.Base64");
  219.         Method mainMethod= clazz.getMethod("encode", byte[].class);
  220.         mainMethod.setAccessible(true);
  221.         Object retObj=mainMethod.invoke(null, new Object[]{input});
  222.         return (String)retObj;
  223.     }
  224.     /***
  225.      * decode by Base64
  226.      */
  227.     public static byte[] decodeBase64(String input) throws Exception{
  228.         Class clazz=Class.forName("com.sun.org.apache.xerces.internal.impl.dv.util.Base64");
  229.         Method mainMethod= clazz.getMethod("decode", String.class);
  230.         mainMethod.setAccessible(true);
  231.         Object retObj=mainMethod.invoke(null, input);
  232.         return (byte[])retObj;
  233.     }
  234.  
  235.     public static PublicKey getPublicKey(String key) throws Exception {
  236.         byte[] keyBytes;
  237.         keyBytes = (new BASE64Decoder()).decodeBuffer(key);
  238.         X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
  239.         KeyFactory keyFactory = KeyFactory.getInstance("RSA");
  240.         PublicKey publicKey = keyFactory.generatePublic(keySpec);
  241.         return publicKey;
  242.     }
  243.  
  244.     public static PrivateKey getPrivateKey(String key) throws Exception {
  245.         byte[] keyBytes;
  246.         keyBytes = (new BASE64Decoder()).decodeBuffer(key);
  247.         PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);
  248.         KeyFactory keyFactory = KeyFactory.getInstance("RSA");
  249.         PrivateKey privateKey = keyFactory.generatePrivate(keySpec);
  250.         return privateKey;
  251.     }
  252.  
  253. }

该步骤总代码：

  1. PublicKey pub;
  2. try {
  3.     pub = RSAwxUtil.getPublicKey(readStream(wxPayAppConfig.getRsaPublicKeyStream()));
  4. } catch (Exception e) {
  5.     e.printStackTrace();
  6.     baseEntity.setStatus(2);
  7.     baseEntity.setMessage("读取RSA公钥时异常："+e.getMessage());
  8.     return baseEntity;
  9. }

加密流程（以卡号为例）：

1.直接复制（文档要求）

String rsa ="RSA/ECB/OAEPWITHSHA-1ANDMGF1PADDING";

2.调用encrypt()函数，直接贴我的逻辑代码：

  1. byte[] enc_bank_no_byte;
  2. try {
  3.     enc_bank_no_byte = RSAwxUtil.encrypt(bank_card.getBytes(),pub,2048,11,rsa);
  4. } catch (Exception e) {
  5.     e.printStackTrace();
  6.     baseEntity.setStatus(2);
  7.     baseEntity.setMessage("对银行卡号进行加密时异常，异常原因："+e.getMessage());
  8.     return baseEntity;
  9. }
  10.  
  11. String enc_bank_no;//最终银行卡号参数
  12. try {
  13.     enc_bank_no = BASE64.encode(enc_bank_no_byte);
  14. } catch (Exception e) {
  15.     e.printStackTrace();
  16.     baseEntity.setStatus(2);
  17.     baseEntity.setMessage("将银行卡号byte转为字符串时异常，异常原因："+e.getMessage());
  18.     return baseEntity;
  19. }

——真实姓名：加密过程一致，不赘述。

——银行卡代号：不赘述

——金额：这里要注意，没做过支付的朋友，这个单位是分不是元，用订单金额*100即可。

——签名：上面已经贴了签名工具类，下面会贴我的请求代码。

最终请求代码：

  1. SortedMap<String, String> params = new TreeMap<>();
  2. try{
  3.     params.put("mch_id",wxPayAppConfig.getMchID());
  4.     params.put("partner_trade_no",orderNo);           // 商户订单号
  5.     params.put("nonce_str",WXPayUtils.generateUUID());//随机值
  6.     params.put("enc_bank_no",enc_bank_no);//加密后的银行卡号
  7.     params.put("enc_true_name",enc_true_name);//加密后的真实姓名
  8.     params.put("bank_code",bank_code);//银行卡代号
  9.     params.put("amount",amount);// 标价金额（单位为分）
  10.     params.put("desc", "提现");
  11.     //sign签名
  12.     String sign = WXPayUtils.createSign(params, wxPayAppConfig.getKey());
  13.     params.put("sign",sign);
  14. } catch (Exception e){
  15.     e.printStackTrace();
  16.     baseEntity.setStatus(2);
  17.     baseEntity.setMessage("请求前，封装入参时异常，异常原因："+e.getMessage());
  18.     return baseEntity;
  19. }

因为入参格式要求xml，请用工具类（上面找）转换：

  1. String payXml;
  2. try{
  3.     payXml = WXPayUtils.mapToXml(params);
  4. } catch (Exception e){
  5.     e.printStackTrace();
  6.     baseEntity.setStatus(2);
  7.     baseEntity.setMessage("请求接口前，map转xml异常，异常原因："+e.getMessage());
  8.     return baseEntity;
  9. }

到此，入参封装好了。

三、请求转账接口

 直接调用请求类请求，下面会发，在请求之前，说一说证书路径。如果要将jar部署到云服务器上，可以将你的证书放在云服务器里和项目同一个目录，然后用以下方法直接获取路径：

String path = System.getProperty("user.dir")+"/apiclient_cert.p12";

下面是请求类：

  1. import java.io.File;
  2. import java.io.FileInputStream;
  3. import java.security.KeyStore;
  4.  
  5. import javax.net.ssl.SSLContext;
  6.  
  7. import org.apache.http.HttpEntity;
  8. import org.apache.http.client.methods.CloseableHttpResponse;
  9. import org.apache.http.client.methods.HttpPost;
  10. import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
  11. import org.apache.http.conn.ssl.SSLContexts;
  12. import org.apache.http.entity.StringEntity;
  13. import org.apache.http.impl.client.CloseableHttpClient;
  14. import org.apache.http.impl.client.HttpClients;
  15. import org.apache.http.util.EntityUtils;
  16.  
  17. /**
  18.  * This example demonstrates how to create secure connections with a custom SSL
  19.  * context.
  20.  */
  21. public class ClientCustomSSL {
  22.  
  23.     @SuppressWarnings("deprecation")
  24.     public static String doRefund(String url, String data, String p12_path, String p12_key) throws Exception {
  25.         
  26.  
  27.         KeyStore keyStore = KeyStore.getInstance("PKCS12");
  28.         
  29.  
  30.         FileInputStream instream = new FileInputStream(new File(p12_path));//P12文件目录
  31.  
  32.         try {
  33.             /**
  34.              * 下载证书时的密码、默认密码是你的MCHID mch_id
  35.              * */
  36.             keyStore.load(instream, p12_key.toCharArray());
  37.         } finally {
  38.             instream.close();
  39.         }
  40.  
  41.         // Trust own CA and all self-signed certs
  42.         /**
  43.          * 下载证书时的密码、默认密码是你的MCHID mch_id
  44.          * */
  45.         SSLContext sslcontext = SSLContexts.custom()
  46.                 .loadKeyMaterial(keyStore, p12_key.toCharArray())//这里也是写密码的
  47.                 .build();
  48.         // Allow TLSv1 protocol only
  49.         SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(
  50.                 sslcontext,
  51.                 SSLConnectionSocketFactory.BROWSER_COMPATIBLE_HOSTNAME_VERIFIER);
  52.                 CloseableHttpClient httpclient = HttpClients.custom()
  53.                 .setSSLSocketFactory(sslsf)
  54.                 .build();
  55.         try {
  56.             HttpPost httpost = new HttpPost(url); 
  57.             httpost.addHeader("Connection", "keep-alive");
  58.             httpost.addHeader("Accept", "*/*");
  59.             httpost.addHeader("Content-Type", "application/x-www-form-urlencoded; charset=UTF-8");
  60.             httpost.addHeader("Host", "api.mch.weixin.qq.com");
  61.             httpost.addHeader("X-Requested-With", "XMLHttpRequest");
  62.             httpost.addHeader("Cache-Control", "max-age=0");
  63.             httpost.addHeader("User-Agent", "Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 6.0) ");
  64.             httpost.setEntity(new StringEntity(data, "UTF-8"));
  65.             CloseableHttpResponse response = httpclient.execute(httpost);
  66.             try {
  67.                 HttpEntity entity = response.getEntity();
  68.  
  69.                 String jsonStr = EntityUtils.toString(response.getEntity(), "UTF-8");
  70.                 EntityUtils.consume(entity);
  71.                 return jsonStr;
  72.             } finally {
  73.                 response.close();
  74.             }
  75.         } finally {
  76.             httpclient.close();
  77.         }
  78.     }
  79. }

 我的请求代码：（请求类四个参数分别是：付款url，入参xml，证书路径，商户号）

  1. String result;
  2. try{
  3.     result = ClientCustomSSL.doRefund(url, payXml,path,wxPayAppConfig.getMchID());
  4. } catch (Exception e){
  5.     e.printStackTrace();
  6.     baseEntity.setStatus(2);
  7.     baseEntity.setMessage("请求转账接口时异常，异常原因："+e.getMessage());
  8.     return baseEntity;
  9. }

 最后需要将xml转为map：

  1. Map<String, String> payBankMap;
  2. try{
  3.     payBankMap = WXPayUtils.xmlToMap(s);
  4. } catch (Exception e){
  5.     e.printStackTrace();
  6.     baseEntity.setStatus(2);
  7.     baseEntity.setMessage("请求结果xml数据转map时异常，异常原因："+e.getMessage());
  8.     return baseEntity;
  9. }

至此，付款请求完成。

根据payBankMap.get("result_code")参数可以知道付款成功或失败。

最后不要忘记更新相关数据库表的业务逻辑，如：付款后，订单改为已付款之类的。

还有，请保证微信支付运营账户余额大于1.5元，因为每一笔打款订单，微信起步手续费1元。也就是说，就算你打款0.01元，将被扣1.01元。

因为文档没有体现手续费起步1元，我浪费了大半天时间百度，就连技术客服都不知道这个规则，还帮我看后台日志，最后问他同事才知道。这种坑实在是不应该，还有请求时突然不支持的协议（该文档已经屏蔽），从开发社区里看到，两年前的文档漏洞，今天还没改...

另外需要注意的是，每个商户最低打款额不同，有些商户是0.01元，也有看到有很多商户是0.03元。

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

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

  

闽ICP备14008679号