微信H5支付

最新推荐文章于 2024-09-26 11:13:47 发布
最新推荐文章于 2024-09-26 11:13:47 发布
阅读量1.6k 收藏 6
点赞数 1
分类专栏： java基础 文章标签： 微信H5支付
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wy_0830/article/details/96483512
版权

微信H5支付

官方文档

总体概述：

在项目中，首先是本地下单，接下来点击微信支付，我们希望能拉起微信H5支付页面完成支付。
首先得调用微信统一下单，得到拉起支付页面的链接，返回给前端跳转，页面拉起支付活动，支付完成回到支付完成页面，异步通知到回调接口。
具体流程如下：
在这里插入图片描述

1、用户在商户侧完成下单，使用微信支付进行支付
2、由商户后台向微信支付发起下单请求（调用统一下单接口）注：交易类型trade_type=MWEB
3、统一下单接口返回支付相关参数给商户后台，如支付跳转url（参数名“mweb_url”），商户通过mweb_url调起微信支付中间页
4、中间页进行H5权限的校验，安全性检查（此处常见错误请见下文）
5、如支付成功，商户后台会接收到微信侧的异步通知
6、用户在微信支付收银台完成支付或取消支付,返回商户页面（默认为返回支付发起页面）
7、商户在展示页面，引导用户主动发起支付结果的查询
8,9、商户后台判断是否接到收微信侧的支付结果通知，如没有，后台调用我们的订单查询接口确认订单状态
10、展示最终的订单支付结果给用户

准备工作

商户接入微信支付，调用API必须遵循以下规则：
传输方式 为保证交易安全性，采用HTTPS传输
提交方式 采用POST方法提交
数据格式 提交和返回数据都为XML格式，根节点名为xml
字符编码 统一采用UTF-8字符编码
签名算法 MD5/HMAC-SHA256
签名要求 请求和接收数据均需要校验签名，详细方法请参考安全规范-签名算法
证书要求 调用申请退款、撤销订单、红包接口等需要商户api证书，各api接口文档均有说明。
判断逻辑 先判断协议字段返回，再判断业务返回，最后判断交易状态

特别提示：
必须严格按照API的说明进行一单一支付，一单一红包，一单一付款，在未得到支付系统明确的回复之前不要换单，防止重复支付或者重复付款

在商户平台上图这个位置配置h5支付的域名(需要通过备案的域名，外网能直接访问)
申请入口：登录商户平台–>开发配置–>支付配置–>H5支付

微信统一下单接口

URL地址：https://api.mch.weixin.qq.com/pay/unifiedorder
是否需要证书：否
请求参数不列举了，下面直接给代码，注意一下几点

  1. 接口中参数支付金额单位为【分】
  2. 交易类型trade_type

JSAPI–JSAPI支付（或小程序支付）、NATIVE–Native支付、APP–app支付，MWEB–H5支付，不同trade_type决定了调起支付的方式，请根据支付产品正确上传

MICROPAY–付款码支付，付款码支付有单独的支付接口，所以接口不需要上传，该字段在对账单中会出现

统一下单代码
appid：公众平台的appid
mch_id：公众平台的商户号

  /**
     * H5付款-统一下单
     * @param bizOrder
     * @return
     */
    public Map<String, String> payH5() {
        Map<String, String> resultMap = null;
        try {
            WXPayConfig config = new MyWXPayConfig();
            WXPay wxPay = new WXPay(config);

            Map<String, String> map = new HashMap<>();
            map.put("appid", appid);//公众平台的appid
            map.put("mch_id", mch_id);//公众平台的商户号
            map.put("nonce_str", WXPayUtil.generateNonceStr());
             map.put("body", "腾讯充值中心-QQ会员充值" );
            map.put("out_trade_no",orderNo());//订单号
            map.put("total_fee", orderFee());//订单金额
            map.put("spbill_create_ip", ip);//当前设备的ip
            map.put("notify_url", h5_notify_url);//异步回调地址
            map.put("trade_type", "MWEB");//H5支付的交易类型为MWEB
            map.put("sign_type", "HMAC-SHA256");
            String xmlStr = WXPayUtil.generateSignedXml(map, key);

            resultMap = wxPay.unifiedOrder(WXPayUtil.xmlToMap(xmlStr));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return resultMap;
    }



/**
     * 微信H5支付
     *
     * @param bizOrder
     * @return
     */
    private CommonResponse getPayH5ByWx(BizOrder bizOrder,String ip) {
        CommonResponse commonResponse = new CommonResponse();
        Map<String, String> resultMap = payH5(bizOrder,ip);
        if (resultMap.get("return_code").equals("SUCCESS") && "SUCCESS".equals(resultMap.get("result_code"))) {
           //mweb_url为拉起微信支付收银台的中间页面，可通过访问该url来拉起微信客户端，完成支付,mweb_url的有效期为5分钟。
            if (StringUtils.isNotEmpty(resultMap.get("mweb_url"))) {
                System.out.println(resultMap.get("mweb_url"));
                commonResponse.setSuccess(resultMap.get("mweb_url"));
            } else {
                commonResponse.setFailed("-2", resultMap.get("err_code_des"));
            }
        } else if (resultMap.get("return_code").equals("SUCCESS") && "ORDERPAID".equals(resultMap.get("err_code"))) {
            commonResponse.setFailed("001", "订单已支付,请勿重复支付");
        } else {
            commonResponse.setFailed("-2", resultMap.get("err_code_des"));
        }
        return commonResponse;
    }

统一下单成功以后我们可以得到 mweb_url，
这时前端js直接返回即可。

 window.location.href = mweb_url;

这里用到的一些工具类,一一贴出来

package com.github.wxpay.sdk;

import java.io.InputStream;

public abstract class WXPayConfig {



    /**
     * 获取 App ID
     *
     * @return App ID
     */
    public abstract String getAppID();


    /**
     * 获取 Mch ID
     *
     * @return Mch ID
     */
    public abstract String getMchID();


    /**
     * 获取 API 密钥
     *
     * @return API密钥
     */
    public abstract String getKey();


    /**
     * 获取商户证书内容
     *
     * @return 商户证书内容
     */
    public abstract InputStream getCertStream();

    /**
     * HTTP(S) 连接超时时间，单位毫秒
     *
     * @return
     */
    public int getHttpConnectTimeoutMs() {
        return 6*1000;
    }

    /**
     * HTTP(S) 读数据超时时间，单位毫秒
     *
     * @return
     */
    public int getHttpReadTimeoutMs() {
        return 8*1000;
    }

    /**
     * 获取WXPayDomain, 用于多域名容灾自动切换
     * @return
     */
    public abstract IWXPayDomain getWXPayDomain();

    /**
     * 是否自动上报。
     * 若要关闭自动上报，子类中实现该函数返回 false 即可。
     *
     * @return
     */
    public boolean shouldAutoReport() {
        return true;
    }

    /**
     * 进行健康上报的线程的数量
     *
     * @return
     */
    public int getReportWorkerNum() {
        return 6;
    }


    /**
     * 健康上报缓存消息的最大数量。会有线程去独立上报
     * 粗略计算：加入一条消息200B，10000消息占用空间 2000 KB，约为2MB，可以接受
     *
     * @return
     */
    public int getReportQueueMaxSize() {
        return 10000;
    }

    /**
     * 批量上报，一次最多上报多个数据
     *
     * @return
     */
    public int getReportBatchSize() {
        return 10;
    }

}


package com.github.wxpay.sdk;

import com.github.wxpay.sdk.WXPayConstants.SignType;

import java.util.HashMap;
import java.util.Map;

public class WXPay {

    private WXPayConfig config;
    private SignType signType;
    private boolean autoReport;
    private boolean useSandbox;
    private String notifyUrl;
    private WXPayRequest wxPayRequest;

    public WXPay(final WXPayConfig config) throws Exception {
        this(config, null, true, false);
    }

    public WXPay(final WXPayConfig config, final boolean autoReport) throws Exception {
        this(config, null, autoReport, false);
    }


    public WXPay(final WXPayConfig config, final boolean autoReport, final boolean useSandbox) throws Exception{
        this(config, null, autoReport, useSandbox);
    }

    public WXPay(final WXPayConfig config, final String notifyUrl) throws Exception {
        this(config, notifyUrl, true, false);
    }

    public WXPay(final WXPayConfig config, final String notifyUrl, final boolean autoReport) throws Exception {
        this(config, notifyUrl, autoReport, false);
    }

    public WXPay(final WXPayConfig config, final String notifyUrl, final boolean autoReport, final boolean useSandbox) throws Exception {
        this.config = config;
        this.notifyUrl = notifyUrl;
        this.autoReport = autoReport;
        this.useSandbox = useSandbox;
        if (useSandbox) {
            this.signType = SignType.MD5; // 沙箱环境
        }
        else {
            this.signType = SignType.HMACSHA256;
        }
        this.wxPayRequest = new WXPayRequest(config);
    }

    private void checkWXPayConfig() throws Exception {
        if (this.config == null) {
            throw new Exception("config is null");
        }
        if (this.config.getAppID() == null || this.config.getAppID().trim().length() == 0) {
            throw new Exception("appid in config is empty");
        }
        if (this.config.getMchID() == null || this.config.getMchID().trim().length() == 0) {
            throw new Exception("appid in config is empty");
        }
        if (this.config.getCertStream() == null) {
            throw new Exception("cert stream in config is empty");
        }
        if (this.config.getWXPayDomain() == null){
            throw new Exception("config.getWXPayDomain() is null");
        }

        if (this.config.getHttpConnectTimeoutMs() < 10) {
            throw new Exception("http connect timeout is too small");
        }
        if (this.config.getHttpReadTimeoutMs() < 10) {
            throw new Exception("http read timeout is too small");
        }

    }

    /**
     * 向 Map 中添加 appid、mch_id、nonce_str、sign_type、sign <br>
     * 该函数适用于商户适用于统一下单等接口，不适用于红包、代金券接口
     *
     * @param reqData
     * @return
     * @throws Exception
     */
    public Map<String, String> fillRequestData(Map<String, String> reqData) throws Exception {
        reqData.put("appid", config.getAppID());
        reqData.put("mch_id", config.getMchID());
        reqData.put("nonce_str", WXPayUtil.generateNonceStr());
        if (SignType.MD5.equals(this.signType)) {
            reqData.put("sign_type", WXPayConstants.MD5);
        }
        else if (SignType.HMACSHA256.equals(this.signType)) {
            reqData.put("sign_type", WXPayConstants.HMACSHA256);
        }
        reqData.put("sign", WXPayUtil.generateSignature(reqData, config.getKey(), this.signType));
        return reqData;
    }

    /**
     * 判断xml数据的sign是否有效，必须包含sign字段，否则返回false。
     *
     * @param reqData 向wxpay post的请求数据
     * @return 签名是否有效
     * @throws Exception
     */
    public boolean isResponseSignatureValid(Map<String, String> reqData) throws Exception {
        // 返回数据的签名方式和请求中给定的签名方式是一致的
        return WXPayUtil.isSignatureValid(reqData, this.config.getKey(), this.signType);
    }

    /**
     * 判断支付结果通知中的sign是否有效
     *
     * @param reqData 向wxpay post的请求数据
     * @return 签名是否有效
     * @throws Exception
     */
    public boolean isPayResultNotifySignatureValid(Map<String, String> reqData) throws Exception {
        String signTypeInData = reqData.get(WXPayConstants.FIELD_SIGN_TYPE);
        SignType signType;
        if (signTypeInData == null) {
            signType = SignType.HMACSHA256;
        }
        else {
            signTypeInData = signTypeInData.trim();
            if (signTypeInData.length() == 0) {
                signType = SignType.HMACSHA256;
            }
            else if (WXPayConstants.MD5.equals(signTypeInData)) {
                signType = SignType.MD5;
            }
            else if (WXPayConstants.HMACSHA256.equals(signTypeInData)) {
                signType = SignType.HMACSHA256;
            }
            else {
                throw new Exception(String.format("Unsupported sign_type: %s", signTypeInData));
            }
        }
        return WXPayUtil.isSignatureValid(reqData, this.config.getKey(), signType);
    }


    /**
     * 不需要证书的请求
     * @param urlSuffix String
     * @param reqData 向wxpay post的请求数据
     * @param connectTimeoutMs 超时时间，单位是毫秒
     * @param readTimeoutMs 超时时间，单位是毫秒
     * @return API返回数据
     * @throws Exception
     */
    public String requestWithoutCert(String urlSuffix, Map<String, String> reqData,
                                     int connectTimeoutMs, int readTimeoutMs) throws Exception {
        String msgUUID = reqData.get("nonce_str");
        String reqBody = WXPayUtil.mapToXml(reqData);

        String resp = this.wxPayRequest.requestWithoutCert(urlSuffix, msgUUID, reqBody, connectTimeoutMs, readTimeoutMs, autoReport);
        return resp;
    }


    /**
     * 需要证书的请求
     * @param urlSuffix String
     * @param reqData 向wxpay post的请求数据  Map
     * @param connectTimeoutMs 超时时间，单位是毫秒
     * @param readTimeoutMs 超时时间，单位是毫秒
     * @return API返回数据
     * @throws Exception
     */
    public String requestWithCert(String urlSuffix, Map<String, String> reqData,
                                  int connectTimeoutMs, int readTimeoutMs) throws Exception {
        String msgUUID= reqData.get("nonce_str");
        String reqBody = WXPayUtil.mapToXml(reqData);

        String resp = this.wxPayRequest.requestWithCert(urlSuffix, msgUUID, reqBody, connectTimeoutMs, readTimeoutMs, this.autoReport);
        return resp;
    }

    /**
     * 处理 HTTPS API返回数据，转换成Map对象。return_code为SUCCESS时，验证签名。
     * @param xmlStr API返回的XML格式数据
     * @return Map类型数据
     * @throws Exception
     */
    public Map<String, String> processResponseXml(String xmlStr) throws Exception {
        String RETURN_CODE = "return_code";
        String return_code;
        Map<String, String> respData = WXPayUtil.xmlToMap(xmlStr);
        if (respData.containsKey(RETURN_CODE)) {
            return_code = respData.get(RETURN_CODE);
        }
        else {
            throw new Exception(String.format("No `return_code` in XML: %s", xmlStr));
        }

        if (return_code.equals(WXPayConstants.FAIL)) {
            return respData;
        }
        else if (return_code.equals(WXPayConstants.SUCCESS)) {
           if (this.isResponseSignatureValid(respData)) {
               return respData;
           }
           else {
               throw new Exception(String.format("Invalid sign value in XML: %s", xmlStr));
           }
        }
        else {
            throw new Exception(String.format("return_code value %s is invalid in XML: %s", return_code, xmlStr));
        }
    }

     /**
     * 作用：统一下单<br>
     * 场景：公共号支付、扫码支付、APP支付
     * @param reqData 向wxpay post的请求数据
     * @return API返回数据
     * @throws Exception
     */
    public Map<String, String> unifiedOrder(Map<String, String> reqData) throws Exception {
        return this.unifiedOrder(reqData, config.getHttpConnectTimeoutMs(), this.config.getHttpReadTimeoutMs());
    }

 
 


   // end class


package com.github.wxpay.sdk;

import com.github.wxpay.sdk.WXPayConstants.SignType;
import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import javax.servlet.http.HttpServletRequest;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.io.StringWriter;
import java.security.MessageDigest;
import java.security.SecureRandom;
import java.util.*;


public class WXPayUtil {

    private static final String SYMBOLS = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";

    private static final Random RANDOM = new SecureRandom();

    /**
     * XML格式字符串转换为Map
     *
     * @param strXML XML字符串
     * @return XML数据转换后的Map
     * @throws Exception
     */
    public static Map<String, String> xmlToMap(String strXML) throws Exception {
        try {
            Map<String, String> data = new HashMap<String, String>();
            DocumentBuilder documentBuilder = WXPayXmlUtil.newDocumentBuilder();
            InputStream stream = new ByteArrayInputStream(strXML.getBytes("UTF-8"));
            org.w3c.dom.Document doc = documentBuilder.parse(stream);
            doc.getDocumentElement().normalize();
            NodeList nodeList = doc.getDocumentElement().getChildNodes();
            for (int idx = 0; idx < nodeList.getLength(); ++idx) {
                Node node = nodeList.item(idx);
                if (node.getNodeType() == Node.ELEMENT_NODE) {
                    org.w3c.dom.Element element = (org.w3c.dom.Element) node;
                    data.put(element.getNodeName(), element.getTextContent());
                }
            }
            try {
                stream.close();
            } catch (Exception ex) {
                // do nothing
            }
            return data;
        } catch (Exception ex) {
            WXPayUtil.getLogger().warn("Invalid XML, can not convert to map. Error message: {}. XML content: {}", ex.getMessage(), strXML);
            throw ex;
        }

    }

    /**
     * 将Map转换为XML格式的字符串
     *
     * @param data Map类型数据
     * @return XML格式的字符串
     * @throws Exception
     */
    public static String mapToXml(Map<String, String> data) throws Exception {
        org.w3c.dom.Document document = WXPayXmlUtil.newDocument();
        org.w3c.dom.Element root = document.createElement("xml");
        document.appendChild(root);
        for (String key: data.keySet()) {
            String value = data.get(key);
            if (value == null) {
                value = "";
            }
            value = value.trim();
            org.w3c.dom.Element filed = document.createElement(key);
            filed.appendChild(document.createTextNode(value));
            root.appendChild(filed);
        }
        TransformerFactory tf = TransformerFactory.newInstance();
        Transformer transformer = tf.newTransformer();
        DOMSource source = new DOMSource(document);
        transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
        transformer.setOutputProperty(OutputKeys.INDENT, "yes");
        StringWriter writer = new StringWriter();
        StreamResult result = new StreamResult(writer);
        transformer.transform(source, result);
        String output = writer.getBuffer().toString(); //.replaceAll("\n|\r", "");
        try {
            writer.close();
        }
        catch (Exception ex) {
        }
        return output;
    }


    /**
     * 生成带有 sign 的 XML 格式字符串
     *
     * @param data Map类型数据
     * @param key API密钥
     * @return 含有sign字段的XML
     */
    public static String generateSignedXml(final Map<String, String> data, String key) throws Exception {
        return generateSignedXml(data, key, SignType.MD5);
    }

    /**
     * 生成带有 sign 的 XML 格式字符串
     *
     * @param data Map类型数据
     * @param key API密钥
     * @param signType 签名类型
     * @return 含有sign字段的XML
     */
    public static String generateSignedXml(final Map<String, String> data, String key, SignType signType) throws Exception {
        String sign = generateSignature(data, key, signType);
        data.put(WXPayConstants.FIELD_SIGN, sign);
        return mapToXml(data);
    }


    /**
     * 判断签名是否正确
     *
     * @param xmlStr XML格式数据
     * @param key API密钥
     * @return 签名是否正确
     * @throws Exception
     */
    public static boolean isSignatureValid(String xmlStr, String key) throws Exception {
        Map<String, String> data = xmlToMap(xmlStr);
        if (!data.containsKey(WXPayConstants.FIELD_SIGN) ) {
            return false;
        }
        String sign = data.get(WXPayConstants.FIELD_SIGN);
        return generateSignature(data, key).equals(sign);
    }

    /**
     * 判断签名是否正确，必须包含sign字段，否则返回false。使用MD5签名。
     *
     * @param data Map类型数据
     * @param key API密钥
     * @return 签名是否正确
     * @throws Exception
     */
    public static boolean isSignatureValid(Map<String, String> data, String key) throws Exception {
        return isSignatureValid(data, key, SignType.MD5);
    }

    /**
     * 判断签名是否正确，必须包含sign字段，否则返回false。
     *
     * @param data Map类型数据
     * @param key API密钥
     * @param signType 签名方式
     * @return 签名是否正确
     * @throws Exception
     */
    public static boolean isSignatureValid(Map<String, String> data, String key, SignType signType) throws Exception {
        if (!data.containsKey(WXPayConstants.FIELD_SIGN) ) {
            return false;
        }
        String sign = data.get(WXPayConstants.FIELD_SIGN);
        return generateSignature(data, key, signType).equals(sign);
    }

    /**
     * 生成签名
     *
     * @param data 待签名数据
     * @param key API密钥
     * @return 签名
     */
    public static String generateSignature(final Map<String, String> data, String key) throws Exception {
        return generateSignature(data, key, SignType.MD5);
    }

    /**
     * 生成签名. 注意，若含有sign_type字段，必须和signType参数保持一致。
     *
     * @param data 待签名数据
     * @param key API密钥
     * @param signType 签名方式
     * @return 签名
     */
    public static String generateSignature(final Map<String, String> data, String key, SignType signType) throws Exception {
        Set<String> keySet = data.keySet();
        String[] keyArray = keySet.toArray(new String[keySet.size()]);
        Arrays.sort(keyArray);
        StringBuilder sb = new StringBuilder();
        for (String k : keyArray) {
            if (k.equals(WXPayConstants.FIELD_SIGN)) {
                continue;
            }
            if (data.get(k).trim().length() > 0) // 参数值为空，则不参与签名
                sb.append(k).append("=").append(data.get(k).trim()).append("&");
        }
        sb.append("key=").append(key);
        if (SignType.MD5.equals(signType)) {
            return MD5(sb.toString()).toUpperCase();
        }
        else if (SignType.HMACSHA256.equals(signType)) {
            return HMACSHA256(sb.toString(), key);
        }
        else {
            throw new Exception(String.format("Invalid sign_type: %s", signType));
        }
    }


    /**
     * 获取随机字符串 Nonce Str
     *
     * @return String 随机字符串
     */
    public static String generateNonceStr() {
        char[] nonceChars = new char[32];
        for (int index = 0; index < nonceChars.length; ++index) {
            nonceChars[index] = SYMBOLS.charAt(RANDOM.nextInt(SYMBOLS.length()));
        }
        return new String(nonceChars);
    }


    /**
     * 生成 MD5
     *
     * @param data 待处理数据
     * @return MD5结果
     */
    public static String MD5(String data) throws Exception {
        MessageDigest md = MessageDigest.getInstance("MD5");
        byte[] array = md.digest(data.getBytes("UTF-8"));
        StringBuilder sb = new StringBuilder();
        for (byte item : array) {
            sb.append(Integer.toHexString((item & 0xFF) | 0x100).substring(1, 3));
        }
        return sb.toString().toUpperCase();
    }

    /**
     * 生成 HMACSHA256
     * @param data 待处理数据
     * @param key 密钥
     * @return 加密结果
     * @throws Exception
     */
    public static String HMACSHA256(String data, String key) throws Exception {
        Mac sha256_HMAC = Mac.getInstance("HmacSHA256");
        SecretKeySpec secret_key = new SecretKeySpec(key.getBytes("UTF-8"), "HmacSHA256");
        sha256_HMAC.init(secret_key);
        byte[] array = sha256_HMAC.doFinal(data.getBytes("UTF-8"));
        StringBuilder sb = new StringBuilder();
        for (byte item : array) {
            sb.append(Integer.toHexString((item & 0xFF) | 0x100).substring(1, 3));
        }
        return sb.toString().toUpperCase();
    }

    /**
     * 日志
     * @return
     */
    public static Logger getLogger() {
        Logger logger = LoggerFactory.getLogger("wxpay java sdk");
        return logger;
    }

    /**
     * 获取当前时间戳，单位秒
     * @return
     */
    public static long getCurrentTimestamp() {
        return System.currentTimeMillis()/1000;
    }

    /**
     * 获取当前时间戳，单位毫秒
     * @return
     */
    public static long getCurrentTimestampMs() {
        return System.currentTimeMillis();
    }


    /**
     * 从请求request中获取IP地址
     *
     * @param request
     * @return IP
     */
    public static String getIp(HttpServletRequest request) {
        String ip = request.getHeader("x-forwarded-for");
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("X-Real-IP");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getRemoteAddr();
        }
        if (ip != null && ip.toLowerCase().contains("x-forwarded-for")) {
            String ip_temp = "";
            if (ip.contains(":") && ip.split(":").length > 0 && !ip.endsWith(":")) {
                ip_temp = ip.split(":")[1];
                if (StringUtils.isBlank(ip_temp)) {
                    ip_temp = ip.substring(0, ip.lastIndexOf("X-Forwarded-For"));
                }
            } else {
                ip_temp = ip.substring(0, ip.lastIndexOf("X-Forwarded-For"));
            }
            ip = ip_temp.replaceAll(" ", "");
        }
        if (ip != null && ip.indexOf(",") > -1) {
            String ip_temp = ip.split(",")[0];
            ip_temp = ip_temp.replaceAll(" ", "");
            if (ip_temp.startsWith("10.") && ip.split(",").length > 1) {
                ip = ip.split(",")[1];
                ip = ip.replaceAll(" ", "");
            } else {
                ip = ip_temp;
            }
        }
        return ip;
    }


}


package cn.com.artlife.archiveCenterService.model;

/**
 * 通用接口返回对象
 */
public class CommonResponse {

    //默认成功状态
    public static final String SUCCESS = "0";
    //默认失败状态
    public static final String ERROR = "-1";

    //接口状态
    private String status = ERROR;
    //接口消息
    private String msg = "";
    //接口返回对象
    private Object data = null;

    public String getStatus() {
        return status;
    }

    public void setStatus(String status) {
        this.status = status;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }

    public Object getData() {
        return data;
    }

    public void setData(Object data) {
        this.data = data;
    }

    //失败
    public void setFailed(String status,String msg){
        setStatus(status);
        setMsg(msg);
    }

    //带返回对象的成功
    public void setSuccess(Object data){
        setStatus(SUCCESS);
        setData(data);
    }

    //没有返回对象的成功
    public void setSuccess(){
        setSuccess(null);
    }

//    //判断是否成功
//    public boolean isSuccess(){
//        return SUCCESS.equals(status);
//    }
}

常见问题

  1. 网络环境未能通过安全验证，请稍后再试

在这里插入图片描述

商户侧统一下单传的终端IP(spbill_create_ip)与用户实际调起支付时微信侧检测到的终端IP不一致导致的，这个问题一般是商户在统一下单时没有传递正确的终端IP到spbill_create_ip导致

  1. 商家参数格式有误，请联系商家解决

在这里插入图片描述

当前调起H5支付的referer为空导致，一般是因为直接访问页面调起H5支付，js直接跳转就可以，不要复制链接再浏览器中打开，会报上面这个错。

3.商家存在未配置的参数，请联系商家解决

在这里插入图片描述

当前调起H5支付的域名（微信侧从referer中获取）与申请H5支付时提交的授权域名不一致，这里是H5的支付域名，不是公众号支付

  1. 支付请求已失效，请重新发起支付

在这里插入图片描述

统一下单返回的MWEB_URL生成后，有效期为5分钟，如超时请重新生成MWEB_URL后再发起支付

java代码

github 地址

wySama0830
关注
专栏目录
微信H5支付微信H5支付微信H5支付
11-08
微信H5支付是一种在网页端实现的支付方式，由微信支付提供，允许用户在移动浏览器中通过微信支付接口完成商品或服务的支付流程。这种方式主要适用于移动端网站，为用户提供便捷的在线购物体验，无需跳转到微信应用内...
微信公众号H5支付（一）
weixin_44795226的博客
12-15 679
最近，公司有个项目，要我写个微信H5支付的程序，我花了3天时间，查微信H5开发文档，各种百度，最终被我整出来了。写写心得 流程 大致业务流程呢，就是手机浏览器打开商品支付页面，点击支付，跳转到微信，在微信支付，输入密码，支付成功，跳转回原商品订单页面。 准备 首先得准备H5支付必须的东西： 域名 需要又外网能够直接访问的域名。 微信公众号（一般由公司提供，普通私用的话好像不太现实） 必须得是服务...
微信H5支付详解(案列) 秒懂
在北极吃火锅的博客
01-03 3133
1.了解微信H5支付 流程 1、用户在商户侧完成下单，使用微信支付进行支付 2、由商户后台向微信支付发起下单请求（调用统一下单接口）注：交易类型trade_type=MWEB 3、统一下单接口返回支付相关参数给商户后台，如支付跳转url（参数名“mweb_url”），商户通过mweb_url调起微信支付中间页 4、中间页进行H5权限的校验，安全性检查（此处常见错误请见下文） 5、如...
H5支付 两种成熟方案
最新发布
Beatingworldline的博客
09-26 716
H5支付，对前端来讲并不算难。主要工作量都在后端，需要对接支付宝API文档配置大量参数与商户信息。前端需要做的是正常调取支付接口，拿到配置好的支付信息，触发后续流程，再利用本地存储拿支付订单号判断支付结果即可【如果跳转支付宝的H5支付中间页，不同于IOS的机制，在嵌套安卓APP-webview的情况下会被销毁，无法保持页面状态，其中一个解决方案就是localStorage需要保存支付订单号】。
php h5对接 java接口_PHP接入微信H5支付的方法示例
weixin_42503660的博客
02-26 363
开发前配置进行代码接入前，需在微信后台填写授权回调域名，此域名必须经过ICP备案开发主要流程用户下单时选择微信支付商户进行业务逻辑处理并调用微信统一下单接口，微信H5交易类型为：trade_type=MWEB调用下单接口成功时，微信会返回包含支付跳转URL等相关参数，商户通过参数mweb_url调起支付中间页在中间页微信会进行H5权限的校验支付成功，微信会向商户发送异步结果通知正式开发接口请求参数...
微信支付参数规定交易类型trade_type
weixin_40854327的博客
07-06 2964
JSAPI--JSAPI支付（或小程序支付）、NATIVE--Native支付、APP--app支付，MWEB--H5支付，不同trade_type决定了调起支付的方式，请根据支付产品正确上传 MICROPAY--付款码支付，付款码支付有单独的支付接口，所以接口不需要上传，该字段在对账单中会出现 ...
微信h5支付前端代码
dandan1924的博客
09-09 5009
一.首先，需要确认是否在微信开通了这个服务，如果开通了，如下图 二.就是前段和后台互调。 ????????微信h5支付官网地址：https://pay.weixin.qq.com/wiki/doc/api/H5.php?chapter=15_4 根据官网解释，前段要做的事情很简单：就是在用户点击微信支付按钮的时候，跳转到后台返回的MWEB_URL即可。 但是，官网说： 注意： 1.需对redirect_url...
微信H5支付DEMO 绝对可用
01-01
微信H5支付是一种在网页上实现的支付方式，由微信官方提供的一种支付接口，主要用于移动端的在线交易。在这个“微信H5支付DEMO”中，包含了一整套完整的支付流程示例，帮助开发者快速理解和集成微信H5支付功能。下面...
微信H5支付DEMO
07-20
微信H5支付DEMO是一个基于C#和ASP.NET技术实现的微信H5支付示例，主要目的是为了展示如何集成微信支付功能，使用户能够在H5网页中流畅地完成支付过程。这个DEMO涵盖了从调用微信支付接口进行统一下单到引导用户完成...
微信H5支付源码示例
04-24
2 ,H5支付不能直接在微信浏览器中打开支付，需要打开外部浏览器才能支付。 3 ,微信公众号需要设置网页授权域名，添加支付目录，业务域名，js安全域。( 这项我不确定，公众号支付是要设置这些的) 4 ,需要在线上测试...
微信h5支付
01-13
这里主要是h5支付,压缩包里有使用文档跟注意事项，实现微信外浏览器调用h5页面回到微信支付
java 微信H5支付Demo
03-29
java 微信H5支付Demo，已经成功使用在项目里，具体业务没有删除，请自动过滤业务层代码
SpringBoot集成H5微信支付宝支付
02-28
6. **生成H5支付跳转链接**：根据预支付交易会话标识，生成微信支付H5页面的跳转链接，用户点击后将进入微信支付页面。 7. **处理支付结果**：微信支付成功后，用户会被重定向到指定的回调URL，需在此处处理支付结果...
java实现微信H5支付方法详解
08-30
本篇文章主要介绍了java实现微信H5支付方法详解，非常具有实用价值，需要的朋友可以参考下
ectouch微信支付(含微信H5支付)
11-27
ectouch微信支付(含微信H5支付，含说明文档) 注意： 1、wxpay.php文件里面的 get_h5，获取H5微信支付链接 2、getPrepayId 方法新增一个参数，如果是h5支付则返回返回数组 （有问题请留言）
微信h5支付前端源码，h5支付前端demo源代码
03-06
微信h5支付前端源码是子恒老师微信h5支付开发系列视频中的，关于h5支付的前端页面，为后端php实现h5支付提供便利。视频观看学习地址https://edu.csdn.net/course/play/6899/138877
微信 获取wx.config 参数 基类
weixin_33798152的博客
01-24 393
原文:微信 获取wx.config 参数 基类using System;using System.Collections.Generic;using System.Linq;using System.Web;using System.Web.Script.Serialization;using System.Text;using System.Web.Caching; namespace Sat...
微信调用H5支付
weixin_41761540的博客
10-12 2666
一：参考网站 微信开发文档：https://pay.weixin.qq.com/wiki/doc/api/index.html 二：准备 去商户平台获取商户账户id（appid）、微信支付商户号、密钥 微信支付网关：https://api.mch.weixin.qq.com/pay/unifiedorder 三：配置文件yml 在yml文件中配置微信付款需要的参数 #微信支付配置 wechat: #商户账号id appId: xxxxxxxxxx #微信支付商户号 mcHid
h5收银台html静态页微信,前端H5微信内部支付
weixin_39639698的博客
06-07 1725
上一章讲了微信外部的H5支付，当然同一个页面是不会仅仅满足在微信外部支付的，扩展到JSAPI支付；实际上很多操作都是你的后端小伙伴完成的，感谢后端大大；交互细节：以下是支付场景的交互细节，请认真阅读，设计商户页面的逻辑：用户打开商户网页选购商品，发起支付，在网页通过JavaScript调用getBrandWCPayRequest接口，发起微信支付请求，用户进入支付流程。用户成功支付点击完成按钮后，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值