微信app支付java后台流程、原理分析及nei网穿透

一.流程步骤

　　本实例是基于springmvc框架编写

　　1.执行流程
           当手机端app(就是你公司开发的app)在支付页面时，调起服务端(后台第1个创建订单接口)接口，后台把需要调起微信支付的参数返回给手机端，手机端拿到
         这些参数后，拉起微信支付环境完成支付，完成支付后会调异步通知(第2个接口)，此时需要给微信返回成功或者失败信息，成功后，由app端调用同步通知(第3个接口)
         返回支付成功页面，完成整个支付流程。
        
      2.需要说明的事项

        因为微信支付都是用自己工具类生成加密、解析xml、验签等方法，需要写的类比较多，因此大家在参考此文档时，直接复制就行了

二.配置文件及通用类

　　1.配置文件类

　　ConstantUtil（各应应用id的配置,把自己应用对应的找到即可）

package com.qtkj.app.weixinpay.util;

public class ConstantUtil {
   
    // 微信开发平台应用ID*             
    public static final String APP_ID="";
    
    // 应用对应的凭证  appsecret                  
    public static final String APP_SECRET="";
    
    // 应用对应的密钥 appkey                 
    public static final String APP_KEY="";
   
    //微信支付商户号 
    public static final String MCH_ID="";
    
    //商户id 
    public static final String PARTNER_ID="";
    
    //商品描述
    public static final String BODY="游戏币-账户充值";
    
     // 获取预支付id的接口访问路径 
    public static String GATEURL = "https://api.mch.weixin.qq.com/pay/unifiedorder";
    
    // 微信服务器回调通知url
    public static String NOTIFY_URL="";
}

2.工具类(一共8个,直接复制使用即可)　

　TenpayUtil

package com.qtkj.app.weixinpay.util;

import java.text.SimpleDateFormat;
import java.util.Date;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class TenpayUtil {
    
    /**
     * 把对象转换成字符串
     * @param obj
     * @return String 转换成字符串,若对象为null,则返回空字符串.
     */
    public static String toString(Object obj) {
        if(obj == null)
            return "";
        
        return obj.toString();
    }
    
    /**
     * 把对象转换为int数值.
     * 
     * @param obj
     *            包含数字的对象.
     * @return int 转换后的数值,对不能转换的对象返回0。
     */
    public static int toInt(Object obj) {
        int a = 0;
        try {
            if (obj != null)
                a = Integer.parseInt(obj.toString());
        } catch (Exception e) {

        }
        return a;
    }
    
    /**
     * 获取当前时间 yyyyMMddHHmmss
     * @return String
     */ 
    public static String getCurrTime() {
        Date now = new Date();
        SimpleDateFormat outFormat = new SimpleDateFormat("yyyyMMddHHmmss");
        String s = outFormat.format(now);
        return s;
    }
    
    /**
     * 获取当前日期 yyyyMMdd
     * @param date
     * @return String
     */
    public static String formatDate(Date date) {
        SimpleDateFormat formatter = new SimpleDateFormat("yyyyMMdd");
        String strDate = formatter.format(date);
        return strDate;
    }
    
    /**
     * 取出一个指定长度大小的随机正整数.
     * 
     * @param length
     *            int 设定所取出随机数的长度。length小于11
     * @return int 返回生成的随机数。
     */
    public static int buildRandom(int length) {
        int num = 1;
        double random = Math.random();
        if (random < 0.1) {
            random = random + 0.1;
        }
        for (int i = 0; i < length; i++) {
            num = num * 10;
        }
        return (int) ((random * num));
    }
    
    /**
     * 获取编码字符集
     * @param request
     * @param response
     * @return String
     */
    public static String getCharacterEncoding(HttpServletRequest request,
            HttpServletResponse response) {
        
        if(null == request || null == response) {
            return "gbk";
        }
        
        String enc = request.getCharacterEncoding();
        if(null == enc || "".equals(enc)) {
            enc = response.getCharacterEncoding();
        }
        
        if(null == enc || "".equals(enc)) {
            enc = "gbk";
        }
        
        return enc;
    }
    
    /**
     * 获取unix时间，从1970-01-01 00:00:00开始的秒数
     * @param date
     * @return long
     */
    public static long getUnixTime(Date date) {
        if( null == date ) {
            return 0;
        }
        
        return date.getTime()/1000;
    }
        
    /**
     * 时间转换成字符串
     * @param date 时间
     * @param formatType 格式化类型
     * @return String
     */
    public static String date2String(Date date, String formatType) {
        SimpleDateFormat sdf = new SimpleDateFormat(formatType);
        return sdf.format(date);
    }
}

　　PrepayIdRequestHandler

package com.qtkj.app.weixinpay.handler;

import java.util.Iterator;
import java.util.Map;
import java.util.Set;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import com.qtkj.app.weixinpay.util.ConstantUtil;
import com.qtkj.app.weixinpay.util.MD5Util;
import com.qtkj.app.weixinpay.util.XMLUtil;

public class PrepayIdRequestHandler extends RequestHandler {

    public PrepayIdRequestHandler(HttpServletRequest request,
            HttpServletResponse response) {
        super(request, response);
    }

    public String createMD5Sign() {
        StringBuffer sb = new StringBuffer();
        Set es = super.getAllParameters().entrySet();
        Iterator it = es.iterator();
        while (it.hasNext()) {
            Map.Entry entry = (Map.Entry) it.next();
            String k = (String) entry.getKey();
            String v = (String) entry.getValue();
            sb.append(k + "=" + v + "&");
        }
        String params=sb.append("key="+ConstantUtil.APP_KEY).substring(0);

        
        String sign = MD5Util.MD5Encode(params, "utf8");
        return sign.toUpperCase();
    }

    // 提交预支付
    public String sendPrepay() throws Exception {
        String prepayid = "";
        Set es=super.getAllParameters().entrySet();
        Iterator it=es.iterator();
        StringBuffer sb = new StringBuffer("<xml>");
        while(it.hasNext()){
            Map.Entry entry = (Map.Entry) it.next();
            String k = (String) entry.getKey();
            String v = (String) entry.getValue();
            sb.append("<"+k+">"+v+"</"+k+">");
        }
        sb.append("</xml>");
        String params=sb.substring(0);
        System.out.println("请求参数："+params);
        String requestUrl = super.getGateUrl();
        System.out.println("请求url："+requestUrl);
        TenpayHttpClient httpClient = new TenpayHttpClient();
        httpClient.setReqContent(requestUrl);
        String resContent = "";
        if (httpClient.callHttpPost(requestUrl, params)) {
            resContent = httpClient.getResContent();
            System.out.println("获取prepayid的返回值："+resContent);
            Map<String,String> map=XMLUtil.doXMLParse(resContent);
            if(map.containsKey("prepay_id"))
                prepayid=map.get("prepay_id");
        }
        return prepayid;
    }
}

　　RequestHandler

package com.qtkj.app.weixinpay.handler;

import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.SortedMap;
import java.util.TreeMap;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import com.qtkj.app.weixinpay.util.MD5Util;
import com.qtkj.app.weixinpay.util.TenpayUtil;

/**
 * 请求处理类
 * 请求处理类继承此类，重写createSign方法即可。
 *
 */
public class RequestHandler {
    
    /** 网关url地址 */
    private String gateUrl;
    
    /** 密钥 */
    private String key;
    
    /** 请求的参数 */
    private SortedMap parameters;
    
    protected HttpServletRequest request;
    
    protected HttpServletResponse response;
    
    /**
     * 构造函数
     * @param request
     * @param response
     */
    public RequestHandler(HttpServletRequest request, HttpServletResponse response) {
        this.request = request;
        this.response = response;
        
        this.gateUrl = "https://gw.tenpay.com/gateway/pay.htm";
        this.key = "";
        this.parameters = new TreeMap();
    }
    
    /**
    *初始化函数。
    */
    public void init() {
        //nothing to do
    }

    /**
    *获取入口地址,不包含参数值
    */
    public String getGateUrl() {
        return gateUrl;
    }

    /**
    *设置入口地址,不包含参数值
    */
    public void setGateUrl(String gateUrl) {
        this.gateUrl = gateUrl;
    }

    /**
    *获取密钥
    */
    public String getKey() {
        return key;
    }

    /**
    *设置密钥
    */
    public void setKey(String key) {
        this.key = key;
    }
    
    /**
     * 获取参数值
     * @param parameter 参数名称
     * @return String 
     */
    public String getParameter(String parameter) {
        String s = (String)this.parameters.get(parameter); 
        return (null == s) ? "" : s;
    }
    
    /**
     * 设置参数值
     * @param parameter 参数名称
     * @param parameterValue 参数值
     */
    public void setParameter(String parameter, Object parameterValue) {
        String v = "";
        if(null != parameterValue) {
            if(parameterValue instanceof String)
            v = ((String) parameterValue).trim();
        }
        this.parameters.put(parameter, v);
    }
    
    /**
     * 返回所有的参数
     * @return SortedMap
     */
    public SortedMap getAllParameters() {        
        return this.parameters;
    }
    
    /**
     * 获取带参数的请求URL
     * @return String
     * @throws UnsupportedEncodingException 
     */
    public String getRequestURL() throws UnsupportedEncodingException {
        
        this.createSign();
        
        StringBuffer sb = new StringBuffer();
        String enc = TenpayUtil.getCharacterEncoding(this.request, this.response);
        Set es = this.parameters.entrySet();
        Iterator it = es.iterator();
        while(it.hasNext()) {
            Map.Entry entry = (Map.Entry)it.next();
            String k = (String)entry.getKey();
            String v = (String)entry.getValue();
            
            if(!"spbill_create_ip".equals(k)) {
                sb.append(k + "=" + URLEncoder.encode(v, enc) + "&");
            } else {
                sb.append(k + "=" + v.replace("\\.", "%2E") + "&");
            }
        }
        
        //去掉最后一个&
        String reqPars = sb.substring(0, sb.lastIndexOf("&"));
        
        return this.getGateUrl() + "?" + reqPars;
        
    }
    
    public void doSend() throws UnsupportedEncodingException, IOException {
        this.response.sendRedirect(this.getRequestURL());
    }
    
    /**
     * 创建md5摘要,规则是:按参数名称a-z排序,遇到空值的参数不参加签名。
     */
    protected void createSign() {
        StringBuffer sb = new StringBuffer();
        Set es = this.parameters.entrySet();
        Iterator it = es.iterator();
        while(it.hasNext()) {
            Map.Entry entry = (Map.Entry)it.next();
            String k = (String)entry.getKey();
            String v = (String)entry.getValue();
            if(null != v && !"".equals(v) 
                    && !"sign".equals(k) && !"key".equals(k)) {
                sb.append(k + "=" + v + "&");
            }
        }
        sb.append("key=" + this.getKey());
        String enc = TenpayUtil.getCharacterEncoding(this.request, this.response);
        String sign = MD5Util.MD5Encode(sb.toString(), enc).toUpperCase();
        
        this.setParameter("sign", sign);
        
    }
    
    protected HttpServletRequest getHttpServletRequest() {
        return this.request;
    }
    
    protected HttpServletResponse getHttpServletResponse() {
        return this.response;
    }
}

　　MD5Util

/**
 * 
 */
package com.qtkj.app.weixinpay.util;

import java.security.MessageDigest;

/**
* @author Zhao
* @version 创建时间：2017年10月22日 下午3:24:07 
* 
*/
/**
*<p>Title:MD5Util </p>
*<p>Description:</p>
*<p>Company:</p> 
*@author ZHAO
*@date 2017年10月22日
*/
public class MD5Util {
     /**
     * MD5加密
     * @param b
     * @return
     */
    private static String byteArrayToHexString(byte b[]) {
        StringBuffer resultSb = new StringBuffer();
        for (int i = 0; i < b.length; i++)
            resultSb.append(byteToHexString(b[i]));

        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 = new String(origin);
            MessageDigest md = MessageDigest.getInstance("MD5");//MD5加密
            if (charsetname == null || "".equals(charsetname)){
                resultString = byteArrayToHexString(md.digest(resultString.getBytes()));
            }else{
                resultString = byteArrayToHexString(md.digest(resultString.getBytes(charsetname)));
            }
        } catch (Exception exception) {
        }
        return resultString;
    }

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

TenpayHttpClient

package com.qtkj.app.weixinpay.handler;

import java.io.BufferedOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;

import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSocketFactory;


import com.qtkj.app.weixinpay.util.HttpClientUtil;

public class TenpayHttpClient {

    

    
    /** 请求内容，无论post和get，都用get方式提供 */
    private String reqContent;
    
    /** 应答内容 */
    private String resContent;
    
    /** 请求方法 */
    private String method;
    
    /** 错误信息 */
    private String errInfo;
    
    /** 超时时间,以秒为单位 */
    private int timeOut;
    
    /** http应答编码 */
    private int responseCode;
    
    /** 字符编码 */
    private String charset;
    
    private InputStream inputStream;
    
    public TenpayHttpClient() {
        this.reqContent = "";
        this.resContent = "";
        this.method = "POST";
        this.errInfo = "";
        this.timeOut = 30;//30秒
        
        this.responseCode = 0;
        this.charset = "utf8";
        
        this.inputStream = null;
    }
    
    /**
     * 设置请求内容
     * @param reqContent 表求内容
     */
    public void setReqContent(String reqContent) {
        this.reqContent = reqContent;
    }
    
    /**
     * 获取结果内容
     * @return String
     * @throws IOException 
     */
    public String getResContent() {
        try {
            this.doResponse();
        } catch (IOException e) {
            this.errInfo = e.getMessage();
            //return "";
        }
        
        return this.resContent;
    }
    
    /**
     * 设置请求方法post或者get
     * @param method 请求方法post/get
     */
    public void setMethod(String method) {
        this.method = method;
    }
    
    /**
     * 获取错误信息
     * @return String
     */
    public String getErrInfo() {
        return this.errInfo;
    }
    
    /**
     * 设置超时时间,以秒为单位
     * @param timeOut 超时时间,以秒为单位
     */
    public void setTimeOut(int timeOut) {
        this.timeOut = timeOut;
    }
    
    /**
     * 获取http状态码
     * @return int
     */
    public int getResponseCode() {
        return this.responseCode;
    }
    
    protected void callHttp() throws IOException {
        
        if("POST".equals(this.method.toUpperCase())) {
            String url = HttpClientUtil.getURL(this.reqContent);
            String queryString = HttpClientUtil.getQueryString(this.reqContent);
            byte[] postData = queryString.getBytes(this.charset);
            this.httpPostMethod(url, postData);
            
            return ;
        }
        
        this.httpGetMethod(this.reqContent);
        
    } 
    
    public boolean callHttpPost(String url, String postdata) {
        boolean flag = false;
        byte[] postData;
        try {
            postData = postdata.getBytes(this.charset);
            this.httpPostMethod(url, postData);
            flag = true;
        } catch (IOException e1) {
            e1.printStackTrace();
        }
        return flag;
    }
    
    /**
     * 以http post方式通信
     * @param url
     * @param postData
     * @throws IOException
     */
    protected void httpPostMethod(String url, byte[] postData)
            throws IOException {

        HttpURLConnection conn = HttpClientUtil.getHttpURLConnection(url);

        this.doPost(conn, postData);
    }
    
    /**
     * 以http get方式通信
     * 
     * @param url
     * @throws IOException
     */
    protected void httpGetMethod(String url) throws IOException {
        
        HttpURLConnection httpConnection =
            HttpClientUtil.getHttpURLConnection(url);
        
        this.setHttpRequest(httpConnection);
        
        httpConnection.setRequestMethod("GET");
        
        this.responseCode = httpConnection.getResponseCode();
        
        this.inputStream = httpConnection.getInputStream();
        
    }
    
    /**
     * 以https get方式通信
     * @param url
     * @param sslContext
     * @throws IOException
     */
    protected void httpsGetMethod(String url, SSLContext sslContext)
            throws IOException {

        SSLSocketFactory sf = sslContext.getSocketFactory();

        HttpsURLConnection conn = HttpClientUtil.getHttpsURLConnection(url);

        conn.setSSLSocketFactory(sf);

        this.doGet(conn);

    }
    
    protected void httpsPostMethod(String url, byte[] postData,
            SSLContext sslContext) throws IOException {

        SSLSocketFactory sf = sslContext.getSocketFactory();

        HttpsURLConnection conn = HttpClientUtil.getHttpsURLConnection(url);

        conn.setSSLSocketFactory(sf);

        this.doPost(conn, postData);

    }
    
    /**
     * 设置http请求默认属性
     * @param httpConnection
     */
    protected void setHttpRequest(HttpURLConnection httpConnection) {
        
        //设置连接超时时间
        httpConnection.setConnectTimeout(this.timeOut * 1000);
        
        
        //不使用缓存
        httpConnection.setUseCaches(false);
        
        //允许输入输出
        httpConnection.setDoInput(true);
        httpConnection.setDoOutput(true);
        
    }
    
    /**
     * 处理应答
     * @throws IOException
     */
    protected void doResponse() throws IOException {
        
        if(null == this.inputStream) {
            return;
        }

        //获取应答内容
        this.resContent=HttpClientUtil.InputStreamTOString(this.inputStream,this.charset); 

        //关闭输入流
        this.inputStream.close();
        
    }
    
    /**
     * post方式处理
     * @param conn
     * @param postData
     * @throws IOException
     */
    protected void doPost(HttpURLConnection conn, byte[] postData)
            throws IOException {

        // 以post方式通信
        conn.setRequestMethod("POST");

        // 设置请求默认属性
        this.setHttpRequest(conn);

        // Content-Type
        conn.setRequestProperty("Content-Type",
                "application/x-www-form-urlencoded");

        BufferedOutputStream out = new BufferedOutputStream(conn
                .getOutputStream());

        final int len = 1024; // 1KB
        HttpClientUtil.doOutput(out, postData, len);

        // 关闭流
        out.close();

        // 获取响应返回状态码
        this.responseCode = conn.getResponseCode();

        // 获取应答输入流
        this.inputStream = conn.getInputStream();

    }
    
    /**
     * get方式处理
     * @param conn
     * @throws IOException
     */
    protected void doGet(HttpURLConnection conn) throws IOException {
        
        //以GET方式通信
        conn.setRequestMethod("GET");
        
        //设置请求默认属性
        this.setHttpRequest(conn);
        
        //获取响应返回状态码
        this.responseCode = conn.getResponseCode();
        
        //获取应答输入流
        this.inputStream = conn.getInputStream();
    }

    
}

XMLUtil

package com.qtkj.app.weixinpay.util;
/**
*<p>Title:XMLUtil </p>
*<p>Description:</p>
*<p>Company:</p> 
*@author ZHAO
*@date 2017年10月22日
*/
import java.io.IOException;
import java.io.InputStream;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

import org.jdom2.Document;
import org.jdom2.Element;
import org.jdom2.JDOMException;
import org.jdom2.input.SAXBuilder;
import java.io.ByteArrayInputStream;
public class XMLUtil {
    /**
     * 解析xml,返回第一级元素键值对。如果第一级元素有子节点，则此节点的值是子节点的xml数据。
     * @param strxml
     * @return
     * @throws JDOMException
     * @throws IOException
     */
    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();
        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 = XMLUtil.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(XMLUtil.getChildrenText(list));
                }
                sb.append(value);
                sb.append("</" + name + ">");
            }
        }
         
        return sb.toString();
    }
     
    /**
     * 获取xml编码字符集
     * @param strxml
     * @return
     * @throws IOException
     * @throws JDOMException
     */
    public static String getXMLEncoding(String strxml) throws JDOMException, IOException {
        InputStream in = HttpClientUtil.String2Inputstream(strxml);
        SAXBuilder builder = new SAXBuilder();
        Document doc = builder.build(in);
        in.close();
        return (String)doc.getProperty("encoding");
    }
     
    /**
     * 支付成功，返回微信那服务器
     * @param return_code
     * @param return_msg
     * @return
     */
    public static String setXML(String return_code, String return_msg) {
        return "<xml><return_code><![CDATA[" + return_code + "]]></return_code><return_msg><![CDATA[" + return_msg + "]]></return_msg></xml>";
    }
     
    public static String createXML(Map<String,Object> map){
        Set<Entry<String,Object>> set=map.entrySet();
        set.iterator();
        return null;
    }
     
}

WXUtil

package com.qtkj.app.weixinpay.util;

import java.util.Random;

public class WXUtil {
    /**
     * 生成随机字符串
     * @return
     */
    public static String getNonceStr() {
        Random random = new Random();
        return MD5Util.MD5Encode(String.valueOf(random.nextInt(10000)), "utf8");
    }
    /**
     * 获取时间戳
     * @return
     */
    public static String getTimeStamp() {
        return String.valueOf(System.currentTimeMillis() / 1000);
    }
}

  HttpClientUtil

package com.qtkj.app.weixinpay.util;
import java.io.ByteArrayOutputStream;
import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.security.KeyManagementException;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.security.UnrecoverableKeyException;
import java.security.cert.CertificateException;
import java.util.HashMap;
import java.util.Map;

import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.KeyManagerFactory;
import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManagerFactory;


public class HttpClientUtil {
    /**
     * http客户端工具类
     *
     */
    public static final String SunX509 = "SunX509";
    public static final String JKS = "JKS";
    public static final String PKCS12 = "PKCS12";
    public static final String TLS = "TLS";
    
    /**
     * get HttpURLConnection
     * @param strUrl url地址
     * @return HttpURLConnection
     * @throws IOException
     */
    public static HttpURLConnection getHttpURLConnection(String strUrl)
            throws IOException {
        URL url = new URL(strUrl);
        HttpURLConnection httpURLConnection = (HttpURLConnection) url
                .openConnection();
        return httpURLConnection;
    }
    
    /**
     * get HttpsURLConnection
     * @param strUrl url地址ַ
     * @return HttpsURLConnection
     * @throws IOException
     */
    public static HttpsURLConnection getHttpsURLConnection(String strUrl)
            throws IOException {
        URL url = new URL(strUrl);
        HttpsURLConnection httpsURLConnection = (HttpsURLConnection) url
                .openConnection();
        return httpsURLConnection;
    }
    
    /**
     * 获取不带查询串的url
     * @param strUrl
     * @return String
     */
    public static String getURL(String strUrl) {

        if(null != strUrl) {
            int indexOf = strUrl.indexOf("?");
            if(-1 != indexOf) {
                return strUrl.substring(0, indexOf);
            } 
            
            return strUrl;
        }
        
        return strUrl;
        
    }
    
    /**
     * 获取查询串
     * @param strUrl
     * @return String
     */
    public static String getQueryString(String strUrl) {
        
        if(null != strUrl) {
            int indexOf = strUrl.indexOf("?");
            if(-1 != indexOf) {
                return strUrl.substring(indexOf+1, strUrl.length());
            } 
            
            return "";
        }
        
        return strUrl;
    }
    
    /**
     * 查询字符串转化为map
     * name1=key1&name2=key2&...
     * @param queryString
     * @return
     */
    public static Map queryString2Map(String queryString) {
        if(null == queryString || "".equals(queryString)) {
            return null;
        }
        
        Map m = new HashMap();
        String[] strArray = queryString.split("&");
        for(int index = 0; index < strArray.length; index++) {
            String pair = strArray[index];
            HttpClientUtil.putMapByPair(pair, m);
        }
        
        return m;
        
    }
    
    /**
     * 把键值添加到map
     * pair:name=value
     * @param pair name=value
     * @param m
     */
    public static void putMapByPair(String pair, Map m) {
        
        if(null == pair || "".equals(pair)) {
            return;
        }
        
        int indexOf = pair.indexOf("=");
        if(-1 != indexOf) {
            String k = pair.substring(0, indexOf);
            String v = pair.substring(indexOf+1, pair.length());
            if(null != k && !"".equals(k)) {
                m.put(k, v);
            }
        } else {
            m.put(pair, "");
        }
    }
    /**
     * BufferedReader转换成String<br/>
     * 注意:流关闭需要自行处理
     * @param reader
     * @return
     * @throws IOException
     */
    public static String bufferedReader2String(BufferedReader reader) throws IOException {
        StringBuffer buf = new StringBuffer();
        String line = null;
        while( (line = reader.readLine()) != null) {
            buf.append(line);
            buf.append("\r\n");
        }
                
        return buf.toString();
    }
    /**
     * 处理输出<br/>
     * 注意:流关闭需要自行处理
     * @param out
     * @param data
     * @param len
     * @throws IOException
     */
    public static void doOutput(OutputStream out, byte[] data, int len)
            throws IOException {
        int dataLen = data.length;
        int off = 0;
        while (off < data.length) {
            if (len >= dataLen) {
                out.write(data, off, dataLen);
                off += dataLen;
            } else {
                out.write(data, off, len);
                off += len;
                dataLen -= len;
            }

            // ˢ�»�����
            out.flush();
        }

    }
    /**
     * 获取SSLContext
     * @param trustFile 
     * @param trustPasswd
     * @param keyFile
     * @param keyPasswd
     * @return
     * @throws NoSuchAlgorithmException 
     * @throws KeyStoreException 
     * @throws IOException 
     * @throws CertificateException 
     * @throws UnrecoverableKeyException 
     * @throws KeyManagementException 
     */
    public static SSLContext getSSLContext(
            FileInputStream trustFileInputStream, String trustPasswd,
            FileInputStream keyFileInputStream, String keyPasswd)
            throws NoSuchAlgorithmException, KeyStoreException,
            CertificateException, IOException, UnrecoverableKeyException,
            KeyManagementException {

        // ca
        TrustManagerFactory tmf = TrustManagerFactory.getInstance(HttpClientUtil.SunX509);
        KeyStore trustKeyStore = KeyStore.getInstance(HttpClientUtil.JKS);
        trustKeyStore.load(trustFileInputStream, HttpClientUtil
                .str2CharArray(trustPasswd));
        tmf.init(trustKeyStore);

        final char[] kp = HttpClientUtil.str2CharArray(keyPasswd);
        KeyManagerFactory kmf = KeyManagerFactory.getInstance(HttpClientUtil.SunX509);
        KeyStore ks = KeyStore.getInstance(HttpClientUtil.PKCS12);
        ks.load(keyFileInputStream, kp);
        kmf.init(ks, kp);

        SecureRandom rand = new SecureRandom();
        SSLContext ctx = SSLContext.getInstance(HttpClientUtil.TLS);
        ctx.init(kmf.getKeyManagers(), tmf.getTrustManagers(), rand);

        return ctx;
    }
    
    /**
     * 字符串转换成char数组
     * @param str
     * @return char[]
     */
    public static char[] str2CharArray(String str) {
        if(null == str) return null;
        
        return str.toCharArray();
    }
    
    public static InputStream String2Inputstream(String str) {
        return new ByteArrayInputStream(str.getBytes());
    }
    
    /**
     * InputStream转换成Byte
     * 注意:流关闭需要自行处理
     * @param in
     * @return byte
     * @throws Exception
     */
    public static byte[] InputStreamTOByte(InputStream in) throws IOException{  
        
        int BUFFER_SIZE = 4096;  
        ByteArrayOutputStream outStream = new ByteArrayOutputStream(); 
        byte[] data = new byte[BUFFER_SIZE];  
        int count = -1;  
        
        while((count = in.read(data,0,BUFFER_SIZE)) != -1)  
            outStream.write(data, 0, count);  
          
        data = null;  
        byte[] outByte = outStream.toByteArray();
        outStream.close();
        
        return outByte;  
    } 
    
    /**
     * InputStream转换成String
     * 注意:流关闭需要自行处理
     * @param in
     * @param encoding 编码
     * @return String
     * @throws Exception
     */
    public static String InputStreamTOString(InputStream in,String encoding) throws IOException{  

        return new String(InputStreamTOByte(in),encoding);
        
    }  

}

 

三.控制层的接入(Controller)

　　1.Controller层的代码实现过程

package com.qtkj.app.weixinpay.controller;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.UnsupportedEncodingException;
import java.math.BigDecimal;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.jdom2.JDOMException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;

import com.qtkj.admin.common.CacheXmlConfig;
import com.qtkj.admin.settings.entity.SiteConfig;
import com.qtkj.admin.user.entity.User;
import com.qtkj.admin.user.service.UserService;
import com.qtkj.app.weixinpay.handler.ClientRequestHandler;
import com.qtkj.app.weixinpay.handler.PrepayIdRequestHandler;
import com.qtkj.app.weixinpay.util.ConstantUtil;
import com.qtkj.app.weixinpay.util.MD5Util;
import com.qtkj.app.weixinpay.util.TenpayUtil;
import com.qtkj.app.weixinpay.util.UUID;
import com.qtkj.app.weixinpay.util.WXUtil;
import com.qtkj.app.weixinpay.util.XMLUtil;
import com.qtkj.user.entity.Trade;
import com.qtkj.user.service.TradeService;
import com.qtkj.util.NumberUtils;
import com.qtkj.util.PageHelper;


/**
*<p>Title:WeiXinPayController </p>
*<p>Description:</p>
*<p>Company:</p> 
*@author ZHAO
*@date 2017年10月27日
*/
@Controller
public class WeiXinPayController {
    
    @Autowired
    private TradeService tradeservice;
    
    @Autowired
    private TradeService tradeService;
    
    @Autowired
    private UserService userService;
    
    //------------------------------------------------------------------------------------------------------------------------------------------------------------------
    
    /**
    * 9.1.生成订单
    *@author Zhao
    *@date 2017年10月31日
    *@param request
    *@param response
    *@param model
    *@param legalMoney         充值法币金额(legalMoney)
    *@param totalPrice        充值金额(RMB)
    *@param userId            用户id
    *@return
    *@throws Exception
     */
    @RequestMapping("api/weixin/createOrder")  
    @ResponseBody
    public Model doWeinXinRequest(HttpServletRequest request,HttpServletResponse response,Model model,
            @RequestParam("totalPrice") String totalPrice, 
            @RequestParam("legalMoney") String legalMoney, 
            @RequestParam("userId") String userId
            ) throws Exception {  
        Map<String,Object> resultMap = new LinkedHashMap<>(); 
        try {
            
            //---------------2 生成订单号 开始------------------------  
            //2.1.当前时间 yyyyMMddHHmmss  
            String currTime = TenpayUtil.getCurrTime();  
            //2.2 8位日期  
            String strTime = currTime.substring(8, currTime.length());  
            //2.3四位随机数  
            String strRandom = TenpayUtil.buildRandom(4) + "";  
            //2.4 10位序列号,可以自行调整。  
            String strReq = strTime + strRandom;  
            //2.5 订单号，此处用时间加随机数生成，商户根据自己情况调整，只要保持全局唯一就行  
            String out_trade_no = strReq;  
            //---------------生成订单号 结束 ------------------------  
            
            //3.获取生成预支付订单的请求类
            PrepayIdRequestHandler prepayReqHandler = new PrepayIdRequestHandler(request, response);
            
            //3.1封装数据
            String nonce_str = WXUtil.getNonceStr();        //订单号
            out_trade_no = String.valueOf(UUID.next());                
            String timestamp = WXUtil.getTimeStamp();        //超时时间
           
            //3.2---------------------------------------------- ***** 统一下单开始 *****  -----------------------------------------------------------
            prepayReqHandler.setParameter("appid",  ConstantUtil.APP_ID);                //平台应用appId
            prepayReqHandler.setParameter("mch_id", ConstantUtil.MCH_ID);                //商户号
            prepayReqHandler.setParameter("nonce_str", nonce_str);                        //随机字符串
            prepayReqHandler.setParameter("body",   ConstantUtil.BODY);                    //商品描述
            prepayReqHandler.setParameter("out_trade_no", out_trade_no);                //订单号
            prepayReqHandler.setParameter("total_fee",String.valueOf(totalPrice));        //订单价格
            prepayReqHandler.setParameter("spbill_create_ip", request.getRemoteAddr());    //获取客户端ip
            prepayReqHandler.setParameter("notify_url", ConstantUtil.NOTIFY_URL);        //回调通知
            prepayReqHandler.setParameter("trade_type", "APP");                            //支付类型
            prepayReqHandler.setParameter("time_start", timestamp);                        //时间戳
            prepayReqHandler.setGateUrl(ConstantUtil.GATEURL);                            //设置预支付id的接口url
           
            //3.3 注意签名（sign）的生成方式，具体见官方文档（传参都要参与生成签名，且参数名按照字典序排序，最后接上APP_KEY,转化成大写）
            prepayReqHandler.setParameter("sign", prepayReqHandler.createMD5Sign());    //sign 签名
            
            //3.4 提交预支付,获取prepayid 
            String prepayid = prepayReqHandler.sendPrepay();    
            //---------------------------------------------- ***** 统一下单 结束 *****  --------------------------------------------------------------
            
            //3.5 若获取prepayid成功，将相关信息返回客户端
            if (prepayid != null && !prepayid.equals("")) {
                                                
                
                 //---------------4.封装订单数据开始 ------------------------  
                                此处用于封装你自己实体类的订单信息
                                
                                例：Trade trade = new Trade();
                 
                 //---------------4.封装订单数据开始 ------------------------  
                
                String signs = 
                        "appid=" + ConstantUtil.APP_ID +
                        "&noncestr=" + nonce_str + 
                        "&package=Sign=WXPay"+ 
                        "&partnerid="+ ConstantUtil.PARTNER_ID + 
                        "&prepayid=" + prepayid + 
                        "&timestamp=" + timestamp+
                        "&key="+ ConstantUtil.APP_KEY;    
                
                resultMap.put("appid", ConstantUtil.APP_ID);
                resultMap.put("partnerid", ConstantUtil.PARTNER_ID);    //商家id
                resultMap.put("prepayid", prepayid);                    //预支付id
                resultMap.put("package", "Sign=WXPay");                  //固定常量
                resultMap.put("noncestr", nonce_str);                   //与请求prepayId时值一致
                resultMap.put("timestamp", timestamp);                  //等于请求prepayId时的time_start
                resultMap.put("sign", MD5Util.MD5Encode(signs, "utf8").toUpperCase());//签名方式与上面类似
                 model.addAttribute("orderNum", out_trade_no);
                 model.addAttribute("resultMap", resultMap);
                model.addAttribute("msg", "获取prepayid成功,生成订单成功");
                model.addAttribute("status",0);
            }else {
                model.addAttribute("msg", "获取prepayid失败");
                model.addAttribute("status",1);
            }
        } catch (Exception e) {
            model.addAttribute("msg", "订单生成失败");
            model.addAttribute("status",2);
        }
        return model;
    }
    
    /**
    * 9.2 接收微信支付成功通知
    * @param request
    * @param response
    * @throws IOException
     * @throws java.io.IOException 
     * @throws ParseException 
    */
    @RequestMapping(value = "api/weixin/notify")
    public void getnotify(HttpServletRequest request, HttpServletResponse response)
           throws IOException, ParseException {
         System.err.println("微信支付回调");
         System.err.println("微信支付回调");
         //1.创建输入输出流
         PrintWriter writer = response.getWriter();
         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();
            //2.将结果转换
            String result = new String(outSteam.toByteArray(), "utf-8");
            System.out.println("微信支付通知结果：" + result);
            Map<String, String> map = null;
            try {
                //3.解析微信通知返回的信息
                map = XMLUtil.doXMLParse(result);
                System.err.println(map);
            } catch (JDOMException e) {
                e.printStackTrace();
            }
            // 4.若支付成功，则告知微信服务器收到通知
            if (map.get("return_code").equals("SUCCESS")) {
                if (map.get("result_code").equals("SUCCESS")) {
                    System.out.println("充值成功！");
                    //4.1 修改当前订单状态为:付款成功 2
                    System.err.println("交易号："+Long.valueOf(map.get("out_trade_no")));
                   // Trade trade = tradeservice.selectByOrderNumber((String)(map.get("out_trade_no")));
                    Trade trade = tradeservice.selectByTradeNumber((String)(map.get("out_trade_no")));
                    if(trade !=null){
                          trade.setTradeType((byte)2);                                        //设置状态
                          trade.setPaymentTime(new Date());
                          trade.setPayTime(new Date());
                          if(tradeservice.updateByPrimaryKeySelective(trade) > 0){
                              //更新成功
                              System.err.println("通知微信后台");
                              String notifyStr = XMLUtil.setXML("SUCCESS", "");
                              writer.write(notifyStr);
                              writer.flush();
                          }
                    }else{
                         String notifyStr = XMLUtil.setXML("ERROR", "");
                          writer.write(notifyStr);
                          writer.flush();
                    }
                }
            }    
    }
   
    /**
    *微信支付成功后.通知页面
    *@author Zhao
    *@date 2017年11月2日
    *@param request
    *@return
    *@throws UnsupportedEncodingException
     */
    @RequestMapping(value="api/weixin/return",method={RequestMethod.POST,RequestMethod.GET})
    @ResponseBody
    public Model returnUrl(@RequestParam("id") String id,HttpServletRequest request,Model model) throws UnsupportedEncodingException {  
        System.err.println("。。。。。。 微信同步通知 。。。。。。");
        System.err.println("。。。。。。 微信同步通知 。。。。。。");
        System.err.println("。。。。。。 微信同步通知 。。。。。。");
        Map  returnMap = new HashMap();  
        try {
            
            Trade trade = tradeservice.selectByTradeNumber(id);
             // 返回值Map  
            if(trade !=null && trade.getTradeStatus() == 2){
                257                 User user = userService.selectByPrimaryKey(trade.gettUserId());
                returnMap.put("tradeType", trade.getTradeType()); //支付方式
                returnMap.put("phoneNum", user.getPhoneNumber()); //支付帐号
                returnMap.put("tradeMoney", trade.getTradeMoney()+""); //订单金额
            }else{
                 model.addAttribute("msg", "查询失败");
                 model.addAttribute("status", 0);
            }
             model.addAttribute("returnMap", returnMap);
             System.err.println(returnMap);
             model.addAttribute("msg", "查询成功");
             model.addAttribute("status", 0);
        } catch (Exception e) {
            model.addAttribute("msg", "查询失败");
            model.addAttribute("status", 1);
        }
         
         return model;  
    }
}

　　2.微信的支付注意事项

　　　　1.在第1个接口中,生成订单时,是签名2次,将数据返回给app端的,手机端可以直接用来向微信发起支付

　　　　2.第2个接口是app端支付成功后,微信的服务器需要回调你的这个接口,所以这个接口的地址要公网可以测,具体见上一篇的支付宝支付中的(nei wang chuan tou),这里

　　　还可能出现验签失败等情况,微信特别坑,就返回 -1,然后就没有提示信息了,所以希望看官不要急,先去查找一下自己的参数有没有问题,必要时可以一个一个对一遍,避免因 

　　　为不认真造成失误。

　　　　3.第3个接口是在第2个接口返回给微信服务器信息后(这个信息是确认我确实收到钱了)，手机端支付成功后跳转页面时所需要的数据，这个接口根据自己的业务需要把

　　　数据返回给手机端即可。

四.测试

　　微信支付在app端支付成功后，要调用异步通知，微信官方并未提供沙箱环境，因此需要访问的url必须是外网可以访问的，在这里推荐一款内网穿透工具natapp,需要用身份证号验证，测试个支付是没问题的

　　 附：

　　　　1. natapp官网: https://natapp.cn

　　　　2.natapp 1分钟新手图文教程: https://natapp.cn/article/natapp_newbie

 

　　由于本人能力水平有限，理解能为一般，有不当之处，请名位看官批评指正！！！