JAVA微信支付 实现服务端返回预付单号和签名

最新推荐文章于 2022-07-19 15:51:56 发布
最新推荐文章于 2022-07-19 15:51:56 发布
阅读量6.4k 收藏 9
点赞数 2
分类专栏： springmvc 微信支付 httpClient 文章标签： 微信 支付 xml
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014535678/article/details/49688413
版权 
package com.jade.laiding.client.util;

import java.util.*;

import com.jade.laiding.order.order.Order;
import org.apache.commons.lang3.StringUtils;
import org.apache.http.NameValuePair;
import org.apache.http.message.BasicNameValuePair;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;

import javax.servlet.http.HttpServletRequest;

/**
 * Created by tusm on 公元15-10-27.
 */
public class WeChatPayUtil {

    private static final String WeChat_APP_ID="#####################";
    private static final String WeChat_MCH_ID="#####################";
    private static final String WeChat_API_KEY="####################";


    //微信支付第一步，先从微信的服务器获取prepayId
    public static String getPrepayId(String url,Order order){
        Map<String,String> xml=new HashMap<String,String>();
        String prePayId = "";

        if(order != null){
            String entity = genProductArgs(order);
            byte[] buf = Util.httpPost(url, entity);
            if(buf != null){

                String content = new String(buf);
                //Log.e("orion", content);
                try {
                    Document doc = (Document)DocumentHelper.parseText(content);
                    Element root = doc.getRootElement();
                    List<Element> list = root.elements();
                    for (Element e : list) {
                        xml.put(e.getName(), e.getText());
                    }
                } catch (DocumentException e) {
                    e.printStackTrace();
                }
                if(xml != null){
                    prePayId = xml.get("prepay_id");
                    return prePayId;
                }
            }
        }

        return null;
    }



    //第二步，根据prepayId生成签名参数
    public static PayReq genPayReq(PayReq req,String prePayId) {
        req.setAppId(WeChatPayUtil.WeChat_APP_ID);
        req.setPartnerId(WeChatPayUtil.WeChat_MCH_ID);
        req.setPrepayId(prePayId);
        req.setPackageValue("Sign=WXPay");
        req.setNonceStr(genNonceStr());
        req.setTimeStamp(String.valueOf(genTimeStamp()));


        List<NameValuePair> signParams = new LinkedList<NameValuePair>();
        signParams.add(new BasicNameValuePair("appid", req.getAppId()));
        signParams.add(new BasicNameValuePair("noncestr", req.getNonceStr()));
        signParams.add(new BasicNameValuePair("package",req.getPackageValue()));
        signParams.add(new BasicNameValuePair("partnerid",req.getPartnerId()));
        signParams.add(new BasicNameValuePair("prepayid",req.getPrepayId()));
        signParams.add(new BasicNameValuePair("timestamp", req.getTimeStamp()));

        req.setSign(genAppSign(signParams));

        return req;
        //Log.i("orion", signParams.toString());

    }

    //第三步，调用支付接口支付
   /* public static void Pay(IWXAPI msgApi,PayReq req){
            msgApi.sendReq(req);
    }*/


    /**
     * 拼接参数
     * @param order
     * @return
     */
    private static String genProductArgs(Order order) {
        StringBuffer xml = new StringBuffer();
        try {
            String	nonceStr = genNonceStr();

            xml.append("</xml>");
            List<NameValuePair> packageParams = new LinkedList<NameValuePair>();
            packageParams.add(new BasicNameValuePair("appid", WeChatPayUtil.WeChat_APP_ID));
            packageParams.add(new BasicNameValuePair("body", "测试"));//商品描述，商品或支付单简要描述，必填
            packageParams.add(new BasicNameValuePair("mch_id", WeChatPayUtil.WeChat_MCH_ID));
            packageParams.add(new BasicNameValuePair("nonce_str", nonceStr));//随机字符串，不长于32位。必填
            packageParams.add(new BasicNameValuePair("notify_url", "http://外网IP:8182/client/order/editOrderWxPayStatus"));//接收微信支付异步通知回调地址.必填
            packageParams.add(new BasicNameValuePair("out_trade_no",order.getId()+""));//商户系统内部的订单号,32个字符内、可包含字母,必填
            packageParams.add(new BasicNameValuePair("spbill_create_ip",order.getIp()));//APP和网页支付提交用户端ip.必填
            packageParams.add(new BasicNameValuePair("total_fee", (int)(order.getFinalAmount()*100)+""));//订单总金额，只能为整数.必填
            packageParams.add(new BasicNameValuePair("trade_type", "APP"));//取值如下：JSAPI，NATIVE，APP，WAP,必填


            String sign = genPackageSign(packageParams);
            packageParams.add(new BasicNameValuePair("sign", sign));//签名


            String xmlstring =toXml(packageParams);

            xmlstring = new String(xmlstring.getBytes("UTF-8"), "ISO-8859-1");

            return xmlstring;

        } catch (Exception e) {
            //Log.e("e", "genProductArgs fail, ex = " + e.getMessage());
            return null;
        }
    }

    /**
     * 拼接异步通知成功通知微信参数
     * @return
     */
    public static String returnCodeSUCCESS() {
        StringBuffer xml = new StringBuffer();
        try {
            xml.append("</xml>");
            List<NameValuePair> packageParams = new LinkedList<NameValuePair>();
            packageParams.add(new BasicNameValuePair("return_code", "SUCCESS"));//SUCCESS表示商户接收通知成功并校验成功必填
            String xmlstring =toXml(packageParams);
            xmlstring = new String(xmlstring.getBytes("UTF-8"), "ISO-8859-1");
            return xmlstring;
        } catch (Exception e) {
            return null;
        }
    }

    /**
     * 拼接异步通知失败通知微信参数
     * @return
     */
    public static String returnCodeFAIL() {
        StringBuffer xml = new StringBuffer();
        try {
            xml.append("</xml>");
            List<NameValuePair> packageParams = new LinkedList<NameValuePair>();
            packageParams.add(new BasicNameValuePair("return_code", "FAIL"));//FAIL失败
            String xmlstring =toXml(packageParams);
            xmlstring = new String(xmlstring.getBytes("UTF-8"), "ISO-8859-1");
            return xmlstring;
        } catch (Exception e) {
            return null;
        }
    }




    /**
     生成签名
     */

    private static String genPackageSign(List<NameValuePair> params) {
        StringBuilder sb = new StringBuilder();

        for (int i = 0; i < params.size(); i++) {
            sb.append(params.get(i).getName());
            sb.append('=');
            sb.append(params.get(i).getValue());
            sb.append('&');
        }
        sb.append("key=");
        sb.append(WeChatPayUtil.WeChat_API_KEY);


        String packageSign = MD5.getMessageDigest(sb.toString().getBytes()).toUpperCase();
        //Log.e("orion",packageSign);
        return packageSign;
    }

    /**
     * 转换成String格式的xml
     * @param params
     * @return
     */
    private static String toXml(List<NameValuePair> params) {
        StringBuilder sb = new StringBuilder();
        sb.append("<xml>");
        for (int i = 0; i < params.size(); i++) {
            sb.append("<"+params.get(i).getName()+">");


            sb.append(params.get(i).getValue());
            sb.append("</"+params.get(i).getName()+">");
        }
        sb.append("</xml>");

        //Log.e("orion",sb.toString());
        return sb.toString();
    }

    /**
     * 生成有key的app签名
     * @param params
     * @return
     */
    private static String genAppSign(List<NameValuePair> params) {
        StringBuilder sb = new StringBuilder();

        for (int i = 0; i < params.size(); i++) {
            sb.append(params.get(i).getName());
            sb.append('=');
            sb.append(params.get(i).getValue());
            sb.append('&');
        }
        sb.append("key=");
        sb.append(WeChatPayUtil.WeChat_API_KEY);

        String appSign = MD5.getMessageDigest(sb.toString().getBytes()).toUpperCase();
        //Log.e("orion",appSign);
        return appSign;
    }

    /**
     * 时间戳
     * @return
     */
    private static long genTimeStamp() {
        return System.currentTimeMillis() / 1000;
    }

    /**
     * 随机字符串
     * @return
     */
    private static  String genNonceStr() {
        Random random = new Random();
        return MD5.getMessageDigest(String.valueOf(random.nextInt(10000)).getBytes());
    }

    public static String getIp2(HttpServletRequest request) {
        String ip = request.getHeader("X-Forwarded-For");
        if(StringUtils.isNotEmpty(ip) && !"unKnown".equalsIgnoreCase(ip)){
            //多次反向代理后会有多个ip值，第一个ip才是真实ip
            int index = ip.indexOf(",");
            if(index != -1){
                return ip.substring(0,index);
            }else{
                return ip;
            }
        }
        ip = request.getHeader("X-Real-IP");
        if(StringUtils.isNotEmpty(ip) && !"unKnown".equalsIgnoreCase(ip)){
            return ip;
        }
        return request.getRemoteAddr();
    }
}


有些类可能没用到的，看情况删掉，这段代码 我本人测试可用,大家只需要关注核心——怎么将string 类型的xml 参数封装成 entity，并且以 http请求post方式传递给微信服务端，然后使用Dom4j解析返回的XML,再封装成Map!


package com.jade.laiding.client.util;

import java.security.MessageDigest;

public class MD5 {

	private MD5() {}
	
	public final static String getMessageDigest(byte[] buffer) {
		char hexDigits[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
		try {
			MessageDigest mdTemp = MessageDigest.getInstance("MD5");
			mdTemp.update(buffer);
			byte[] md = mdTemp.digest();
			int j = md.length;
			char str[] = new char[j * 2];
			int k = 0;
			for (int i = 0; i < j; i++) {
				byte byte0 = md[i];
				str[k++] = hexDigits[byte0 >>> 4 & 0xf];
				str[k++] = hexDigits[byte0 & 0xf];
			}
			return new String(str);
		} catch (Exception e) {
			return null;
		}
	}
}


package com.jade.laiding.client.util;

import java.security.MessageDigest;

public class MD5Util {

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

}


package com.jade.laiding.client.util;

/**
 * @author <a href="mailto:haoran.zhang@basung.com">zhanghaoran</a>
 * @version 1.0
 * @date 15/10/29 上午11:22
 * 支付请求辅助类,这个类本来应该是Jar自带的功能，结果我没找到Jar，所以自己新建了这个辅助类，只是为了存数据而已<pre name="code" class="java">package com.jade.laiding.client.util;

import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;
import org.apache.http.HttpVersion;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.conn.ClientConnectionManager;
import org.apache.http.conn.scheme.PlainSocketFactory;
import org.apache.http.conn.scheme.Scheme;
import org.apache.http.conn.scheme.SchemeRegistry;
import org.apache.http.conn.ssl.SSLSocketFactory;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.impl.conn.tsccm.ThreadSafeClientConnManager;
import org.apache.http.params.BasicHttpParams;
import org.apache.http.params.HttpParams;
import org.apache.http.params.HttpProtocolParams;
import org.apache.http.protocol.HTTP;
import org.apache.http.util.EntityUtils;

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.net.Socket;
import java.net.UnknownHostException;
import java.security.KeyManagementException;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.UnrecoverableKeyException;
import java.security.cert.X509Certificate;
import java.util.ArrayList;
import java.util.List;

import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;

public class Util {
	
	private static final String TAG = "SDK_Sample.Util";


	public static byte[] httpGet(final String url) {
		if (url == null || url.length() == 0) {
			//Log.e(TAG, "httpGet, url is null");
			return null;
		}

		HttpClient httpClient = getNewHttpClient();
		HttpGet httpGet = new HttpGet(url);

		try {
			HttpResponse resp = httpClient.execute(httpGet);
			if (resp.getStatusLine().getStatusCode() != HttpStatus.SC_OK) {
				//Log.e(TAG, "httpGet fail, status code = " + resp.getStatusLine().getStatusCode());
				return null;
			}

			return EntityUtils.toByteArray(resp.getEntity());

		} catch (Exception e) {
			//Log.e(TAG, "httpGet exception, e = " + e.getMessage());
			e.printStackTrace();
			return null;
		}
	}
	
	public static byte[] httpPost(String url, String entity) {
		if (url == null || url.length() == 0) {
			//Log.e(TAG, "httpPost, url is null");
			return null;
		}
		
		HttpClient httpClient = getNewHttpClient();
		
		HttpPost httpPost = new HttpPost(url);
		
		try {
			httpPost.setEntity(new StringEntity(entity));
			httpPost.setHeader("Accept", "application/json");
			httpPost.setHeader("Content-type", "application/json");

			HttpResponse resp = httpClient.execute(httpPost);
			if (resp.getStatusLine().getStatusCode() != HttpStatus.SC_OK) {
				//Log.e(TAG, "httpGet fail, status code = " + resp.getStatusLine().getStatusCode());
				return null;
			}

			return EntityUtils.toByteArray(resp.getEntity());
		} catch (Exception e) {
			//Log.e(TAG, "httpPost exception, e = " + e.getMessage());
			e.printStackTrace();
			return null;
		}
	}
	
	private static class SSLSocketFactoryEx extends SSLSocketFactory {      
	      
	    SSLContext sslContext = SSLContext.getInstance("TLS");      
	      
	    public SSLSocketFactoryEx(KeyStore truststore) throws NoSuchAlgorithmException, KeyManagementException, KeyStoreException, UnrecoverableKeyException {      
	        super(truststore);      
	      
	        TrustManager tm = new X509TrustManager() {      
	      
	            public X509Certificate[] getAcceptedIssuers() {      
	                return null;      
	            }      
	      

				public void checkClientTrusted(X509Certificate[] chain, String authType) throws java.security.cert.CertificateException {
				}


				public void checkServerTrusted(X509Certificate[] chain,	String authType) throws java.security.cert.CertificateException {
				}  
	        };      
	      
	        sslContext.init(null, new TrustManager[] { tm }, null);      
	    }      
	      
		@Override
		public Socket createSocket(Socket socket, String host, int port, boolean autoClose) throws IOException, UnknownHostException {
			return sslContext.getSocketFactory().createSocket(socket, host,	port, autoClose);
		}

		@Override
		public Socket createSocket() throws IOException {
			return sslContext.getSocketFactory().createSocket();
		} 
	}  

	private static HttpClient getNewHttpClient() { 
	   try { 
	       KeyStore trustStore = KeyStore.getInstance(KeyStore.getDefaultType()); 
	       trustStore.load(null, null); 

	       SSLSocketFactory sf = new SSLSocketFactoryEx(trustStore); 
	       sf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER); 

	       HttpParams params = new BasicHttpParams(); 
	       HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1); 
	       HttpProtocolParams.setContentCharset(params, HTTP.UTF_8); 

	       SchemeRegistry registry = new SchemeRegistry(); 
	       registry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
	       registry.register(new Scheme("https", sf, 443));

	       ClientConnectionManager ccm = new ThreadSafeClientConnManager(params, registry);

	       return new DefaultHttpClient(ccm, params); 
	   } catch (Exception e) { 
	       return new DefaultHttpClient(); 
	   } 
	}
	
	public static byte[] readFromFile(String fileName, int offset, int len) {
		if (fileName == null) {
			return null;
		}

		File file = new File(fileName);
		if (!file.exists()) {
			//Log.i(TAG, "readFromFile: file not found");
			return null;
		}

		if (len == -1) {
			len = (int) file.length();
		}

		//Log.d(TAG, "readFromFile : offset = " + offset + " len = " + len + " offset + len = " + (offset + len));

		if(offset <0){
			//Log.e(TAG, "readFromFile invalid offset:" + offset);
			return null;
		}
		if(len <=0 ){
			//Log.e(TAG, "readFromFile invalid len:" + len);
			return null;
		}
		if(offset + len > (int) file.length()){
			//Log.e(TAG, "readFromFile invalid file len:" + file.length());
			return null;
		}

		byte[] b = null;
		try {
			RandomAccessFile in = new RandomAccessFile(fileName, "r");
			b = new byte[len]; // ´´½¨ºÏÊÊÎļþ´óСµÄÊý×é
			in.seek(offset);
			in.readFully(b);
			in.close();

		} catch (Exception e) {
			//Log.e(TAG, "readFromFile : errMsg = " + e.getMessage());
			e.printStackTrace();
		}
		return b;
	}

	
	public static String sha1(String str) {
		if (str == null || str.length() == 0) {
			return null;
		}
		
		char hexDigits[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
		
		try {
			MessageDigest mdTemp = MessageDigest.getInstance("SHA1");
			mdTemp.update(str.getBytes());
			
			byte[] md = mdTemp.digest();
			int j = md.length;
			char buf[] = new char[j * 2];
			int k = 0;
			for (int i = 0; i < j; i++) {
				byte byte0 = md[i];
				buf[k++] = hexDigits[byte0 >>> 4 & 0xf];
				buf[k++] = hexDigits[byte0 & 0xf];
			}
			return new String(buf);
		} catch (Exception e) {
			return null;
		}
	}
	
	public static List<String> stringsToList(final String[] src) {
		if (src == null || src.length == 0) {
			return null;
		}
		final List<String> result = new ArrayList<String>();
		for (int i = 0; i < src.length; i++) {
			result.add(src[i]);
		}
		return result;
	}
}

 

 

 

 

package com.jade.laiding.client.util;

import java.util.List;

/**
 * @author <a href="mailto:haoran.zhang@basung.com">zhanghaoran</a>
 * @version 1.0
 * @date 15/10/29 下午1:20
 * 微信支付辅助类
 */
public class WxPay {

    private List<Long> idList;
    private long paymentId;

    public List<Long> getIdList() {
        return idList;
    }

    public void setIdList(List<Long> idList) {
        this.idList = idList;
    }

    public long getPaymentId() {
        return paymentId;
    }

    public void setPaymentId(long paymentId) {
        this.paymentId = paymentId;
    }
}

 

 

 

 

 


 

 /**
     * @api {post} /order/editOrderPayStatus 修改订单支付状态(支付宝)
     * @apiName editOrderPayStatus API
     * @apiGroup Order
     * @apiDescription 修改订单支付状态(支付宝)
     * @apiVersion 0.1.0
     * @apiParam {String} id 订单编号.
     * @apiParam {String} orderStatus 订单状态
     * @apiParam {String} PayStatus 支付状态 Paying,Paied,PartPaied,PartRefund,Refund
     * @apiParam {String} ShipStatus  Pending("0"),Shipped("1"),PartPending("2"),PartShipped("3"),Returned("4")
     */
    @RequestMapping(value = "/editOrderPayStatus", method = RequestMethod.POST)
    public @ResponseBody DisplayData editOrderPayStatus(HttpServletRequest request,HttpServletResponse response) {
        Order oldorder = null;
        try {
            String trade_status=request.getParameter("trade_status");//交易状态
            Long trade_no=Long.parseLong(request.getParameter("out_trade_no"));//交易订单号
            float total_fee=Float.parseFloat(request.getParameter("total_fee"));//订单总金额
            oldorder=orderManager.get(Order.class,trade_no);
            float FinalAmount=oldorder.getFinalAmount();//数据库订单金额
            if("TRADE_SUCCESS".equals(trade_status)&&trade_status!=null){
                if(null!=oldorder){
                    if(total_fee==FinalAmount){
                        //待支付订单状态条件
                        if ((oldorder.getOrderStatus() == OrderStatus.Active) && (oldorder.getPayStatus() == PayStatus.Paying || oldorder.getPayStatus() == PayStatus.PartPaied) && (oldorder.getShipStatus() == ShipStatus.Pending)) {
                            oldorder.setOrderStatus(OrderStatus.Active);//已支付
                            oldorder.setPayStatus(PayStatus.Paied);
                            oldorder.setShipStatus(oldorder.getShipStatus());
                            orderManager.update(oldorder);
                            response.getWriter().println("success");	//请不要修改或删除
                        }
                    }else{
                        response.getWriter().println("fail");//请不要修改或删除
                    }
                }
            }else{
                response.getWriter().println("fail");//请不要修改或删除
            }
            return new DisplayData(request,StatusCode.SUCCESS,"inf.jade.bss.commons.success",oldorder);
        } catch (Exception e) {
            return new DisplayData(request, StatusCode.FAIL,e.getMessage());
        }
    }



    /**
     * @api {post} /order/editOrderWxPayStatus 修改订单支付状态(微信)
     * @apiName editOrderWxPayStatus API
     * @apiGroup Order
     * @apiDescription 修改订单支付状态(微信)
     * @apiVersion 0.1.0
     * @apiParam {String} id 订单编号.
     * @apiParam {String} orderStatus 订单状态
     * @apiParam {String} PayStatus 支付状态 Paying,Paied,PartPaied,PartRefund,Refund
     * @apiParam {String} ShipStatus  Pending("0"),Shipped("1"),PartPending("2"),PartShipped("3"),Returned("4")
     */
    @RequestMapping(value = "/editOrderWxPayStatus", method = RequestMethod.POST)
    public @ResponseBody DisplayData editOrderWxPayStatus(HttpServletRequest request,HttpServletResponse response) {
        Order oldorder = null;
        try {
                // 将解析结果存储在HashMap中
                Map map = new HashMap();
                // 从request中取得输入流
                InputStream inputStream = request.getInputStream();
                // 读取输入流
                SAXReader reader = new SAXReader();
                Document document =reader.read(inputStream);
                // 得到xml根元素
                Element root = document.getRootElement();
                // 得到根元素的所有子节点
                List<Element> list = root.elements();
                // 遍历所有子节点
                for (Element e : list){
                    map.put(e.getName(), e.getText());
                }
                inputStream.close();
                inputStream=null;
                if("SUCCESS".equals(map.get("result_code"))){
                    Long trade_no=Long.parseLong(map.get("out_trade_no").toString());//订单号
                    float total_fee=Float.parseFloat(map.get("total_fee").toString());//订单金额
                    oldorder=orderManager.get(Order.class,trade_no);
                    float FinalAmount=oldorder.getFinalAmount();//数据库订单金额
                    if(null!=oldorder){
                        if((total_fee/100)==FinalAmount){
                            //待支付订单状态条件
                            if ((oldorder.getOrderStatus() == OrderStatus.Active) && (oldorder.getPayStatus() == PayStatus.Paying || oldorder.getPayStatus() == PayStatus.PartPaied) && (oldorder.getShipStatus() == ShipStatus.Pending)) {
                                oldorder.setOrderStatus(OrderStatus.Active);//已支付
                                oldorder.setPayStatus(PayStatus.Paied);
                                oldorder.setShipStatus(oldorder.getShipStatus());
                                orderManager.update(oldorder);
                                String entity = WeChatPayUtil.returnCodeSUCCESS();
                                response.getWriter().println(entity);	//请不要修改或删除
                                //return entity;
                            }else{
                                String entity = WeChatPayUtil.returnCodeFAIL();
                                response.getWriter().println(entity);	//请不要修改或删除
                                //return entity;
                            }

                        }
                    }else{
                        String entity = WeChatPayUtil.returnCodeFAIL();
                        response.getWriter().println(entity);	//请不要修改或删除
                        //return entity;
                    }
                }
        } catch (Exception e) {
            return new DisplayData(request, StatusCode.FAIL,e.getMessage());
        }
        return new DisplayData(request,StatusCode.SUCCESS,"inf.jade.bss.commons.success",oldorder);
    }

 


 
 

 

 
 

如果使用我以上代码在centos6.5系统报如下错误，
 

 
 

请不要用系统自带的openJDK，自己下载在oracle的JDK安装并配置环境，重启 OK~~
 

上面还少了一步验证签名的过程，异步回调result_code 是SUCCESS，则开始验证签名，验签成功，修改订单状态为已支付

                

        

        

    




    

      

        

            

              
                
                  不会编程的小菜
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                    2
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    9
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                  2
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      

            

                专栏目录
          










                



	

		

			

				
					
java微信支付 openid_微信支付之获取openid

				
			

			

				

					weixin_39814482的博客
				

				

					02-13
					
					830
					
				

			

		

		

			
				
2.文档阅读接着阅读文档我们可以发现网页授权有两种scope,snsapi_base和snsapi_userinfo。两种scope都可以获取到opeid，不同的是snsapi_userinfo除了openid外还可以获取到用户的基本信息，但是需要用户手动进行确认。再往下阅读我们可以看到官方文档的授权步骤第一步：用户同意授权，获取code第二步：通过code换取网页授权access_token以及...

			
		

	



                

              
                



	

		

			

				
					
java中微信小程序统一下单签名错误

				
			

			

				

					小四是个程序猿的博客
				

				

					08-06
					
					738
					
				

			

		

		

			
				
微信小程序支付是JSAPI支付，这里有很多坑。
微信小程序统一下单是需要生成两次sign的。这里就很坑。
还有一个坑是第二次生成的时候appId的i要大写，第一次小写。
代码：
/**
     * @author Abell
     * @descibe 统一下单
     * @date 2020/8/6 12:50
     */
    @PostMapping(value = "/unifiedOrder", produces = "application/json;charset=utf-8"

			
		

	



                


  
              

                


	

		

			

				
					
JAVA版 微信支付 获取预支付id 14年11月18日最新版本

				
			

			

				

					11-18
				

			

		

		

			
				
截止到 当前时间 2014年11月18日 ，我在网上找到很多个关于获取微信获取预支付的问题，都不能解决我的问题，首先是微信支付，版本分歧很多，并且给的DEMO没有java版本的，文档写得很烂，经过了3天的努力，发现了很多坑，以为很容易的一件事情，搞了3天浪费时间，最后自己研究出来了，得到的一个单类，简单易懂的获取 微信预支付id ，我的CSDN没有分了，所以开价6分，希望给点支持，肯定值这个分，有问题 happyyou2009@gmail.com邮件我
注明：里边使用到的 httpclient是 

  <dependency>
            <groupId>org.jsoup</groupId>
            <artifactId>jsoup</artifactId>
            <version>1.7.2</version>
        </dependency>

     <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
            <version>4.3.6</version>
        </dependency>

httpClient是 4.3.6我把 maven贴出来了，方便大家看，

			
		

	





	

		

			

				
					
Java中的微信支付: 微信API-V3签名生成工具类

				
			

			

				

					qq_43097257的博客
				

				

					08-11
					
					3805
					
				

			

		

		

			
				
微信支付API v3简介
微信官方文档地址
为了在 保证支付 安全的前提下，带给商户 简单、一致且易用的开发体验，我们推出了全新的微信支付API v3。
相较于之前的微信支付API，主要区别是：

遵循统一的REST ful的设计风格
使用JSON作为数据交互的格式，不再使用XML
使用基于非对称密钥的SHA256-RSA的数字签名算法，不再使用MD5或HMAC-SHA256
不再要求HTTPS客户端证书
使用AES-256-GCM，对回调中的关键信息进行加密保护
在接口规则中，你将了解到微信支付API v

			
		

	



		

			
		



	

		

			

				
					
微信小程序支付（Java）

				
			

			

				

					大道至简
				

				

					04-12
					
					6230
					
				

			

		

		

			
				
相信进行过微信公众号支付的同学对于微信小程序支付的开发上手很快，如下是微信官方对三种接入方式的对比注意坑一：发起支付必须是HTTPS流程然后我们整理下发起订单的思路。如下是官方给的流程图，发起支付已经做了标注。由此可见，服务器端发起订单需要以下五小步，我们来各个击破。第一步：获取openid第二步：生成商户订单第三步：调用支付统一下单API第四步：获取预支付会话标识 prepayId第五步：将组合...

			
		

	





	

		

			

				
					
Java微信支付-微信App支付服务端源代码

				
			

			

				

					10-07
				

			

		

		

			
				
微信支付-微信app支付java服务器端代码 实现功能：微信支付 支付查询 申请退款 退款查询 微信服务器端异步支付结果通知 参考博文：http://blog.csdn.net/fengshizty/article/details/53199356

			
		

	





	

		

			

				
					
Java后台实现微信支付和微信退款

				
			

			

				

					08-19
				

			

		

		

			
				
在Java后台实现微信支付时，需要对微信支付流程进行详细的了解和实现。  知识点2：WXPay类的使用 WXPay类是微信支付官方提供的Java SDK，用于实现微信支付的基本功能。在本资源中，WXPay类被用于实现微信统一下单...

			
		

	





	

		

			

				
					
java实现微信支付（服务端）

				
			

			

				

					09-03
				

			

		

		

			
				
在Java中实现微信支付服务端涉及的关键步骤包括获取微信服务器的令牌（Token）、生成订单、创建支付签名以及请求预付单ID。以下是对这些步骤的详细解释：  1. **获取Token**：  微信支付服务端首先需要获取微信...

			
		

	





	

		

			

				
					
java实现微信App支付服务端

				
			

			

				

					08-26
				

			

		

		

			
				
主要为大家详细介绍了java实现微信App支付服务端，具有一定的参考价值，感兴趣的小伙伴们可以参考一下

			
		

	





	

		

			

				
					
微信小程序支付流程，后端Java

				
			

			

				

					The_dream_is_a_verb的专栏
				

				

					03-25
					
					861
					
				

			

		

		

			
				
微信小程序支付前需要统一下单，下单成功，返回json对象。获取json中值拿去支付

微信小程序我是用nui框架，发送一个下单请求：


                     //下单请求
                    uni.request({
                    url: "....",//自己后端链接
					data: {
						//传一些值，比如...

			
		

	





	

		

			

				
					
微信支付获取预支付交易会话标识prepay_id完整代码

				
			

			

				

					12-29
				

			

		

		

			
				
除被扫支付场景以外，其他几种微信支付方式都需要调用统一下单接口获取获取预支付交易会话标识prepay_id之后才能调用支付接口。以上代码是完整的获取prepay_id的服务端代码。

			
		

	





	

		

			

				
					
java 微信支付成功回调_java 微信扫码支付成功后回调重复

				
			

			

				

					weixin_31854817的博客
				

				

					02-26
					
					762
					
				

			

		

		

			
				
java 微信支付成功后，回调一直重复，下面是源代码//微信支付@RequestMapping({"/weixinpay.jsp"})public void WeixinpayAction(ActionMapping mapping, ActionForm form,HttpServletRequest request, HttpServletResponse response)throws Ex...

			
		

	





	

		

			

				
					
java 微信小程序_Java实现微信小程序支付（完整版）

				
			

			

				

					weixin_29055137的博客
				

				

					02-12
					
					1217
					
				

			

		

		

			
				
在开发微信小程序支付的功能前，我们先熟悉下微信小程序支付的业务流程图：不熟悉流程的建议还是仔细阅读微信官方的开发者文档。一，准备工作事先需要申请企业版小程序，并开通“微信支付”(即商户功能)。并获取一下参数：appid=******** //小程序appidmchid=********  //小程序绑定商户idkey=*****************  //商户后台设置的key并在商户后天设置开...

			
		

	





	

		

			

				
					
微信支付开发(5) 订单查询

				
			

			

				

					weixin_34126215的博客
				

				

					05-27
					
					258
					
				

			

		

		

			
				
由于微信支付接口更新，本文档已过期，请查看新版微信支付教程。地址 http://www.cnblogs.com/txw1958/category/624506.html
 
本文介绍微信支付中订单查询功能的实现。
作者：方倍工作室
地址：http://www.cnblogs.com/txw1958/p/wxpay-order-query.html
 
一、订单查询
因为某一方技术的原...

			
		

	





	

		

			

				
					
微信订单查询java开发_Java微信支付开发之查询订单

				
			

			

				

					weixin_39942474的博客
				

				

					02-16
					
					766
					
				

			

		

		

			
				
该接口提供所有微信支付订单的查询，商户可以通过查询订单接口主动查询订单状态，完成下一步的业务逻辑。一、应用场景当商户后台、网络、服务器等出现异常，商户系统最终未接收到支付通知调用支付接口后，返回系统错误或未知交易状态情况调用刷卡支付API，返回USERPAYING的状态调用关单或撤销接口API之前，需确认支付状态二、请求参数可以根据微信订单号(优先使用)或者商户订单号进行查询package com...

			
		

	





	

		

			

				
					
微信支付java版本之查询订单

				
			

			

				

					初晴
				

				

					10-09
					
					2328
					
				

			

		

		

			
				
1.接口简介










2.代码实现




[java] view
 plain copy


 print?



package com.zhrd.bussinss.platform.controller.shop;  
  
import java.io.File;  
import java.io.FileInputStre

			
		

	





	

		

			

				
					
java超详细小程序对接微信支付（一），看完不会你打我

				
			

			

				

					m0_67601895的博客
				

				

					07-19
					
					9764
					
				

			

		

		

			
				
小程序对接微信支付，看完同理学会对接其他支付平台，原理一样

			
		

	





	

		

			

				
					
Java实现字节小程序微信担保支付及回调超详细

				
			

			

				

					m0_59963277的博客
				

				

					02-21
					
					2567
					
				

			

		

		

			
				
Java实现字节小程序微信担保支付下单及回调支付签名验证超详细

			
		

	





	

		

			

				
					
Java开发实现微信小程序支付（微信支付）

					
热门推荐

				
			

			

				

					12程序猿的博客
				

				

					08-30
					
					1万+
					
				

			

		

		

			
				
目录一、前期准备工作1.申请小程序开发者账号并认证2.小程序开通微信支付3.开发指引4.到官方下载Java的支付SDK二、代码实现1.开发流程：2.实现步骤2.1 下单，生成待支付订单2.2 调用微信统一下单2.3 小程序发起微信支付3.后台业务逻辑涉及到的工具类及参数封装类3.1 WeChatPayDto3.2 WeChatPayUtil：微信支付工具类3.3 WXPayUtil、WxPayNotifyResponse3.4 HttpUtils工具类3.5 ErrorCode：返回码3.6 request

			
		

	





	

		

			

				
					
java版微信支付v3_微信支付V3版本JAVA服务端

					
最新发布

				
			

			

				

					05-17
				

			

		

		

			
				
Java版微信支付V3是微信支付的一种服务端API，它基于微信支付V3版本API开发而成，提供了一系列的支付接口和工具类，方便Java开发者快速接入微信支付。

接入微信支付V3版本，需要进行以下几个步骤：

1.注册微信商户号

2.开通微信支付功能

3.下载微信支付SDK

4.配置微信支付参数

5.调用微信支付接口

Java版微信支付V3提供了以下几个重要接口：

1.统一下单接口

2.订单查询接口

3.关闭订单接口

4.申请退款接口

5.查询退款接口

6.下载对账单接口

7.交易保障接口

8.支付结果通知接口

以上接口都有对应的Java类和方法，可以直接调用。

微信支付V3版本还提供了一些工具类，如签名工具类、加密解密工具类等，可以帮助开发者更方便地使用微信支付API。

总的来说，Java版微信支付V3是一款非常便捷、实用的支付服务端API，适合Java开发者快速接入微信支付。

			
		

	



              



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

  

      
    
          
  • 
              
    
                  
                  
              
    
              
    非常没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    一般
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    有帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    非常有帮助
    
          
    • 
      

      

      

          
          提交
      

      

  




          




        



    





    



      

      

        
      

      





	

		
评论 2

	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值