微信支付（公众号支付APIJS、app支付）服务端统一下单接口java版

最新推荐文章于 2022-07-16 23:00:23 发布
最新推荐文章于 2022-07-16 23:00:23 发布
阅读量284 收藏
点赞数
文章标签： java json 后端

 一、微信公众号支付APIJS：

要完整的实现微信支付功能，需要前后端一起实现，还需要微信商户平台的配置。这里只是涉及服务端的代码。

jar包：pom.xml

<!-- ↓↓↓↓↓↓↓↓ 支付相关 ↓↓↓↓↓↓↓↓ -->
        <!-- http -->
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
            <version>4.5.2</version>
        </dependency>
        <dependency>
            <groupId>commons-httpclient</groupId>
            <artifactId>commons-httpclient</artifactId>
            <version>3.1</version>
        </dependency>
        <!-- xml处理 -->
        <dependency>
            <groupId>org.jdom</groupId>
            <artifactId>jdom</artifactId>
            <version>1.1.3</version>
        </dependency>
        <!-- fast-json包-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.1.39</version>
        </dependency>
        <!-- ↑↑↑↑↑↑↑↑ 支付相关 ↑↑↑↑↑↑↑↑ -->

目录结构：

 

MD5Util.java

package webapp.payutil;

import java.security.MessageDigest;

public class MD5Util {
    private static String byteArrayToHexString(byte b[]) {
        StringBuilder resultSb = new StringBuilder();
        for (byte aB : b) resultSb.append(byteToHexString(aB));
        return resultSb.toString();
    }

    private static String byteToHexString(byte b) {
        int n = b;
        if (n < 0)
            n += 256;
        int d1 = n / 16;
        int d2 = n % 16;
        return hexDigits[d1] + hexDigits[d2];
    }

    public static String MD5Encode(String origin, String charsetname) {
        String resultString = null;
        try {
            resultString = origin;
            MessageDigest md = MessageDigest.getInstance("MD5");
            if (charsetname == null || "".equals(charsetname))
                resultString = byteArrayToHexString(md.digest(resultString
                        .getBytes()));
            else
                resultString = byteArrayToHexString(md.digest(resultString
                        .getBytes(charsetname)));
        } catch (Exception ignored) {
        }
        return resultString;
    }

    private static final String hexDigits[] = { "0", "1", "2", "3", "4", "5",
            "6", "7", "8", "9", "a", "b", "c", "d", "e", "f" };
}

 

PayCommonUtil.java

package webapp.payutil;

import org.apache.http.Consts;
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 org.jdom.Document;
import org.jdom.Element;
import org.jdom.JDOMException;
import org.jdom.input.SAXBuilder;

import javax.net.ssl.SSLContext;
import javax.servlet.http.HttpServletRequest;
import java.io.*;
import java.math.BigDecimal;
import java.net.ConnectException;
import java.net.HttpURLConnection;
import java.net.URL;
import java.security.KeyStore;
import java.util.*;

public class PayCommonUtil {
    //微信参数配置
    public static String API_KEY = "kshdf554sdf4s5f2sf121sdfsd1f5sdf";
    public static String APPID = "wxd5609f7b5b4dd051";
    public static String MCH_ID = "1230989902";

    /**
     * 微信公众号支付
     * @param trade_no      订单号
     * @param totalAmount   支付金额
     * @param description   文字内容说明
     * @param attach        自定义参数 length=127
     * @param openId        微信公众号openId
     * @param wxnotify      回调地址
     * @param request       -
     * @return              -
     */
    public static SortedMap<String, Object> WxPublicPay(String trade_no, BigDecimal totalAmount, String description, String attach, String openId, String wxnotify, HttpServletRequest request) {
        Map<String, String> map = weixinPrePay(trade_no,totalAmount,description,attach,openId,wxnotify,request);
        SortedMap<String, Object> finalpackage = new TreeMap<>();
        finalpackage.put("appId", PayCommonUtil.APPID);
        finalpackage.put("timeStamp", System.currentTimeMillis() / 1000);
        finalpackage.put("nonceStr", getRandomString(32));
        finalpackage.put("package", "prepay_id=" + map.get("prepay_id"));
        finalpackage.put("signType", "MD5");
        String sign = PayCommonUtil.createSign(finalpackage);
        finalpackage.put("paySign", sign);
        return finalpackage;
    }

    /**
     *                      -
     * @param trade_no      订单号
     * @param totalAmount   支付金额
     * @param description   文字内容说明
     * @param attach        自定义参数 length=127
     * @param openid        微信公众号openId
     * @param wxnotify      回调地址
     * @param request       -
     * @return              -
     */
    private static Map<String, String> weixinPrePay(String trade_no, BigDecimal totalAmount, String description, String attach, String openid, String wxnotify, HttpServletRequest request) {
        SortedMap<String, Object> parameterMap = new TreeMap<>();
        parameterMap.put("appid", PayCommonUtil.APPID);
        parameterMap.put("mch_id", PayCommonUtil.MCH_ID);
        parameterMap.put("nonce_str", getRandomString(32));
        parameterMap.put("body", description);
        parameterMap.put("attach", attach);
        parameterMap.put("out_trade_no", trade_no);
        parameterMap.put("fee_type", "CNY");
        BigDecimal total = totalAmount.multiply(new BigDecimal(100));
        java.text.DecimalFormat df = new java.text.DecimalFormat("0");
        parameterMap.put("total_fee", df.format(total));
        parameterMap.put("spbill_create_ip", request.getRemoteAddr());
        parameterMap.put("notify_url", wxnotify);
        parameterMap.put("trade_type", "JSAPI");
        //trade_type为JSAPI是 openid为必填项
        parameterMap.put("openid", openid);
        String sign = PayCommonUtil.createSign(parameterMap);
        parameterMap.put("sign", sign);
        String requestXML = PayCommonUtil.getRequestXml(parameterMap);
        String result = PayCommonUtil.httpsRequest("https://api.mch.weixin.qq.com/pay/unifiedorder", "POST", requestXML);
        System.out.println(result);
        Map<String, String> map = null;
        try {
            map = PayCommonUtil.doXMLParse(result);
        } catch (JDOMException | IOException e) {
            e.printStackTrace();
        }
        return map;
    }

    //随机字符串生成
    private static String getRandomString(int length) { //length表示生成字符串的长度
        String base = "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
        Random random = new Random();
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < length; i++) {
            int number = random.nextInt(base.length());
            sb.append(base.charAt(number));
        }
        return sb.toString();
    }

    //请求xml组装
    private static String getRequestXml(SortedMap<String, Object> parameters){
        StringBuilder sb = new StringBuilder();
        sb.append("<xml>");
        Set es = parameters.entrySet();
        for (Object e : es) {
            Map.Entry entry = (Map.Entry) e;
            String key = (String) entry.getKey();
            String value = (String) entry.getValue();
            if ("attach".equalsIgnoreCase(key) || "body".equalsIgnoreCase(key) || "sign".equalsIgnoreCase(key)) {
                sb.append("<").append(key).append(">").append("<![CDATA[").append(value).append("]]></").append(key).append(">");
            } else {
                sb.append("<").append(key).append(">").append(value).append("</").append(key).append(">");
            }
        }
        sb.append("</xml>");
        return sb.toString();
    }

    //生成签名
    private static String createSign(SortedMap<String, Object> parameters){
        StringBuilder sb = new StringBuilder();
        Set es = parameters.entrySet();
        for (Object e : es) {
            Map.Entry entry = (Map.Entry) e;
            String k = (String) entry.getKey();
            Object v = entry.getValue();
            if (null != v && !"".equals(v)
                    && !"sign".equals(k) && !"key".equals(k)) {
                sb.append(k).append("=").append(v).append("&");
            }
        }
        sb.append("key=").append(API_KEY);
        System.out.println(sb.toString());
        return MD5Util.MD5Encode(sb.toString(), "UTF-8").toUpperCase();
    }

    /**
     * 验证回调签名
     * @param map
     * @return
     */
    public static boolean isTenpaySign(Map<String, String> map) {
        String charset = "utf-8";
        String signFromAPIResponse = map.get("sign");
        if (signFromAPIResponse == null || signFromAPIResponse.equals("")) {
            System.out.println("API返回的数据签名数据不存在，有可能被第三方篡改!!!");
            return false;
        }
        System.out.println("服务器回包里面的签名是:" + signFromAPIResponse);
        //过滤空 设置 TreeMap
        SortedMap<String,String> packageParams = new TreeMap<>();
        for (String parameter : map.keySet()) {
            String parameterValue = map.get(parameter);
            String v = "";
            if (null != parameterValue) {
                v = parameterValue.trim();
            }
            packageParams.put(parameter, v);
        }
        StringBuilder sb = new StringBuilder();
        Set es = packageParams.entrySet();
        for (Object e : es) {
            Map.Entry entry = (Map.Entry) e;
            String k = (String) entry.getKey();
            String v = (String) entry.getValue();
            if (!"sign".equals(k) && null != v && !"".equals(v)) {
                sb.append(k).append("=").append(v).append("&");
            }
        }
        sb.append("key=").append(API_KEY);
        //将API返回的数据根据用签名算法进行计算新的签名，用来跟API返回的签名进行比较
        //算出签名
        String tobesign = sb.toString();
        String resultSign = MD5Util.MD5Encode(tobesign, "utf-8").toUpperCase();
        String tenpaySign = packageParams.get("sign").toUpperCase();
        return tenpaySign.equals(resultSign);
    }

    //请求方法
    private static String httpsRequest(String requestUrl, String requestMethod, String outputStr) {
        try {
            URL url = new URL(requestUrl);
            HttpURLConnection conn = (HttpURLConnection) url.openConnection();

            conn.setDoOutput(true);
            conn.setDoInput(true);
            conn.setUseCaches(false);
            // 设置请求方式（GET/POST）
            conn.setRequestMethod(requestMethod);
            conn.setRequestProperty("content-type", "application/x-www-form-urlencoded");
            // 当outputStr不为null时向输出流写数据
            if (null != outputStr) {
                OutputStream outputStream = conn.getOutputStream();
                // 注意编码格式
                outputStream.write(outputStr.getBytes("UTF-8"));
                outputStream.close();
            }
            // 从输入流读取返回内容
            InputStream inputStream = conn.getInputStream();
            InputStreamReader inputStreamReader = new InputStreamReader(inputStream, "utf-8");
            BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
            String str = null;
            StringBuilder buffer = new StringBuilder();
            while ((str = bufferedReader.readLine()) != null) {
                buffer.append(str);
            }
            // 释放资源
            bufferedReader.close();
            inputStreamReader.close();
            inputStream.close();
            conn.disconnect();
            return buffer.toString();
        } catch (ConnectException ce) {
            System.out.println("连接超时：{}"+ ce);
        } catch (Exception e) {
            System.out.println("https请求异常：{}"+ e);
        }
        return null;
    }

    //退款的请求方法
    public static String httpsRequest2(String requestUrl, String requestMethod, String outputStr) throws Exception {
        KeyStore keyStore  = KeyStore.getInstance("PKCS12");
        StringBuilder res = new StringBuilder("");
        try (FileInputStream instream = new FileInputStream(new File("/home/apiclient_cert.p12"))) {
            keyStore.load(instream, "".toCharArray());
        }

        // Trust own CA and all self-signed certs
        SSLContext sslcontext = SSLContexts.custom()
                .loadKeyMaterial(keyStore, "1313329201".toCharArray())
                .build();
        // Allow TLSv1 protocol only
        SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(
                sslcontext,
                new String[] { "TLSv1" },
                null,
                SSLConnectionSocketFactory.BROWSER_COMPATIBLE_HOSTNAME_VERIFIER);
        try (CloseableHttpClient httpclient = HttpClients.custom()
                .setSSLSocketFactory(sslsf)
                .build()) {
            HttpPost httpost = new HttpPost("https://api.mch.weixin.qq.com/secapi/pay/refund");
            httpost.addHeader("Connection", "keep-alive");
            httpost.addHeader("Accept", "*/*");
            httpost.addHeader("Content-Type", "application/x-www-form-urlencoded; charset=UTF-8");
            httpost.addHeader("Host", "api.mch.weixin.qq.com");
            httpost.addHeader("X-Requested-With", "XMLHttpRequest");
            httpost.addHeader("Cache-Control", "max-age=0");
            httpost.addHeader("User-Agent", "Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 6.0) ");
            StringEntity entity2 = new StringEntity(outputStr, Consts.UTF_8);
            httpost.setEntity(entity2);
            System.out.println("executing request" + httpost.getRequestLine());
            try (CloseableHttpResponse response = httpclient.execute(httpost)) {
                HttpEntity entity = response.getEntity();
                System.out.println("----------------------------------------");
                System.out.println(response.getStatusLine());
                if (entity != null) {
                    System.out.println("Response content length: " + entity.getContentLength());
                    BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(entity.getContent()));
                    String text = "";
                    res.append(text);
                    while ((text = bufferedReader.readLine()) != null) {
                        res.append(text);
                        System.out.println(text);
                    }
                }
                EntityUtils.consume(entity);
            }
        }
        return  res.toString();

    }

    //xml解析
    public static Map doXMLParse(String strxml) throws JDOMException, IOException {
        strxml = strxml.replaceFirst("encoding=\".*\"", "encoding=\"UTF-8\"");
        if(null == strxml || "".equals(strxml)) {
            return null;
        }

        Map m = new HashMap();
        InputStream in = new ByteArrayInputStream(strxml.getBytes("UTF-8"));
        SAXBuilder builder = new SAXBuilder();
        Document doc = builder.build(in);
        Element root = doc.getRootElement();
        List list = root.getChildren();
        for (Object aList : list) {
            Element e = (Element) aList;
            String k = e.getName();
            String v = "";
            List children = e.getChildren();
            if (children.isEmpty()) {
                v = e.getTextNormalize();
            } else {
                v = getChildrenText(children);
            }
            m.put(k, v);
        }
        //关闭流
        in.close();
        return m;
    }

    private static String getChildrenText(List children) {
        StringBuilder sb = new StringBuilder();
        if(!children.isEmpty()) {
            for (Object aChildren : children) {
                Element e = (Element) aChildren;
                String name = e.getName();
                String value = e.getTextNormalize();
                List list = e.getChildren();
                sb.append("<").append(name).append(">");
                if (!list.isEmpty()) {
                    sb.append(getChildrenText(list));
                }
                sb.append(value);
                sb.append("</").append(name).append(">");
            }
        }

        return sb.toString();
    }
}

 

WeiXinPayController.java

 

package webapp.controller;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import org.jdom.JDOMException;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import webapp.payutil.PayCommonUtil;

import javax.servlet.http.HttpServletRequest;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.math.BigDecimal;
import java.util.Map;
import java.util.SortedMap;
import java.util.UUID;

@Controller
@RequestMapping(value = "/api")
public class WeiXinPayController {
    private static String wxnotify = "/api/json/money/wxpay/succ";

    /**
     * @param totalAmount    支付金额
     * @param description    描述
     * @param openId         微信公众号openId   （可以前端传code,然后后台再通过微信对应接口换取openId）
     * @param request -
     * @return -
     */
    @RequestMapping(value = "/weixin/weixinPay/{totalAmount}/{description}/{openId}",
            method = RequestMethod.GET,
            produces = MediaType.APPLICATION_JSON_VALUE)
    @ResponseBody
    public SortedMap<String, Object> ToPay(@PathVariable BigDecimal totalAmount, @PathVariable String description, @PathVariable String openId, HttpServletRequest request) {
        String sym = request.getRequestURL().toString().split("/api/")[0];
        // 订单号
        String tradeNo = UUID.randomUUID().toString().replaceAll("-", "").toLowerCase().substring(0,32);
        // 回调地址
        String notifyUrl = sym + wxnotify;
        // 自定义参数
        Long userId = 100L; //对应用户id自己修改
        JSONObject jsAtt = new JSONObject();
        jsAtt.put("uid", userId);
        String attach = jsAtt.toJSONString();
        // 返回预支付参数
        return PayCommonUtil.WxPublicPay(tradeNo, totalAmount, description, attach, openId, notifyUrl, request);
    }

    /**
     * 支付回调地址
     * @param request
     * @return
     * @throws IOException
     */
    @RequestMapping(value = "/json/money/wxpay/succ",
            produces = MediaType.APPLICATION_JSON_VALUE)
    public String wxpaySucc(HttpServletRequest request) throws IOException {
        System.out.println("微信支付回调");
        InputStream inStream = request.getInputStream();
        ByteArrayOutputStream outSteam = new ByteArrayOutputStream();
        byte[] buffer = new byte[1024];
        int len = 0;
        while ((len = inStream.read(buffer)) != -1) {
            outSteam.write(buffer, 0, len);
        }
        String resultxml = new String(outSteam.toByteArray(), "utf-8");
        Map<String, String> params = null;
        try {
            params = PayCommonUtil.doXMLParse(resultxml);
        } catch (JDOMException e) {
            e.printStackTrace();
        }
        outSteam.close();
        inStream.close();
        if (!PayCommonUtil.isTenpaySign(params)) {
            // 支付失败
            return "fail";
        } else {
            System.out.println("===============付款成功==============");
            // ------------------------------
            // 处理业务开始
            // ------------------------------
            // 此处处理订单状态，结合自己的订单数据完成订单状态的更新
            // ------------------------------

            String total_fee = params.get("total_fee");
            double v = Double.valueOf(total_fee) / 100;
            // 取出用户id
            String attach = params.get("attach");
            JSONObject jsonObject = JSON.parseObject(attach);
            Long userId = Long.parseLong(jsonObject.get("uid").toString());

            //更新
            //updateUserPay(userId, String.valueOf(v));

            // 处理业务完毕
            // ------------------------------
            return "success";
        }
    }

}

 

二、app支付：

 和公众号支付一样，但是支付接口不需要openId，

PayCommonUtil.java:

第83行改为parameterMap.put("trade_type", "APP");

去掉第85行。

参考：http://blog.csdn.net/gbguanbo/article/details/50915333

 

注意项目中如果有权限配置，微信支付相关接口权限要放行。

 

一些资料：

JAVA微信扫码支付模式二功能实现以及回调： http://blog.csdn.net/bestlove12345/article/details/51858203

微信APP支付Java后端回调处理:  http://www.cnblogs.com/xu-xiang/p/5804757.html

回调：  http://blog.csdn.net/maple980326/article/details/51828554

 地

Joe?
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
H5页面跳转小程序分享-山东标梵互动
标梵互动
01-12 1173
最近，非个人主体的认证的小程序，可以直接在html页面中打开，这个权限还挺有用的，不仅适用于微信内部的浏览器，而且还可以在外部浏览器或者app中打开，比如UC浏览器、华为浏览器等。这里注意一下，官方特别说明：是使用云开发托管的网页。 开通条件： 准备好非个人主体的认证的小程序 开通云开发 使用云开托管静态网站 方法也很简单，在正常的公众号网页开发中，引入公众号JSSDK， <script src="https://res.wx.qq.com/open/js/jweixin-1.6.0.js">
APP 对接 java 微信支付统一下单接口
太#阳%鸟的博客
01-13 744
统一下单时候的请求对象，需要把这个转为xml 文件格式所以需要在pom.xml 文件中导入 <dependency> <groupId>com.thoughtworks.xstream</groupId> <artifactId>xstream</artifactId> <version>1.4.10&...
微信app支付统一下单接口
Xiazhiyu_whu的博客
01-31 1047
在groovy中使用https调用微信app支付统一下单接口，和java基本相同，解析xml需要导入dom4j，jaxen的jar包。import groovy.sql.Sql import org.dom4j.Document import org.dom4j.DocumentException import org.dom4j.DocumentHelper import org.dom4j.E...
手把手教你--JAVA微信支付（公众号支付JSAPI）
热门推荐
小流至江河的博客
03-07 8万+
自己的第一篇博客,请各位看官海涵! JAVA开发微信支付-公众号支付/微信浏览器支付（JSAPI） 写这篇文章的目的有2个,一是自己的项目刚开发完微信支付功能,趁热回个炉温习一下,二也是帮助像我这样对微信支付不熟悉,反复看了多天文档还是一知半解,原理都没摸清,更不要说实现了。本以为网上的微信开发教程会和“java的重写与重载”一样铺天盖地,可搜出来的结果,要么是PHP的教程（微信支付官...
微信公众号之微信支付(V3版)jsp页面jsapi统一下单调启支付(java版)
小静的专栏
03-04 6109
web项目 按顺序一步一步来 准备: 申请了微信支付接口的微信公众号一枚 , 备案的域名网站一枚, (如果有没有的这两个东西会耽误你很久,因为微信支付必须是线上,无法本地调试,)  这里说一下 如果有经济条件的最好申请一台win系统的服务器作为测试服务器这样会使你省去很多的麻烦,装上开发软件直接在线调试很爽. 首先截了几张需要设置的图,了解一下,开发中自己需要的参数常量
微信支付之统一下单--JAVA版
weixin_34248705的博客
06-29 181
都说微信支付有些坑，都抱怨微信支付的文档太烂，一会APPId，一会商户id，还有appsecret，支付API秘钥让你傻傻分不清楚，还有这里大写那里小写，几种标准，让你眼花缭乱。没错，这就是很多技术团队都存在的问题，没有统一的标准！且团队越大越严重，即使是在微信这样的顶尖团队。然而这些在一番痛苦折腾之后，最后都会不值一提。这里只详细讲JSAPI方式的公众号支付 简要思路图 配置支付授权目录 ...
详解APP微信支付（java后台_统一下单和回调）
08-26
主要介绍了APP微信支付（java后台_统一下单和回调），文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
微信公众号支付（二）实现统一下单接口
09-03
本篇文章主要给大家介绍调用微信公众支付的统一下单API，通过参数封装为xml格式并发送到微信给的接口地址就可以获得返回内容，需要的朋友可以参考下本
ASP微信公众号支付接口源码-最新V3版
05-20
ASP微信公众号支付V3版源码 1.纯ASP代码，无需安装任何其他组件。 2.专业级仿微信UI，美观清爽。 3.可选无数据库版、Access版、MySQL版。 4.最新微信支付V3版。
java实现微信支付统一下单接口的调用.zip
05-13
里面有两个微信支付接口实现的代码。分别是jsapi和native。代码里几乎每步都有详细的注释（我的注释写的很详细），如果还看不懂的话，我也没办法了。代码可直接拷贝使用到项目中。至于其它接口都可参照这两个接口来...
微信支付、公众号支付、JSAPI，vue 调取微信支付功能
01-20
JSAPI微信支付 （需要在公众号后台配置一下,paydatac变量需要后台返回 微信签名之类的） if (typeof WeixinJSBridge == undefined) { if (document.addEventListener) { document.addEventListener('...
微信公众号支付服务端SprfingMVC版
01-12
这个是SpringMVC版本的Java后台支付，修改后可以直接使用，APP支付的话跟这个流程大体差不多，修改一些参数位置，和加密方式就可以。
微信小程序最新版支付接口wx.requestOrderPayment()对接流程
t_332741160的专栏
07-16 5774
lln.tips({titledata.successTip||'支付成功',durationduration},function(){callback&&callback(true);log.info("微信验证signature={}&echostr={}×tamp={}&nonce={}",signature,echostr,timestamp,nonce);结果花了一天时间才把前后端全部调整完。log.warn("公众平台支付回调，交易不存在{}",tradeNo);.........
微信支付统一下单及调起支付接口的php接口实现 (可以用于app集成)
A9925的专栏
04-12 4681
http://jileniao.net/wechatpay-php.html 新版微信支付(APP支付)没有了服务端demo，并且老版本的php服务端demo也不能使用了，需要商户自己开发来实现。 仔细看了下微信支付提供的接口说明，开发起来也不是那么复杂，完全可以把这些放到一个php中，后续方便其他项目的调用。 参考了csdn的一篇文章及下载资料，先把php代码贴出来。 <?php
Java微信开发之公众号支付接口
weixin_34146410的博客
11-18 194
1、设置支付路径 使用微信公众号支付接口，必须在微信公众号管理后台中设置支付路径。这个微信接口文档说得很清楚，请参考：https://pay.weixin.qq.com/wiki/doc/api/jsapi.php?chapter=7_3 2、公众号支付业务流程 简单的描述就是： 首先需要根据我们自己的订单（4），也就是...
微信支付 第二篇 JSAPI 调用统一下单接口获取预支付交易数据
dianyoulian8756的博客
10-08 1179
上一篇讲到成功获取 openid，本篇要调用微信统一接口创建预支付交易单 除付款码支付场景以外，商户系统先调用该接口在微信支付服务后台生成预支付交易单，返回正确的预支付交易会话标识后再按Native、JSAPI、APP等不同场景生成交易串调起支付。 第三步，调用微信统一下单接口创建预支付交易单 微信统一下单API是微信支付的一个“统一”处理入口，官方给出的地址是 https://ap...
微信支付(java版本)_统一下单
weixin_30883777的博客
02-20 232
最近工作接触到微信支付，刚开始解决微信支付很神秘，接触之后发现并没有那么神秘，就是有很多坑，在开发的时候需要注意，整理出来： 1.准备工作 首先需要登录微信支付公众平台阅读接口文档，地址：https://pay.weixin.qq.com/wiki/doc/api/app.php?chapter=9_12&index=2 ； 其次了解微信支付商户系统和微信支付系统主要交互说明...
微信支付之微信统一下单接口接入
weixin_45589505的博客
04-02 1711
不管是学习一门新的技术还是使用他人接口的时候最好的方式就是先看官方的文档，所以在使用微信支付的统一下单最好先看一下官方的文档 https://pay.weixin.qq.com/wiki/doc/api/app/app.php?chapter=9_ 首先导入依赖 <dependency> <groupId>org.apache.httpcomponents<...
java 微信支付v3统一下单
最新发布
11-09
微信支付V3统一下单是指使用Java语言编写的一种支付方式，通过微信支付接口实现对用户的统一下单操作。 在Java中，可以通过调用微信支付的API接口来完成统一下单的功能。首先，需要引入微信支付的Java SDK，并将其...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值