java --微信支付

如下是微信支付工具类

package com.readygo.pet.utils;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;import java.io.InputStreamReader;
import java.security.KeyStore;
import java.security.MessageDigest;
import java.text.SimpleDateFormat;

import javax.net.ssl.SSLContext;
import javax.servlet.http.HttpServletRequest;
import org.springframework.util.StringUtils;
import java.util.*;

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.conn.ssl.SSLContexts;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;

/** * 程序名 :WXPayUtils.java * 程序功能 :微信支付工具类 * 作成者 :xx * 作成日期 :2016-04-27 * 修改履历 * 项目名 状态 作成者 作成日期 * ----------------------------------- * pets 新规 xx 2016-04-27 */
public class WXPayUtils {

    /** 微信支付预支付单失败 */
    public static final String MSG_WXPAY_ORDER_FAILED = "微信支付连接失败，请检查网络。";
    /** 微信支付失败 */
    public static final String MSG_WXPAY_PAY_FAILED = "微信支付付款失败。";
    /** 微信支付查询 */
    public static final String MSG_WXPAY_SEARCH_FAILED = "微信支付付款失败。";
    /** 微信支付关闭失败 */
    public static final String MSG_WXPAY_CLOSE_FAILED = "支付订单关闭失败。";

    public static final String SunX509 = "SunX509";
    public static final String JKS = "JKS";
    public static final String PKCS12 = "PKCS12";
    public static final String TLS = "TLS";

    /** * 采番表对象枚举 */
    public enum TableType {
        T_WXPAY_ORDER_RECORD("WX_PAY_ORDER_RECORD_ID"), // 微信预支付订单记录表
        T_WXPAY_RECORD("WX_PAY_RECORD_ID"), // 微信支付记录表
        T_WXPAY_CLOSE_RECORD("WX_PAY_CLOSE_RECORD_ID"), // 微信支付订单关闭记录表
        T_WXPAY_REFUND_RECORD("WX_PAY_REFUND_RECORD_ID"); // 微信退款订单记录表

        private String type;

        private TableType(String type) {
            this.type = type;
        }

        public String getType() {
            return this.type;
        }
    }

    /** * 错误码枚举 **/
    public enum ResultCode {
        SUCCESS(0), // 成功
        FAILED(1), // 失败
        SUCCESS_UPLOADIMG(2);// 评论成功，上传图片失败

        private int type;

        private ResultCode(Integer type) {
            this.type = type;
        }

        public Integer getType() {
            return this.type;
        }
    }

    /** * 获取系统时间 * * @return 系统时间(格式为：yyyyMMddHHmmss) */
    public static String getSysTime() {
        SimpleDateFormat df = new SimpleDateFormat("yyyyMMddHHmmss");
        Date curDate = new Date();// 获取当前时间
        String str = df.format(curDate);
        return str;
    }

    /** * 获取ip地址 * * @param request * 请求包 * @return 本次请求的ip地址 */
    public static String getIpAddr(HttpServletRequest request) {
        String ip = request.getHeader("x-forwarded-for");
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("Proxy-Client-IP");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("WL-Proxy-Client-IP");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("HTTP_CLIENT_IP");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("HTTP_X_FORWARDED_FOR");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getRemoteAddr();
        }
        return ip;
    }

    /** * 对象转XML字符串 * 扩展xstream使其支持CDATA * * @param pi * 微信发起支付订单参数 * @return xml字符串 * */
    /* * public static String payInfoToXML(WXPayParam pi) { xstream.alias("xml", * pi.getClass()); return xstream.toXML(pi); } * * private static XStream xstream = new XStream(new XppDriver() { public * HierarchicalStreamWriter createWriter(Writer out) { return new * PrettyPrintWriter(out) { // 增加CDATA标记 boolean cdata = true; * * @SuppressWarnings("rawtypes") public void startNode(String name, Class * clazz) { super.startNode(name, clazz); } * * protected void writeText(QuickWriter writer, String text) { if (cdata) { * writer.write("<![CDATA["); writer.write(text); writer.write("]]>"); } * else { writer.write(text); } } }; } }); */

    /** * MAP转XML * * @param vo * 参数map * @param rootElement * 根节点 * @return xml字符串 */
    public static String map2xmlBody(Map<String, Object> vo, String rootElement) {
        org.dom4j.Document doc = DocumentHelper.createDocument();
        Element body = DocumentHelper.createElement(rootElement);
        doc.add(body);
        __buildMap2xmlBody(body, vo);
        return doc.asXML();
    }

    @SuppressWarnings("unchecked")
    private static void __buildMap2xmlBody(Element body, Map<String, Object> vo) {
        if (vo != null) {
            Iterator<String> it = vo.keySet().iterator();
            while (it.hasNext()) {
                String key = (String) it.next();
                if (!StringUtils.isEmpty(key)) {
                    Object obj = vo.get(key);
                    Element element = DocumentHelper.createElement(key);
                    if (obj != null) {
                        if (obj instanceof java.lang.String) {
                            element.setText((String) obj);
                        } else {
                            if (obj instanceof java.lang.Character || obj instanceof java.lang.Boolean
                                    || obj instanceof java.lang.Number || obj instanceof java.math.BigInteger
                                    || obj instanceof java.math.BigDecimal) {
                                org.dom4j.Attribute attr = DocumentHelper.createAttribute(element, "type",
                                        obj.getClass().getCanonicalName());
                                element.add(attr);
                                element.setText(String.valueOf(obj));
                            } else if (obj instanceof java.util.Map) {
                                org.dom4j.Attribute attr = DocumentHelper.createAttribute(element, "type",
                                        java.util.Map.class.getCanonicalName());
                                element.add(attr);
                                __buildMap2xmlBody(element, (Map<String, Object>) obj);
                            } else {
                            }
                        }
                    }
                    body.add(element);
                }
            }
        }
    }

    /** * XML转MAP * * @param xml * xml字符串 * @return map */
    @SuppressWarnings("unchecked")
    public static SortedMap<String, String> parseXml(String xml) throws Exception {
        SortedMap<String, String> map = new TreeMap<String, String>();
        if (!StringUtils.isEmpty(xml)) {
            Document document = DocumentHelper.parseText(xml);
            Element root = document.getRootElement();
            List<Element> elementList = root.elements();
            for (Element e : elementList) {
                map.put(e.getName(), e.getText());
            }
        }
        return map;
    }

    /** * 生成签名 * * @param charaterEncodeing * 编码格式 * @param parameters * 请求参数(按ascii排序后) * @param apiKey * 商户支付秘钥 * @return */
    @SuppressWarnings("rawtypes")
    public static String createSign(String charaterEncodeing, SortedMap<String, Object> parameters, String apiKey)
            throws Exception {
        StringBuffer sb = new StringBuffer();
        Set es = parameters.entrySet();
        Iterator it = es.iterator();
        while (it.hasNext()) {
            Map.Entry entry = (Map.Entry) it.next();
            String k = (String) entry.getKey();
            Object v = entry.getValue();
            if (!StringUtils.isEmpty(v) && !"sing".equals(k) && !"key".equals(k)) {
                sb.append(k + "=" + v + "&");
            }

        }
        System.out.println("生成字符串：" + sb.toString());
        sb.append("key=" + apiKey);
        System.out.println("连接商户key字符串：" + sb.toString());
        String sign = MD5Encode(sb.toString(), charaterEncodeing).toUpperCase();
        return sign;
    }

    /** ----------------MD5相关方法--------------------- */
    private static final String hexDigits[] = { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d",
            "e", "f" };

    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];
    }

    private static String byteArrayToHexString(byte b[]) {
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < b.length; i++) {
            sb.append(byteToHexString(b[i]));
        }

        return sb.toString();
    }

    /** * MD5加密 * * @param origin * 加密串 * @param charsetname * 编码格式(UTF-8) * @return 加密后字符串 * @throws Exception */
    public static String MD5Encode(String origin, String charsetname) throws Exception {
        String resultString = null;
        resultString = new String(origin);

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

        if (StringUtils.isEmpty(charsetname)) {
            resultString = byteArrayToHexString(md.digest(resultString.getBytes()));
        } else {
            resultString = byteArrayToHexString(md.digest(resultString.getBytes(charsetname)));
        }

        return resultString;

    }

    /** ----------------MD5相关方法--------------------- */

    /** * 生成指定长度的随机字符串（英数字） * * @param length * 生成字符串的长度 * @return 随机字符串 */
    public static String getRandomString(int length) {
        String base = "abcdefghijklmnopqrstuvwxyz0123456789";
        Random random = new Random();
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < length; i++) {
            int number = random.nextInt(base.length());
            sb.append(base.charAt(number));
        }
        return sb.toString();
    }

    /** * 带证书的HTTPS请求 * * @param requestURL * 请求地址 * @param outputStr * 请求参数 * @param certPath * 证书本地路径 * @param keyPasswd * 私密密码 * @return 请求结果 * @throws Exception * */
    public static String httpsRequestWithCert(String requestURL, String outputStr, String certPath, String keyPasswd)
            throws Exception {

        StringBuffer buffer = new StringBuffer();

        // P12私密
        FileInputStream keyFileInputStream = new FileInputStream(new File(certPath));
        final char[] kp = keyPasswd.toCharArray();
        KeyStore ks = KeyStore.getInstance(PKCS12);
        ks.load(keyFileInputStream, kp);
        keyFileInputStream.close();

        // 相信自己的CA和所有自签名的证书
        SSLContext sslcontext = SSLContexts.custom().loadKeyMaterial(ks, kp).build();

        // 只允许使用TLSv1协议
        SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(sslcontext, new String[] { "TLSv1" }, null,
                SSLConnectionSocketFactory.BROWSER_COMPATIBLE_HOSTNAME_VERIFIER);

        CloseableHttpClient httpclient = HttpClients.custom().setSSLSocketFactory(sslsf).build();
        // 创建http请求(post方式)
        HttpPost httpPost = new HttpPost(requestURL);

        System.out.println("executing request" + httpPost.getRequestLine());

        StringEntity reqEntity = new StringEntity(outputStr);
        // 设置类型
        reqEntity.setContentType("application/x-www-form-urlencoded");
        httpPost.setEntity(reqEntity);
        // 进行访问并获取返回
        CloseableHttpResponse response = httpclient.execute(httpPost);

        // 获取返回内容
        HttpEntity entity = response.getEntity();
        if (entity != null) {
            System.out.println("Response content length: " + entity.getContentLength());

            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(entity.getContent(), "UTF-8"));
            String str = null;

            while ((str = bufferedReader.readLine()) != null) {
                buffer.append(str);
            }
            bufferedReader.close();
        }
        // 关闭应该关闭的资源
        EntityUtils.consume(entity);
        response.close();
        httpclient.close();

        return buffer.toString();
    }
}