微信提现到银行卡

已于 2022-12-05 10:56:47 修改
阅读量1.1k 收藏 3
点赞数
文章标签： 微信 java spring
于 2022-10-17 09:59:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lskapdkpw/article/details/127357825
版权

微信端提供接口文档：
付款到银行卡API：https://pay.weixin.qq.com/wiki/doc/api/tools/mch_pay_yhk.php?chapter=25_2

主方法：

 /**
     * 发送微信提现请求
     *
     * @param userName              用户姓名
     * @param userBank              用户银行卡号
     * @param userBankCode          用户银行所属编码
     * @param amount                提现金额 单位分
     * @param desc                  描述
     * @param outMoney              扣除金额
     * @param idNumber              身份证号
     * @param platformServiceCharge 平台手续费
     * @param inWxServiceCharge     入微信平台手续费
     * @param outWxServiceCharge    出微信平台手续费
     */
    public Map<String, String> transferBank(String userName, String userBank, String userBankCode, String orderId, String amount, String desc,
                                            String outMoney, String idNumber, String platformServiceCharge, String inWxServiceCharge,
                                            String outWxServiceCharge,String userBankName) throws Exception {
        int intValue = new BigDecimal(amount).multiply(new BigDecimal("100")).intValue();
        String name = RSAUtils.encrypt(userName);
        String bank = RSAUtils.encrypt(userBank);
        String str = RequestUtils.getUUID();
        Map<String, Object> params = new TreeMap<>();
        params.put("mch_id", IExtractConstant.MCH_ID);
        params.put("partner_trade_no", orderId);
        params.put("nonce_str", str);
        params.put("enc_bank_no", bank);
        params.put("enc_true_name", name);
        params.put("bank_code", userBankCode);
        params.put("amount", intValue);
        if (StringUtils.isNoneBlank(desc)) {
            params.put("desc", desc);
        }
        //生成签名
        String sign = SignUtils.getSign(params, IExtractConstant.MCH_KEY);
        params.put("sign", sign);
        //将请求参数转换为xml格式
        String requestXml = XmlUtil.getRequestXml(params);
        //请求前插入提现记录表
        extractCashMapper.insertExtractCashRecord(userName, idNumber, outMoney, orderId, userBank, userBankCode,
                intValue + "", desc, platformServiceCharge, inWxServiceCharge, outWxServiceCharge, "1", str,userBankName);
        String weChatResponse = SendWeChatRequestUtil.sendWeChatRequest(IExtractConstant.MCH_ID,
                IExtractConstant.PAY_BANK_URL,
                requestXml,
                IExtractConstant.CERT_PATH);
        return XmlUtil.xmlToMap(weChatResponse);
    }

RSAUtils：

package com.sdjx.wx.util;

import com.sdjx.wx.constant.IExtractConstant;
import org.springframework.util.Base64Utils;

import javax.crypto.Cipher;
import java.io.*;
import java.lang.reflect.Method;
import java.security.KeyFactory;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;

/**
 * @Author:wpf
 * @ClassName:RSAUtils
 * @Date:2022/10/8
 * @Description:
 */

public class RSAUtils {

    /**
     * rsa加密公钥
     * 请求微信api获得pkcs1格式
     * 通过转换工具转换成pkcs8格式
     */
    private static final String PKCS8_PUBLIC = IExtractConstant.RSA_PUBLIC_KEY_PKCS8;


    public static byte[] decrypt(byte[] encryptedBytes, PrivateKey privateKey, int keyLength, int reserveSize, String cipherAlgorithm) throws Exception {
        int keyByteSize = keyLength / 8;
        int decryptBlockSize = keyByteSize - reserveSize;
        int nBlock = encryptedBytes.length / keyByteSize;
        ByteArrayOutputStream outbuf = null;
        try {
            Cipher cipher = Cipher.getInstance(cipherAlgorithm);
            cipher.init(Cipher.DECRYPT_MODE, privateKey);

            outbuf = new ByteArrayOutputStream(nBlock * decryptBlockSize);
            for (int offset = 0; offset < encryptedBytes.length; offset += keyByteSize) {
                int inputLen = encryptedBytes.length - offset;
                if (inputLen > keyByteSize) {
                    inputLen = keyByteSize;
                }
                byte[] decryptedBlock = cipher.doFinal(encryptedBytes, offset, inputLen);
                outbuf.write(decryptedBlock);
            }
            outbuf.flush();
            return outbuf.toByteArray();
        } catch (Exception e) {
            throw new Exception("DEENCRYPT ERROR:", e);
        } finally {
            try{
                if(outbuf != null){
                    outbuf.close();
                }
            }catch (Exception e){
                outbuf = null;
                throw new Exception("CLOSE ByteArrayOutputStream ERROR:", e);
            }
        }
    }
    public static byte[] encrypt(byte[] plainBytes, PublicKey publicKey, int keyLength, int reserveSize, String cipherAlgorithm) throws Exception {
        int keyByteSize = keyLength / 8;
        int encryptBlockSize = keyByteSize - reserveSize;
        int nBlock = plainBytes.length / encryptBlockSize;
        if ((plainBytes.length % encryptBlockSize) != 0) {
            nBlock += 1;
        }
        ByteArrayOutputStream outbuf = null;
        try {
            Cipher cipher = Cipher.getInstance(cipherAlgorithm);
            cipher.init(Cipher.ENCRYPT_MODE, publicKey);

            outbuf = new ByteArrayOutputStream(nBlock * keyByteSize);
            for (int offset = 0; offset < plainBytes.length; offset += encryptBlockSize) {
                int inputLen = plainBytes.length - offset;
                if (inputLen > encryptBlockSize) {
                    inputLen = encryptBlockSize;
                }
                byte[] encryptedBlock = cipher.doFinal(plainBytes, offset, inputLen);
                outbuf.write(encryptedBlock);
            }
            outbuf.flush();
            return outbuf.toByteArray();
        } catch (Exception e) {
            throw new Exception("ENCRYPT ERROR:", e);
        } finally {
            try{
                if(outbuf != null){
                    outbuf.close();
                }
            }catch (Exception e){
                outbuf = null;
                throw new Exception("CLOSE ByteArrayOutputStream ERROR:", e);
            }
        }
    }


    public static PublicKey getPublicKey(String keyAlgorithm) throws Exception {
        try
        {
            //加载公钥
            X509EncodedKeySpec pubX509 = new X509EncodedKeySpec(decodeBase64(PKCS8_PUBLIC));
            KeyFactory keyFactory = KeyFactory.getInstance(keyAlgorithm);
            PublicKey publicKey = keyFactory.generatePublic(pubX509);
            return publicKey;
        } catch (Exception e) {
            e.printStackTrace();
            throw new Exception("READ PUBLIC KEY ERROR:", e);
        }
    }


    //一下面是base64的编码和解码
    public static String encodeBase64(byte[]input) throws Exception{
        Class clazz=Class.forName("com.sun.org.apache.xerces.internal.impl.dv.util.Base64");
        Method mainMethod= clazz.getMethod("encode", byte[].class);
        mainMethod.setAccessible(true);
        Object retObj=mainMethod.invoke(null, new Object[]{input});
        return (String)retObj;
    }


    /***
     * decode by Base64
     */
    public static byte[] decodeBase64(String input) throws Exception{
        Class clazz=Class.forName("com.sun.org.apache.xerces.internal.impl.dv.util.Base64");
        Method mainMethod= clazz.getMethod("decode", String.class);
        mainMethod.setAccessible(true);
        Object retObj=mainMethod.invoke(null, input);
        return (byte[])retObj;
    }



    /**
     * <p>
     * 按照微信要求进行加密
     * </p>
     *
     * @param data 加密前的开户姓名/银行卡号
     * @return java.lang.String 加密后秘文
     * @author Winder
     * @date 2021/1/26 上午10:28
     */
    public static String encrypt(String data){
        PublicKey pub = null;
        try {
            //rsa加密
            pub = RSAUtils.getPublicKey("RSA");
            String rsa = "RSA/ECB/OAEPWITHSHA-1ANDMGF1PADDING";
            byte[] estrName = RSAUtils.encrypt(data.getBytes(), pub, 2048, 11, rsa);
            //base64加密
            data = Base64Utils.encodeToString(estrName);
            return data;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    public static void main(String[] args) {
        String str = encrypt("张三");
        System.out.println(str);
    }

}

RequestUtils：

package com.sdjx.wx.util;

import com.sdjx.wx.constant.IExtractConstant;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;

import java.io.BufferedWriter;
import java.io.File;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.security.NoSuchAlgorithmException;
import java.security.PublicKey;
import java.security.spec.InvalidKeySpecException;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
import java.util.UUID;

/**
 * @Author:wpf
 * @ClassName:RequestUtils
 * @Date:2022/9/30
 * @Description:f发送请求工具类
 */

@Slf4j
public class RequestUtils {

    /**
     * 获取RSA加密公钥
     * @return RSA加密公钥
     *接口默认输出PKCS#1格式的公钥，商户需根据自己开发的语言选择公钥格式
     *
     * RSA公钥格式PKCS#1,PKCS#8互转说明
     * PKCS#1 转 PKCS#8:
     * openssl rsa -RSAPublicKey_in -in <filename> -pubout
     *
     * PKCS#8 转 PKCS#1:
     * openssl rsa -pubin -in <filename> -RSAPublicKey_out
     *
     * PKCS#1 格式密钥：
     * -----BEGIN RSA PUBLIC KEY-----
     * MIIBCgKCAQEArT82k67xybiJS9AD8nNAeuDYdrtCRaxkS6cgs8L9h83eqlDTlrdw
     * zBVSv5V4imTq/URbXn4K0V/KJ1TwDrqOI8hamGB0fvU13WW1NcJuv41RnJVua0QA
     * lS3tS1JzOZpMS9BEGeFvyFF/epbi/m9+2kUWG94FccArNnBtBqqvFncXgQsm98JB
     * 3a62NbS1ePP/hMI7Kkz+JNMyYsWkrOUFDCXAbSZkWBJekY4nGZtK1erqGRve8Jbx
     * TWirAm/s08rUrjOuZFA21/EI2nea3DidJMTVnXVPY2qcAjF+595shwUKyTjKB8v1
     * REPB3hPF1Z75O6LwuLfyPiCrCTmVoyfqjwIDAQAB
     * -----END RSA PUBLIC KEY-----
     *
     * PKCS#8 格式密钥：
     * -----BEGIN PUBLIC KEY-----
     * MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEArT82k67xybiJS9AD8nNA
     * euDYdrtCRaxkS6cgs8L9h83eqlDTlrdwzBVSv5V4imTq/URbXn4K0V/KJ1TwDrqO
     * I8hamGB0fvU13WW1NcJuv41RnJVua0QAlS3tS1JzOZpMS9BEGeFvyFF/epbi/m9+
     * lkUWG94FccArNnBtBqqvFncXgQsm98JB3a42NbS1ePP/hMI7Kkz+JNMyYsWkrOUF
     * DCXAbSZkWBJekY4nGZtK1erqGRve8JbxTWirAm/s08rUrjOuZFA21/EI2nea3Did
     * JMTVnXVPY2qcAjF+595shwUKyTjKB8v1REPB3hPF1Z75O6LwuLfyPiCrCTmVoyfq
     * jwIDAQAB
     * -----END PUBLIC KEY-----
     */
    public static String getEncryptPublicKey() {
        try {
            Map<String, Object> param = new TreeMap<>();
            param.put("mch_id", IExtractConstant.MCH_ID);
            param.put("nonce_str", getUUID());
            param.put("sign_type", "MD5");
            String sign = SignUtils.getSign(param, IExtractConstant.MCH_KEY);
            param.put("sign", sign);
            String response = SendWeChatRequestUtil.sendWeChatRequest(IExtractConstant.MCH_ID,
                    IExtractConstant.GET_WECHAT_ENCRYPT_PUBLIC_KEY_URL,
                    XmlUtil.getRequestXml(param),
                    IExtractConstant.CERT_PATH);
            System.out.println("-------------------");
            System.out.println(response);
            if (StringUtils.isNotEmpty(response)) {
                Map<String, String> responseMap = XmlUtil.xmlToMap(response);
                if ("SUCCESS".equals(responseMap.get("return_code")) && "SUCCESS".equals(responseMap.get("result_code"))) {
                    return responseMap.get("pub_key");
                }else {
                    log.info(" weixin return fall :{}", response);
                }
            }

        } catch (Exception e) {
            log.error("调用微信企业付款至银行卡生成公钥异常:{}", e.getMessage());
        }
        return null;
    }

    /**
     * uuid 随机字符串
     * @return uuid 随机字符串
     */
    public static String getUUID() {
        return UUID.randomUUID().toString().replace("-", "");
    }

    /**
     * 变更公钥格式PKCS#1至PKCS#8
     * @param publicKeyString
     * @return
     * @throws InvalidKeySpecException
     * @throws NoSuchAlgorithmException
     */
    public  static PublicKey getPublicKey(String publicKeyString) throws InvalidKeySpecException, NoSuchAlgorithmException {
        //把RSA公钥格式PKCS#1转换成PKCS#8
        org.bouncycastle.asn1.pkcs.RSAPublicKey rsaPublicKey =  org.bouncycastle.asn1.pkcs.RSAPublicKey.getInstance(
                org.bouncycastle.util.encoders.Base64.decode(publicKeyString));

        java.security.spec.RSAPublicKeySpec publicKeySpec = new java.security.spec.RSAPublicKeySpec(rsaPublicKey.getModulus(), rsaPublicKey.getPublicExponent());

        java.security.KeyFactory keyFactory = java.security.KeyFactory.getInstance("RSA");

        PublicKey publicKey = keyFactory.generatePublic(publicKeySpec);

        return publicKey;
    }

    public  static String readLocalPubKey(String pubKey) throws IOException {
        File file = null;
        try {

            Path tmpFile = Files.createTempFile("payToBank", ".pem");
            File file1 = tmpFile.toFile();
            String absolutePath = file1.getAbsolutePath();
            log.info("本地公钥路径:"+absolutePath);
            try (BufferedWriter writer = Files.newBufferedWriter(tmpFile)) {
                writer.write(pubKey);
            } catch (IOException e) {
                e.printStackTrace();
            }
            List<String> lines = Files.readAllLines(Paths.get(absolutePath), StandardCharsets.UTF_8);
            StringBuilder sb = new StringBuilder();
            for (String line : lines) {
                if (line.charAt(0) == '-') {
                    continue;
                } else {
                    sb.append(line);
                    sb.append('\r');
                    System.out.println("**"+sb);
                }
            }
            return sb.toString();
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            if (file != null){
                file.deleteOnExit();
            }
        }
        return null;
    }

}

SignUtils：

package com.sdjx.wx.util;

import lombok.extern.slf4j.Slf4j;
import org.apache.commons.codec.digest.DigestUtils;

import java.util.Map;
import java.util.TreeMap;


/**
 * @Author:wpf
 * @ClassName:SignUtils
 * @Date:2022/9/29
 * @Description:获取签名工具类
 */

@Slf4j
public class SignUtils {

    /**
     * 获取签名方法
     *
     * @param requestParam 所有发送或者接收到的数据
     * @param key          key为商户平台设置的密钥key
     * @return 签名
     * 第一步，设所有发送或者接收到的数据为集合M，将集合M内非空参数值的参数按照参数名ASCII码从小到大排序（字典序），使用URL键值对的格式（即key1=value1&key2=value2…）拼接成字符串stringA。
     * 特别注意以下重要规则：
     * <p>
     * ◆ 参数名ASCII码从小到大排序（字典序）；
     * ◆ 如果参数的值为空不参与签名；
     * ◆ 参数名区分大小写；
     * ◆ 验证调用返回或微信主动通知签名时，传送的sign参数不参与签名，将生成的签名与该sign值作校验。
     * ◆ 微信接口可能增加字段，验证签名时必须支持增加的扩展字段
     * 第二步，在stringA最后拼接上key得到stringSignTemp字符串，并对stringSignTemp进行MD5运算，再将得到的字符串所有字符转换为大写，得到sign值signValue。 注意：密钥的长度为32个字节。
     * <p>
     * ◆ key设置路径：微信商户平台(pay.weixin.qq.com)-->账户中心-->账户设置-->API安全-->设置API密钥
     */
    public static String getSign(Map<String, Object> requestParam, String key) {
        Map<String, Object> params = new TreeMap<>();
        params.putAll(requestParam);
        StringBuffer buffer = new StringBuffer();
        for (Map.Entry<String, Object> param : params.entrySet()) {
            if (param.getValue() != null) {
                buffer.append(param.getKey() + "=" + param.getValue() + "&");
            }
        }
        buffer.append("key=" + key);
        String stringSignTemp = buffer.toString();
        String signValue = DigestUtils.md5Hex(stringSignTemp).toUpperCase();
        return signValue;
    }



}

XmlUtil：

package com.sdjx.wx.util;

import com.jfinal.weixin.sdk.utils.XmlHelper;
import org.apache.commons.lang3.StringUtils;
import org.xml.sax.SAXException;

import java.io.IOException;
import java.util.Map;


/**
 * @Author:wpf
 * @ClassName:XmlUtils
 * @Date:2022/9/29
 * @Description:xml和对象之间相互转化工具类
 */

public class XmlUtil {

    /**
     * 将请求集合拼接成xml字符串
     * @param params 请求集合
     * @return xml字符串
     */
    public static String getRequestXml(Map<String, Object> params) {
        StringBuffer sb = new StringBuffer();
        sb.append("<xml>");
        for (Map.Entry<String, Object> entry : params.entrySet()) {
            String key = entry.getKey();
            String value = entry.getValue().toString();
            // 略过空值
            if (StringUtils.isBlank(value)) continue;
            sb.append("<").append(key).append(">");
            sb.append(entry.getValue());
            sb.append("</").append(key).append(">");
        }
        sb.append("</xml>");
        return sb.toString();
    }

    /**
     * 微信返回xml解析成为Map集合
     * @param xmlStr 待解析xml字符串
     * @return 解析后Map集合
     */
    public static Map<String,String> xmlToMap(String xmlStr){
        XmlHelper xmlHelper = XmlHelper.of(xmlStr);
        return xmlHelper.toMap();
    }


    public static void main(String[] args) throws IOException, SAXException {
        Map<String, String> stringStringMap = xmlToMap("<xml>\n" +
                "<return_code><![CDATA[SUCCESS]]></return_code>\n" +
                "<return_msg><![CDATA[支付失败]]></return_msg>\n" +
                "<result_code><![CDATA[FAIL]]></result_code>\n" +
                "<err_code><![CDATA[FATAL_ERROR]]></err_code>\n" +
                "<err_code_des><![CDATA[订单信息不一致，请先查询订单]]></err_code_des>\n" +
                "<nonce_str><![CDATA[50780e0cca98c8c8e814883e5caa672e]]></nonce_str>\n" +
                "<mch_id><![CDATA[2302758702]]></mch_id>\n" +
                "<partner_trade_no><![CDATA[1212121221278]]></partner_trade_no>\n" +
                "<amount>5000</amount>\n" +
                "</xml>");
        System.out.println(stringStringMap);
        System.out.println(stringStringMap.get("return_msg"));
    }


}

SendWeChatRequestUtil：

package com.sdjx.wx.util;

import org.apache.http.HttpEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.ssl.SSLContexts;
import org.apache.http.util.EntityUtils;

import javax.net.ssl.SSLContext;
import java.io.FileInputStream;
import java.security.KeyStore;

/**
 * @Author:wpf
 * @ClassName:SendWeChatRequestUtil
 * @Date:2022/9/29
 * @Description:携带证书发送微信请求
 */

public class SendWeChatRequestUtil {

    /**
     * 携带证书发送微信请求
     *
     * @param mchId    证书密码 默认MCHID
     * @param url      请求路径
     * @param data     请求体
     * @param certPath 证书路径
     * @return 微信请求响应结果
     * <p>
     * 注意PKCS12证书 是从微信商户平台-》账户设置-》 API安全 中下载的
     */
    public static String sendWeChatRequest(String mchId, String url, String data, String certPath) throws Exception {
        //指定读取证书格式为PKCS12
        KeyStore keyStore = KeyStore.getInstance("PKCS12");
        //读取证书文件
        FileInputStream inputStream = new FileInputStream(certPath);
        try {
            //指定PKCS12的密码
            keyStore.load(inputStream, mchId.toCharArray());
        } finally {
            inputStream.close();
        }
        //信任自己的CA和所有自签名证书
        SSLContext sslcontext = SSLContexts.custom().loadKeyMaterial(keyStore, mchId.toCharArray()).build();
        //仅允许TLSv1协议
        SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(sslcontext, SSLConnectionSocketFactory.getDefaultHostnameVerifier());
        CloseableHttpClient httpclient = HttpClients.custom().setSSLSocketFactory(sslsf).build();
        try {
            HttpPost httpPost = new HttpPost(url);
            httpPost.setEntity(new StringEntity(data, "UTF-8"));
            CloseableHttpResponse response = httpclient.execute(httpPost);
            try {
                HttpEntity entity = response.getEntity();
                String jsonStr = EntityUtils.toString(response.getEntity(), "UTF-8");
                EntityUtils.consume(entity);
                return jsonStr;
            } finally {
                response.close();
            }
        } finally {
            httpclient.close();
        }

    }
}

PKCS#1转成PKCS#8在线工具 网址 http://www.metools.info/code/c85.html

万能的小帅
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
微信企业付款到个人银行卡demo java
07-26
微信企业付款到个人银行卡的Java实现是一个常见的支付接口调用任务，主要涉及到微信支付API的使用，以及公钥和私钥的加密解密操作。在这个过程中，开发者需要对微信支付平台的接口规范有深入理解，并熟悉Java的加密...
接入微信提现Api（企业付款到零钱--向微信用户个人付款）
热门推荐
嘻嘻的博客
04-25 1万+
文章目录业务场景接口介绍接入流程第一步第二步 业务场景   微信提现使用场景一般为用户客户端发起提现申请，服务端收到请求后调用微信Api发起微信提现。然后通过查询提现结果接口确认一下即可。 接口介绍   https://api.mch.weixin.qq.com/mmpaymkttransfers/promotion/transfers 特别注意：该接口对微信商户有如下要求： 商户号已入驻90日且截止今日回推30天商户号保持连续不间断的交易。 接入流程 第一步   登录微信商户平台，配置一下（配置微信商
微信小程序基于java实现v2支付，提现，退款
风尘小白沙
11-09 5661
v2微信官方文档 封装支付请求实体 这个回调地址是你自己代码里面定义的回调接口，例如你定义的controller回调接口url是 feedback/wx/notifurl , 即是 wxform.setNotifyUrl(“feedback/wx/notifurl”)，微信终端会去调用这个回调方法的，可以通过日志确认。 生成xml字符串 getPayXmlString(); 生成秘钥签名 WeixinResponse转换实体 JsonUtils.object2JsonString() v
平台处理“提现”的8种支付接口，你能区分吗？
最新发布
M95888的博客
04-06 310
因为单独“代付”存在很大洗钱风险，支付机构不知道你用于代付的钱是从哪里来的，是否合法，所以要求如果要开代付，同时必须使用支付通道用于收单，而且实现“收支分离”。支付公司给平台方开一级账户，给需要充值、提现、余额支付的业务参与方开二级账户，从而构建一个账户体系。转账到支付宝账户是为了满足支付宝商户向其他支付宝账户进行单笔转账的需求，针对具备开发能力的商户，提供通过 API 接口完成单笔转账的功能。电商平台可以通过余额提现API帮助你的二级商户发起账户余额提现申请，完成账户余额提现。
微信提现
My_Way666的博客
11-28 657
转载自：：https://blog.csdn.net/baidu_37366055/article/details/81215962 微信官方提供了微信企业账户付款到微信个人零钱接口，提供企业向用户付款的功能，支持企业通过API接口付款，或通过微信支付商户平台网页功能操作付款。该接口并不是直接所有的商户都...
PHP实现微信小程序提现到零钱
qq_56816632的博客
05-22 1245
err_code_des] => 产品权限验证失败,请查看您当前是否具有该产品的权限。特别注意一点 小程序需要开通提现相关接口 否则会提现失败。如果你的小程序用的是个人营业执照注册的 将不能申请提现业务。
微信企业账户提现到微信用户钱包零钱（通过openid）
wwwwwwweq的博客
06-01 1801
商户退钱到微信用户钱包零钱 3.结果实体 4.实现代码 小结：代码需要更换参数 具体位置请自行查找（有点乱，请自行配置修改在同一个位置）
微信支付提现到银行卡的
10-26
微信支付是腾讯公司推出的一种移动支付方式，它方便快捷，被广泛应用...总之，微信支付提现到银行卡的操作简单便捷，但需注意费用、限额和安全问题。遇到任何问题，都可以通过微信的帮助中心或联系客服获得解答和帮助。
（nodejs）微信小程序提现
09-14
开发商用微信小程序，必不可少的微信提现功能。 主要结构就是 js 下载后自己改吧改吧可以当做功能模块使用。api 接口用微信官网接口、这个东西研究了一天，实话说有些文档都是说的简单，实际使用还是要开发经验的。...
php企业微信支付到银行卡
05-07
本人最近做的php企业微信支付到银行卡，踩了不少坑，算是做出来，分享给大家
java微信支付DEMO, 微信JSAPI支付, 微信退款, 微信提现, 微信付款查询
08-03
4. **微信提现**：指的是将商户账户中的资金提取到银行账户。在Java实现中，需要调用微信商户平台的提现接口，输入提现金额、银行账号等信息。提现操作同样可能涉及异步处理，需监听提现结果并更新状态。 5. **微信...
微信有关接口资源（各类支付，红包提现）
05-29
微信接口资源：包含微信分享、微信公众号支付、微信红包、提现、微信扫码支付、微信手机支付、申请流程以及demo以及SDK
微信支付之企业付款到个人（提现）
L15810356216的博客
05-23 2996
先去官网了解开发文档：https://pay.weixin.qq.com/wiki/doc/api/tools/mch_pay.php?chapter=14_2 1、先去下载证书 apiclient_cert.p12证书：在微信商户平台–>账户设置–>API安全–>证书中下载的 。（自行下载） 将下载好的证书放在src/main/resources下 2、导入相关pom...
提现自动到账的技术接入方法
venus150的博客
08-18 291
很多电商平台，分享平台，任务平台，商业模式项目平台，用户的获得佣金和奖励是在平台的余额里面，用户想要把余额提现到自己的银行卡账户里，是需要在财务中心发起提现申请，然后平台看到申请信息后，手动打款给当前提现账户，然后再修改当前提现申请为成功，如果账户信息错误，打款失败，再次手动选择当前提现状态为失败，并说明提现失败的原因。这个只能自动提现到支付宝，并且有额度的限制，提现限额是短时间不能解决的，因为和新商户营业执照，新商户支付宝账户，商户行业等属性有关系。
PHP开发微信商家转账到零钱接口
小李不是歪理的博客
10-21 5675
php版本的微信商家转账到零钱功能，包含了完整的代码，大量的注释，可根据项目需求进行调整，目前该功能已在使用中，有问题可以留言或者关注公众号大家交流。
微信支付、企业转账到零钱、商家转账到零钱、退款
qq_27257535的博客
11-01 2134
微信支付、企业转账到零钱、商家转账到零钱、退款
Java 微信企业付款到个人银行卡-调用获取RSA公钥API
weixin_44949109的博客
12-16 1973
package co.ganxiang.mp.test; import java.io.*; import java.security.KeyStore; import java.security.MessageDigest; import java.security.PublicKey; import java.security.SecureRandom; import java.util.*; import javax.net.ssl.SSLContext; import javax.xml.tra.
接银行支付系列(四)[平台充值与提现,自有资金分户间转账]
天涯芳草
04-14 362
平台充值与提现流程: 平台充值：调用接口IESI111013，平台一般对公户-->平台普通资金分户01 平台提现：调用接口IESI111014，平台普通资金分户01-->平台一般对公户 平台调用平台充值接口后在普通资金分户01中留有一定金额，用于下一步平台自有资金分户间转账验证 平台自有资金分户间转账: 调用接口IESI1...
微信转账api(企业付款)
chenrui310的博客
01-11 4399
提供企业向用户付款的功能，支持企业通过API接口付款，或通过微信支付商户平台网页功能操作付款。企业付款业务是基于微信支付商户平台的资金管理能力，为了协助商户方便地实现企业向个人付款，针对部分有开发能力的商户，提供通过API完成企业付款的功能。比如目前的保险行业向客户退保、给付、理赔。企业付款将使用商户的可用余额，需确保可用余额充足。查看可用余额、充值、提现请登录商户平台“资金管理”进行操作。注意：与商户微信支付收款资金并非同一账户，需要单独充值。业务流程接口简介付款企业付款。
uniapp实现微信提现
03-20
Uniapp可以通过微信开放平台提供的API实现微信提现功能。具体实现步骤如下： 1. 在微信开放平台注册开发者账号，并创建一个应用。 2. 在应用中添加微信支付功能，并获取到商户号、支付密钥等信息。 3. 在Uniapp中引入微信支付插件，并配置支付参数。 4. 调用微信支付插件提供的API，实现微信提现功能。 需要注意的是，微信提现功能需要满足一定的条件，比如用户必须绑定了银行卡等。同时，提现金额也有一定的限制。具体的限制条件可以参考微信开放平台的文档。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值