Java微信支付

已于 2022-06-20 09:54:44 修改
阅读量5.1k 收藏 26
点赞数 5
分类专栏： 日常记录 文章标签： 微信 java 微信小程序
于 2022-02-22 11:07:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44765388/article/details/123063421
版权

目录

前言

代码实现

1、yaml配置

2、前端唤醒微信支付controller

3、前端唤醒微信支付controller传参

4、前端唤醒微信支付controller返回参数

5、前端唤醒微信支付service具体实现

6、常量配置

7、微信支付工具类

8、微信支付回调

9、解析回调参数

前言

微信支付开发者文档

代码实现

1、yaml配置

#微信配置
wechat:
  appId: xxxxxxxx
  secret: xxxxxxxxxxxxxxxxxxxxxxxxxxx
  #商户号
  mchId: xxxxxxxx
  #商户秘钥
  key: xxxxxxxxxxxxxxxxxxxxxxx
  #终端IP
  clientIp: xxx.xx.xxx.xxx
  #订单微信支付回调地址
  orderPayNotifyUrl: https://xx.xxxxxxx.com/wechat/callback
  #订单微信退款回调地址
  orderRefundNotifyUrl: https://xx.xxxxxxx.com/wechat/refund/callback
  #退款证书
  refundCertPath: cert/apiclient_cert.p12

2、前端唤醒微信支付controller


    @PostMapping(value = "/wechat")
    @ApiOperation("微信支付")
    @ApiImplicitParam(paramType = Constants.HEADER, dataType = Constants.STRING, name = Constants.AUTHORIZATION, value = "授权token", required = true)
    public Result<OrderWechatPayVO> wechat(@Valid @RequestBody OrderPayDTO params) {
        OrderWechatPayVO orderWechatPayVO = orderPayService.wechatPay(params);
        return Result.ok(orderWechatPayVO);
    }

3、前端唤醒微信支付controller传参

@Data
@Accessors(chain = true)
@ApiModel("订单支付")
public class OrderPayDTO {

    @ApiModelProperty(value = "订单id", required = true)
    @NotNull(message = "订单id不能为空")
    private Long orderId;

    @ApiModelProperty(value = "下单用户终端 1.app 2.微信小程序", required = true)
    @NotNull(message = "下单用户终端不能为空")
    private Integer terminal;

    @ApiModelProperty(value = "是否部分支付", required = true)
    @NotNull(message = "是否部分支付不能为空")
    private Boolean partPay;

    @ApiModelProperty(value = "部分支付金额，部分支付时必传", required = false)
    private BigDecimal payPrice;

}

4、前端唤醒微信支付controller返回参数

@Data
@ApiModel(value = "订单微信支付返回")
public class OrderWechatPayVO {

    @ApiModelProperty(value = "支付流水id")
    private Long id;

    @ApiModelProperty(value = "支付流水号")
    private String payNo;

    @ApiModelProperty(value = "支付金额")
    private BigDecimal payPrice;

    @ApiModelProperty(value = "支付唤醒参数")
    private Map<String, Object> payData;

}

5、前端唤醒微信支付service具体实现


    /**
     * 微信支付
     *
     * @param params
     */
    @Transactional(rollbackFor = Exception.class)
    public OrderWechatPayVO wechatPay(OrderPayDTO params) {
        //创建支付流水
        OrderPay orderPay = createOrderPay(params, PayMethodCode.WECHAT_PAY.getCode());

        Map<String, Object> payResult;
        //app支付
        if (orderPay.getTerminal() == OrderTerminalCode.APP.getCode()) {
            payResult = wechatPayUtil.appOrder(orderPay.getPayNo(), orderPay.getPayPrice(), "购买", wechatProperties.getCourseOrderPayNotifyUrl());
        } else {
            //TODO 小程序支付获取会员openid
            payResult = wechatPayUtil.mpOrder(orderPay.getPayNo(), orderPay.getPayPrice(), "购买", "", wechatProperties.getCourseOrderPayNotifyUrl());
        }

        OrderWechatPayVO wechatPayVO = new OrderWechatPayVO();
        wechatPayVO.setId(orderPay.getId());
        wechatPayVO.setPayNo(orderPay.getPayNo());
        wechatPayVO.setPayPrice(orderPay.getPayPrice());
        wechatPayVO.setPayData(payResult);
        return wechatPayVO;
    }

    /**
     * 创建支付流水
     *
     * @param params
     * @param patMethod
     * @return
     */
    private OrderPay createOrderPay(OrderPayDTO params, int patMethod) {
        Order order = orderRepository.findByIdAndMemberId(params.getOrderId(), SecurityContextHolder.getUserId());
        Assert.notNull(order, "订单不存在");
        Assert.isFalse(order.getStatus() != OrderStatusCode.WAIT_PAY.getCode() && order.getStatus() != OrderStatusCode.PART_PAY.getCode(), "该订单无法支付");

        OrderPay orderPay = new OrderPay();
        orderPay.setMemberId(courseOrder.getMemberId());
        orderPay.setOrderId(courseOrder.getId());
        orderPay.setOrderNo(courseOrder.getOrderNo());
        orderPay.setTerminal(params.getTerminal());
        orderPay.setPayMethod(patMethod);
        orderPay.setOrderType(PayOrderTypeCode.COURSE_ORDER.getCode());
        orderPay.setStatus(PayStatusCode.WAIT_PAY.getCode());
        String payNo = DateUtil.format(new Date(), "yyyyMMddHHmmssSSS") + RandomUtil.randomNumbers(7);
        orderPay.setPayNo(payNo);
        orderPay.setPayPrice(courseOrder.getWaitPayPrice());
        orderPayRepository.insert(orderPay);
        return orderPay;
    }

6、常量配置


/**
 * 微信支付常量
 *
 * @author: CYL
 * @date: 2022-01-17 16:09
 */
public final class WechatPayConstants {

    /**
     * 小程序支付url
     */
    public static final String JSAPI_PAY_URL = "https://api.mch.weixin.qq.com/pay/unifiedorder";

    /**
     * app支付url
     */
    public static final String APP_PAY_URL = "https://api.mch.weixin.qq.com/v3/pay/transactions/app";

    /**
     * 查询订单url
     */
    public static final String QUERY_URL = "https://api.mch.weixin.qq.com/pay/orderquery";

    /**
     * 退款url
     */
    public static final String REFUND_URL = "https://api.mch.weixin.qq.com/secapi/pay/refund";

    /**
     * 响应成功
     */
    public static final String SUCCESS = "SUCCESS";

    /**
     * 响应失败
     */
    public static final String FAIL = "FAIL";

    /**
     * JSAPI--JSAPI支付（或小程序支付）
     */
    public static final String JSAPI = "JSAPI";

    /**
     * APP--app支付
     */
    public static final String APP = "APP";

    /**
     * 支付加密方式md5
     */
    public static final String MD5 = "MD5";


}

/**
 * 订单状态
 *
 * @author: cyl
 * @date: 2022-01-14 11:53
 */
@Getter
public enum OrderStatusCode {

    WAIT_PAY(1, "待支付"),
    PART_PAY(2, "部分支付"),
    PAY_SUCCESS(3, "支付成功"),
    CANCEL(7, "已取消"),
    CLOSE(8, "已关闭"),
    ;

    private final int code;
    private final String msg;

    OrderStatusCode(int code, String msg) {
        this.code = code;
        this.msg = msg;
    }

}

/**
 * 支付方式
 *
 * @author: cyl
 * @date: 2022-01-17 15:52
 */
@Getter
public enum PayMethodCode {

    WECHAT_PAY(1, "微信支付"),
    ALIPAY_PAY(2, "支付宝支付"),
    BALANCE_PAY(3, "余额支付"),
    POS_PAY(4, "POS机支付");

    private final int code;
    private final String msg;

    PayMethodCode(int code, String msg) {
        this.code = code;
        this.msg = msg;
    }


}

package com.lw.order.properties;

import lombok.Getter;
import lombok.Setter;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

/**
 * 微信支付配置
 *
 * @author: cyl
 * @date: 2022-01-17 16:14
 */
@Getter
@Setter
@Component
@ConfigurationProperties(prefix = "wechat")
public class WechatProperties {

    /**
     * 微信appId
     */
    private String appId;

    /**
     * 微信secret
     */
    private String secret;

    /**
     * 商户号
     */
    private String mchId;

    /**
     * 商户key
     */
    private String key;

    /**
     * 服务端ip地址
     */
    private String clientIp;

    /**
     * 订单支付回调地址
     */
    private String courseOrderPayNotifyUrl;

    /**
     * 订单微信退款回调地址
     */
    private String courseOrderRefundNotifyUrl;

    /**
     * 退款证书存储路径
     */
    private String refundCertPath;


}

7、微信支付工具类

package com.lw.order.util;

import cn.hutool.core.util.NumberUtil;
import cn.hutool.core.util.RandomUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.core.util.XmlUtil;
import cn.hutool.crypto.SecureUtil;
import cn.hutool.http.HttpRequest;
import com.google.common.base.Joiner;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.lw.order.constant.WechatPayConstants;
import com.lw.order.properties.WechatProperties;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.http.HttpResponse;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.conn.ssl.DefaultHostnameVerifier;
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 org.springframework.stereotype.Component;

import javax.net.ssl.SSLContext;
import java.io.InputStream;
import java.math.BigDecimal;
import java.security.KeyStore;
import java.util.List;
import java.util.Map;

/**
 * 微信支付
 *
 * @author: cyl
 * @date: 2022-01-17 16:06
 */
@Component
@RequiredArgsConstructor
@Slf4j
public class WechatPayUtil {

    private final WechatProperties wechatProperties;


    /**
     * 小程序微信支付
     *
     * @param outTradeNo 订单号
     * @param amount     支付金额
     * @param body       支付明细
     * @param openid     用户openid
     * @param notifyUrl  支付回调地址
     * @return
     */
    public Map<String, Object> mpOrder(String outTradeNo, BigDecimal amount, String body, String openid, String notifyUrl) {
        //订单金额单位分
        int totalAmount = NumberUtil.mul(amount, 100).intValue();
        Map<String, Object> params = Maps.newHashMap();
        params.put("appid", wechatProperties.getAppId());
        params.put("mch_id", wechatProperties.getMchId());
        params.put("nonce_str", RandomUtil.randomString(30));
        params.put("sign_type", WechatPayConstants.MD5);
        params.put("body", body);
        params.put("openid", openid);
        params.put("trade_type", WechatPayConstants.JSAPI);
        params.put("out_trade_no", outTradeNo);
        params.put("total_fee", String.valueOf(totalAmount));
        params.put("spbill_create_ip", wechatProperties.getClientIp());
        params.put("notify_url", notifyUrl);
        params.put("sign", buildSign(params));
        String xml = XmlUtil.mapToXmlStr(params);
        log.info("app小程序支付xml：{}", xml);

        String result = HttpRequest.post(WechatPayConstants.JSAPI_PAY_URL)
                .body(xml)
                .timeout(20000)
                .execute()
                .body();

        log.info("微信支付响应：{}", result);

        Map<String, Object> map = XmlUtil.xmlToMap(result);
        if (!WechatPayConstants.SUCCESS.equals(map.get("return_code"))) {
            log.error("微信支付异常：{}", map.get("return_msg").toString());
            throw new IllegalArgumentException("微信支付异常");
        }

        if (!WechatPayConstants.SUCCESS.equals(map.get("result_code"))) {
            log.error("微信支付异常：{}", map.get("err_code_des").toString());
            throw new IllegalArgumentException("微信支付异常");
        }

        long timestamp = System.currentTimeMillis() / 1000;

        Map<String, Object> data = Maps.newHashMap();
        data.put("appid", map.get("appid"));
        data.put("noncestr", map.get("nonce_str"));
        data.put("package", "Sign=WXPay");
        data.put("partnerid", map.get("mch_id"));
        data.put("prepayid", map.get("prepay_id"));
        data.put("timestamp", timestamp);
        String sign = buildSign(data);
        data.put("paySign", sign);
        return data;
    }


    /**
     * app微信支付
     *
     * @param outTradeNo 订单号
     * @param amount     支付金额
     * @param body       商品描述
     * @param notifyUrl  支付回调地址
     * @return
     */
    public Map<String, Object> appOrder(String outTradeNo, BigDecimal amount, String body, String notifyUrl) {
        //订单金额单位分
        int totalAmount = NumberUtil.mul(amount, 100).intValue();
        Map<String, Object> params = Maps.newHashMap();
        params.put("appid", wechatProperties.getAppId());
        params.put("mch_id", wechatProperties.getMchId());
        params.put("nonce_str", RandomUtil.randomString(30));
        params.put("sign_type", WechatPayConstants.MD5);
        params.put("body", body);
        params.put("trade_type", WechatPayConstants.APP);
        params.put("out_trade_no", outTradeNo);
        params.put("total_fee", String.valueOf(totalAmount));
        params.put("spbill_create_ip", wechatProperties.getClientIp());
        params.put("notify_url", notifyUrl);
        params.put("sign", buildSign(params));
        String xml = XmlUtil.mapToXmlStr(params);
        log.info("app微信支付xml：{}", xml);

        String result = HttpRequest.post(WechatPayConstants.APP_PAY_URL)
                .body(xml)
                .timeout(20000)
                .execute()
                .body();

        log.info("微信支付响应：{}", result);

        Map<String, Object> map = XmlUtil.xmlToMap(result);
        if (!WechatPayConstants.SUCCESS.equals(map.get("return_code"))) {
            log.error("微信支付异常：{}", map.get("return_msg").toString());
            throw new IllegalArgumentException("微信支付异常");
        }

        if (!WechatPayConstants.SUCCESS.equals(map.get("result_code"))) {
            log.error("微信支付异常：{}", map.get("err_code_des").toString());
            throw new IllegalArgumentException("微信支付异常");
        }

        long timestamp = System.currentTimeMillis() / 1000;

        Map<String, Object> data = Maps.newHashMap();
        data.put("appid", map.get("appid"));
        data.put("partnerid", map.get("mch_id"));
        data.put("prepayid", map.get("prepay_id"));
        data.put("noncestr", map.get("nonce_str"));
        data.put("timestamp", String.valueOf(timestamp));
        data.put("package", "Sign=WXPay");
        data.put("sign", buildSign(map));
        return data;
    }


    /**
     * 微信退款
     *
     * @param outTradeNo   订单号
     * @param outRefundNo  订单退款单号
     * @param totalAmount  订单总金额
     * @param refundAmount 退款金额
     * @param notifyUrl    退款回调地址
     * @return
     */
    public String refund(String outTradeNo, String outRefundNo, BigDecimal totalAmount, BigDecimal refundAmount, String notifyUrl) {
        try {
            //订单金额单位分
            int totalAmountFee = NumberUtil.mul(totalAmount, 100).intValue();
            //退款金额单位分
            int refundAmountFee = NumberUtil.mul(refundAmount, 100).intValue();

            Map<String, Object> params = Maps.newHashMap();
            params.put("appid", wechatProperties.getAppId());
            params.put("mch_id", wechatProperties.getMchId());
            params.put("nonce_str", RandomUtil.randomString(30));
            params.put("out_trade_no", outTradeNo);
            params.put("out_refund_no", outRefundNo);
            params.put("total_fee", String.valueOf(totalAmountFee));
            params.put("refund_fee", String.valueOf(refundAmountFee));
            params.put("notify_url", notifyUrl);
            params.put("sign", buildSign(params));

            String xml = XmlUtil.mapToXmlStr(params);
            log.info("退款xml：{}", xml);

            KeyStore keyStore = KeyStore.getInstance("PKCS12");
            try (InputStream inputStream = getClass().getClassLoader().getResourceAsStream(wechatProperties.getRefundCertPath())) {
                keyStore.load(inputStream, wechatProperties.getMchId().toCharArray());
            }

            SSLContext sslcontext = SSLContexts.custom().loadKeyMaterial(keyStore, wechatProperties.getMchId().toCharArray()).build();
            SSLConnectionSocketFactory socketFactory = new SSLConnectionSocketFactory(sslcontext, new String[]{"TLSv1"}, null, new DefaultHostnameVerifier());
            CloseableHttpClient httpClient = HttpClients.custom().setSSLSocketFactory(socketFactory).build();

            HttpPost httpPost = new HttpPost(WechatPayConstants.REFUND_URL);
            httpPost.setEntity(new StringEntity(xml, "UTF-8"));
            HttpResponse response = httpClient.execute(httpPost);
            String result = EntityUtils.toString(response.getEntity(), "UTF-8");

            Map<String, Object> map = XmlUtil.xmlToMap(result);

            if (WechatPayConstants.FAIL.equals(map.get("return_code"))) {
                log.error(map.get("return_msg").toString());
                return map.get("return_msg").toString();
            }

            if (WechatPayConstants.FAIL.equals(map.get("result_code"))) {
                log.error("退款申请提交业务失败，" + map.get("err_code_des") + "；错误代码:" + map.get("err_code"));
                return "退款申请提交业务失败，" + map.get("err_code_des") + "；错误代码:" + map.get("err_code");
            }

            if (WechatPayConstants.SUCCESS.equals(map.get("result_code"))) {
                return WechatPayConstants.SUCCESS;
            }

        } catch (Exception e) {
            log.error("微信退款异常", e);
        }
        return WechatPayConstants.FAIL;
    }


    /**
     * 查询订单状态
     *
     * @param outTradeNo
     * @return
     */
    public boolean queryOrder(String outTradeNo) {
        Map<String, Object> params = Maps.newHashMap();
        params.put("appid", wechatProperties.getAppId());
        params.put("mch_id", wechatProperties.getMchId());
        params.put("nonce_str", RandomUtil.randomString(30));
        params.put("sign_type", WechatPayConstants.MD5);
        params.put("out_trade_no", outTradeNo);
        params.put("sign", buildSign(params));
        String xml = XmlUtil.mapToXmlStr(params);

        String result = HttpRequest.post(WechatPayConstants.QUERY_URL)
                .body(xml)
                .timeout(20000)
                .execute()
                .body();

        Map<String, Object> map = XmlUtil.xmlToMap(result);

        if (!WechatPayConstants.SUCCESS.equals(map.get("return_code"))) {
            log.error("微信查询接口失败：{}", result);
            return false;
        }

        if (!WechatPayConstants.SUCCESS.equals(map.get("result_code"))) {
            log.error("微信查询接口失败：{}", result);
            return false;
        }

        return WechatPayConstants.SUCCESS.equals(map.get("trade_state"));
    }


    /**
     * 参数签名
     *
     * @param params 参数
     * @return 签名字符串
     */
    public String buildSign(Map<String, Object> params) {
        List<String> list = Lists.newArrayList();
        for (Map.Entry<String, Object> entry : params.entrySet()) {
            if ("sign".equals(entry.getKey())) {
                continue;
            }

            //参数值为空不参与签名
            if (StrUtil.isNotEmpty(entry.getValue().toString())) {
                list.add(entry.getKey() + "=" + entry.getValue());
            }
        }
        list.sort(String::compareTo);
        list.add("key=" + wechatProperties.getKey());
        return SecureUtil.md5(Joiner.on("&").join(list)).toUpperCase();
    }


    /**
     * 支付回调响应
     *
     * @param returnCode 返回状态
     * @param returnMsg  返回提示
     * @return
     */
    public String buildResponse(String returnCode, String returnMsg) {
        Map<String, String> map = Maps.newHashMap();
        map.put("return_code", returnCode);
        map.put("return_msg", returnMsg);
        return XmlUtil.mapToXmlStr(map);
    }

}

8、微信支付回调


    @PostMapping(value = "/wechat/callback")
    @ApiOperation(value = "微信支付回调", hidden = true)
    public String wechatCallback(HttpServletRequest request) {
        RLock lock = null;
        try {
            Document xml = XmlUtil.readXML(request.getInputStream());
            String xmlStr = XmlUtil.toStr(xml);
            log.info("[微信支付异步回调通知报文]:" + xmlStr);
            Map<String, Object> resultMap = XmlUtil.xmlToMap(xmlStr);

            if (!WechatPayConstants.SUCCESS.equalsIgnoreCase(resultMap.get("return_code").toString())) {
                //响应不成功
                return wechatPayUtil.buildResponse(WechatPayConstants.FAIL, "return_code不为SUCCESS");
            }

            String tradeNo = resultMap.get("out_trade_no").toString();
            String sign = wechatPayUtil.buildSign(resultMap);
            if (!sign.equals(resultMap.get("sign"))) {
                log.error("[微信支付回调通知签名校验不通过]");
                return wechatPayUtil.buildResponse(WechatPayConstants.FAIL, "签名校验不通过");
            }

            if (!WechatPayConstants.SUCCESS.equalsIgnoreCase(resultMap.get("result_code").toString())) {
                return wechatPayUtil.buildResponse(WechatPayConstants.FAIL, "支付未成功");
            }

            //使用redisson获取分布式锁
            lock = redissonClient.getLock(DLockConstants.WECHAT_OUT_TRADE_NO + tradeNo);
            //尝试加锁，设置等待时间10秒，锁超时时间10秒
            boolean locked = lock.tryLock(10, 10, TimeUnit.SECONDS);

            if (locked) {
                OrderPay orderPay = orderPayService.findByPayNo(tradeNo);
                if (null == orderPay || orderPay.getStatus() != PayStatusCode.WAIT_PAY.getCode()) {
                    return wechatPayUtil.buildResponse(WechatPayConstants.FAIL, "订单不存在或已支付");
                }

                //重新调用微信接口查询订单状态
                if (wechatPayUtil.queryOrder(tradeNo)) {
                    orderPayService.paySuccess(orderPay, PayMethodCode.WECHAT_PAY.getCode(), resultMap.get("transaction_id").toString());
                    return wechatPayUtil.buildResponse(WechatPayConstants.SUCCESS, "支付成功");
                }

                log.error("微信支付回调通知二次校验不通过：{}", tradeNo);
                return wechatPayUtil.buildResponse(WechatPayConstants.FAIL, "二次校验订单不通过");
            }

            log.error("微信支付回调通知排队中：{}", tradeNo);
            return wechatPayUtil.buildResponse(WechatPayConstants.FAIL, "处理异常");
        } catch (Exception e) {
            log.error("[微信支付回调处理异常]", e);
            return wechatPayUtil.buildResponse(WechatPayConstants.FAIL, "处理异常");
        } finally {
            if (null != lock && lock.isLocked() && lock.isHeldByCurrentThread()) {
                lock.unlock();
            }
        }
    }

9、解析回调参数

    /**
     * 解析回调参数
     *
     * @param request
     * @return
     */
    private static Map<String, String> requestParam(HttpServletRequest request) {
        Map<String, String> params = Maps.newHashMap();
        Map<String, String[]> requestParams = request.getParameterMap();
        for (Map.Entry<String, String[]> entry : requestParams.entrySet()) {
            String valueStr = String.join(",", entry.getValue());
            params.put(entry.getKey(), valueStr);
        }
        return params;
    }

跟我说谢谢小猫
关注
  • 5
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
详解APP微信支付（java后台_统一下单和回调）
08-26
主要介绍了APP微信支付（java后台_统一下单和回调），文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
中付-机构交易流水通知内容
无心
12-18 450
每当有自己服务商名下pos机交易时就会自动推送到你的接口，这不是实时的，可能会有几分钟的延时。把你的接口部署到线上之后，跟中付的人说一下，他们就会把你的接口与你的服务商号进行关联。dataList是一个数组，一般为一个元素，但是有时候会有多个元素。Controller直接用@RequestBody接收就行。
java 财付通支付_从另外一个角度看微信支付
weixin_39631301的博客
11-11 149
前几天用微信支付预约了小米三，以为没有多少人会开通微信抢手机，于是并不在意，等今天再去抢的时候，发现已经卖光，让我对觉得不可思议。后来看新闻，有630W人用微信支付参与预约。先无论这个数字是否有水分，但是至少说明这次微信支付获得了非常大的关注度。在微信之前，就听说微信要推出支付，从当时的想法，直接和财付通关联即可，就和淘宝以及支付宝打通一样，这样选择财付通支付就可以ok了，这样可以扩展财付通的使用...
Java后端对接微信支付(微信小程序、APP、PC端扫码)非常全，包含查单、退款
最新发布
2401_84103386的博客
04-29 867
Java架构学习技术内容包含有：Spring，Dubbo，MyBatis, RPC, 源码分析，高并发、高性能、分布式,性能优化，微服务 高级架构开发等等。还有Java核心知识点+全套架构师学习资料和视频+一线大厂面试宝典+面试简历模板可以领取+阿里美团网易腾讯小米爱奇艺快手哔哩哔哩面试题+Spring源码合集+Java架构实战电子书+2021年最新大厂面试题。l;
由存钱想到的”致富之路“——浅谈Java生产者消费者模型
weixin_45949956的博客
12-03 118
@[TOC]由存钱想到的“致富之路”——关于数据统一 在网络支付和互联金融高度发达的今天，去银行Pos机或者柜台存钱似乎已经不那么多见了。约莫十年前，大街小巷是仍然可见到处的Pos机前来来往往的人流：神色凝重，表情严肃，着墨镜，戴帽子，手中紧握鼓鼓的包袱，似乎在拍港警片中抢银行的桥段。那时候的我也不例外。 然而，在许多次Pos机前杀青后我突然开始思索一个事情：如果有可能的话，我和我隔壁的小王同时在不同的Pos机上面操作同一张银行卡上面相同的500元钱，同时取出全部余额，如果我们的动作整齐划一，不分先后，完完
微信回调 java_详解APP微信支付（java后台_统一下单和回调）
weixin_30768881的博客
02-12 2420
1.微信配置信息 global.properties2.方法wxpay用于生成预支付订单信息方法notifyWeiXinPay用于微信支付成功后的回调, 注意: 在手机端使用微信支付成功后，微信服务器会根据提供的回调地址进行回调,parameterMap.put("notify_url", wxnotify); (见下面代码)在局域网是无法进行回调的，必须将你的服务端放在公网上进行测试， 回调函...
Java - 扫呗支付
Mryfl的博客
11-28 1159
● 获取openid: https://developers.weixin.qq.com/miniprogram/dev/framework/open-ability/login.html。（不知道大家有没有遇见过这个问题，解决办法其实有很多种，反正我是踩了一次这个坑，虽然已经解决了，印象很深刻，貌似好像只是针对于扫呗支付我才遇见过，其他的支付还没有踩坑，大家可以思考一下!● 调js支付： https://pay.weixin.qq.com/wiki/doc/api/wxa/wxa_api.php?
java微信支付v3系列——5.微信支付成功回调
qq_45740561的博客
12-21 1万+
还记得WxPayCallbackUtil回调接口工具类吗，当时是用于支付成功的回调，我们接下来向里面添加一个退款成功的回调方法，在添加前我们先来做一个准备操作。
微信支付v3版java_H5支付+支付结果通知+查询订单
03-12
微信支付V3版系列课程详细讲解微信支付的JSAPI支付、H5支付、Native支付、申请退款、支付结果通知、退款结果通知、申请交易账单、申请资金账单、下载账单、关闭订单。提供java版、c#版、python3版、php版课程。按照课程体系，课程分为大全家桶、小全家桶、套餐1、套餐2、套餐3，以便于学员选择。购课请提前联系九宝老师
java微信小程序支付-回调（Jsapi-APIv3）
tiantiannianni的博客
05-03 9416
java springboot 微信小程序支付-支付回调（Jsapi-APIv3）
java对接微信支付：JSAPI支付成功之“微信回调”
m0_57007247的博客
07-10 6531
微信支付回调处理
Java微信支付之关闭订单
08-27
Java微信支付之关闭订单 Java微信支付之关闭订单是指在微信支付中，商户订单支付失败需要生成新单号重新发起支付，要对原订单号调用关单，避免重复支付系统下单后，用户支付超时，系统退出不再受理，避免用户继续，...
2023-JAVA微信支付-工具类，包含微信退款，微信支付，微信相关V2版本V3接口集成
05-10
内容：微信支付-工具类，包含微信退款，微信支付，微信相关V2版本V3接口集成 适用人群：JAVA 使用场景：集成好微信支付，可自由调整相关类，自由编写业务场景 说明： 将工具类导入该自行项目，将maven-jar 的配置...
java微信支付工具类v3版：微信支付v3版+微信退款v3版+微信交易状态查询+企业打款
06-09
微信支付工具类v3版 包含： 1. 微信支付v3版 2. 微信退款v3版 3. 微信交易状态查询 4. 企业打款到个人零钱（旧版） 本人在企业项目中使用，自己封装的的微信交易相关的一套工具类。 直接调用方法传入对应的参数即可...
java微信支付（小程序），退款（V3版本）
11-19
开发java微信支付（小程序），退款（V3版本）
java 微信支付素材
06-16
全面的java微信支付素材包括了： 01-二维码生成js 02-微信sdk 03-微信支付工具类 04-微信支付二维码生成页面 05-jar包 01-生成二维码js插件使用.docx 02-微信支付申请和开发流程介绍.docx 03-微信sdk阅读和使用.docx...
java微信支付v3系列——8.微信支付之退款成功回调
qq_45740561的博客
12-21 3679
还记得WxPayCallbackUtil回调接口工具类吗，当时是用于支付成功的回调，我们接下来向里面添加一个退款成功的回调方法，在添加前我们先来做一个准备操作。more。
java解析pos,POS响应代码解析
weixin_36343495的博客
03-13 322
代码POS显示的内容原因／操作员应采取的措施00交易成功承兑或交易成功01交易失败 请联系发卡行 查发卡行02交易失败 请联系发卡行向发卡行查询03商户未登记联系银行卡服务中心处理04没收卡 请联系收单行 操作员没收卡05交易失败请联系发卡行 发卡不予承兑，与发银行联系查询06交易失...
微信支付-java实现微信支付-后端篇
热门推荐
王佳楠的专栏
08-11 2万+
四 Java 实现微信支付 — 后端篇 技术栈 Spring boot java XML (微信在http协议中数据传输方案) MD5 签名 微信支付术语 openid (OpenID是公众号一对一对应用户身份的标识) app_id (公众号id，登录微信公众号–开发–基本配置中获得；) key (收款商户后台进行配置，登录微信商户平台–账户中心–API安全-设置秘钥，设...
java微信支付回调接口
04-01
Java微信支付回调接口是用于处理微信支付回调通知的接口，通常由商户后台系统提供实现。微信支付回调接口需要接收微信服务器发送的HTTP POST请求，并根据请求中的参数进行验证、处理支付结果、更新订单状态等操作。 以下是Java微信支付回调接口的基本实现步骤： 1. 接收微信服务器发送的HTTP POST请求，获取请求中的参数。 2. 对请求参数进行签名验证，确保请求来自微信服务器，并防止数据篡改。 3. 根据请求中的订单号和支付结果更新商户订单状态。 4. 返回XML格式的响应消息给微信服务器，告知支付结果处理成功或失败。 Java微信支付回调接口的实现可以参考微信支付官方文档提供的示例代码，在此基础上根据具体业务需求进行定制化开发。同时，为了保证接口的稳定性和安全性，建议采用HTTPS协议进行数据传输，并加入必要的安全措施，如IP地址白名单、请求频率限制等。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值