官方文档：https://pay.weixin.qq.com/wiki/doc/api/jsapi.php?chapter=9_1

微信PC二维码支付方式参考：https://www.cnblogs.com/pxblog/p/10542917.html

沙箱环境调试：https://www.cnblogs.com/pxblog/p/13844925.html

本地开发环境支付回调调试方法可以参考：https://www.cnblogs.com/pxblog/p/11623053.html

引入jdom-1.1.3.jar包

HttpClientUtil.java

package weixinpay;

import org.apache.commons.lang.StringUtils;

import org.apache.http.HttpEntity;

import org.apache.http.HttpResponse;

import org.apache.http.StatusLine;

import org.apache.http.client.ClientProtocolException;

import org.apache.http.client.HttpClient;

import org.apache.http.client.HttpResponseException;

import org.apache.http.client.ResponseHandler;

import org.apache.http.client.methods.CloseableHttpResponse;

import org.apache.http.client.methods.HttpGet;

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.HttpClientBuilder;

import org.apache.http.impl.client.HttpClients;

import org.apache.http.util.EntityUtils;

import javax.net.ssl.SSLContext;

import javax.net.ssl.TrustManager;

import javax.net.ssl.X509TrustManager;

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStreamReader;

import java.io.OutputStreamWriter;

import java.net.MalformedURLException;

import java.net.URI;

import java.net.URL;

import java.net.URLConnection;

import java.security.cert.CertificateException;

import java.security.cert.X509Certificate;

public class HttpClientUtil {

    private static class SingletonHolder{

        private final static  HttpClientUtil INSTANCE=new HttpClientUtil();

    }   

    private HttpClientUtil(){}

    public static HttpClientUtil getInstance(){

        return SingletonHolder.INSTANCE;

    }

    public  String get(String url){

        CharsetHandler handler = new CharsetHandler("UTF-8");

         CloseableHttpClient client = null;

        try {

            HttpGet httpget = new HttpGet(new URI(url));

            HttpClientBuilder httpClientBuilder = HttpClientBuilder.create();

            client= httpClientBuilder.build();

            client = (CloseableHttpClient) wrapClient(client);

            return client.execute(httpget, handler);

        } catch (Exception e) {

            //e.printStackTrace();

            return "";

        }finally {

            try {

                if(client!=null){

                    client.close();

                }

            } catch (IOException e) {

                e.printStackTrace();

            }

       }

    }

    public static String post(String url, String params,String contentType)

       {

          //创建HttpClientBuilder

          HttpClientBuilder httpClientBuilder = HttpClientBuilder.create();

          //HttpClient

          CloseableHttpClient client = httpClientBuilder.build();

          client = (CloseableHttpClient) wrapClient(client);

           HttpPost post = new HttpPost(url);

           CloseableHttpResponse res = null;

           try

           {

               StringEntity s = new StringEntity(params,"UTF-8");

               if(StringUtils.isBlank(contentType)){

                   s.setContentType("application/json");

               }

               s.setContentType(contentType);

               s.setContentEncoding("utf-8");

               post.setEntity(s);

               res = client.execute(post);

               HttpEntity entity = res.getEntity();

               return EntityUtils.toString(entity, "utf-8");

           }

           catch (Exception e)

           {

               e.printStackTrace();

           } finally {

                try {

                    res.close();

                    client.close();

                } catch (IOException e) {

                    e.printStackTrace();

                }

           }

        return "";

     }

    public static String post(String urlStr,String xmlInfo) {

        String line1 = "";

        try {

            URL url = new URL(urlStr);

            URLConnection con = url.openConnection();

            con.setDoOutput(true);

            //con.setRequestProperty("Pragma:", "no-cache");

            con.setRequestProperty("Cache-Control", "no-cache");

            con.setRequestProperty("Content-Type", "text/xml"); 

            OutputStreamWriter out = new OutputStreamWriter(con

            .getOutputStream());

            out.write(new String(xmlInfo.getBytes("utf-8")));

            out.flush();

            out.close();

            BufferedReader br = new BufferedReader(new InputStreamReader(con

            .getInputStream()));

            String line = "";

            for (line = br.readLine(); line != null; line = br.readLine()) {

                line1+=line;

            }

            return new String(line1.getBytes(),"utf-8");

            } catch (MalformedURLException e) {

                e.printStackTrace();

            } catch (IOException e) {

                e.printStackTrace();

            }

            return null;

        }

    private class CharsetHandler implements ResponseHandler<String> {

        private String charset;

        public CharsetHandler(String charset) {

            this.charset = charset;

        }

        public String handleResponse(HttpResponse response)

                throws ClientProtocolException, IOException {

            StatusLine statusLine = response.getStatusLine();

            if (statusLine.getStatusCode() >= 300) {

                throw new HttpResponseException(statusLine.getStatusCode(),

                        statusLine.getReasonPhrase());

            }

            HttpEntity entity = response.getEntity();

            if (entity != null) {

                if (!StringUtils.isBlank(charset)) {

                    return EntityUtils.toString(entity, charset);

                } else {

                    return EntityUtils.toString(entity);

                }

            } else {

                return null;

            }

        }

    }

    private static HttpClient wrapClient(HttpClient base) {

        try {

            SSLContext ctx = SSLContext.getInstance("TLSv1");

            X509TrustManager tm = new X509TrustManager() {

                public void checkClientTrusted(X509Certificate[] xcs,

                        String string) throws CertificateException {

                }

                public void checkServerTrusted(X509Certificate[] xcs,

                        String string) throws CertificateException {

                }

                public X509Certificate[] getAcceptedIssuers() {

                    return null;

                }

            };

            ctx.init(null, new TrustManager[] { tm }, null);

            SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(ctx, new String[] { "TLSv1" }, null,

                    SSLConnectionSocketFactory.BROWSER_COMPATIBLE_HOSTNAME_VERIFIER);

            CloseableHttpClient httpclient = HttpClients.custom().setSSLSocketFactory(sslsf).build();

            return httpclient;

        } catch (Exception ex) {

            return null;

        }

    }

}

Num62.java

package weixinpay;

/**

 * 62进制数字

 */

public class Num62 {

    /**

     * 62个字母和数字，含大小写

     */

    public static final char[] N62_CHARS = { '0', '1', '2', '3', '4', '5', '6',

            '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J',

            'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W',

            'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j',

            'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w',

            'x', 'y', 'z' };

    /**

     * 36个小写字母和数字

     */

    public static final char[] N36_CHARS = { '0', '1', '2', '3', '4', '5', '6',

            '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j',

            'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w',

            'x', 'y', 'z' };

    /**

     * 10 个数字

     */

    public static final char[] N10_CHARS = { '0', '1', '2', '3', '4', '5', '6',

            '7', '8', '9' };

    /**

     * 长整型用N36表示的最大长度

     */

    public static final int LONG_N36_LEN = 13;

    /**

     * 长整型用N62表示的最大长度

     */

    public static final int LONG_N62_LEN = 11;

    /**

     * 长整型转换成字符串

     *

     * @param l

     * @param chars

     * @return

     */

    private static StringBuilder longToNBuf(long l, char[] chars) {

        int upgrade = chars.length;

        StringBuilder result = new StringBuilder();

        int last;

        while (l > 0) {

            last = (int) (l % upgrade);

            result.append(chars[last]);

            l /= upgrade;

        }

        return result;

    }

    /**

     * 长整数转换成N62

     *

     * @param l

     * @return

     */

    public static String longToN62(long l) {

        return longToNBuf(l, N62_CHARS).reverse().toString();

    }

    /**

     * 长整型转换成N36

     *

     * @param l

     * @return

     */

    public static String longToN36(long l) {

        return longToNBuf(l, N36_CHARS).reverse().toString();

    }

    /**

     * 长整数转换成N62

     *

     * @param l

     * @param length

     *            如不足length长度，则补足0。

     * @return

     */

    public static String longToN62(long l, int length) {

        StringBuilder sb = longToNBuf(l, N62_CHARS);

        for (int i = sb.length(); i < length; i++) {

            sb.append('0');

        }

        return sb.reverse().toString();

    }

    /**

     * 长整型转换成N36

     *

     * @param l

     * @param length

     *            如不足length长度，则补足0。

     * @return

     */

    public static String longToN36(long l, int length) {

        StringBuilder sb = longToNBuf(l, N36_CHARS);

        for (int i = sb.length(); i < length; i++) {

            sb.append('0');

        }

        return sb.reverse().toString();

    }

    /**

     * N62转换成整数

     *

     * @param n62

     * @return

     */

    public static long n62ToLong(String n62) {

        return nToLong(n62, N62_CHARS);

    }

    /**

     * N36转换成整数

     *

     * @param n36

     * @return

     */

    public static long n36ToLong(String n36) {

        return nToLong(n36, N36_CHARS);

    }

    private static long nToLong(String s, char[] chars) {

        char[] nc = s.toCharArray();

        long result = 0;

        long pow = 1;

        for (int i = nc.length - 1; i >= 0; i--, pow *= chars.length) {

            int n = findNIndex(nc[i], chars);

            result += n * pow;

        }

        return result;

    }

    private static int findNIndex(char c, char[] chars) {

        for (int i = 0; i < chars.length; i++) {

            if (c == chars[i]) {

                return i;

            }

        }

        throw new RuntimeException("N62(N36)非法字符：" + c);

    }

    public static void main(String[] args) {

        System.out.println(longToN62(Long.MAX_VALUE));

    }

}

微信支付支付参数配置类

PaymentConfig.java

package weixinpay;

public class PaymentConfig {

    /*******微信支付参数*********/

    //公众账号ID

    public static final String appid="wxd";

    //密钥

    public static final String appKey="h";

    //商户号

    public static final String mch_id="1584";

    //接口地址

    public static final String pay_url="https://api2.mch.weixin.qq.com/pay/unifiedorder";

//交易场景信息

    public static final String scene_info = "{\"store_info\" : {\"id\": \"zxbm\",\"name\": \"支付\",\"area_code\": \"430000\",\"address\": \"中国\" }}";

}

PayUtil.java

package weixinpay;

import org.apache.commons.lang.StringUtils;

import org.jdom.Document;

import org.jdom.Element;

import org.jdom.JDOMException;

import org.jdom.input.SAXBuilder;

import java.io.*;

import java.security.MessageDigest;

import java.util.*;

public class PayUtil {

    /**

    * 将需要传递给微信的参数转成xml格式

    * @param parameters

    * @return

    */

    public static String assembParamToXml(Map<String,String> parameters){

        StringBuffer sb = new StringBuffer();

        sb.append("<xml>");

        Set<String> es = parameters.keySet();

        List<Object> list=new ArrayList<Object>(es);

        Object[] ary =list.toArray();

        Arrays.sort(ary);

        list=Arrays.asList(ary);

        Iterator<Object> it = list.iterator();

        while(it.hasNext()) {

            String key =  (String) it.next();

            String val=(String) parameters.get(key);

            if ("attach".equalsIgnoreCase(key)||"body".equalsIgnoreCase(key)||"sign".equalsIgnoreCase(key)) {

                sb.append("<"+key+">"+"<![CDATA["+val+"]]></"+key+">");

            }else {

                sb.append("<"+key+">"+val+"</"+key+">");

            }

        }

        sb.append("</xml>");

        return sb.toString();

    }

    /**

    * 解析xml,返回第一级元素键值对。如果第一级元素有子节点，则此节点的值是子节点的xml数据。

    * @param strxml

    * @return

    * @throws JDOMException

    * @throws IOException

    */

    public static Map parseXMLToMap(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();

        Iterator it = list.iterator();

        while(it.hasNext()) {

            Element e = (Element) it.next();

            String k = e.getName();

            String v = "";

            List children = e.getChildren();

            if(children.isEmpty()) {

                v = e.getTextNormalize();

            } else {

                v =PayUtil.getChildrenText(children);

            }

            m.put(k, v);

        }

        //关闭流

        in.close();

        return m;

    }

    /**

    * 获取子结点的xml

    * @param children

    * @return String

    */

    public static String getChildrenText(List children) {

        StringBuffer sb = new StringBuffer();

        if(!children.isEmpty()) {

            Iterator it = children.iterator();

            while(it.hasNext()) {

                Element e = (Element) it.next();

                String name = e.getName();

                String value = e.getTextNormalize();

                List list = e.getChildren();

                sb.append("<" + name + ">");

                if(!list.isEmpty()) {

                    sb.append(getChildrenText(list));

                }

                sb.append(value);

                sb.append("</" + name + ">");

            }

        }

        return sb.toString();

    }

    /**

    * 微信支付签名sign

    * @param param

    * @param key

    * @return

    */

    @SuppressWarnings("unchecked")

    public static String createSign(Map<String, String> param,String key){

        //签名步骤一：按字典排序参数

        List list=new ArrayList(param.keySet());

        Object[] ary =list.toArray();

        Arrays.sort(ary);

        list=Arrays.asList(ary);

        String str="";

        for(int i=0;i<list.size();i++){

            str+=list.get(i)+"="+param.get(list.get(i)+"")+"&";

        }

        //签名步骤二：加上key

        str+="key="+key;

        //步骤三：加密并大写

        str=PayUtil.MD5Encode(str,"utf-8").toUpperCase();

        return str;

    }

    public static String MD5Encode(String origin,String charsetName){

        String resultString=null;

        try{

            resultString=new String(origin);

            MessageDigest md=MessageDigest.getInstance("MD5");

            if(StringUtils.isBlank(charsetName)){

                resultString=byteArrayToHexString(md.digest(resultString.getBytes()));

            }else{

                resultString=byteArrayToHexString(md.digest(resultString.getBytes(charsetName)));

            }

        }catch(Exception e){

        }

        return resultString;

    }

    public static String byteArrayToHexString(byte b[]){

        StringBuffer resultSb=new StringBuffer();

        for(int i=0;i<b.length;i++){

            resultSb.append(PayUtil.byteToHexString(b[i]));

        }

        return resultSb.toString();

    }

    public static String byteToHexString(byte b){

        int n=b;

        if(n<0){

            n+=256;

        }

        int d1=n/16;

        int d2=n%16;

        return PayUtil.hexDigits[d1]+PayUtil.hexDigits[d2];

    }

    public static final String hexDigits[]={ "0", "1", "2", "3", "4", "5",

    "6", "7", "8", "9", "a", "b", "c", "d", "e", "f" };

    /**

     * 元转换为分

     * @param amount

     */

    public static String changeY2F(Double amount){

            String currency =  amount.toString();

            int index = currency.indexOf(".");

            int length = currency.length();

            Long amLong = 0l;

            if(index == -1){

                amLong = Long.valueOf(currency+"00");

            }else if(length - index >= 3){

                amLong = Long.valueOf((currency.substring(0, index+3)).replace(".", ""));

            }else if(length - index == 2){

                amLong = Long.valueOf((currency.substring(0, index+2)).replace(".", "")+0);

            }else{

                amLong = Long.valueOf((currency.substring(0, index+1)).replace(".", "")+"00");

            }

            return amLong.toString();

    }

}

WeixinPay.java

package weixinpay;

import org.apache.commons.lang.RandomStringUtils;

import org.apache.commons.lang.StringUtils;

import org.springframework.ui.ModelMap;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import java.util.HashMap;

import java.util.Map;

public class WeixinPay {

    /**

     * 微信统一下单

     *

     * @param trade_type 交易类型

     * @param openId     用户的openId

     * @param request

     * @param wxReturn   微信支付异步回调地址

     * @param orderNo    订单号

     * @param price      订单金额

     * @return

     */

    public static Map<String, String> weixinUniformOrder(String openId,

                                                         HttpServletRequest request, String wxReturn, String orderNo, Double price) {

        Map<String, String> paramMap = new HashMap<String, String>();

        // 微信分配的公众账号ID（企业号corpid即为此appId）[必填]

        paramMap.put("appid", PaymentConfig.appid);

        // 微信支付分配的商户号 [必填]

        paramMap.put("mch_id", PaymentConfig.mch_id);

        // 终端设备号(门店号或收银设备ID)，注意：PC网页或公众号内支付请传"WEB" [非必填]

        paramMap.put("device_info", "WEB");

        // 随机字符串，不长于32位。 [必填]

        paramMap.put("nonce_str", RandomStringUtils.random(10, Num62.N62_CHARS));

        // 商品或支付单简要描述 [必填]

        paramMap.put("body", PaymentConfig.mch_id);

        // 商户系统内部的订单号,32个字符内、可包含字母, [必填]

        paramMap.put("out_trade_no", orderNo);

        // 符合ISO 4217标准的三位字母代码，默认人民币：CNY. [非必填]

        paramMap.put("fee_type", "CNY");

        // 金额必须为整数 单位为分 [必填]

        paramMap.put("total_fee", PayUtil.changeY2F(price));

        // APP和网页支付提交用户端ip，Native支付填调用微信支付API的机器IP [必填]

        paramMap.put("spbill_create_ip", request.getRemoteAddr());

        // 接收微信支付异步通知回调地址，通知url必须为直接可访问的url，不能携带参数。 [必填]

        paramMap.put("notify_url", wxReturn);

        // 交易类型{取值如下：JSAPI，NATIVE，APP，(JSAPI--公众号支付、NATIVE--原生扫码支付、APP--app支付)}

        // [必填]

        paramMap.put("trade_type", "JSAPI");

        //openid trade_type=JSAPI，此参数必传，用户在商户appid下的唯一标识

        paramMap.put("openid", openId);

        // 商品ID{trade_type=NATIVE，此参数必传。此id为二维码中包含的商品ID，商户自行定义。}

        paramMap.put("product_id", "商品ID");

        // 根据微信签名规则，生成签名

        paramMap.put("sign", PayUtil.createSign(paramMap, PaymentConfig.appKey));

        // 把参数转换成XML数据格式

        String xmlWeChat = PayUtil.assembParamToXml(paramMap);

        String resXml = HttpClientUtil.post(PaymentConfig.pay_url, xmlWeChat);

        Map<String, String> map = new HashMap<String, String>();

        try {

            if (StringUtils.isNotBlank(resXml)) {

                map = PayUtil.parseXMLToMap(resXml);

            }

        } catch (Exception e) {

            e.printStackTrace();

        }

        return map;

    }

    /**

     * 微信公众号支付(手机端)

     *

     * @param wxReturn 微信支付异步回调地址

     * @param openId   用户的openid

     * @param orderNo  订单号

     * @param price    订单金额

     * @param request

     * @param response

     * @param model

     * @return

     */

    public static String weixinPayByMobile(String wxReturn, String openId, String orderNo, Double price,

                                           HttpServletRequest request, HttpServletResponse response,

                                           ModelMap model) {

        Map<String, String> map = weixinUniformOrder(openId,

                request, wxReturn, orderNo, price);

        String returnCode = map.get("return_code");

        if (returnCode.equalsIgnoreCase("FAIL")) {

            //调用失败操作

            //当return_code为FAIL时返回信息为错误原因 ，例如 签名失败、参数格式校验错误

            map.get("return_msg");

        } else if (returnCode.equalsIgnoreCase("SUCCESS")) {

            if (map.get("err_code") != null) {

                //支付失败操作

                //错误代码描述

                map.get("err_code_des");

            } else if (map.get("result_code").equalsIgnoreCase(

                    "SUCCESS")) {

                String prepay_id = map.get("prepay_id");

                Long time = System.currentTimeMillis() / 1000;

                String nonceStr = RandomStringUtils.random(16, Num62.N10_CHARS);

                //公众号appid

                model.addAttribute("appId", PaymentConfig.appid);

                //时间戳 当前的时间 需要转换成秒

                model.addAttribute("timeStamp", time);

                //随机字符串  不长于32位

                model.addAttribute("nonceStr", nonceStr);

                //订单详情扩展字符串 统一下单接口返回的prepay_id参数值，提交格式如：prepay_id=***

                model.addAttribute("package", "prepay_id=" + prepay_id);

                //签名方式 签名算法，暂支持MD5

                model.addAttribute("signType", "MD5");

                Map<String, String> paramMap = new HashMap<String, String>();

                paramMap.put("appId", PaymentConfig.appid);

                paramMap.put("timeStamp", time.toString());

                paramMap.put("nonceStr", nonceStr);

                paramMap.put("package", "prepay_id=" + prepay_id);

                paramMap.put("signType", "MD5");

                //签名

                model.addAttribute("paySign", PayUtil.createSign(paramMap, PaymentConfig.appKey));

                //跳转到 weixin_prepay.html

                return "weixin_prepay.html";

            }

        }

        // 失败提示跳转页面，自己设计

        return "error.html";

    }

    //通知微信正确接收

    public static String getSuccessXml() {

        String xml = "<xml>" +

                "<return_code><![CDATA[SUCCESS]]></return_code>" +

                "<return_msg><![CDATA[OK]]></return_msg>" +

                "</xml>";

        return xml;

    }

}

微信公众号支付跳转页面主要逻辑代码

weixin_prepay.html

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"

        "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml">

<head>

    <meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>

    <title>微信支付</title>

    <script src="http://res.wx.qq.com/open/js/jweixin-1.0.0.js" type="text/javascript"></script>

    <script type="text/javascript">

        wx.config({

            debug: false, // 开启调试模式,调用的所有api的返回值会在客户端alert出来，若要查看传入的参数，可以在pc端打开，参数信息会通过log打出，仅在pc端时才会打印。

            appId: '${appId!}', // 必填，公众号的唯一标识

            timestamp: "${timeStamp!}", // 必填，生成签名的时间戳

            nonceStr: '${nonceStr!}', // 必填，生成签名的随机串

            signature: "${paySign!}", // 必填，签名，见附录1

            jsApiList: ['chooseWXPay'] // 必填，需要使用的JS接口列表，所有JS接口列表见附录2

        });

        wx.ready(function () {

            wx.chooseWXPay({

                appId: "${appId!}",

                timestamp: "${timeStamp!}",

                nonceStr: "${nonceStr!}",

                package: "${package!}",

                signType: "MD5",

                paySign: "${paySign!}",

                success: function (res) {

                    alert("成功");

                    window.location.href = "成功之后跳转地址";

                },

                cancel: function () {

                    alert("用户已取消");

                },

                error: function (e) {

                    alert("失败");

                }

            });

        });

    </script>

</head>

<body>

<div class="w1187b">

    <div class="w1173">

    </div>

</div>

</body>

</html>

后台控制器调用类

WeixinPayAct.java

package weixinpay;

import org.apache.commons.lang.StringUtils;

import org.jdom.JDOMException;

import org.springframework.stereotype.Controller;

import org.springframework.ui.ModelMap;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.ResponseBody;

import weixin.XMLUtil;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import java.io.*;

import java.util.*;

@Controller

public class WeixinPayAct {

    /**

     * 微信支付

     *

     * @param request

     * @param response

     * @param model

     * @return

     */

    @RequestMapping(value = "weixin_Pay")

    public String selectPay(HttpServletRequest request,

                            HttpServletResponse response, ModelMap model) {

        String wxReturn = "微信支付异步回调地址";

        String orderNo = "订单号";

        String openId = "用户的openId";

        //支付金额

        Double price = 0.01;

        return WeixinPay.weixinPayByMobile(wxReturn, openId, orderNo, price,

                request, response, model);

    }

    /**

     * 微信支付通知

     *

     * @return

     */

    @ResponseBody

    @RequestMapping(value = "/wechart_notice")

    public String wechartNotice(HttpServletRequest request, HttpServletResponse response, ModelMap model) {

        String result = "";

        try {

            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);

            }

            outSteam.close();

            inStream.close();

            result = new String(outSteam.toByteArray(), "utf-8");

        } catch (IOException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        }

        //判断返回报文是否为空

        if (StringUtils.isNotBlank(result)) {

            try {

                Map<String, String> map = XMLUtil.doXMLParse(result);

                //获取商家订单编号 对应orderID

                String orderNo = map.get("out_trade_no");

                //String orderNo = RequestUtils.getQueryParam(request,"orderNo");

                //获取微信支付订单号

                String transaction_id = map.get("transaction_id");

                Order order = orderMng.findByOrderNo(orderNo);

                //判断支付是否成功

                if ("SUCCESS".equals(map.get("result_code"))) {

                    //支付成功，这里之所以加了一个判断，是因为这个回调可能会有多次，所以我们只有当订单状态时未支付的情况下，才执行下面操作

                    if (!Constants.ORDER_SUCCESS.equals(order.getStatus())) {

                        //当微信支付成功后，把订单支付状态改为已支付

                        order.setStatus(Constants.ORDER_SUCCESS);

                    }

                    //处理业务逻辑

                } else {

                    //支付失败

                    order.setStatus(Constants.ORDER_FAIL);

                }

                orderMng.update(order);

            } catch (JDOMException e) {

                // TODO Auto-generated catch block

                e.printStackTrace();

            } catch (IOException e) {

                // TODO Auto-generated catch block

                e.printStackTrace();

            }

        }

        return WeixinPay.getSuccessXml();

    }

}

如果浏览器请求返回:errMsg: "chooseWXPay:fail, the permission value is offline verifying"

这个错误是由于我们用的开发工具开发，只要在手机上打开就可以了

最新文章

  1. Redis 3.2.1集群搭建
  2. nodejs学习之实现简易路由
  3. POJ 2992 求组合数的因子个数
  4. 关于Objective-C 对象release操作的一个小问题探讨
  5. 深入理解Java String#intern() 内存模型
  6. SQL 插入查询的最大ID 号 进行批量
  7. onActivityResult不执行 或者 onActivityResult的解决方法
  8. android 设计模式学习
  9. tomcat不编译webapps下的war包的解决办法
  10. selenium——鼠标事件
  11. golang rc4加密
  12. @lazy注解处理循环注入问题
  13. ARTS（一）
  14. Java自定义类加载器与双亲委派模型
  15. express中app.get和app.use的解析
  16. hadoop day 3
  17. Linux网卡绑定探析
  18. Odoo创建基础模块和相关内容
  19. ORACLE 管道技术应用
  20. Spring定时器Quartz的用法

热门文章

  1. FJOI2020 的两道组合计数题
  2. Python pandas merge不能根据列名合并两个数据框（Key Error）？
  3. cd-hit 去除冗余序列
  4. yum和apt-get的用法和区别
  5. Oracle-连接多个字段
  6. PHP socket Workerman实用的php框架
  7. X-MagicBox-820的luatOS之路连载系列6
  8. RTSP, RTP, RTCP, RTMP傻傻分不清？
  9. 修改linux文件权限命令：chmod 转载至 Avril 的随笔
  10. 增大Oracle Virtualbox的磁盘空间