支付

最近项目上用到了调用微信和支付宝的第三方支付接口，因为以前没用过，所以这次用到了之后总结一下分享给大家，这里介绍两种支付方式，即app支付和扫码支付方式。

一、app支付（这里只介绍Java端调用支付，安卓或iOS端自己参考相关的调用文档）

首先可以看一看项目支付流程（图解）

1.      在页面上选择支付方式（微信或支付宝）

2.      由相应的客户端调用相应的支付方式进入相应的支付页面（安卓或ios调用支付接口并进入微信或支付宝支付页面，显示支付的信息）

3.      输入密码进行支付

4.      调用支付结果接口，来返回支付成功与否

           

四图分别是选择支付方式、微信支付页面、支付宝支付页面、微信支付结果(成功)页面

也是基本的支付三个步骤。

一、先看微信支付：

在调用微信支付之前你应该已经下单成功(即订单信息入库成功),这里需要几个值：

OrderName(订单名称),orderNumber(订单编号,唯一),amount(金额), prepayId(交易会话id)

前三个参数直接从数据库里获取。prepayid是什么？可以具体看微信支付文档，我们可以从下单接口中返回获得这个会话id并且需要入库，这个参数最重要的作用是用于第一次我们没有支付，但已经生成了一个待支付的订单。这种情况下我们不需要再次去调用下单接口返回prepayId，因为我们已经生成过了这个值

下面看手机端页面的js代码：

[javascript] view plain copy

1. //微信支付   
2.             function wxPay(outTradeNo){  
3.                 var orderType="0"; //路线 订单   
4.                  $.ajax({  
5.                         url :'<%=basePath%>client/travel/getWXClientPayInfo.do?outTradeNo='+outTradeNo+'&orderType='+orderType,  
6.                         cache : false,  
7.                         type : "get",  
8.                         success : function(data)  
9.                         {  
10.                               
11.                             if(data!=null){  
12.                                 data = jQuery.parseJSON(data);  
13.                                   
14.                                 var u = navigator.userAgent;  
15.                                 var isAndroid = u.indexOf('Android') > -1 || u.indexOf('Adr') > -1; //android终端  
16.                                 var isiOS = !!u.match(/\(i[^;]+;( U;)? CPU.+Mac OS X/); //ios终端  
17.                                 if(isAndroid){  
18.                                     ClientInterface.pay(outTradeNo,data.prepayid,data.noncestr,data.timestamp,data.sign,orderType);  
19.                                 }else if(isiOS){  
20.                                     window.location.href='http://localhost/pay/'+outTradeNo+';'+data.prepayid+";"+data.noncestr+";"+data.timestamp+";"+data.sign+";"+orderType;  
21.                                 }     
22.                                   
23.                              }   
24.                         }  
25.                     });  
26.             }  

这里outTradeNo即是唯一的订单编号，orderType是自己定义的订单类型，这里的ajax就是根据这两个参数去后台去操作下单，然后返回必要的参数给安卓或ios调用

然后看后台的这个方法：

[java] view plain copy

1. /**获取微信客户端支付信息 如 签名 随机数等 
2.      * @param page 
3.      * @throws Exception 
4.      */  
5.     @RequestMapping(value="/getWXClientPayInfo")  
6.     @ResponseBody  
7.     public String getWeixinPayInfo(HttpServletRequest request) throws Exception{  
8.         String orderNumber = request.getParameter("outTradeNo");  
9.         String orderType = request.getParameter("orderType");  
10.         Map<String, Object> map=new HashMap<String, Object>();  
11.         map.put("orderNumber", orderNumber);  
12.         map.put("type", orderType);  
13.         //获取订单信息  
14.         Map<String, Object> orderMap=travelOrderService.getOrderInfoByOrderType(map);  
15.         String amount="";  
16.         String prepayId="";  
17.         if(null!=orderMap&&orderMap.size()>0){  
18.             if(orderMap.containsKey("amount")){  
19.                 amount=orderMap.get("amount").toString();  
20.             }  
21.             if(orderMap.containsKey("prepayId")){  
22.                 prepayId=orderMap.get("prepayId").toString();  
23.             }  
24.         }  
25.         //获取微信支付会话id  
26.         if("".equals(prepayId)){  
27.             Float totalMoney=Float.valueOf(amount);  
28.             totalMoney=totalMoney*100;  
29.             int totalFee=totalMoney.intValue();  
30.             String money=String.valueOf(totalFee);  
31.             <span style="color:#ff6666;">String xmlStr=WeixinPayUtil.add(orderNumber,money,orderType); //获得会话ID</span>  
32.             Map<String, Object> m=new HashMap<String, Object>();  
33.             Document doc = DocumentHelper.parseText(xmlStr);    
34.             Element rootElement = doc.getRootElement();    
35.             XmlToBean.ele2map(m,rootElement);  
36.             String str="";  
37.             if(m.containsKey("prepay_id")){  
38.                 str=m.get("prepay_id").toString();  
39.                 str=str.replace("{prepay_id=", "");  
40.                 str=str.substring(0,str.length()-1);  
41.             }  
42.             prepayId=str;  
43.             map.put("prepayId", prepayId);  
44.             travelOrderService.updateOrderInfoByType(map);  
45.         }  
46.          //转成sortedMap,微信支付后台生成sign需要排序过的map  
47.         SortedMap<String,Object> sort=new TreeMap<String,Object>();  
48.         String partnerid = sysparam.getStringParamByKey("c.wxpay.partnerid");  
49.         //相关参数,可以定义一个Map做成动态的  
50.         sort.put("appid", sysparam.getStringParamByKey("c.wxpay.appid"));  
51.         sort.put("partnerid", partnerid);  
52.         sort.put("prepayid",prepayId);  
53.         sort.put("package", "Sign=WXPay");  
54.         String noncestr = RandomUtil.CreateRandom(32);  
55.         sort.put("noncestr", noncestr);  
56.         String timestamp = String.valueOf(System.currentTimeMillis());  
57.         timestamp = timestamp.substring(0,timestamp.length()-3);  
58.         sort.put("timestamp", timestamp);  
59.         String securit = sysparam.getStringParamByKey("c.wxpay.secret");  
60.         //生成sign  
61.         String sign=WeixinSignUtil.createSign("UTF-8", sort,securit);  
62.           
63.         Map<String,Object> resultParam = new HashMap<String, Object>();  
64.         resultParam.put("timestamp", timestamp);  
65.         resultParam.put("noncestr", noncestr);  
66.         resultParam.put("sign", sign);  
67.         resultParam.put("prepayid", prepayId);  
68.         return JsonUtil.Object2JsonSting(resultParam);  
69.     }  

这里需要注意的是

StringxmlStr=WeixinPayUtil.add(orderNumber,money,orderType); //获得会话ID

这个add方法即微信的下单接口，返回的xmlStr是xml格式的字符串，进行解析后，得出来perpayid入库。这里的money即金额，必须以分为单位！

依次参考下单接口:

[java] view plain copy

1. public static String add(String orderNo,String TotalMoney,String orderType) throws Exception {  
2.        URL postUrl = new URL("https://api.mch.weixin.qq.com/pay/unifiedorder");  
3.        SysParamServiceImpl systemParam = (SysParamServiceImpl)SpringContextHolder.getBean(SysParamServiceImpl.class);  
4.        HttpsURLConnection con = (HttpsURLConnection) postUrl.openConnection();//打开连接  
5.        con.setRequestMethod("POST");//post方式提交  
6.        
7.        con.setDoOutput(true);//打开读写属性，默认均为false  
8.        con.setDoInput(true);  
9.        con.setUseCaches(false);//Post请求不能使用缓存  
10.        con.setInstanceFollowRedirects(true);  
11.        DataOutputStream out = new DataOutputStream(con.getOutputStream());  
12.        Map<String, Object> vo = new HashMap<String, Object>();  
13.        //相关参数,可以定义一个Map做成动态的  
14.        vo.put("appid", systemParam.getStringParamByKey("c.wxpay.appid"));  
15.        vo.put("attach", "支付测试");  
16.        vo.put("body", "APP应用支付");  
17.        vo.put("mch_id", systemParam.getStringParamByKey("c.wxpay.partnerid"));  
18.        vo.put("nonce_str", RandomUtil.CreateRandom(32));  
19.        String notifyUrl=systemParam.getStringParamByKey("sys.domain");  
20.        notifyUrl=notifyUrl+"/interface/wxpay/"+orderType; //调用微信下发通知的接口  
21.        vo.put("notify_url", notifyUrl);  
22.        vo.put("out_trade_no", orderNo);  
23.        vo.put("spbill_create_ip", "14.23.150.211");  
24.        vo.put("total_fee", TotalMoney);  
25.        vo.put("trade_type", "APP");  
26.        //转成sortedMap,微信支付后台生成sign需要排序过的map  
27.        SortedMap<String,Object> sort=new TreeMap<String,Object>(vo);  
28.        String secrit = systemParam.getStringParamByKey("c.wxpay.secret");  
29.        //生成sign  
30.        String sign=WeixinSignUtil.createSign("UTF-8", sort,secrit);  
31.        //把sign放入map中  
32.        vo.put("sign", sign);  
33.        org.dom4j.Document doc = DocumentHelper.createDocument();  
34.        Element body = DocumentHelper.createElement("xml");  
35.        XmlUtil.buildMap2xmlBody(body,vo);  
36.        doc.add(body);  
37.        //发送请求  
38.        out.writeUTF(doc.asXML());    
39.        System.out.println(doc.asXML());  
40.        out.flush();  
41.        out.close();  
42.        
43.        //接收数据    
44.        BufferedReader reader = new BufferedReader(new InputStreamReader(con.getInputStream(), "UTF-8"));    
45.        String line;    
46.        StringBuffer responseText = new StringBuffer();    
47.        while ((line = reader.readLine()) != null) {    
48.            responseText.append(line).append("\r\n");    
49.        }    
50.        reader.close();  
51.        con.disconnect();    
52.        return responseText.toString()+"";    
53.    }    

这里需要几个微信支付所需要的开发者账号信息，包括appid,微信支付商户号:partnerid,微信支付密码:

secret这些是商户申请微信app支付的信息提供给我们开发者，还有nonce_str参数需要配置我们自己定义的一个请求

该请求会在支付完成后，微信会主动根据这个请求来返回结果给我们。而且必须是外网，内网调不通

最后一步就是支付之后，微信会调用我们配置的nonce_str这个请求返回xml格式的结果给我们

[java] view plain copy

1. @RequestMapping(value = "/interface/wxpay/{orderType}", produces = "text/html;charset=UTF-8")  
2.     @ResponseBody  
3.     public String getWeixinPayResult(HttpServletRequest request,  
4.                                      HttpServletResponse response)  
5.         throws IOException  
6.     {  
7.         try  
8.         {  
9.             String reqcontent = getRequestContent(request);  
10.             interfaceLogger  
11.                 .info("################### ################# WeiXinPayResultInterface::getWeixinPayResult,request msg:"  
12.                       + reqcontent);  
13.             ResponseHandler resHandler = new ResponseHandler(request, response);  
14.   
15.             // 创建请求对象  
16.   
17.             // RequestHandler queryReq = new RequestHandler(request, response);  
18.             String type = request.getParameter("orderType"); // 获取订单类型  
19.   
20.             // queryReq.init();  
21.             String securit = sysParam.getStringParamByKey("c.wxpay.secret");  

[java] view plain copy

1. <span style="white-space:pre">  </span>    //判断证书  
2.             if (resHandler.getParameter("sign").equals(  
3.                 WeixinSignUtil.createSign("utf-8",  
4.                     resHandler.getAllParameters(), securit)))  
5.             {  
6.   
7.                 // 商户订单号  
8.   
9.                 String out_trade_no = resHandler.getParameter("out_trade_no");  
10.                 String totalFee = resHandler.getParameter("total_fee");  
11.                 System.out.println("out_trade_no:" + out_trade_no);  
12.                 Map<String, Object> map = new HashMap<String, Object>();  
13.                 String result_code = resHandler.getParameter("result_code");  
14.                 if (result_code.equals("SUCCESS"))  
15.                 {  
16.                 <span style="font-family: Arial, Helvetica, sans-serif;">// 金额,以分为单位</span><pre name="code" class="java"><span style="white-space:pre">     </span>String total_fee = resHandler.getParameter("total_fee");</pre><pre name="code" class="java"><span style="white-space:pre">       </span>//进行支付后操作...</pre><span style="white-space:pre"></span>} else { return resHandler.getParameter("err_code_des"); } // 给微信服务器返回success 否则30分钟通知8次 return "success"; } else { System.out.println("通知签名验证失败"); resHandler.sendToCFT("fail");  
17.  response.setCharacterEncoding("utf-8"); return "FAIL"; } } catch (Exception e) { return "FAIL"; } }  
18. <pre></pre>  
19. <p></p>  
20. <pre></pre>  
21. 这是微信调用我们定义的请求来主动返回支付结果，但我们也可以写接口主动调用微信来获取订单信息  
22. <p></p>  
23. <p><span style="font-size:14px"><span style="font-size:14px">这里需要ios或者安卓调用我们java后台写的接口来获取支付结果：</span></span></p>  
24. <p><span style="font-size:14px"><span style="font-size:14px">接口如下：</span></span></p>  
25. <p><span style="font-size:14px"><span style="font-size:14px"></span></span></p>  
26. <pre name="code" class="java">/** 
27.      * 客户端微信支付成功后查询后台支付结果接口 
28.      *  
29.      * @param req 
30.      * @param rsp 
31.      * @return String 返回json字符串 如果有违例，请使用@exception/throws [违例类型] 
32.      *         [违例说明：异常的注释必须说明该异常的含义及什么条件下抛出该 
33.      * @throws Exception 
34.      * @see [类、类#方法、类#成员] 
35.      */  
36.     @RequestMapping(value = "/interface/payStatus", method = RequestMethod.POST, produces = "text/html;charset=UTF-8")  
37.     @ResponseBody  
38.     public String getPayStatus(HttpServletRequest req, HttpServletResponse rsp)  
39.         throws Exception  
40.     {  
41.         Map<String, Object> resultMap = new HashMap<String, Object>();  
42.         try  
43.         {  
44.             URL postUrl = new URL(  
45.                 "https://api.mch.weixin.qq.com/pay/orderquery");  
46.             // 获取请求内容  
47.             String requestContent = getRequestContent(req);  
48.             // 日志  
49.             interfaceLogger.info("request payStatus:" + requestContent);  
50.             // 解析参数  
51.             requestParam = parseAndCheckParam(requestContent, resultMap,  
52.                 requestParam, systemParam.getSystemKey());  
53.             // 校验参数  
54.             checkStatusParam(resultMap);  
55.             // 校验token及获取用户信息  
56.             Map<String, Object> userInfo = checkTokenAndGetUserInfo(  
57.                 tokenService, appuserManager, requestParam, resultMap);  
58.   
59.             String user_id = (String)userInfo.get("userId");  
60.             String totalFee = (String)requestParam.get("totalFee");  
61.             String type = (String)requestParam.get("orderType"); // 获取订单类型参数  
62.             if (null == user_id)  
63.             {  
64.                 resultMap.put("resultCode",  
65.                     ErrorCodeConstants.INVALID_TOKEN_ERROR);  
66.             }  
67.             SysParamServiceImpl sysParam = (SysParamServiceImpl)SpringContextHolder  
68.                 .getBean(SysParamServiceImpl.class);  
69.             HttpsURLConnection con = (HttpsURLConnection)postUrl  
70.                 .openConnection();// 打开连接  
71.             con.setRequestMethod("POST");// post方式提交  
72.             con.setDoOutput(true);// 打开读写属性，默认均为false  
73.             con.setDoInput(true);  
74.             con.setUseCaches(false);// Post请求不能使用缓存  
75.             con.setInstanceFollowRedirects(true);  
76.             // DataOutputStream out = new  
77.             // DataOutputStream(con.getOutputStream());  
78.             PrintWriter out = new PrintWriter(con.getOutputStream());  
79.             Map<String, Object> map = new HashMap<String, Object>();  
80.             // 相关参数,可以定义一个Map做成动态的  
81.             map.put("appid", sysParam.getStringParamByKey("c.wxpay.appid")); // appID  
82.             map.put("mch_id", sysParam.getStringParamByKey("c.wxpay.partnerid")); // 商户号  
83.             map.put("nonce_str", RandomUtil.CreateRandom(32)); // 随机数  
84.             String orderId = requestParam.get("outTradeNo").toString();  
85.             map.put("out_trade_no", orderId); // 订单号  
86.             // String mo="3000";  
87.             // insertMoneyAccounting(orderId,mo); //利润分配  
88.             // 转成sortedMap,微信支付后台生成sign需要排序过的map  
89.             SortedMap<String, Object> sort = new TreeMap<String, Object>(map);  
90.             String secrit = sysParam.getStringParamByKey("c.wxpay.secret");  
91.             // 生成sign  
92.             String sign = WeixinSignUtil.createSign("UTF-8", sort, secrit);  
93.             // 把sign放入map中  
94.             map.put("sign", sign); // 签名  
95.             Document doc = DocumentHelper.createDocument();  
96.             Element body = DocumentHelper.createElement("xml");  
97.             buildMap2xmlBody(body, map);  
98.             doc.add(body);  
99.             // 发送请求  
100.             // out.writeUTF(doc.asXML());  
101.             String outStr = doc.asXML();  
102.             out.print(outStr);  
103.             System.out.println(doc.asXML());  
104.             out.flush();  
105.             out.close();  
106.             // 接收数据  
107.             BufferedReader reader = new BufferedReader(new InputStreamReader(  
108.                 con.getInputStream(), "UTF-8"));  
109.             String line;  
110.             StringBuffer responseText = new StringBuffer();  
111.             while ( (line = reader.readLine()) != null)  
112.             {  
113.                 responseText.append(line).append("\r\n");  
114.             }  
115.             reader.close();  
116.             con.disconnect();  
117.             String resXml = responseText.toString() + ""; // 获取从微信付款的结果  
118.                                                           // ，以String类型的xml格式返回  
119.             System.out.println("result:" + resXml);  
120.             // 解析xml  
121.             Map<String, Object> m = new HashMap<String, Object>();  
122.             Document d = DocumentHelper.parseText(resXml);  
123.             Element rootElement = d.getRootElement();  
124.             XmlToBean.ele2map(m, rootElement);  
125.             String str = "";  
126.             if (m.containsKey("trade_state"))  
127.             {  
128.                 str = m.get("trade_state").toString();  
129.                 str = str.replace("{trade_state=", "");  
130.                 str = str.substring(0, str.length() - 1);  
131.                 if ("SUCCESS" == str || "SUCCESS".equals(str))  
132.                 {  
133.                     if ("0".equals(type)) {  
134.                         //支付成功后操作...  
135.                     }  
136.                 }  
137.                 else if ("REFUND" == str || "REFUND".equals(str))  
138.                 {  
139.                     str = "1"; // 转入退款  
140.                 }  
141.                 else if ("NOTPAY" == str || "NOTPAY".equals(str))  
142.                 {  
143.                     str = "2"; // 未支付  
144.                 }  
145.                 else if ("CLOSED" == str || "CLOSED".equals(str))  
146.                 {  
147.                     str = "3"; // 已关闭  
148.                 }  
149.                 else if ("REVOKED" == str || "REVOKED".equals(str))  
150.                 {  
151.                     str = "4"; // 已撤销  
152.                 }  
153.                 else if ("USERPAYING" == str || "USERPAYING".equals(str))  
154.                 {  
155.                     str = "5"; // 用户支付中  
156.                 }  
157.                 else if ("PAYERROR" == str || "PAYERROR".equals(str))  
158.                 {  
159.                     str = "6"; // 支付失败  
160.                 }  
161.                 resultMap.put("status", str);  
162.                 resultMap.put("resultCode",  
163.                     ErrorCodeConstants.RESULT_CODE_SUCCESS);  
164.             }  
165.         }  
166.         catch (Exception e)  
167.         {  
168.             logger.error("loginOut:system exception!", e);  
169.             resultMap.clear();  
170.             resultMap.put("resultCode", ErrorCodeConstants.SYSTEM_ERROR);  
171.         }  
172.         interfaceLogger.info("response payStatus:" + resultMap.toString());  
173.         return JsonUtil.Object2EncodeJsonSting(resultMap,  
174.             systemParam.getSystemKey());  
175.     }</pre><br>  
176. requestParam.get("XXX")，XXX是客户端调用我们接口给我们传的参数，需要给我们totalFee(金额)，orderType(订单类型)等<br>  
177. <p></p>  
178. <p><span style="font-size:14px"><span style="font-size:14px">然后我们返回支付结果给客户端</span></span></p>  
179. <p><span style="font-size:14px; color:#ff0000">二、支付宝支付:</span></p>  
180. <p><span style="font-size:14px">支付宝支付流程上和微信支付稍微有所差别，支付宝不需要调用下单结果，但是也需要一个类似于微信prepayId的字段来入库，作用上跟prepayId差不多，名称可以自己定义，我这边暂时为aliPayInfo:</span></p>  
181. <p><span style="font-size:14px">首先看js代码：</span></p>  
182. <p><span style="font-size:14px"></span></p>  
183. <pre name="code" class="javascript">//支付宝支付   
184.             function aliPay(outTradeNo){  
185.                 var orderType="0";  
186.                 var info = $("#aliPayInfo").val();//订单信息   
187.                 var totalAmount = $("#moeny").val();//总金额  
188.                 var orderName = $("#orderName").val();//订单名称  
189.                   
190.                 //type 0：线路 1：景点  2：酒店 3：商城 4：VIP  
191.                 var prams = {  
192.                         aliPayInfo : info,  
193.                         type : orderType,  
194.                         orderNumber : outTradeNo,  
195.                         money : totalAmount,  
196.                         orderName : orderName  
197.                 };  
198.                 //先调支付宝确定是否下单 否则返回支付宝会话信息  
199.                 $.ajax({  
200.                     url : '<%=basePath%>client/hotel/foundZFBOrder.do',  
201.                     type : "post",  
202.                     data : prams,  
203.                     cache : false,  
204.                     dataType : "json",  
205.                     success : function(data)  
206.                     {  
207.                         //alert("info +===="+data.info);  
208.                         if(data.isSuccess){  
209.                             if(isAndroid){  
210.                                 ClientInterface.aliPay(data.info,outTradeNo,orderType,totalAmount);  
211.                             }else if(isiOS){  
212.                                 window.location.href='http://localhost/aliPay/'+data.info+';'+outTradeNo+";"+orderType+";"+totalAmount;  
213.                             }  
214.                         }else{  
215.                             var title = "支付宝下单失败";  
216.                             prompt(title);  
217.                         }  
218.                     },   
219.                     error : function(data){  
220.                         var title = "支付宝下单失败";  
221.                         prompt(title);  
222.                     }  
223.                 });  
224.             }</pre><br>  
225. <pre name="code" class="javascript"></pre>页面上的aliPayInfo可以为空，因为第一次去调用支付宝时这个为空，如果不支付，但是还是入库了，需要去数据库里查一下，那么共用这个页面的话aliPayInfo就不为空<p></p><p><span style="font-size:14px">然后去后台写这个ajax请求</span></p><p><span style="font-size:14px"></span></p><pre name="code" class="java">@RequestMapping(value="/foundZFBOrder", produces = "application/json;charset=UTF-8")  
226.     @ResponseBody  
227.     public Map<String, Object> foundZFBOrder(HttpServletRequest request){  
228.         //支付宝信息  
229.         String aliPayInfo = request.getParameter("aliPayInfo");  
230.         //金额  
231.         String money = request.getParameter("money");  
232.         //订单名称  
233.         String orderName = request.getParameter("orderName");  
234.         //订单编号  
235.         String orderNumber = request.getParameter("orderNumber");  
236.         //订单类型（0：线路 1：景点  2：酒店 3：商城 4：VIP）  
237.         String type = request.getParameter("type");  
238.           
239.         boolean isSuccess = false;  
240.           
241.         //判断是否生成过支付宝信息  
242.         if(StringUtils.isBlank(aliPayInfo)){  
243.              
244.             //生成支付宝信息  
245.             aliPayInfo = AliPayUtil.orderInfo(money, orderName, orderNumber, type);  
246.               
247.             //修改表中支付宝信息  
248.             if(StringUtils.isNotBlank(aliPayInfo)){  
249.                 isSuccess = true;  
250.                 Map<String, Object> map = new HashMap<String, Object>();  
251.                 map.put("aliPayInfo", aliPayInfo);  
252.                 map.put("type", type);  
253.                 map.put("orderNumber", orderNumber);  
254.                 try {  
255.                     travelOrderService.updateOrderInfoByType(map);  
256.                 }  
257.                 catch (Exception e) {  
258.                     e.printStackTrace();  
259.                 }  
260.             }  
261.               
262.             /** 打印支付宝响应日志  */  
263.             if (interfaceLogger.isInfoEnabled()) {  
264.                 interfaceLogger.info("[HotelController][foundZFBOrder]ZFB " + table + " result :["  
265.                                      + JSON.toJSONString(aliPayInfo) + "]");  
266.             }  
267.         }  
268.           
269.         Map<String, Object> map = new HashMap<String, Object>();  
270.         map.put("info", aliPayInfo);  
271.         map.put("isSuccess", isSuccess);  
272.         return map;  
273.     }</pre><br>  
274. <pre name="code" class="java"></pre>这里的 aliPayInfo = AliPayUtil.orderInfo(money, orderName, orderNumber, type);<p></p><p><span style="font-size:14px">类似于微信的下单接口（<span style="font-size:14px">aliPayInfo </span>需要入库），但不是下单接口，因为支付宝支付没有下单接口，详情可以查看支付宝支付文档</span></p><p><span style="font-size:14px">下面继续写orderInfo方法：</span></p><pre name="code" class="java">/** 
275.      *  
276.      * @param amount 订单金额 
277.      * @param subject 订单标题 
278.      * @param body 订单描述 
279.      * @param outTradeNo订单号 
280.      * @return 
281.      */  
282.     public static String orderInfo(String amount,String subject,String outTradeNo,String type) {  
283.         //获取appid  
284.         String appId=Const.APPID;  
285.         Map<String, String> authInfoMap = OrderInfoUtil.buildOrderParamMap(appId,amount,subject,outTradeNo,type);  
286.         String info = OrderInfoUtil.buildOrderParam(authInfoMap);  
287.         String rsaPrivate =Const.RSAPRIVATE; //获取商户密钥  
288.         String sign = OrderInfoUtil.getSign(authInfoMap, rsaPrivate);  
289.         final String orderInfo = info + "&" + sign;  
290.         return orderInfo;  
291.     }</pre><br>  
292. <span style="font-size:18px">这里和微信一样需要支付宝商户的appid和RSAPRIVATE提供给我们开发者，</span><br>  
293. <p style="font-size:14px">然后编写支付宝支付工具类：</p>  
294. <p style="font-size:14px"></p>  
295. <pre name="code" class="java">public class OrderInfoUtil {  
296.       
297.     /** 
298.      * 构造授权参数列表 
299.      *  
300.      * @param pid 
301.      * @param app_id 
302.      * @param target_id 
303.      * @return 
304.      */  
305.     public static Map<String, String> buildAuthInfoMap(String pid, String app_id, String target_id) {  
306.         Map<String, String> keyValues = new HashMap<String, String>();  
307.   
308.         // 商户签约拿到的app_id，如：2013081700024223  
309.         keyValues.put("app_id", app_id);  
310.   
311.         // 商户签约拿到的pid，如：2088102123816631  
312.         keyValues.put("pid", pid);  
313.   
314.         // 服务接口名称， 固定值  
315.         keyValues.put("apiname", "com.alipay.account.auth");  
316.   
317.         // 商户类型标识， 固定值  
318.         keyValues.put("app_name", "mc");  
319.   
320.         // 业务类型， 固定值  
321.         keyValues.put("biz_type", "openservice");  
322.   
323.         // 产品码， 固定值  
324.         keyValues.put("product_id", "APP_FAST_LOGIN");  
325.   
326.         // 授权范围， 固定值  
327.         keyValues.put("scope", "kuaijie");  
328.   
329.         // 商户唯一标识，如：kkkkk091125  
330.         keyValues.put("target_id", target_id);  
331.   
332.         // 授权类型， 固定值  
333.         keyValues.put("auth_type", "AUTHACCOUNT");  
334.   
335.         // 签名类型  
336.         keyValues.put("sign_type", "RSA");  
337.   
338.         return keyValues;  
339.     }  
340.   
341.     /** 
342.      * 构造支付订单参数列表 
343.      * @param pid 
344.      * @param app_id 
345.      * @param target_id 
346.      * @return 
347.      */  
348.     public static Map<String, String> buildOrderParamMap(String appId,String amount,String subject,String outTradeNo,String type) {  
349.         Map<String, String> keyValues = new HashMap<String, String>();  
350.   
351.         keyValues.put("app_id", appId);  
352.   
353.         keyValues.put("biz_content", "{\"timeout_express\":\"30m\",\"product_code\":\"QUICK_MSECURITY_PAY\",\"total_amount\":\""+amount+"\",\"subject\":\""+subject+"\",\"out_trade_no\":\"" +outTradeNo +  "\"}");  
354.           
355.         keyValues.put("charset", "utf-8");  
356.   
357.         keyValues.put("method", "alipay.trade.app.pay");  
358.   
359.         keyValues.put("sign_type", "RSA");  
360.         //获取域名   
361.         SysParamServiceImpl systemParam = (SysParamServiceImpl)SpringContextHolder.getBean(SysParamServiceImpl.class);  
362.         //String notifyUrl="http://180.96.11.10:8080/tourism";  
363.         String notifyUrl=systemParam.getStringParamByKey("sys.domain");  
364.           
365.         notifyUrl=notifyUrl+"/interface/alipay/"+type;  
366.           
367.         keyValues.put("notify_url", notifyUrl);  
368.           
369.         String timestamp = "";  
370.         Date date=new Date();  
371.         SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); //设置时间格式  
372.         timestamp=sdf.format(date);  
373.         keyValues.put("timestamp", timestamp);  
374.         keyValues.put("version", "1.0");  
375.         return keyValues;  
376.     }  
377.       
378.     /** 
379.      * 构造支付订单参数信息 
380.      *  
381.      * @param map 
382.      * 支付订单参数 
383.      * @return 
384.      */  
385.     public static String buildOrderParam(Map<String, String> map) {  
386.         List<String> keys = new ArrayList<String>(map.keySet());  
387.   
388.         StringBuilder sb = new StringBuilder();  
389.         for (int i = 0; i < keys.size() - 1; i++) {  
390.             String key = keys.get(i);  
391.             String value = map.get(key);  
392.             sb.append(buildKeyValue(key, value, true));  
393.             sb.append("&");  
394.         }  
395.   
396.         String tailKey = keys.get(keys.size() - 1);  
397.         String tailValue = map.get(tailKey);  
398.         sb.append(buildKeyValue(tailKey, tailValue, true));  
399.   
400.         return sb.toString();  
401.     }  
402.       
403.     /** 
404.      * 拼接键值对 
405.      *  
406.      * @param key 
407.      * @param value 
408.      * @param isEncode 
409.      * @return 
410.      */  
411.     private static String buildKeyValue(String key, String value, boolean isEncode) {  
412.         StringBuilder sb = new StringBuilder();  
413.         sb.append(key);  
414.         sb.append("=");  
415.         if (isEncode) {  
416.             try {  
417.                 sb.append(URLEncoder.encode(value, "UTF-8"));  
418.             } catch (UnsupportedEncodingException e) {  
419.                 sb.append(value);  
420.             }  
421.         } else {  
422.             sb.append(value);  
423.         }  
424.         return sb.toString();  
425.     }  
426.       
427.     /** 
428.      * 对支付参数信息进行签名 
429.      *  
430.      * @param map 
431.      *            待签名授权信息 
432.      *  
433.      * @return 
434.      */  
435.     public static String getSign(Map<String, String> map, String rsaKey) {  
436.         List<String> keys = new ArrayList<String>(map.keySet());  
437.         // key排序  
438.         Collections.sort(keys);  
439.   
440.         StringBuilder authInfo = new StringBuilder();  
441.         for (int i = 0; i < keys.size() - 1; i++) {  
442.             String key = keys.get(i);  
443.             String value = map.get(key).toString();  
444.             authInfo.append(buildKeyValue(key, value, false));  
445.             authInfo.append("&");  
446.         }  
447.   
448.         String tailKey = keys.get(keys.size() - 1);  
449.         String tailValue =map.get(tailKey).toString();  
450.         authInfo.append(buildKeyValue(tailKey, tailValue, false));  
451.   
452.         String oriSign = SignUtils.sign(authInfo.toString(), rsaKey);  
453.         String encodedSign = "";  
454.   
455.         try {  
456.             encodedSign = URLEncoder.encode(oriSign, "UTF-8");  
457.         } catch (UnsupportedEncodingException e) {  
458.             e.printStackTrace();  
459.         }  
460.         return "sign=" + encodedSign;  
461.     }  
462.       
463.     /** 
464.      * 要求外部订单号必须唯一。 
465.      * @return 
466.      */  
467.     private static String getOutTradeNo() {  
468.         SimpleDateFormat format = new SimpleDateFormat("MMddHHmmss", Locale.getDefault());  
469.         Date date = new Date();  
470.         String key = format.format(date);  
471.   
472.         Random r = new Random();  
473.         key = key + r.nextInt();  
474.         key = key.substring(0, 15);  
475.         return key;  
476.     }  
477.   
478. }</pre><br>  
479. <span style="color:#ff0000">keyValues.put("notify_url", notifyUrl);这个和微信一样，需要设置一个供支付宝支付后返回给我们的支付结果通知的请求，需自己定义，可带参数，必须在外网下才能调用</span><br>  
480. <p></p>  
481. <p style="font-size:14px">最后根据我们定义的请求，来写接收支付宝返回给我们的结果：</p>  
482. <p style="font-size:14px"></p>  
483. <pre name="code" class="java">@RequestMapping(value = "/interface/alipay/{type}", produces = "text/html;charset=UTF-8")  
484.     @ResponseBody  
485.     public String getzfbPayResult(HttpServletRequest request,HttpServletResponse response){  
486.         try{  
487.             String reqcontent = getRequestContent(request);  
488.             interfaceLogger.info("################### ################# WeiXinPayResultInterface::alipay,request msg:"+reqcontent);  
489.             //解析url  
490.             //reqcontent=stringFarmat(reqcontent);   
491.              try {  
492.                  reqcontent= URLDecoder.decode(reqcontent, "UTF-8");  
493.                     } catch (UnsupportedEncodingException e) {  
494.                         e.printStackTrace();  
495.                     }  
496.             interfaceLogger.info("###########获取参数解析url:$@@@@@@@@@@@@@@@@@@@@@@@@@========="+reqcontent);  
497.             //转换为map  
498.             Map<String, String> paramMap=stringtoArray(reqcontent);  
499.             //获取orderType  
500.             String orderType=request.getRequestURI();  
501.             int i=orderType.lastIndexOf("/");  
502.             orderType=orderType.substring(i+1, orderType.length());   
503.             //验证签名  
504.             //支付宝公钥  
505.             String publicKey=Const.PUBLICKEY; //支付宝公钥  
506.              //字符集  
507.             String charsetType="UTF-8";  
508.             //验证签名  
509.             boolean signVerified = AlipaySignature.rsaCheckV1(paramMap, publicKey, charsetType); //调用SDK验证签名  
510.                 interfaceLogger.info("###########验证签名结果:$@@@@@@@@@@@@@@@@@@@@@@@@@========="+signVerified);  
511.                 if(signVerified){  
512.                         //验证金额订单号  
513.                     interfaceLogger.info("*****************验证签名成功:&&&&&&&&&&&&&&&&&&&&&&&&&&&&");  
514.                     if(paramMap.containsKey("trade_status")){  
515.                         String resultStr=paramMap.get("trade_status");  
516.                         if(resultStr.equals("TRADE_SUCCESS")||resultStr.equals("TRADE_FINISHED")){  
517.                             //支付成功后操作...  
518.                     }  
519.                     return "success";  
520.                 }else{  
521.                     interfaceLogger.info("&&&&&&&&&&&&&&&&验证签名失败:***************************");  
522.                    return "failure";      
523.                 }  
524.               
525.         }catch (Exception e){  
526.             interfaceLogger.info("###########待签名字符串str:$@@@@@@@@@@@@@@@@@@@@@@@@@=========",e);  
527.             e.printStackTrace();  
528.             return "failure";  
529.         }  
530.     }  
531.   </pre>这一步需要商户提供给我们的PUBLICKEY支付宝公钥来进行证书验证。<pre name="code" class="java">-------------------------------------------------------------------------------------------------------------------------------------</pre>这里介绍了app上面的两种支付方式。下面介绍下微信和支付宝的二维码支付  
532. <p></p>  
533. <p style="font-size:14px">先看java后台代码：</p>  
534. <pre name="code" class="java"> /** 
535.     *去支付界面(支付订单) 
536.     * @param request 
537.     * @return 
538.     * @throws Exception 
539.     */  
540.    @RequestMapping(value="/payOrder")  
541.    public ModelAndView payOrder(HttpServletRequest request) throws Exception{  
542.        ModelAndView mv = this.getModelAndView();  
543.        PageData pd = new PageData();  
544.        String type=request.getParameter("type");  
545.        String orderId=request.getParameter("orderId");  
546.        pd = this.getPageData();  
547.        User user=SessionUtil.getUser(request);  
548.       /* User user=new User(); 
549.        user.setUserId("wang");*/  
550.        String userId="";  
551.        if(null!=user){  
552.            userId=user.getUserId();  
553.        }  
554.        pd.put("userId", userId);  
555.        pd=travelOrderService.getAllOrderDetail(pd);  
556.        String orderNumber="";  
557.        String amount="0.01";//测试金额  
558.        String orderName="";  
559.        if(pd.containsKey("orderName")){  
560.            if(!StringUtils.isBlank(pd.get("orderName")))  
561.                orderName=pd.get("orderName").toString();  
562.        }  
563.        if(pd.containsKey("orderNumber")){  
564.            if(!StringUtils.isBlank(pd.get("orderNumber")))  
565.                orderNumber=pd.get("orderNumber").toString();  
566.        }  
567.        //元转成分   
568.        String flag = sysparam.getStringParamByKey("system.flag");  
569.        if(flag=="1"||flag.equals("1")){  
570.            //type为0,3,4时取amount,type为1,2时取js_amount  
571.            if(type.equals("0")||type.equals("3")||type.equals("4")){  
572.                if(pd.containsKey("amount")){  
573.                    if(!StringUtils.isBlank(pd.get("amount")))  
574.                        amount=pd.get("amount").toString();  
575.                }  
576.            }else if(type.equals("1")||type.equals("2")){  
577.                if(pd.containsKey("js_amount")){  
578.                    if(!StringUtils.isBlank(pd.get("js_amount")))  
579.                        amount=pd.get("js_amount").toString();  
580.                }  
581.            }  
582.              
583.        }  
584.        if (logger.isInfoEnabled())  
585.        {  
586.            logger.info("PayController:payOrder:amount:[" + amount + "]==>");  
587.        }  
588.        //以分为单位  
589.        amount=floatToString(amount);  
590.        //获取生成微信二维码的url和prepayId  
591.        Map<String, Object> map=weChatPay(orderNumber,amount,type);  
592.        String imageUrl="";  
593.     f(map.containsKey("urlCode")){  
594.            if(!StringUtils.isBlank(map.get("urlCode"))){  
595.                imageUrl=map.get("urlCode").toString();  
596.            }  
597.        }  
598.         
599.        //获取生成支付宝二维码的url(金额要改成元！)  
600.        amount=stringToFloat(amount);  
601.        String aliPayCodeUrl=AliPayUtil.aliPay(orderNumber, orderName, amount, type);  
602.          
603.        map.put("type", type);  
604.        map.put("orderNumber", orderNumber);  
605.        map.put("aliPayCodeUrl", aliPayCodeUrl);  
606.          
607.        //将二维码入库  
608.        travelOrderService.updateOrderInfoByType(map);  
609.          
610.        //订单编号  
611.        pd.put("type", type);  
612.        pd.put("orderId", orderId);  
613.        mv.addObject("pd", pd);  
614.        mv.addObject("productId", orderNumber);  
615.        mv.addObject("imageUrl", imageUrl);  
616.        mv.addObject("aliPayCodeUrl", aliPayCodeUrl);  
617.        mv.setViewName("/pay/pay-4");  
618.        return mv;  
619.    }</pre><br>  
620. <p></p>  
621. <p style="font-size:14px">这里我把微信和支付宝支付前生成的二维码写在同一个方法里，<span style="font-size:14px">imageURL是微信二维码url,aliPayCodeUrl是支付宝的二维码</span>，和app支付不同的是，扫码支付需要事先生成二维码，并且二维码需要入库，并带到页面去用于显示（下面会讲）</p>  
622. <p style="font-size:14px">微信下单并生成urlCode</p>  
623. <p style="font-size:14px"></p>  
624. <pre name="code" class="java">/** 
625.     * 微信下单并返回生成二维码的url 
626.     * 〈一句话功能简述〉 
627.     * 〈功能详细描述〉 
628.     * @param orderNo 
629.     * @param TotalMoney 
630.     * @param orderType 
631.     * @return 
632.     * @throws Exception String 
633.     * 如果有违例，请使用@exception/throws [违例类型]   [违例说明：异常的注释必须说明该异常的含义及什么条件下抛出该  
634.     * @see          [类、类#方法、类#成员] 
635.     */  
636.    @SuppressWarnings("rawtypes")  
637. public Map<String, Object> weChatPay(String orderNo,String TotalMoney,String orderType) throws Exception{  
638.        URL postUrl = new URL("https://api.mch.weixin.qq.com/pay/unifiedorder");  
639.        HttpsURLConnection con = (HttpsURLConnection) postUrl.openConnection();//打开连接  
640.        con.setRequestMethod("POST");//post方式提交  
641.        con.setDoOutput(true);//打开读写属性，默认均为false  
642.        con.setDoInput(true);  
643.        con.setUseCaches(false);//Post请求不能使用缓存  
644.        con.setInstanceFollowRedirects(true);  
645.        DataOutputStream out = new DataOutputStream(con.getOutputStream());  
646.        Map<String, Object> vo = new HashMap<String, Object>();  
647.        //相关参数,可以定义一个Map做成动态的  
648.        String appid = sysparam.getStringParamByKey("c.wxpay.appid");  
649.        vo.put("appid", appid);  
650.        vo.put("attach", "支付测试");  
651.        vo.put("body", "PC端支付测试");  
652.        String mchid = sysparam.getStringParamByKey("c.wxpay.partnerid");  
653.        vo.put("mch_id",mchid);  
654.        vo.put("nonce_str", RandomUtil.CreateRandom(32));  
655.        /String notifyUrl=sysparam.getStringParamByKey("sys.pc.domain");  
656.        if (logger.isInfoEnabled())  
657.        {  
658.            logger.info("微信支付回调地址设置:notifyUrl:[" + notifyUrl + "]==>");  
659.        }  
660.        notifyUrl=notifyUrl+"/travelWeb/pay/getWeChatPayResult/"+orderType; //调用微信下发通知的接口  
661.        vo.put("notify_url", notifyUrl);  
662.        vo.put("out_trade_no", orderNo);  
663.        vo.put("spbill_create_ip", "14.23.150.211");  
664.        vo.put("total_fee", TotalMoney);  
665.        vo.put("trade_type", "NATIVE");  
666.        //转成sortedMap,微信支付后台生成sign需要排序过的map  
667.        SortedMap<String,Object> sort=new TreeMap<String,Object>(vo);  
668.        //String secrit = "YNKSK648KG70j1085YYolajdfYUI7865";  
669.        String secrit =sysparam.getStringParamByKey("c.wxpay.secret");  
670.        //生成sign  
671.        String sign=WeixinSignUtil.createSign("UTF-8", sort,secrit);  
672.        //把sign放入map中  
673.        vo.put("sign", sign);  
674.        org.dom4j.Document doc = DocumentHelper.createDocument();  
675.        Element body = DocumentHelper.createElement("xml");  
676.        XmlUtil.buildMap2xmlBody(body,vo);  
677.        doc.add(body);  
678.        //发送请求  
679.        out.writeUTF(doc.asXML());    
680.        System.out.println(doc.asXML());  
681.        out.flush();  
682.        out.close();  
683.        //接收数据    
684.        BufferedReader reader = new BufferedReader(new InputStreamReader(con.getInputStream(), "UTF-8"));    
685.        String line;    
686.        StringBuffer responseText = new StringBuffer();    
687.        while ((line = reader.readLine()) != null) {    
688.            responseText.append(line).append("\r\n");    
689.        }    
690.        reader.close();  
691.        con.disconnect();    
692.        String requestXML = responseText.toString()+"";   
693.        if (logger.isInfoEnabled())  
694.        {  
695.            logger.info("weChatPay:输出参数列表:[" + requestXML + "]==>");  
696.        }  
697.        //xml转换为map  
698.        Map map = XMLUtil.doXMLParse(requestXML);    
699.        String urlCode = (String) map.get("code_url");    
700.        String prepayId = (String) map.get("prepay_id");   
701.        //返回生成二维码的url和预支付交易会话id  
702.        Map<String, Object> resultMap=new HashMap<String, Object>();  
703.        resultMap.put("urlCode", urlCode);  
704.        resultMap.put("prepayId", prepayId);  
705.        return resultMap;   
706.    }</pre>  
707. <p></p>  
708. <p style="font-size:14px">支付宝生成urlCode</p>  
709. <p style="font-size:14px"></p>  
710. <pre name="code" class="java">/** 
711.      *  
712.      * 〈一句话功能简述〉 
713.      * 〈功能详细描述〉 
714.      * @param orderNo 
715.      *         订单号 
716.      * @param orderTitle 
717.      *         订单标题 
718.      * @param orderPrice 
719.      *         订单总额 
720.      * 如果有违例，请使用@exception/throws [违例类型]   [违例说明：异常的注释必须说明该异常的含义及什么条件下抛出该  
721.      * @see          [类、类#方法、类#成员] 
722.      */  
723.     public static String aliPay(String orderNo, String orderTitle,  
724.                               String orderPrice,String type)  
725.     {  
726.           
727.         String aliPayCodeUrl="";  
728.        // 支付超时，定义为120分钟  
729.         String timeoutExpress = "120m";  
730.     // 创建扫码支付请求builder，设置请求参数  
731.        String notifyUrl=sysParamService.getStringParamByKey("sys.pc.domain");  
732.         notifyUrl=notifyUrl+"/travelWeb/pay/getAliPayResult/"+type; //调用支付宝下发通知的接口  
733.           
734.         AlipayTradePrecreateRequestBuilder builder = new AlipayTradePrecreateRequestBuilder()  
735.             .setSubject(orderTitle)  
736.             .setTotalAmount(orderPrice)  
737.             .setOutTradeNo(orderNo)  
738.               
739.             .setStoreId(storeId)  
740.               
741.             .setTimeoutExpress(timeoutExpress)  
742.             .setNotifyUrl(notifyUrl);//支付宝服务器主动通知商户服务器里指定的页面http路径,根据需要设置  
743.        AlipayF2FPrecreateResult result = tradeService.tradePrecreate(builder);  
744.         switch (result.getTradeStatus())  
745.         {  
746.             case SUCCESS:  
747.                 logger.info("支付宝预下单成功: )");  
748.   
749.                 AlipayTradePrecreateResponse response = result.getResponse();  
750.                 System.out.println("response.getQrCode()====="  
751.                                    + response.getQrCode());  
752.                 aliPayCodeUrl=response.getQrCode();  
753.                   
754.                 break;  
755.   
756.             case FAILED:  
757.                 logger.error("支付宝预下单失败!!!");  
758.                 break;  
759.   
760.             case UNKNOWN:  
761.                 logger.error("系统异常，预下单状态未知!!!");  
762.                 break;  
763.   
764.             default:  
765.                 logger.error("不支持的交易状态，交易返回异常!!!");  
766.                 break;  
767.         }  
768.         return aliPayCodeUrl;  
769.     }</pre><br>  
770. <br>  
771. <p></p>  
772. <p style="font-size:14px"><br>  
773. </p>  
774. <p style="font-size:14px"><br>  
775. </p>  
776. 这个方法和app一样，只是多返回了一个urlcode(urlcode生成二维码，这两个方法必须都要配置回调地址<br>  
777. 下一步需要编写生成两种二维码的方法：  
778. <p style="font-size:14px"></p>  
779. <pre name="code" class="java">/** 
780.     * 生成支付宝二维码 
781.     * 〈一句话功能简述〉 
782.     * 〈功能详细描述〉 
783.     * @param response 
784.     * @param req void 
785.     * 如果有违例，请使用@exception/throws [违例类型]   [违例说明：异常的注释必须说明该异常的含义及什么条件下抛出该  
786.     * @see          [类、类#方法、类#成员] 
787.     */  
788.    @RequestMapping(value = "/createAliPayCode.do", method = RequestMethod.GET)  
789.    public void createAliPayCode(HttpServletResponse response,HttpServletRequest req)  
790.    {  
791.   
792.        String imageUrl=req.getParameter("aliPayCodeUrl");  
793.        //传入二维码连接，图片高度和宽带  
794.        BufferedImage image=ImageUtil.createImage(imageUrl,1000,1000);  
795.        try  
796.        {  
797.            ImageIO.write(image, "gif", response.getOutputStream());  
798.        }  
799.        catch (IOException e)  
800.        {  
801.            e.printStackTrace();  
802.        }  
803.          
804.         
805.    }  
806.    /** 
807.     * 微信支付二维码  
808.     * 〈一句话功能简述〉 
809.     * 〈功能详细描述〉 
810.     * @param response 
811.     * @param req void 
812.     * 如果有违例，请使用@exception/throws [违例类型]   [违例说明：异常的注释必须说明该异常的含义及什么条件下抛出该  
813.  * @throws IOException  
814.  * @throws JDOMException  
815.     * @see          [类、类#方法、类#成员] 
816.     */  
817.    @RequestMapping(value = "/createWXPayCode.do", method = RequestMethod.GET)  
818.    public void createWXPayCode(HttpServletResponse response,HttpServletRequest req) throws IOException, JDOMException  
819.    {  
820.        String imageUrl=req.getParameter("imageUrl");  
821.        //传入二维码连接，图片高度和宽带  
822.        BufferedImage image=ImageUtil.createImage(imageUrl,1000,1000);  
823.        try  
824.        {  
825.            ImageIO.write(image, "gif", response.getOutputStream());  
826.        }  
827.        catch (IOException e)  
828.        {  
829.            e.printStackTrace();  
830.        }  
831.    }</pre>  
832. <p></p>  
833. <p style="font-size:14px">这里生成二维码的方法是用谷歌zhongxin（需要导入jar包）</p>  
834. <p style="font-size:14px"></p>  
835. <pre name="code" class="java"> /** 
836.      * 生成二维码图片方法 
837.      * 〈一句话功能简述〉 
838.      * 〈功能详细描述〉 
839.      * @param text 
840.      * @return BufferedImage 
841.      * 如果有违例，请使用@exception/throws [违例类型]   [违例说明：异常的注释必须说明该异常的含义及什么条件下抛出该  
842.      * @see          [类、类#方法、类#成员] 
843.      */  
844.     @SuppressWarnings({"rawtypes", "unchecked"})  
845.     public static BufferedImage createImage(String text,int width2,int height2)  
846.     {  
847.         //二维码的图片格式   
848. //        String format = "gif";  
849.         Hashtable hints = new Hashtable();  
850.         //内容所使用编码   
851.         hints.put(EncodeHintType.CHARACTER_SET, "utf-8");  
852.         BufferedImage image = null;  
853.         try  
854.         {  
855.             BitMatrix bitMatrix = new MultiFormatWriter().encode(text,  
856.                 BarcodeFormat.QR_CODE, width2, height2, hints);  
857.   
858.             int width = bitMatrix.getWidth();  
859.             int height = bitMatrix.getHeight();  
860.             image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);  
861.             for (int x = 0; x < width; x++ )  
862.             {  
863.                 for (int y = 0; y < height; y++ )  
864.                 {  
865.                     image.setRGB(x, y,  
866.                         bitMatrix.get(x, y) ? 0xFF000000 : 0xFFFFFFFF); //二维码图片为黑白两色  
867.                 }  
868.             }  
869.         }  
870.         catch (WriterException e)  
871.         {  
872.             e.printStackTrace();  
873.         }  
874.         return image;  
875.     }</pre><br>  
876. <br>  
877. <p></p>  
878. <br>  
879. 这里吧之前传来的两个值在面里调用即可（img标签配置src)  
880. <p style="font-size:14px"></p>  
881. <pre name="code" class="html"><div class="boder-line">  
882.     <img src="<%=basePath%>/XX/pay/createWXPayCode.do?imageUrl=${imageUrl}"/>  
883. </div>  
884. <div class="boder-line">  
885.     <img src="<%=basePath%>/XX/pay/createAliPayCode.do?aliPayCodeUrl=${aliPayCodeUrl}"/>  
886. </div></pre><br>  
887. 这样打开扫码支付页面就会有生成好的支付宝和微信支付二维码图片  
888. <p></p>  
889. <p style="font-size:14px">然后发起支付，最后根据配置的回调地址返回支付结果</p>  
890. <p style="font-size:14px">微信如下：</p>  
891. <p style="font-size:14px"></p>  
892. <pre name="code" class="java"> /** 
893.     * 微信支付结果回调地址 
894.     * 〈一句话功能简述〉 
895.     * 〈功能详细描述〉 
896.     * @param request 
897.     * @param response 
898.  * @throws Exception  
899.     * @see          [类、类#方法、类#成员] 
900.     */  
901.    @SuppressWarnings({"unchecked", "rawtypes"})  
902.    @RequestMapping(value = "/getWeChatPayResult/{orderType}", produces = "text/html;charset=UTF-8")  
903.    @ResponseBody  
904.    public void getWeixinPayResult(HttpServletRequest request,  
905.                                     HttpServletResponse response)  
906.        throws Exception  
907.    {  
908.     //读取参数    
909.        InputStream inputStream ;    
910.        StringBuffer sb = new StringBuffer();    
911.        inputStream = request.getInputStream();    
912.        String s ;    
913.        BufferedReader in = new BufferedReader(new InputStreamReader(inputStream, "UTF-8"));    
914.        while ((s = in.readLine()) != null){    
915.            sb.append(s);    
916.        }    
917.        in.close();    
918.        inputStream.close();    
919.    
920.        //解析xml成map    
921.        Map<String, String> m = new HashMap<String, String>();    
922.        m = XMLUtil.doXMLParse(sb.toString());    
923.        //获取orderType  
924.        String orderType=request.getRequestURI();  
925.        int i=orderType.lastIndexOf("/");  
926.        orderType=orderType.substring(i+1, orderType.length());   
927.        logger.info("[PayController][getWeChatPayResult]:orderType:"+orderType);  
928.        //过滤空 设置 TreeMap    
929.        SortedMap<Object,Object> packageParams = new TreeMap<Object,Object>();          
930.        Iterator it = m.keySet().iterator();    
931.        while (it.hasNext()) {    
932.            String parameter = (String) it.next();    
933.            String parameterValue = m.get(parameter);    
934.                
935.            String v = "";    
936.            if(null != parameterValue) {    
937.                v = parameterValue.trim();    
938.            }    
939.            packageParams.put(parameter, v);    
940.        }    
941.     String key =sysparam.getStringParamByKey("c.wxpay.secret");  
942.        logger.info("[PayController][getWeChatPayResult]:packageParams:"+packageParams.toString());  
943.        //判断签名是否正确    
944.        if(PayCommonUtil.isTenpaySign("UTF-8", packageParams,key)) {    
945.           String resXml = "";    
946.            if("SUCCESS".equals((String)packageParams.get("result_code"))){    
947.                // 这里是支付成功    
948.                //////////执行自己的业务逻辑////////////////    
949.                String mch_id = (String)packageParams.get("mch_id");    
950.                String openid = (String)packageParams.get("openid");    
951.                String is_subscribe = (String)packageParams.get("is_subscribe");    
952.                String out_trade_no = (String)packageParams.get("out_trade_no");    
953.                    
954.                String total_fee = (String)packageParams.get("total_fee");    
955.                    
956.                logger.info("[PayController][getWeChatPayResult]:mch_id:"+mch_id+",openid:"+openid+",is_subscribe:"+is_subscribe+",out_trade_no:"+out_trade_no+",total_fee:"+total_fee);    
957.                //////////执行自己的业务逻辑////////////////    
958.                //支付成功后操作....</pre><pre name="code" class="java">              //通知微信.异步确认成功.必写.不然会一直通知后台.八次之后就认为交易失败了.    
959.                resXml = "<xml>" + "<return_code><![CDATA[SUCCESS]]></return_code>"    
960.                        + "<return_msg><![CDATA[OK]]></return_msg>" + "</xml> ";    
961.                    
962.            } else {    
963.                logger.info("支付失败,错误信息：" + packageParams.get("err_code"));    
964.                resXml = "<xml>" + "<return_code><![CDATA[FAIL]]></return_code>"    
965.                        + "<return_msg><![CDATA[报文为空]]></return_msg>" + "</xml> ";    
966.            }    
967.            //------------------------------    
968.            //处理业务完毕    
969.            //------------------------------    
970.            BufferedOutputStream out = new BufferedOutputStream(    
971.                    response.getOutputStream());    
972.            out.write(resXml.getBytes());    
973.            out.flush();    
974.            out.close();    
975.        } else{    
976.            logger.info("[WeiXinPayResultInterface][getWeChatPayResult]:通知签名验证失败");  
977.        }   
978.         
979.     }</pre>支付宝如下：<br>  
980. <br>  
981. <p></p>  
982. <p style="font-size:14px"></p>  
983. <pre name="code" class="java">/** 
984.     * 支付宝支付回调接口  
985.     * 〈一句话功能简述〉 
986.     * 〈功能详细描述〉 
987.     * @param request 
988.     * @param response 
989.     * @return String 
990.     * 如果有违例，请使用@exception/throws [违例类型]   [违例说明：异常的注释必须说明该异常的含义及什么条件下抛出该  
991.  * @throws Exception  
992.     * @see          [类、类#方法、类#成员] 
993.     */  
994.    @RequestMapping(value = "/getAliPayResult/{type}", method = RequestMethod.POST)  
995.    public void getAliPayResult(HttpServletRequest request, HttpServletResponse response) throws Exception {  
996.      logger.info("[PayController][getAliPayResult]: 收到支付宝异步通知！");  
997.      Map<String, String> params = new HashMap<String, String>();  
998.     
999.      //取出所有参数是为了验证签名  
1000.      @SuppressWarnings("unchecked")  
1001.     Enumeration<String> parameterNames = request.getParameterNames();  
1002.      while (parameterNames.hasMoreElements()) {  
1003.        String parameterName = parameterNames.nextElement();  
1004.        params.put(parameterName, request.getParameter(parameterName));  
1005.      }  
1006.      //获取orderType  
1007.      String orderType=request.getRequestURI();  
1008.      int i=orderType.lastIndexOf("/");  
1009.      orderType=orderType.substring(i+1, orderType.length());   
1010.      logger.info("[PayController][getAliPayResult]:orderType:"+orderType);  
1011.      logger.info("[PayController][getAliPayResult]:支付宝返回参数 params:"+params.toString());  
1012.      logger.info("[PayController][getAliPayResult]:配置文件中取出公钥:"+Const.ALIPAYPUBLICKEY);  
1013.      boolean signVerified = false;  
1014.      try {  
1015.        signVerified = AlipaySignature.rsaCheckV1(params, Const.ALIPAYPUBLICKEY, "UTF-8");  
1016.        logger.info("[PayController][getAliPayResult]signVerified:"+signVerified);  
1017.      } catch (AlipayApiException e) {  
1018.        logger.info("[PayController][getAliPayResult]:验证签名失败！");  
1019.        e.printStackTrace();  
1020.      }  
1021.      if (signVerified) {  
1022.        String outtradeno = params.get("out_trade_no");  
1023.        logger.info("[PayController][getAliPayResult]:"+outtradeno + "号订单回调通知。");  
1024.        logger.info("[PayController][getAliPayResult]:验证签名成功！");  
1025.        logger.info("[PayController][getWeChatPayResult]:params"+params.toString());    
1026.        //若参数中的appid和填入的appid不相同，则为异常通知  
1027.        if (!Const.APPID.equals(params.get("app_id"))) {  
1028.          logger.info("[PayController][getAliPayResult]:与付款时的appid不同，此为异常通知，应忽略！");  
1029.        }  
1030.        String status = params.get("trade_status");  
1031.        //如果状态是已经支付成功  
1032.        if (status.equals("TRADE_SUCCESS") || status.equals("TRADE_FINISHED")) {   
1033.            //支付宝支付成功后操作...</pre><pre name="code" class="java">      }  
1034.        logger.info("[PayController][getAliPayResult]:"+outtradeno + "订单的状态已经修改为 :" + status);  
1035.      } else { //如果验证签名没有通过  
1036.        logger.info("[PayController][getAliPayResult]:如果验证签名没有通过");  
1037.      }  
1038.     }</pre><br>  
1039. <br>  
1040. <p></p>  
1041. <p style="font-size:14px"><br>  
1042. <br>  
1043. </p>  
1044. <p style="font-size:14px"><br>  
1045. </p>  
1046. <br>  
1047. <br>  
1048.