微信jsapi支付

丑小鸭_

1746人浏览 · 2021-08-10 21:44:44

丑小鸭_ · 2021-08-10 21:44:44 发布

1、场景说明

微信有三种用于网页支付的方式：

1. jsapi支付
  
  用户在微信内打开的网站，可以用此方式
2. h5支付
  
  用户在其他浏览器打开的网站，可以用此方式
3. Native支付
  
  生成二维码支付，用此方式，一般用于pc端

2、接入前准备

设置支付目录

登录微信支付商户平台(pay.weixin.qq.com)-->产品中心-->开发配置，设置后一般5分钟内生效。
设置授权域名

3、统一下单

统一下单官方文档地址： https://pay.weixin.qq.com/wiki/doc/api/jsapi.php?chapter=9_1

URL地址：https://api.mch.weixin.qq.com/pay/unifiedorder
数据格式：提交和返回数据都为XML格式，根节点名为xml
采用POst提交

		 Map<String, String> params = new HashMap<String, String>();
		 //生成订单号
		 String orderNo = WxPayUtil.generateOrderNo();
		 params.put("out_trade_no", orderNo);
		 //appId
		 String appId = wxServiceConfig.getWxAppId();
		 params.put("appid", appId);
		 //商户Id
		 String mchId = wxServiceConfig.getWxMchId();
		 params.put("mch_id", mchId);
		 //随机字符串
		 String nonceStr = UuidUtil.uuid();
		 params.put("nonce_str", nonceStr);
		 //商品描述
		 String body = serviceConfig.getGoodsName();
		 params.put("body", body);
		 //用户标识
		 params.put("openid", openId);
		 //总金额
		 Integer totalFree = serviceConfig.getDeposit(); 
		 params.put("total_fee", String.valueOf(totalFree));
		 //终端Ip
		 String spbillCreateIp=IPUtils.getIpAddr();
		 params.put("spbill_create_ip", spbillCreateIp);
		 //异步通知地址 用于支付成功后的通知地址需外网可访问
		 String notifyUrl=wxServiceConfig.getWxNotifyUrl();
		 params.put("notify_url", notifyUrl);
		 //交易类型 H5支付的交易类型为MWEB
		 String tradeType = "JSAPI"; 
		 params.put("trade_type", tradeType);
		 //生成签名的xml
		 String paramsXml = WxPayUtil.generateSignedXml(params, wxServiceConfig.getWxPayKey());
                 //下单
                 Result wxH5Pay = wxService.wxH5Pay(paramsXml);
                 Map<String,String> resultMap = (Map<String, String>) wxH5Pay.getObject();
                 //得到付款页面地址
                 String prepayId = resultMap.get("prepay_id");

4、生成付款所需数据及签名

		 Map paySignMap = new HashMap<String,String>();
		 //时间戳
		 paySignMap.put("timeStamp", timestamp);
		 //公众appID
		 paySignMap.put("appId", wxServiceConfig.getWxAppId());
		 //随机字符串
		 paySignMap.put("nonceStr", payStr);
		 //签名类型
		 paySignMap.put("signType", "MD5");
		 //订单详情扩展字符串 统一下单接口返回的prepay_id
		 paySignMap.put("package", "prepay_id="+prepayId);
		 //生成签名
		 String  paySign = WxPayUtil.generateSignature(paySignMap, wxServiceConfig.getWxPayKey());

5、发起付款

wx.chooseWXPay({
  timestamp: 0, // 支付签名时间戳，注意微信jssdk中的所有使用timestamp字段均为小写。但最新版的支付后台生成签名使用的timeStamp字段名需大写其中的S字符
  nonceStr: '', // 支付签名随机串，不长于 32 位
  package: '', // 统一支付接口返回的prepay_id参数值，提交格式如：prepay_id=\*\*\*)
  signType: '', // 微信支付V3的传入RSA,微信支付V2的传入格式与V2统一下单的签名格式保持一致
  paySign: '', // 支付签名
  success: res {
    // 支付成功后的回调函数
  } ，
  fail:()=>{
  //支付失败
  },
  cancel:()=>{
  //"取消支付"         
  },
});

6、支付回调

官方文档地址： https://pay.weixin.qq.com/wiki/doc/api/jsapi.php?chapter=9_7&index=8

/****
	 * 微信支付回调方法
	 * @param request
	 * @param response
	 */
	@RequestMapping(value="/wxPayNotify")
	public void wxPayNotify(HttpServletRequest request, HttpServletResponse response){
        try {
        	// 拿到微信回调信息
        	ServletInputStream inputStream = request.getInputStream();
        	//转成Map
        	Map<String, String> resultMap = WxPayUtil.steamToMap(inputStream);
        	//状态返回码
        	String return_code = resultMap.get("return_code");
			if("SUCCESS".equals(return_code)) {
				//获取业务结果
				String result_code =  resultMap.get("result_code");
				if("SUCCESS".equals(result_code)) {
					 //查询wx配置
					 WxServiceConfig wxServiceConfig = wxService.findWxServiceConfig(Constans.WX_SERVICE_CONFIG_ID);
					//验证签名
					boolean signatureValid = WxPayUtil.isSignatureValid(resultMap, wxServiceConfig.getWxPayKey());
					if(signatureValid) {//签名验证通过
						//获取订单号
						String orderNo = resultMap.get("out_trade_no");
						//查询出订单
						SysOrder sysOrder = businessService.findSysOrderByOrderNo(orderNo);
						if(ObjectUtils.isNotEmpty(sysOrder)) {//验证订单号
							//获取付款金额
							Integer totalFree = Integer.valueOf(resultMap.get("total_fee"));
							if(totalFree.equals(sysOrder.getTotalFree())) {//比对金额
								 //修改订单状态
								 sysOrder.setOrderState(Constans.WX_USER_INFO_IS_PAY);
								 //获取支付的时间
								 String endTimeStr = resultMap.get("time_end");
								 //转换成时间类型
								 Date endTime = DateFormat.StringToDate(endTimeStr, "yyyyMMddHHmmss");
								 sysOrder.setEndTime(endTime);
								 sysOrder.setTransactioId(resultMap.get("transaction_id"));
								 //更新数据库
								 Result saveNewOrder = businessService.saveNewOrder(sysOrder);
								 ServiceConfig serviceConfig = businessService.findServiceConfig(sysOrder.getConfigId());
                                                                  //处理自己的逻辑
								 if(saveNewOrder.getCode() == 200) {
									String returnXml = WxPayUtil.setXML("SUCCESS", "OK");
									PrintWriter writer = response.getWriter();
									writer.write(returnXml);
									writer.close();									 
								 }
								 
							}
						}
					}
				}
			}
        }catch (Exception e) {
        	logger.error(e);
        	logger.error("----处理支付成功逻辑失败!-----");
		}
	}

7、微信工具类

package com.ymwk.wx.util;
 
import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.io.StringWriter;
import java.security.MessageDigest;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.Random;
import java.util.Set;
 
import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
 
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
 
public class WxPayUtil {
	
	
	/***
	 * 回调返回信息
	 * @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>";
    }
	
	/**
	 * 生成订单号
	 * @return
	 */
	public static String generateOrderNo(){
		Date date=new Date();
		SimpleDateFormat sdf=new SimpleDateFormat("yyyyMMddhhmmss");
		String format = sdf.format(date);
	    Random random=new Random();
        for(int i=0;i<3;i++){
        	format+=random.nextInt(10);
        }
		return format;
	}
	
	
	public enum SignType {
        MD5, HMACSHA256
    }
    /**
     * XML格式字符串转换为Map
     *
     * @param strXML XML字符串
     * @return XML数据转换后的Map
     * @throws Exception
     */
    public static Map<String, String> xmlToMap(String strXML) throws Exception {
    	return steamToMap(new ByteArrayInputStream(strXML.getBytes("UTF-8")));
    }
    
    /**
     * strem Xml转换为Map
     *
     * @param stream XML流
     * @return XML数据转换后的Map
     * @throws Exception
     */
    public static Map<String, String> steamToMap(InputStream stream) throws Exception {
        try {
            Map<String, String> data = new HashMap<String, String>();
            DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
            DocumentBuilder documentBuilder = documentBuilderFactory.newDocumentBuilder();
            org.w3c.dom.Document doc = documentBuilder.parse(stream);
            doc.getDocumentElement().normalize();
            NodeList nodeList = doc.getDocumentElement().getChildNodes();
            for (int idx = 0; idx < nodeList.getLength(); ++idx) {
                Node node = nodeList.item(idx);
                if (node.getNodeType() == Node.ELEMENT_NODE) {
                    org.w3c.dom.Element element = (org.w3c.dom.Element) node;
                    data.put(element.getNodeName(), element.getTextContent());
                }
            }
            try {
                stream.close();
            } catch (Exception ex) {
            }
            return data;
        } catch (Exception ex) {
        	WxPayUtil.getLogger().warn("Invalid XML, can not convert to map. Error message: {}. XML content: {}", ex.getMessage(), stream);
            throw ex;
        }
    }
    
    
    
    
 
    /**
     * 将Map转换为XML格式的字符串
     *
     * @param data Map类型数据
     * @return XML格式的字符串
     * @throws Exception
     */
    public static String mapToXml(Map<String, String> data) throws Exception {
        DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
        DocumentBuilder documentBuilder= documentBuilderFactory.newDocumentBuilder();
        org.w3c.dom.Document document = documentBuilder.newDocument();
        org.w3c.dom.Element root = document.createElement("xml");
        document.appendChild(root);
        for (String key: data.keySet()) {
            String value = data.get(key);
            if (value == null) {
                value = "";
            }
            value = value.trim();
            org.w3c.dom.Element filed = document.createElement(key);
            filed.appendChild(document.createTextNode(value));
            root.appendChild(filed);
        }
        TransformerFactory tf = TransformerFactory.newInstance();
        Transformer transformer = tf.newTransformer();
        DOMSource source = new DOMSource(document);
        transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
        transformer.setOutputProperty(OutputKeys.INDENT, "yes");
        StringWriter writer = new StringWriter();
        StreamResult result = new StreamResult(writer);
        transformer.transform(source, result);
        String output = writer.getBuffer().toString(); //.replaceAll("\n|\r", "");
        try {
            writer.close();
        }
        catch (Exception ex) {
        }
        return output;
    }
 
 
    /**
     * 生成带有 sign 的 XML 格式字符串
     *
     * @param data Map类型数据
     * @param key API密钥
     * @return 含有sign字段的XML
     */
    public static String generateSignedXml(final Map<String, String> data, String key) throws Exception {
        return generateSignedXml(data, key, SignType.MD5);
    }
 
    /**
     * 生成带有 sign 的 XML 格式字符串
     *
     * @param data Map类型数据
     * @param key API密钥
     * @param signType 签名类型
     * @return 含有sign字段的XML
     */
    public static String generateSignedXml(final Map<String, String> data, String key, SignType signType) throws Exception {
        String sign = generateSignature(data, key, signType);
        data.put("sign", sign);
        return mapToXml(data);
    }
 
 
    /**
     * 判断签名是否正确
     *
     * @param xmlStr XML格式数据
     * @param key API密钥
     * @return 签名是否正确
     * @throws Exception
     */
    public static boolean isSignatureValid(String xmlStr, String key) throws Exception {
        Map<String, String> data = xmlToMap(xmlStr);
        if (!data.containsKey("sign") ) {
            return false;
        }
        String sign = data.get("sign");
        return generateSignature(data, key).equals(sign);
    }
 
    /**
     * 判断签名是否正确，必须包含sign字段，否则返回false。使用MD5签名。
     *
     * @param data Map类型数据
     * @param key API密钥
     * @return 签名是否正确
     * @throws Exception
     */
    public static boolean isSignatureValid(Map<String, String> data, String key) throws Exception {
        return isSignatureValid(data, key, SignType.MD5);
    }
 
    /**
     * 判断签名是否正确，必须包含sign字段，否则返回false。
     *
     * @param data Map类型数据
     * @param key API密钥
     * @param signType 签名方式
     * @return 签名是否正确
     * @throws Exception
     */
    public static boolean isSignatureValid(Map<String, String> data, String key, SignType signType) throws Exception {
        if (!data.containsKey("sign") ) {
            return false;
        }
        String sign = data.get("sign");
        System.out.println("data+"+data+",key="+key+",signtype="+signType);
        System.out.println("sign="+sign);
        return generateSignature(data, key, signType).equals(sign);
    }
 
    /**
     * 生成签名
     *
     * @param data 待签名数据
     * @param key API密钥
     * @return 签名
     */
    public static String generateSignature(final Map<String, String> data, String key) throws Exception {
        return generateSignature(data, key, SignType.MD5);
    }
    
    
    /**
     * 生成支付签名
     *
     * @param data 待签名数据
     * @param key API密钥
     * @return 签名
     */
    public static String generatePaySignatrue(final Map<String, String> data) throws Exception {
    	  Set<String> keySet = data.keySet();
          String[] keyArray = keySet.toArray(new String[keySet.size()]);
          Arrays.sort(keyArray);
          StringBuilder sb = new StringBuilder();
          for (String k : keyArray) {
              if (k.equals("sign")) {
                  continue;
              }
              if (data.get(k).trim().length() > 0) // 参数值为空，则不参与签名
                  sb.append(k).append("=").append(data.get(k).trim()).append("&");
          }
          return MD5(sb.toString()).toUpperCase();
          
    }
    
    
    
 
    /**
     * 生成签名. 注意，若含有sign_type字段，必须和signType参数保持一致。
     *
     * @param data 待签名数据
     * @param key API密钥
     * @param signType 签名方式
     * @return 签名
     */
    public static String generateSignature(final Map<String, String> data, String key, SignType signType) throws Exception {
        Set<String> keySet = data.keySet();
        String[] keyArray = keySet.toArray(new String[keySet.size()]);
        Arrays.sort(keyArray);
        StringBuilder sb = new StringBuilder();
        for (String k : keyArray) {
            if (k.equals("sign")) {
                continue;
            }
            if (data.get(k).trim().length() > 0) // 参数值为空，则不参与签名
                sb.append(k).append("=").append(data.get(k).trim()).append("&");
        }
        sb.append("key=").append(key);
        if (SignType.MD5.equals(signType)) {
            return MD5(sb.toString()).toUpperCase();
        }
        else if (SignType.HMACSHA256.equals(signType)) {
            return HMACSHA256(sb.toString(), key);
        }
        else {
            throw new Exception(String.format("Invalid sign_type: %s", signType));
        }
    }
 
 
 
 
    /**
     * 生成 MD5
     *
     * @param data 待处理数据
     * @return MD5结果
     */
    public static String MD5(String data) throws Exception {
        java.security.MessageDigest md = MessageDigest.getInstance("MD5");
        byte[] array = md.digest(data.getBytes("UTF-8"));
        StringBuilder sb = new StringBuilder();
        for (byte item : array) {
            sb.append(Integer.toHexString((item & 0xFF) | 0x100).substring(1, 3));
        }
        return sb.toString().toUpperCase();
    }
 
    /**
     * 生成 HMACSHA256
     * @param data 待处理数据
     * @param key 密钥
     * @return 加密结果
     * @throws Exception
     */
    public static String HMACSHA256(String data, String key) throws Exception {
        Mac sha256_HMAC = Mac.getInstance("HmacSHA256");
        SecretKeySpec secret_key = new SecretKeySpec(key.getBytes("UTF-8"), "HmacSHA256");
        sha256_HMAC.init(secret_key);
        byte[] array = sha256_HMAC.doFinal(data.getBytes("UTF-8"));
        StringBuilder sb = new StringBuilder();
        for (byte item : array) {
            sb.append(Integer.toHexString((item & 0xFF) | 0x100).substring(1, 3));
        }
        return sb.toString().toUpperCase();
    }
 
    /**
     * 日志
     * @return
     */
    public static Logger getLogger() {
        Logger logger = LoggerFactory.getLogger("wxpay java sdk");
        return logger;
    }
 
    /**
     * 获取当前时间戳，单位秒
     * @return
     */
    public static String getCurrentTimestamp() {
        return Long.toString(System.currentTimeMillis()/1000);
    }
 
    /**
     * 获取当前时间戳，单位毫秒
     * @return
     */
    public static String getCurrentTimestampMs() {
    	 return Long.toString(System.currentTimeMillis());
    }
 
 
 
}