手把手教你完成App支付JAVA微信支付

于 2019-07-18 07:40:00 发布
阅读量288 收藏 3
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45737309/article/details/102718317
版权

                                                     

640?wx_fmt=jpeg文章代码比例比价多建议收藏自己去实现。


一：支付流程：

这篇内容看标题已经很明确了，由于微信是用xml通讯的，所以这一点比较恶心，各位可能需要在项目里导入一些解析xml的包。
首先放出工具类（包含支付宝用到的工具类），因为现在csdn下载都是扣积分的，因为工具类代码会在文尾贴出。 

首先我在重新贴一下支付流程图吧，我再重复一遍，一定要认真看流程图，这样对你业务逻辑的处理有很大的提升。 

640?wx_fmt=png

知道了支付的大致流程，接下来就要分析如何支付了。在我的项目里，

支付的流程是这样的：

 
 
首先，选择商品和数量等，点击下单，此时会在后台生成一张下单表，此表中的任何一条数据，有效期都在半小时内。半小时后该条下单数据就失效了。因此应该在半小时内完成支付。 
 
 
下单后支付时，后台返回手机端预付单，此时调起微信完成支付。支付后的结果和支付宝一样，依然需要调用后台的数据以确保交易的正确性。虽然很繁琐，但是涉及到金钱的业务，一定要谨慎，作为程序员，我们也要对自己写的代码负责。
 
 
 
 

 
 
 
 
接下来，就从预付单开始说起吧，假设现在已经下了单，那么此时支付的话，需要后台返回给手机端预付单，那么代码就来了：（用到的工具类在文章开头或文末）
 
 

   
 
 
 
  
@ValidatePermission(value = PermissionValidateType.Validate)
@Override
public BaseResult<Orders> getWXPay(BaseRequest<Orders> baseRequest)
 {
 BaseResult<Orders> baseResult = new BaseResult<>()
 LogUtil.debugLog(logger, baseRequest)
 Orders orders = baseRequest.getData()
 Double price = orders.getOrderAmount()
if (price <= 0) // 防止抓包修改订单金额造成损失
 {
 baseResult.setState(-999)
 baseResult.setMsg("付款金额错误!")
 baseResult.setSuccess(false)
return baseResult
 }
try
 {
 SortedMap<Object, Object> parameters = PayCommonUtil.getWXPrePayID()

 TravelFly travelFly = new TravelFly()
 travelFly.setId(orders.getProductId())
 travelFly = travelFlyMapper.selectById(travelFly)
 travelFly.setBusinesser(businesserMapper.selectByPrimaryKey(travelFly.getBusinesserId()))
 orders.setTravelFly(travelFly)
 parameters.put("body", "xxx产品-" + travelFly.getProductName())

 parameters.put("spbill_create_ip", this.request.getRemoteAddr())
 parameters.put("out_trade_no", orders.getId() + PayCommonUtil.getDateStr())
 parameters.put("total_fee", "1")
// parameters.put("total_fee", orders.getOrderAmount()*100+"")

// 设置签名
String sign = PayCommonUtil.createSign("UTF-8", parameters)
 parameters.put("sign", sign)
// 封装请求参数结束
String requestXML = PayCommonUtil.getRequestXml(parameters)
 logger.debug("封装请求参数是：" + requestXML)
// 调用统一下单接口
String result = PayCommonUtil.httpsRequest(PropertyUtil.getInstance().getProperty("WxPay.payURL"), "POST",
 requestXML)
 logger.debug("调用统一下单接口：" + result)
 SortedMap<Object, Object> parMap = PayCommonUtil.startWXPay(result)
 logger.debug("最终的map是：" + parMap.toString())
if (parMap != null)
 {
 orders.setWxPayOrderString(JSON.toJSONString(parMap))
 baseResult.setData(orders)
 } else
 {
 baseResult.setState(-999)
 baseResult.setMsg("支付出现异常，请稍后重试!")
 baseResult.setSuccess(false)
 }
 } catch (Exception e)
 {
 e.printStackTrace()
 baseResult.setState(-999)
 baseResult.setMsg("程序异常!")
 baseResult.setSuccess(false)
 logger.error(e.getMessage())
 }
return baseResult
 }
 
 
 
 

 
 
由于测试的时候一定会在外网测试，因为实际支付结果会通知给后台，所以这里为了调试方便，就将日志保存成了文本。
 
 
 
  
/**
 * 微信异步通知
 */
 @SuppressWarnings("unchecked")
 @ValidatePermission
 @RequestMapping("/wx")
 @ResponseBody
 public void wxNotify(HttpServletRequest request, HttpServletResponse response) throws IOException, JDOMException
 {
 String result = PayCommonUtil.reciverWx(request); // 接收到异步的参数
 Map<String, String> m = new HashMap<String, String>();// 解析xml成map
 if (m != null && !"".equals(m))
 {
 m = XMLUtil.doXMLParse(result);
 }
 // 过滤空 设置 TreeMap
 SortedMap<Object, Object> packageParams = new TreeMap<Object, Object>();
 Iterator it = m.keySet().iterator();
 while (it.hasNext())
 {
 String parameter = (String) it.next();
 String parameterValue = m.get(parameter);
 String v = "";
 if (null != parameterValue)
 {
 v = parameterValue.trim();
 }
 packageParams.put(parameter, v);
 }
 // 判断签名是否正确
 String resXml = "";
 if (PayCommonUtil.isTenpaySign("UTF-8", packageParams))
 {
 if ("SUCCESS".equals((String) packageParams.get("return_code")))
 {
 // 如果返回成功
 String mch_id = (String) packageParams.get("mch_id"); // 商户号
 String out_trade_no = (String) packageParams.get("out_trade_no"); // 商户订单号
 String total_fee = (String) packageParams.get("total_fee");
 // String transaction_id = (String)
 // packageParams.get("transaction_id"); // 微信支付订单号
 // 查询订单 根据订单号查询订单
 String orderId = out_trade_no.substring(0, out_trade_no.length() - PayCommonUtil.TIME.length());
 Orders orders = ordersMapper.selectByPrimaryKey(Integer.parseInt(orderId));

 // 验证商户ID 和 价格 以防止篡改金额
 if (PropertyUtil.getInstance().getProperty("WxPay.mchid").equals(mch_id) && orders != null
 // &&
 // total_fee.trim().toString().equals(orders.getOrderAmount())
 // // 实际项目中将此注释删掉，以保证支付金额相等
 )
 {
 /** 这里是我项目里的消费状态
 * 1.待付款=0 2.付款完成=1
 * 3.消费成功=2
 * 4.取消=-1
 * 5.发起退款=-2
 * 6.退款成功=-3
 * 7.退款失败=3（由于商户拒绝退款或其他原因导致退款失败）
 */
 insertWxNotice(packageParams);
 orders.setPayWay("1"); // 变更支付方式为wx
 orders.setOrderState("1"); // 订单状态为已付款

 ordersMapper.updateByPrimaryKeySelective(orders); // 变更数据库中该订单状态
 // ordersMapper.updatePayStatus(Integer.parseInt(orderId));
 resXml = "<xml>" + "<return_code><![CDATA[SUCCESS]]></return_code>"
 + "<return_msg><![CDATA[OK]]></return_msg>" + "</xml> ";
 } else
 {
 resXml = "<xml>" + "<return_code><![CDATA[FAIL]]></return_code>"
 + "<return_msg><![CDATA[参数错误]]></return_msg>" + "</xml> ";
 }
 } else // 如果微信返回支付失败，将错误信息返回给微信
 {
 resXml = "<xml>" + "<return_code><![CDATA[FAIL]]></return_code>"
 + "<return_msg><![CDATA[交易失败]]></return_msg>" + "</xml> ";
 }
 } else
 {
 resXml = "<xml>" + "<return_code><![CDATA[FAIL]]></return_code>"
 + "<return_msg><![CDATA[通知签名验证失败]]></return_msg>" + "</xml> ";
 }

 // 处理业务完毕，将业务结果通知给微信
 // ------------------------------
 BufferedOutputStream out = new BufferedOutputStream(response.getOutputStream());
 out.write(resXml.getBytes());
 out.flush();
 out.close();
 }
 
 
 
 
 
 

 
 

 
 
附：工具类代码：
 
 
 
  
package com.loveFly.utils;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.io.UnsupportedEncodingException;
import java.net.ConnectException;
import java.net.URL;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Iterator;
import java.util.Map;
import java.util.Random;
import java.util.Set;
import java.util.SortedMap;
import java.util.TreeMap;

import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSocketFactory;
import javax.net.ssl.TrustManager;
import javax.servlet.http.HttpServletRequest;

import com.alibaba.fastjson.JSONObject;
import com.alipay.api.AlipayClient;
import com.alipay.api.DefaultAlipayClient;

public class PayCommonUtil
{
public static final String TIME = "yyyyMMddHHmmss";

/**
 * 创建支付宝交易对象
 */
public static AlipayClient getAliClient()
 {
 AlipayClient alipayClient = new DefaultAlipayClient(PropertyUtil.getInstance().getProperty("AliPay.payURL"),
 PropertyUtil.getInstance().getProperty("AliPay.appId"),
 PropertyUtil.getInstance().getProperty("AliPay.privateKey"), "json", "utf-8",
 PropertyUtil.getInstance().getProperty("AliPay.publicKey"), "RSA2");
return alipayClient;
 }

/**
 * 创建微信交易对象
 */
public static SortedMap<Object, Object> getWXPrePayID()
 {
 SortedMap<Object, Object> parameters = new TreeMap<Object, Object>();
 parameters.put("appid", PropertyUtil.getInstance().getProperty("WxPay.appid"));
 parameters.put("mch_id", PropertyUtil.getInstance().getProperty("WxPay.mchid"));
 parameters.put("nonce_str", PayCommonUtil.CreateNoncestr());
 parameters.put("fee_type", "CNY");
 parameters.put("notify_url", PropertyUtil.getInstance().getProperty("WxPay.notifyurl"));
 parameters.put("trade_type", "APP");
return parameters;
 }

/**
 * 再次签名，支付
 */
public static SortedMap<Object, Object> startWXPay(String result)
 {
try
 {
 Map<String, String> map = XMLUtil.doXMLParse(result);
 SortedMap<Object, Object> parameterMap = new TreeMap<Object, Object>();
 parameterMap.put("appid", PropertyUtil.getInstance().getProperty("WxPay.appid"));
 parameterMap.put("partnerid", PropertyUtil.getInstance().getProperty("WxPay.mchid"));
 parameterMap.put("prepayid", map.get("prepay_id"));
 parameterMap.put("package", "Sign=WXPay");
 parameterMap.put("noncestr", PayCommonUtil.CreateNoncestr());

 parameterMap.put("timestamp",
 Long.parseLong(String.valueOf(System.currentTimeMillis()).toString().substring(0, 10)));
String sign = PayCommonUtil.createSign("UTF-8", parameterMap);
 parameterMap.put("sign", sign);
return parameterMap;
 } catch (Exception e)
 {
 e.printStackTrace();
 }
return null;
 }

/**
 * 创建随机数
 *
 * @param length
 * @return
 */
public static String CreateNoncestr()
 {
String chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
String res = "";
for (int i = 0; i < 16; i++)
 {
 Random rd = new Random();
 res += chars.charAt(rd.nextInt(chars.length() - 1));
 }
return res;
 }

/**
 * 是否签名正确,规则是:按参数名称a-z排序,遇到空值的参数不参加签名。
 *
 * @return boolean
 */
public static boolean isTenpaySign(String characterEncoding, SortedMap<Object, Object> packageParams)
 {
 StringBuffer sb = new StringBuffer();
 Set es = packageParams.entrySet();
 Iterator it = es.iterator();
while (it.hasNext())
 {
 Map.Entry entry = (Map.Entry) it.next();
String k = (String) entry.getKey();
String v = (String) entry.getValue();
if (!"sign".equals(k) && null != v && !"".equals(v))
 {
 sb.append(k + "=" + v + "&");
 }
 }
 sb.append("key=" + PropertyUtil.getInstance().getProperty("WxPay.key"));

String mysign = MD5Util.MD5Encode(sb.toString(), characterEncoding).toLowerCase();
String tenpaySign = ((String) packageParams.get("sign")).toLowerCase();

return tenpaySign.equals(mysign);
 }

/**
 * @Description：创建sign签名
 * @param characterEncoding
 * 编码格式
 * @param parameters
 * 请求参数
 * @return
 */
public static String createSign(String characterEncoding, SortedMap<Object, Object> parameters)
 {
 StringBuffer sb = new StringBuffer();
 Set es = parameters.entrySet();
 Iterator it = es.iterator();
while (it.hasNext())
 {
 Map.Entry entry = (Map.Entry) it.next();
String k = (String) entry.getKey();
Object v = entry.getValue();
if (null != v && !"".equals(v) && !"sign".equals(k) && !"key".equals(k))
 {
 sb.append(k + "=" + v + "&");
 }
 }
 sb.append("key=" + PropertyUtil.getInstance().getProperty("WxPay.key"));
String sign = MD5Util.MD5Encode(sb.toString(), characterEncoding).toUpperCase();
return sign;
 }

/**
 * @Description：将请求参数转换为xml格式的string
 * @param parameters
 * 请求参数
 * @return
 */
public static String getRequestXml(SortedMap<Object, Object> parameters)
 {
 StringBuffer sb = new StringBuffer();
 sb.append("<xml>");
 Set es = parameters.entrySet();
 Iterator it = es.iterator();
while (it.hasNext())
 {
 Map.Entry entry = (Map.Entry) it.next();
String k = (String) entry.getKey();
String v = (String) entry.getValue();
if ("attach".equalsIgnoreCase(k) || "body".equalsIgnoreCase(k))
 {
 sb.append("<" + k + ">" + "<![CDATA[" + v + "]]></" + k + ">");
 } else
 {
 sb.append("<" + k + ">" + v + "</" + k + ">");
 }
 }
 sb.append("</xml>");
return sb.toString();
 }

/**
 * @Description：返回给微信的参数
 * @param return_code
 * 返回编码
 * @param return_msg
 * 返回信息
 * @return
 */
public static String setXML(String return_code, String return_msg)
 {
return "<xml><return_code><![CDATA[" + return_code + "]]></return_code><return_msg><![CDATA[" + return_msg
 + "]]></return_msg></xml>";
 }

/**
 * 发送https请求
 *
 * @param requestUrl
 * 请求地址
 * @param requestMethod
 * 请求方式（GET、POST）
 * @param outputStr
 * 提交的数据
 * @return 返回微信服务器响应的信息
 */
public static String httpsRequest(String requestUrl, String requestMethod, String outputStr)
 {
try
 {

 TrustManager[] tm =
 { new TrustManagerUtil() };
 SSLContext sslContext = SSLContext.getInstance("SSL", "SunJSSE");
 sslContext.init(null, tm, new java.security.SecureRandom());

 SSLSocketFactory ssf = sslContext.getSocketFactory();
 URL url = new URL(requestUrl);
 HttpsURLConnection conn = (HttpsURLConnection) url.openConnection();

 conn.setDoOutput(true);
 conn.setDoInput(true);
 conn.setUseCaches(false);

 conn.setRequestMethod(requestMethod);
 conn.setRequestProperty("content-type", "application/x-www-form-urlencoded");

if (null != outputStr)
 {
 OutputStream outputStream = conn.getOutputStream();

 outputStream.write(outputStr.getBytes("UTF-8"));
 outputStream.close();
 }

 InputStream inputStream = conn.getInputStream();
 InputStreamReader inputStreamReader = new InputStreamReader(inputStream, "UTF-8");
 BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
String str = null;
 StringBuffer buffer = new StringBuffer();
while ((str = bufferedReader.readLine()) != null)
 {
 buffer.append(str);
 }

 bufferedReader.close();
 inputStreamReader.close();
 inputStream.close();
 inputStream = null;
 conn.disconnect();
return buffer.toString();
 } catch (ConnectException ce)
 {

 } catch (Exception e)
 {

 }
return null;
 }

/**
 * 发送https请求
 *
 * @param requestUrl
 * 请求地址
 * @param requestMethod
 * 请求方式（GET、POST）
 * @param outputStr
 * 提交的数据
 * @return JSONObject(通过JSONObject.get(key)的方式获取json对象的属性值)
 */
public static JSONObject httpsRequest(String requestUrl, String requestMethod)
 {
 JSONObject jsonObject = null;
try
 {

 TrustManager[] tm =
 { new TrustManagerUtil() };
 SSLContext sslContext = SSLContext.getInstance("SSL", "SunJSSE");
 sslContext.init(null, tm, new java.security.SecureRandom());

 SSLSocketFactory ssf = sslContext.getSocketFactory();
 URL url = new URL(requestUrl);
 HttpsURLConnection conn = (HttpsURLConnection) url.openConnection();

 conn.setDoOutput(true);
 conn.setDoInput(true);
 conn.setUseCaches(false);
 conn.setConnectTimeout(3000);

 conn.setRequestMethod(requestMethod);




 InputStream inputStream = conn.getInputStream();
 InputStreamReader inputStreamReader = new InputStreamReader(inputStream, "UTF-8");
 BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
String str = null;
 StringBuffer buffer = new StringBuffer();
while ((str = bufferedReader.readLine()) != null)
 {
 buffer.append(str);
 }

 bufferedReader.close();
 inputStreamReader.close();
 inputStream.close();
 inputStream = null;
 conn.disconnect();
 jsonObject = JSONObject.parseObject(buffer.toString());
 } catch (ConnectException ce)
 {

 } catch (Exception e)
 {
 System.out.println(e);

 }
return jsonObject;
 }

public static String urlEncodeUTF8(String source)
 {
String result = source;
try
 {
 result = java.net.URLEncoder.encode(source, "utf-8");
 } catch (UnsupportedEncodingException e)
 {
 e.printStackTrace();
 }
return result;
 }

/**
 * 接收微信的异步通知
 *
 * @throws IOException
 */
public static String reciverWx(HttpServletRequest request) throws IOException
 {
 InputStream inputStream;
 StringBuffer sb = new StringBuffer();
 inputStream = request.getInputStream();
String s;
 BufferedReader in = new BufferedReader(new InputStreamReader(inputStream, "UTF-8"));
while ((s = in.readLine()) != null)
 {
 sb.append(s);
 }
in.close();
 inputStream.close();
return sb.toString();
 }

/**
 * 产生num位的随机数
 *
 * @return
 */
public static String getRandByNum(int num)
 {
String length = "1";
for (int i = 0; i < num; i++)
 {
 length += "0";
 }
 Random rad = new Random();
String result = rad.nextInt(Integer.parseInt(length)) + "";
if (result.length() != num)
 {
return getRandByNum(num);
 }
return result;
 }

/**
 * 返回当前时间字符串
 *
 * @return yyyyMMddHHmmss
 */
public static String getDateStr()
 {
 SimpleDateFormat sdf = new SimpleDateFormat(TIME);
return sdf.format(new Date());
 }

/**
 * 将日志保存至指定路径
 *
 * @param path
 * @param str
 */
public static void saveLog(String path, String str)
 {
 File file = new File(path);
 FileOutputStream fos = null;
try
 {
 fos = new FileOutputStream(path);
 fos.write(str.getBytes());
 fos.close();
 } catch (FileNotFoundException e)
 {
 e.printStackTrace();
 } catch (IOException e)
 {
 e.printStackTrace();
 }
 }

public static void saveE(String path, Exception exception)
 {
try {
 int i = 1 / 0;
 } catch (final Exception e) {
try {
new PrintWriter(new BufferedWriter(new FileWriter(
 path, true)), true).println(new Object() {
public String toString() {
 StringWriter stringWriter = new StringWriter();
 PrintWriter writer = new PrintWriter(stringWriter);
 e.printStackTrace(writer);
 StringBuffer buffer = stringWriter.getBuffer();
return buffer.toString();
 }
 });
 } catch (IOException e1) {
 e1.printStackTrace();
 }
 }

 }
}
 
 
 
 
至此，一套完整的支付流程就跑完了，。可以直接拷贝到项目里用，前提是公钥私钥AppId等都没有问题哦。
ok本系列第三方支付就到此为止，如果真的帮到你，那真的是太好了。
 


                

        

        

    




    

      

        

            

              
                
                  weixin_45737309
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                    1
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    3
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      










              

  



          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

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

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值