微信native支付对接

已于 2023-10-27 16:02:17 修改
阅读量230 收藏 1
点赞数 1
文章标签： 微信 面试 职场和发展 微信native支付
于 2023-10-27 16:00:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_26869339/article/details/134075985
版权

简介

Native支付是指商户系统按微信支付协议生成支付二维码，用户再用微信“扫一扫”完成支付的模式。

应用场景

Native支付适用于PC网站、实体店单品或订单、媒体广告支付等场景，用户扫描商户展示在各种场景的二维码进行支付。聚体步骤如下：

1.商户根据微信支付的规则，为不同商品生成不同的二维码，展示在各种场景，用于用户扫描购买
2.用户使用微信“扫一扫”扫描二维码后，获取商品支付信息，引导用户完成支付。
3.用户确认支付，输入支付密码
4.支付完成后会提示用户支付成功，商户后台得到支付成功的通知，然后进行发货处理

接入前准备

直接跳转微信支付商户平台 https://pay.weixin.qq.com/wiki/doc/apiv3/open/pay/chapter2_7_1.shtml

生成密钥文件：
在这里插入图片描述

配置文件：

wx:
  appId: appId
  keyPath: apiclient_key.pem
  certPath: apiclient_cert.pem
  certP12Path: 暂不用
  platformCertPath: platform_cert.pem
  mchId: mchId
  apiKey3: 暂不用
  apiKey: apiKey
  domain: https://hous.exchang.cn
  serialNo: 序列号

pom文件：

<dependency>
     <groupId>com.github.wechatpay-apiv3</groupId>
     <artifactId>wechatpay-java</artifactId>
     <version>0.2.2</version>
 </dependency>

代码：

配置类：

//获取yml中微信配置
@Data
@ConfigurationProperties(prefix = "wx")
public class WechatProperties {

    private String appId;

    private String keyPath;

    private String certPath;

    private String platformCertPath;

    private String mchId;

    private String apiKey;

    private String domain;

    private String serialNo;
}
//配置类
@Configuration
@EnableConfigurationProperties(WechatProperties.class)
public class WechatNativeConfig {


    private final WechatProperties wechatProperties;

    public WechatNativeConfig(WechatProperties wechatProperties) {
        this.wechatProperties = wechatProperties;
    }

    @Bean
    public RSAConfig rsaConfig() throws IOException {
        ClassPathResource keyResource = new ClassPathResource(wechatProperties.getKeyPath());
        String apiClientKey = keyResource.getFile().getPath();
        ClassPathResource certResource = new ClassPathResource(wechatProperties.getPlatformCertPath());
        String platformCertResourceKey = certResource.getFile().getPath();
        /*String apiClientKey = wechatProperties.getKeyPath();
//        ClassPathResource certResource = new ClassPathResource(wechatProperties.getPlatformCertPath());
        String platformCertResourceKey = wechatProperties.getPlatformCertPath();*/
        return new RSAConfig.Builder()
                .merchantId(wechatProperties.getMchId())
                .privateKeyFromPath(apiClientKey)
                .merchantSerialNumber(wechatProperties.getSerialNo())
                //平台证书
                .wechatPayCertificatesFromPath(platformCertResourceKey)
                .build();
    }

    @Bean
    public NativePayService nativePayService() throws IOException {
        return new NativePayService.Builder()
                .config(this.rsaConfig())
                .build();
    }

    @Bean
    public NotificationParser notificationParser() throws IOException{
        ClassPathResource certResource = new ClassPathResource(wechatProperties.getPlatformCertPath());
        String platformCertResourceKey = certResource.getFile().getPath();
        //String platformCertResourceKey = wechatProperties.getPlatformCertPath();
        NotificationConfig config = new RSANotificationConfig.Builder()
                .apiV3Key(wechatProperties.getApiKey())
                .certificatesFromPath(platformCertResourceKey)
                .build();
        // 初始化 NotificationParser
        return new NotificationParser(config);

    }

    @Bean
    public RefundService refundService() throws IOException {
        return new RefundService.Builder().config(this.rsaConfig()).build();
    }

}

创建支付单：

	@Slf4j
@Service
@EnableConfigurationProperties(WechatProperties.class)
public class WechatNativePayServiceImpl implements BasePayService {

    @Resource
    private WechatProperties wechatProperties;

    @Resource
    private NativePayService nativePayService;

    @Resource
    private RedisCache redisCache;

    @Value("${spring.application.name:scm-ofc-system}")
    private String serviceName;


    @Override
    public AjaxResult<?> payOrder(List<OrderSub> orderSubs) {
    	//总金额，单位分
        Integer payTotal = total.multiply(BigDecimal.valueOf(100)).intValue();
        PrepayRequest prepayRequest = new PrepayRequest();
        prepayRequest.setAppid(wechatProperties.getAppId());
        prepayRequest.setMchid(wechatProperties.getMchId());
        prepayRequest.setDescription("供应链下单");
        //订单编号
        prepayRequest.setOutTradeNo(orderSub.getOrderMsn());
        prepayRequest.setNotifyUrl(wechatProperties.getDomain() + "/" + serviceName + "/callback/wechat/pay");
        prepayRequest.setAttach(BusType.CREATE_ORDER.getDesc());
        Amount amount = new Amount();
        amount.setTotal(payTotal);
        prepayRequest.setAmount(amount);
        log.info("创建预支付单入参：【{}】", JSONObject.toJSONString(prepayRequest));
        try {
            PrepayResponse prepay = nativePayService.prepay(prepayRequest);
            log.info("创建预支付单并生成二维码成功，出参：【{}】", JSONObject.toJSONString(prepay));
            Map<String, String> hashMap = new HashMap<>();
            hashMap.put("orderMsn", orderSub.getOrderMsn());
            hashMap.put("codeUrl", prepay.getCodeUrl());
            //二维码暂存redis
            String value = JSONObject.toJSONString(hashMap);
            redisCache.setCacheObject(RedisKeyConstant.ORDER_PAY_URL_CODE + orderSub.getOrderMsn(), value, 15, TimeUnit.MINUTES);
            return AjaxResult.ok(hashMap);
        } catch (HttpException e) { // 发送HTTP请求失败
            log.error("发送HTTP请求失败:{}", e.getHttpRequest());
            return AjaxResult.fail("发送HTTP请求失败");
        } catch (ServiceException e) { // 服务返回状态小于200或大于等于300，例如500
            log.error("微信支付返回状态异常，{}", e.getResponseBody());
            return AjaxResult.fail("微信支付返回状态异常");
        } catch (MalformedMessageException e) { // 服务返回成功，返回体类型不合法，或者解析返回体失败
            log.error("返回类型不合法:{}", e.getMessage());
            return AjaxResult.fail("返回类型不合法");
        }
    }

    @Override
    public void closeOrder(String outTradeNo) {
        CloseOrderRequest closeOrderRequest = new CloseOrderRequest();
        closeOrderRequest.setMchid(wechatProperties.getMchId());
        closeOrderRequest.setOutTradeNo(outTradeNo);
        nativePayService.closeOrder(closeOrderRequest);
        log.info("订单关闭成功，入参：【{}】", JSONObject.toJSONString(closeOrderRequest));
    }

    @Override
    public Optional<Transaction> getOrderInfo(String outTradeNo) {
        QueryOrderByOutTradeNoRequest request = new QueryOrderByOutTradeNoRequest();
        request.setOutTradeNo(outTradeNo);
        request.setMchid(wechatProperties.getMchId());
        Transaction transaction = nativePayService.queryOrderByOutTradeNo(request);
        if (Objects.isNull(transaction)) {
            return Optional.empty();
        }
        return Optional.of(transaction);
    }

}

创建退款单：

@Slf4j
@Service
@EnableConfigurationProperties(WechatProperties.class)
public class WechatNativeRefundServiceImpl implements BaseRefundService {

    @Resource
    private RefundService refundService;

    @Resource
    private WechatProperties wechatProperties;

    @Resource
    private BaseOrderFeignService baseOrderFeignService;

    @Resource
    private RefundOrderFeignService refundOrderFeignService;

    @Value("${spring.application.name:scm-ofc-system}")
    private String serviceName;

    @Override
    public AjaxResult<?> refundOrder(AsRefundApply asRefundApply) {
        try {
            BigDecimal refundAmount = asRefundApply.getRefundAmount();
            String orderSsn = asRefundApply.getOrderSsn();
            Optional<OrderSub> data = baseOrderFeignService.getOrderSubDetail(orderSsn).getData();
            if (!data.isPresent()) {
                return AjaxResult.fail(500, "当前单不存在");
            }
            //退款金额
            long refundTotal = refundAmount.multiply(BigDecimal.valueOf(100)).longValue();
            OrderSub orderSub = data.get();
            //原支付金额
            String orderMsn = orderSub.getOrderMsn();
            List<OrderSub> orderSubList = baseOrderFeignService.selectOrderSubs(orderMsn).getData();
            BigDecimal officialReceipts = orderSubList.stream().map(OrderSub::getOfficialReceipts).reduce(BigDecimal.ZERO, BigDecimal::add);
            long payTotal = officialReceipts.multiply(BigDecimal.valueOf(100)).longValue();
            //创建微信退款单
            CreateRequest createRequest = new CreateRequest();
            AmountReq amountReq = new AmountReq();
            amountReq.setCurrency("CNY");
            amountReq.setTotal(payTotal);
            amountReq.setRefund(refundTotal);
            createRequest.setOutTradeNo(orderSub.getOrderMsn());
            createRequest.setAmount(amountReq);
            createRequest.setOutRefundNo(asRefundApply.getAfterSaleSn());
            createRequest.setNotifyUrl(wechatProperties.getDomain() + "/" + serviceName +  "/callback/wechat/refund");
            log.info("退款单入参：{}", JSONObject.toJSONString(createRequest));
            Refund refund = refundService.create(createRequest);
            log.info("创建退款单成功：{}", JSONObject.toJSONString(refund));
            if (Objects.isNull(refund)) {
                log.error("退款异常，参数：{}", JSONObject.toJSONString(createRequest));
                return AjaxResult.fail(500, "退款异常，请求微信返回值为null：参数" + JSONObject.toJSONString(createRequest));
            }
            if (Objects.equals(refund.getStatus(), Status.SUCCESS)) {
                return AjaxResult.ok(refund);
            }
        } catch (Exception e) {
            log.error("退款异常：{}", e.getMessage());
            return AjaxResult.fail(500, "退款异常，请求微信报错" + e.getMessage());
        }
        return AjaxResult.ok();
    }

    @Override
    public AjaxResult<?> refundAllOrder(List<OrderSub> orderSubList) {
        try {
            OrderSub orderSub = orderSubList.get(NumberUtils.INTEGER_ZERO);
            BigDecimal officialReceipts = orderSubList.stream().map(OrderSub::getOfficialReceipts).reduce(BigDecimal.ZERO, BigDecimal::add);
            long payTotal = officialReceipts.multiply(BigDecimal.valueOf(100)).longValue();
            //创建微信退款单
            CreateRequest createRequest = new CreateRequest();
            AmountReq amountReq = new AmountReq();
            amountReq.setCurrency("CNY");
            amountReq.setTotal(payTotal);
            amountReq.setRefund(payTotal);
            createRequest.setOutTradeNo(orderSub.getOrderMsn());
            createRequest.setAmount(amountReq);
            createRequest.setOutRefundNo("ALL" + orderSub.getOrderMsn());
            createRequest.setNotifyUrl(wechatProperties.getDomain() + "/callback/wechat/refund");
            Refund refund = refundService.create(createRequest);
            log.info("创建退款单成功：{}", JSONObject.toJSONString(refund));
            if (Objects.isNull(refund)) {
                log.error("退款异常，参数：{}", JSONObject.toJSONString(createRequest));
                return AjaxResult.fail(500, "退款异常，请求微信返回值为null：参数" + JSONObject.toJSONString(createRequest));
            }
            if (Objects.equals(refund.getStatus(), Status.SUCCESS)) {
                return AjaxResult.ok(refund);
            }
        } catch (Exception e) {
            log.error("退款异常：{}", e.getMessage());
            return AjaxResult.fail(500, "退款异常，请求微信报错" + e.getMessage());
        }
        return AjaxResult.ok();
    }

    /**
     * 查询微信退款单详情
     *
     * @param afterSaleSn
     */
    @Override
    public Refund getRefundOrderDetail(String afterSaleSn) {
        QueryByOutRefundNoRequest request = new QueryByOutRefundNoRequest();
        request.setOutRefundNo(afterSaleSn);
        return refundService.queryByOutRefundNo(request);
    }

    @Override
    public AjaxResult<?> returnPayOrder(String orderSn) {
        Optional<OrderSub> optional = baseOrderFeignService.getOrderSubDetail(orderSn).getData();
        if (!optional.isPresent()) {
            throw new ServiceException("订单信息不存在");
        }
        OrderSub orderSub = optional.get();
        String orderSsn = orderSub.getOrderSsn();
        AjaxResult<AsRefundApply> ajaxResult = refundOrderFeignService.createReturnOrder(orderSsn);
        if (ajaxResult.isSuccess()) {
            AsRefundApply asRefundApply = ajaxResult.getData();
            AjaxResult<?> result = this.refundOrder(asRefundApply);
            if (result.isError()) {
                //refundOrderFeignService.deleteReturnOrder();
                throw new ServiceException(result.getMsg());
            }
        }
        return ajaxResult;
    }
}

支付与退款回调

public interface CallbackService {

    /**
     * 微信支付回调
     * @param request
     * @param response
     * @return
     */
    void  wechatPayCallback(HttpServletRequest request, HttpServletResponse response);


    /**
     * 微信退款回调
     * @param request
     * @param response
     */
    void wechatRefundCallback(HttpServletRequest request, HttpServletResponse response);
}

//实现类
@Slf4j
@Service
public class CallbackServiceImpl implements CallbackService {

    @Resource
    private NotificationParser notificationParser;

    @Override
    public void wechatPayCallback(HttpServletRequest request, HttpServletResponse response) {
        try {
            log.info("=========================微信native支付回调通知============================");
            Transaction transaction = this.verifyAndDecrypt(request, Transaction.class);
            log.info("验证签名成功：{}", JSONObject.toJSONString(transaction));
            Transaction.TradeStateEnum tradeState = transaction.getTradeState();
            if (!Objects.equals(tradeState, Transaction.TradeStateEnum.SUCCESS)) {
                return;
            }
            //支付业务
        } catch (Exception e) {
            log.error("支付回调异常：{}", e.getMessage());
        }
    }

    @Override
    public void wechatRefundCallback(HttpServletRequest request, HttpServletResponse response) {
        log.info("=========================微信native退款回调通知============================");
        RefundNotification refundNotification = this.verifyAndDecrypt(request, RefundNotification.class);
        Status refundStatus = refundNotification.getRefundStatus();
        if (!Objects.equals(refundStatus, Status.SUCCESS)) {
            return;
        }
    }
    /**
     * 验证并解密报文
     *
     * @param request
     */
    private <T> T verifyAndDecrypt(HttpServletRequest request, Class<T> clazz) {
        String timestamp = request.getHeader("Wechatpay-Timestamp");
        String nonce = request.getHeader("Wechatpay-Nonce");
        String serialNo = request.getHeader("Wechatpay-Serial");
        String signature = request.getHeader("Wechatpay-Signature");
        String signType = request.getHeader("Wechatpay-Signature-Type");
        String body = this.getBody(request);
        log.info("\n请求头信息:\n" +
                        "Wechatpay-Timestamp：{},\n" +
                        "Wechatpay-Nonce：{},\n" +
                        "Wechatpay-Serial：{},\n" +
                        "Wechatpay-Signature：{},\n" +
                        "Wechatpay-Signature-Type：{},\n" +
                        "body: {}",
                timestamp, nonce, serialNo, signature, signType, body);
        RequestParam requestParam = new RequestParam.Builder()
                .serialNumber(serialNo)
                .nonce(nonce)
                .signature(signature)
                .timestamp(timestamp)
                .signType(signType)
                .body(body)
                .build();
        return notificationParser.parse(requestParam, clazz);
    }

    /**
     * 获取请求体内容
     *
     * @param request
     * @return
     */
    private String getBody(HttpServletRequest request) {
        BufferedReader reader;
        String body = "";
        try {
            reader = request.getReader();
            String line;
            StringBuilder inputString = new StringBuilder();
            while ((line = reader.readLine()) != null) {
                inputString.append(line);
            }
            body = inputString.toString();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return body;
    }
 }

以上就是微信native支付的对接，仅供参考

大小鱼鱼鱼与鱼.
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
微信NATIVE扫码支付JAVA实现（亲测版）
08-25
微信NATIVE扫码支付JAVA实现
PC网站接入微信（Native）支付-扫码
最新发布
withme977的博客
05-10 785
创建完订单后向微信发起创建预支付订单请求，然后会返回code_url，是二维码的url，前端用qrcode库转成待支付的二维码，然后用户进行扫码支付（二维码默认俩小时内有效）以上就是接入微信Native支付的流程 申请好对应的相关信息后直接引入微信的sdk 有没有很方便！ApiV3秘钥(商户内自行设置的，并设置操作密码保存)可选择适合其接入方式，我们目前选择的是Native支付接入。5. 微信回调商户平台接口 -> 微信二维码扫码支付成功后。4. 微信接入创建支付订单。3. 微信支付业务流程。
微信支付-通知验签始终不通过的问题
jingchao1998的博客
12-13 3300
记一次微信支付验签始终异常问题，折腾了两宿，最后是 body 有问题 o(╥﹏╥)o
微信支付总结（JSAPI）(V3)(JAVA)
ZX5191的专栏
06-07 8498
前一阵子做了一个微信支付相关的功能，期间走了不少的弯路。在这里给大家趟趟雷，希望大家能因此受益。在这里，我从头到尾一步步给大家捋顺。
java对接微信支付：JSAPI支付成功之“微信回调”
m0_57007247的博客
07-10 6795
微信支付回调处理
微信支付-开发教程
Good Luck
03-24 4969
⑦merchantSerialNumber：商户证书序列化-登录商户后台获取。③appV3Secret：商户apiV3密钥-登录商户后台获取。①appid：小程序appid-登录小程序后台获取。②secret：小程序密钥-登录小程序后台获取。⑥privateKeyPath：商户私钥。④mchid：商户号-登录商户后台获取。⑤certpath：微信平台。
对接微信支付有时候打不开girhub我把里面的文档放着这里了
weixin_59869203的博客
12-06 758
没
商户对接 微信支付
02-21
商户对接微信支付的过程涉及到一系列的技术实现和业务流程，包括API调用、签名验证、订单处理、支付状态查询以及退款操作等。下面将详细阐述这个过程中的关键知识点。 一、API接口集成 商户对接微信支付的第一步是...
C#.NET整合微信,支付宝,银联支付
06-10
首先，微信支付API提供了多种接口，如JSAPI、Native、H5、APP等，适用于不同的应用场景。在C#.NET中，我们需要导入微信支付的SDK，如WxPaySDK，通过调用其提供的方法生成预支付订单，获取预支付交易串，然后在前端或...
微信刷卡支付WxPay(WINFORM简易版)_C# VS2005
12-10
8. **错误处理**：在对接微信支付API时，可能会遇到各种错误，如网络问题、参数错误、支付失败等。开发者需要编写合适的错误处理代码，以优雅地处理这些问题，提供良好的用户体验。 9. **支付状态回调**：微信支付...
ThinkPHP框架整合微信支付之Native 扫码支付模式二图文详解
01-02
本文实例讲述了ThinkPHP框架整合微信支付之Native 扫码支付模式二。分享给大家供大家参考，具体如下： 大家好，这篇文章是继微信支付之Native 扫码支付 模式一之后的微信支付系列教程第三篇：扫码支付之模式二 介绍...
Java实现微信支付v3的支付回调
一边努力一边摸鱼
03-27 2952
微信v3支付回调
微信支付回调信息接收设计
MinisterOL的博客
03-12 393
如图所示，在接收到微信支付平台推送信息后对数据进行解析处理，根据类型不同解析到不同的处理器中，灵活运用springboot对组件的代理控制。实际上根据业务需求，代码中间抛出的异常可以设计一个微信支付异常类，在异常捕获的时候进行接口特殊处理。退款成功处理接口 RefundSuccessProcessor.java。
Java接入微信支付APIV3（Native）
培根芝士的专栏
03-07 3522
Native支付是指商户系统按微信支付协议生成支付二维码，用户再用微信“扫一扫”完成支付的模式。
1.1 微信Native支付 - 接入指引与支付安全
weixin_51351637的博客
11-07 1077
微信支付 - 中国领先的第三方支付平台 ｜ 微信支付提供安全快捷的支付方式 (qq.com)我们可以看一下“产品中心”中的”支付产品“一个任意长度的字符串Z数据经过哈希运算之后会得到固定长度的字符串数据H，那我们就说H就是自己的哈希结果，又称作数据指纹或摘要MD5就是一个非常典型的摘要算法摘要算法特点1.不可逆:只有算法，没有秘钥，只能加密，不能解密AES算法属于对称加密的一种，需要一个秘钥去加密和解密RSA算法是非对称加密的典型算法，需要公钥和私钥。
微信支付的回调函数实现验签以及解密
qq_39746820的博客
10-04 4645
微信支付V3版本的支付回调，不管是验签还是解密都可以通过sdk提供的方法来实现。
对接微信二维码支付（native方式）
热门推荐
atongmu2017的博客
07-11 2万+
1.微信支付的官网对接手册： 地址：https://pay.weixin.qq.com/wiki/doc/api/index.html 微信对接分多中方式，而native是调用微信支付服务在网页生成二维码，客户扫描二维码支付。 2.准备工作 （1）申请服务号，需要审核认证，300块钱。 （2）服务号申请通过后，在微信公众平台开通微信支付 开通参考地址：https://jingyan...
Java接入微信native、jsapi支付
靖...的博客
04-12 6083
Java接入微信native、jsapi支付 一、说明 本文示例使用的微信支付版本为V2版本，是旧版本，旧版本与新版本的接口不一，并不通用。 微信官方接口文档地址：https://pay.weixin.qq.com/wiki/doc/api/index.html 二、微信支付所需要的参数 appid、mchid、apikey 这些参数，需要公司去微信官方平台进行申请才行，通常来说，作为程序员不用操心。我没有申请过，具体的流程我就不做说明了。 申请地址：https://pay.weixin.qq.com/in
后端---史上最全最小白最简单最细致的Java接入微信支付接口（Native接入）
Nagile-zhou博客
12-21 1万+
距离上一篇博客 史上最全最小白最简单最细致的Java接入支付宝支付接口方法   https://blog.csdn.net/weixin_42504145/article/details/85077635 已经过去快三天了，终于在今天将微信整个电脑网页支付整合在SSM框架上. 大家可以在Github https://github.com/nigel-zhou/reimagined-waddl...
微信 native 支付 php
01-18
微信 Native 支付是指在微信公众号或小程序中，使用用户的微信进行支付的一种方式。PHP是一种常用的服务器端编程语言，可以用来处理网页和服务器之间的交互。 要实现微信 Native 支付，首先需要获取微信支付API的接...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值