1、引入依赖：（对于依赖冲突自行解决）
<dependency>
<groupId>com.github.binarywang</groupId>
<artifactId>weixin-java-pay</artifactId>
<!--<version>3.4.9.B</version>-->
<version>3.5.0</version>
<exclusions>
<exclusion>
<artifactId>httpclient</artifactId>
<groupId>org.apache.httpcomponents</groupId>
</exclusion>
<exclusion>
<artifactId>commons-lang3</artifactId>
<groupId>org.apache.commons</groupId>
</exclusion>
<exclusion>
<artifactId>commons-beanutils</artifactId>
<groupId>commons-beanutils</groupId>
</exclusion>
<exclusion>
<artifactId>guava</artifactId>
<groupId>com.google.guava</groupId>
</exclusion>
</exclusions>
</dependency>
2、
package com.dhht.wechat.controller;
import com.dhht.wechat.VO.PayVO;
import com.dhht.wechat.service.PayService;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
/*
* @Author: sh
* @Description: WxPayController
* @Date: 11:06 2019/7/17
*/
@RestController
@RequestMapping("wechat/")
public class WxPayController {
@Resource
private PayService payService;
/**
* 微信支付统一下单接口(H5)
* @param payVO
* @param request
* @return
*/
@PostMapping(value = "pay",produces = "application/json;charset=UTF-8")
public String unifiedOrder(@RequestBody PayVO payVO, HttpServletRequest request){
return payService.unifiedOrder(payVO,request);
}
/**
* 微信支付接收通知接口（供微信服务调用）
* @param xmlData
* @return
*/
@PostMapping(value = "pay/notify",produces = "application/json;charset=UTF-8")
public synchronized String payNotify(@RequestBody String xmlData){
return payService.payNotifyCallBack(xmlData);
}
/**
* 退款结果通知接口
* @param xmlData
* @return
*/
@PostMapping("/notify/refund")
public synchronized String parseRefundNotifyResult(@RequestBody String xmlData) {
return payService.parseRefundNotifyResult(xmlData);
}
}
package com.dhht.wechat.service;
import com.alibaba.fastjson.JSON;
import com.dhht.wechat.VO.PayVO;
import com.dhht.wechat.service.impservice.OrderRefundResultImplService;
import com.dhht.wechat.service.impservice.SealOrderImplService;
import com.dhht.wechat.service.impservice.SealOrderSealImplService;
import com.dhht.wechat.util.ConstantUtil;
import com.dhht.wechat.util.DateUtil;
import com.dhht.wechat.wxpay.MyX509TrustManager;
import com.dhht.wechat.wxpay.PayRespCodeMsg;
import com.dhht.wechat.wxpay.PayResultVO;
import com.dhht.wechat.wxpay.WechatPayConfigBean;
import com.dhht.wechat.wxpay.config.WxPayProperties;
import com.github.binarywang.wxpay.bean.notify.WxPayNotifyResponse;
import com.github.binarywang.wxpay.bean.notify.WxPayOrderNotifyResult;
import com.github.binarywang.wxpay.bean.notify.WxPayRefundNotifyResult;
import com.github.binarywang.wxpay.bean.order.WxPayMpOrderResult;
import com.github.binarywang.wxpay.bean.request.*;
import com.github.binarywang.wxpay.bean.result.WxPayOrderCloseResult;
import com.github.binarywang.wxpay.bean.result.WxPayOrderQueryResult;
import com.github.binarywang.wxpay.bean.result.WxPayRefundResult;
import com.github.binarywang.wxpay.service.WxPayService;
import net.sf.json.JSONObject;
import org.apache.commons.lang3.StringUtils;
import org.jdom.Document;
import org.jdom.Element;
import org.jdom.input.SAXBuilder;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
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 java.io.*;
import java.math.BigDecimal;
import java.net.ConnectException;
import java.net.URL;
import java.security.MessageDigest;
import java.text.MessageFormat;
import java.util.*;
/**
* WxPayService
*/
@Service
public class PayService {
@Resource
private WechatPayConfigBean wechatPayConfigBean;
@Resource
private WxPayProperties wxPayProperties;// 第三方
@Resource
private SealOrderImplService sealOrderImplService;
@Resource
private WxPayService wxService;// 第三方sdk
// @Resource
// private OrderPayResultImplService orderPayResultImplService;
@Resource
private OrderRefundResultImplService orderRefundResultImplService;
@Value("${spbill_create_ip}")
private String SPBILL_CREATE_IP;
@Value("${appSecret}")
private String appSecret;
@Resource
WeiXinService weiXinService;
@Resource
SealOrderSealImplService sealOrderSealImplService;
/**
* 微信支付统一下单接口（H5）
*
* @param payVO
* @param request
* @return
*/
public String unifiedOrder(PayVO payVO, HttpServletRequest request) {
try {
String orderId = payVO.getOrderId();
String code = payVO.getCode();
if (StringUtils.isEmpty(orderId) || StringUtils.isEmpty(code)) {
PayResultVO payResultVO = new PayResultVO(-1, "NO", null);
return JSON.toJSONString(payResultVO);
}
WxPayOrderQueryResult payOrderQueryResult = wechatOrderQuery(orderId);// wxService.queryOrder(null, orderId);// 查询订单状态
String payOrderQuery_return_code = payOrderQueryResult.getReturnCode();// SUCCESS/FAIL
if (ConstantUtil.PAY_RETURN_CODE_NO.equals(payOrderQuery_return_code)) {// 通信失败：FAIL
PayResultVO queryPayResultVO = new PayResultVO(-1, payOrderQueryResult.getReturnMsg(), null);
return JSON.toJSONString(queryPayResultVO);// 订单查询接口通信失败，直接返回
}
// 订单查询通信成功：SUCCESS
// 若业务成功
/**
* trade_state状态如下：
* SUCCESS—支付成功
* REFUND—转入退款
* NOTPAY—未支付
* CLOSED—已关闭
* REVOKED—已撤销(刷卡支付)
* USERPAYING--用户支付中
* PAYERROR--支付失败(其他原因，如银行返回失败)商户订单支付失败需要生成新单号重新发起支付，要对原订单号调用关单，避免重复支付
*/
String trade_state = payOrderQueryResult.getTradeState();
if (!ConstantUtil.PAY_TRADE_STATE_NOTPAY.equals(trade_state) && null != trade_state) {// 非未支付状态下(可以为null-代表还未生成订单,故需过滤掉)
PayResultVO tradePayResultVO = new PayResultVO(-1, ConstantUtil.PAY_STATUS_MAP.get(trade_state), null);
return JSON.toJSONString(tradePayResultVO);
}
// 以下转入订单未支付处理或还没有生成订单(trade_state==null)的处理逻辑
//String openUrl = "https://api.weixin.qq.com/sns/oauth2/access_token?appid="+wxPayProperties.getAppId()+"&secret="+appSecret+"&code="+code+"&grant_type=authorization_code";
String openId = weiXinService.getOpenId(code);//SendMsgUtil.httpRequest(openUrl,"GET","{}").getString("openid");// 获取openid
// 更新订单openId--2019-09-17
Map<String, Object> paMap = new HashMap<>();
paMap.put("orderId", orderId);
paMap.put("userOpenId", openId);
sealOrderImplService.updateOrderInfo(paMap);
// 获取本系统印章订单信息
Map<String, Object> orderDetails = sealOrderImplService.getOrderMapById(orderId);
String SUB_MCH_ID = (String) orderDetails.get("SUB_MCH_ID");// 营业网点扩展信息表中的子商户号-20190910
if (StringUtils.isEmpty(SUB_MCH_ID)) {// 若无配置子商户号退出
PayResultVO payResultVO = new PayResultVO(-1, "NO-SUB_MCH_ID", null);
return JSON.toJSONString(payResultVO);
}
String siteName = (String) orderDetails.get("siteName");// 营业网点名称(刻章店名称)
float orderPrice = ((BigDecimal) orderDetails.get("ORDER_AMOUNT")).floatValue();// 订单总金额
String bodyName = siteName + "-" + ConstantUtil.ADVANCE_PAY_GOODS_NAME;// 商品名称严格按照规范-公众号支付-例如（商家名称-销售商品类目）
// 设置统一下单请求参数
// 请求对象，注意一些参数如appid、mchid等不用设置，方法内会自动从配置对象中获取到（前提是对应配置中已经设置）
WxPayUnifiedOrderRequest orderRequest = new WxPayUnifiedOrderRequest();
orderRequest.setAppid(wxPayProperties.getAppId());// 服务商appid
orderRequest.setMchId(wxPayProperties.getMchId());// 商户号
orderRequest.setSubMchId(SUB_MCH_ID);// 子商户号
String nonceStr = DateUtil.get32UUIDMilli();
orderRequest.setNonceStr(nonceStr);// 随机串，32位以内！
orderRequest.setSignType(wxPayProperties.getSignType());// 签名类型
orderRequest.setBody(bodyName);
orderRequest.setOutTradeNo(orderId);
orderRequest.setTotalFee(BaseWxPayRequest.yuanToFen(orderPrice + ""/*order.getTotalFee()*/));//元转成分
orderRequest.setSpbillCreateIp(SPBILL_CREATE_IP);// 终端IP
orderRequest.setNotifyUrl(wxPayProperties.getNotifyUrl());// 支付结果异步回调地址
orderRequest.setTradeType(wxPayProperties.getTradeType());// 交易类型
orderRequest.setOpenid(openId);// 设置openid
WxPayMpOrderResult wxPayUnifiedOrderResult = wxService.createOrder(orderRequest);// 统一下单接口调用结果
String appId = wxPayUnifiedOrderResult.getAppId();
String timeStamp = create_timestamp();
String package_ = wxPayUnifiedOrderResult.getPackageValue();// ConstantUtil.PACKAGE_SUFFIX + wxPayUnifiedOrderResult.getPackageValue();
String paySign = wxPayUnifiedOrderResult.getPaySign();
Map<String, Object> resultMapData = new HashMap<>();
resultMapData.put("appId", appId);
resultMapData.put("timeStamp", timeStamp);
resultMapData.put("package", package_);
resultMapData.put("paySign", paySign);
resultMapData.put("nonceStr", wxPayUnifiedOrderResult.getNonceStr());
resultMapData.put("signType", wxPayProperties.getSignType());
PayResultVO paySucessResultVO = new PayResultVO(0, "OK", resultMapData);
return JSON.toJSONString(paySucessResultVO);
} catch (Exception e) {
Map map = new HashMap();
map.put("data", e.getMessage());
PayResultVO payResultVO = new PayResultVO(-1, "NO", map);
return JSON.toJSONString(payResultVO);
}
}
/**
* 支付回调
*
* @param xmlData
* @return
*/
public synchronized String payNotifyCallBack(String xmlData) {
try {
WxPayOrderNotifyResult wxPayOrderNotifyResult = wxService.parseOrderNotifyResult(xmlData);// 解析xml字符串
String return_code = wxPayOrderNotifyResult.getReturnCode();// SUCCESS/FAIL
if (ConstantUtil.PAY_RETURN_CODE_NO.equals(return_code)) {// 支付通信失败
return WxPayNotifyResponse.fail("FAIL");
}
// 以下通信成功操作
String out_trade_no = wxPayOrderNotifyResult.getOutTradeNo();// 商户系统内部订单号（即本系统印章订单号）
// 内部订单支付情况
Map<String, Object> orderDetails = sealOrderImplService.getOrderMapById(out_trade_no);
if (null != orderDetails) {
String paySta = (Integer) orderDetails.get("PAY_STATUS") + "";
if ((ConstantUtil.ORDER_PAYSTATUS_1_ + "").equals(paySta)) {// 已支付直接返回
return WxPayNotifyResponse.success("OK");
}
}
if (ConstantUtil.PAY_RETURN_CODE_OK.equals(return_code)) {// 支付接口通信成功
String result_code = wxPayOrderNotifyResult.getResultCode();// SUCCESS/FAIL 是否真实支付成功
if (ConstantUtil.PAY_RETURN_CODE_OK.equals(result_code)) {// 支付成功
// 检查本库是否已经插入支付成功记录
// orderPayResultImplService.deleteByOrderId(out_trade_no);
//orderPayResultImplService.add(wxPayOrderNotifyResult);
//orderPayResultImplService.insertSelective(wxPayOrderNotifyResult);
sealOrderImplService.updateOrderPaySta(out_trade_no, ConstantUtil.ORDER_PAYSTATUS_1_);// 更新支付状态
// 推送微信内容-2019-09-18
sealOrderSealImplService.sendWXMsgToSite(out_trade_no);
}
if (ConstantUtil.PAY_RETURN_CODE_NO.equals(result_code)) {// 支付失败
closePayOrder(out_trade_no);// 支付失败的话，需要关闭订单，才能重新支付
sealOrderImplService.upOrderRelation(out_trade_no);// 更新该订单的id，主要用于重新支付
sealOrderImplService.updateOrderPaySta(out_trade_no, ConstantUtil.ORDER_PAYSTATUS_2_);// 更新支付状态
}
return WxPayNotifyResponse.success("OK");
} else {// 支付结果通信失败
return WxPayNotifyResponse.fail("FAIL");
}
} catch (Exception e) {
return WxPayNotifyResponse.fail("FAIL");
}
}
/**
* 查询订单状态
*
* @param orderId
* @return
*/
public WxPayOrderQueryResult wechatOrderQuery(String orderId) {
try {
if (StringUtils.isEmpty(orderId)) {
return null;
}
Map<String, Object> orderDetails = sealOrderImplService.getOrderMapById(orderId);// 获取本系统订单的相关信息
String SUB_MCH_ID = (String) orderDetails.get("SUB_MCH_ID");// 营业网点扩展信息表中的子商户号-20190910
WxPayOrderQueryRequest wxPayOrderQueryRequest = new WxPayOrderQueryRequest();
wxPayOrderQueryRequest.setAppid(wxPayProperties.getAppId());
wxPayOrderQueryRequest.setMchId(wxPayProperties.getMchId());
wxPayOrderQueryRequest.setSubMchId(SUB_MCH_ID);// 子商户好最终通过orderId从本系统获取
wxPayOrderQueryRequest.setOutTradeNo(orderId);// 微信内部订单号与本系统订单号二选一
wxPayOrderQueryRequest.setNonceStr(DateUtil.get32UUIDMilli());
wxPayOrderQueryRequest.setSignType(wxPayProperties.getSignType());
WxPayOrderQueryResult wxPayOrderQueryResult = wxService.queryOrder(wxPayOrderQueryRequest);
return wxPayOrderQueryResult;
} catch (Exception e) {
WxPayOrderQueryResult wxPayOrderQueryResult = new WxPayOrderQueryResult();
wxPayOrderQueryResult.setReturnCode(ConstantUtil.PAY_RETURN_CODE_OK);
wxPayOrderQueryResult.setResultCode(ConstantUtil.PAY_RETURN_CODE_OK);
wxPayOrderQueryResult.setTradeState(null);
return wxPayOrderQueryResult;
}
}
/**
* 关闭订单（关闭订单之后，重新提交支付需要更新订单号！）
*
* @param orderId
* @return
*/
public WxPayOrderCloseResult closePayOrder(String orderId) {
if (StringUtils.isEmpty(orderId)) {
return null;
}
try {
Map<String, Object> orderDetails = sealOrderImplService.getOrderMapById(orderId);// 获取本系统订单的相关信息
String SUB_MCH_ID = (String) orderDetails.get("SUB_MCH_ID");// 营业网点扩展信息表中的子商户号-20190910
WxPayOrderCloseRequest wxPayOrderCloseRequest = new WxPayOrderCloseRequest();
wxPayOrderCloseRequest.setAppid(wxPayProperties.getAppId());
wxPayOrderCloseRequest.setMchId(wxPayProperties.getMchId());
wxPayOrderCloseRequest.setSubMchId(SUB_MCH_ID);// 从本系统获取通过orderDetails
wxPayOrderCloseRequest.setOutTradeNo(orderId);
wxPayOrderCloseRequest.setNonceStr(DateUtil.get32UUIDMilli());
wxPayOrderCloseRequest.setSignType(wxPayProperties.getSignType());
WxPayOrderCloseResult wxPayOrderCloseResult = wxService.closeOrder(wxPayOrderCloseRequest);
return wxPayOrderCloseResult;
} catch (Exception e) {
return null;
}
}
/**
* 订单退款（接口请求并非退款结果）
*
* @param orderId
* @return
*/
public PayResultVO refundPayOrder(String orderId) {
try {
if (StringUtils.isEmpty(orderId)) {
return null;
}
Map<String, Object> orderDetails = sealOrderImplService.getOrderMapById(orderId);// 获取本系统订单的相关信息
// 查询微信支付订单信息
WxPayOrderQueryResult wxPayOrderQueryResult = wechatOrderQuery(orderId);
String order_return_code = wxPayOrderQueryResult.getReturnCode();// 订单查询网络状态
if (ConstantUtil.PREPAYID_RETURN_CODE_NO.equals(order_return_code)) {
PayResultVO returnPayResultVO = new PayResultVO(-1, ConstantUtil.PAY_NETWORK_EXCEP, null);
return returnPayResultVO;
}
String order_result_code = wxPayOrderQueryResult.getResultCode();// 订单查询业务状态
if (ConstantUtil.PREPAYID_RETURN_CODE_NO.equals(order_result_code)) {
PayResultVO resultPayResultVO = new PayResultVO(-1, ConstantUtil.REFUND_FAIL_MSG, null);
return resultPayResultVO;
}
String order_trade_state = wxPayOrderQueryResult.getTradeState();// 订单状态（已支付、未支付等等）
if (!ConstantUtil.PAY_TRADE_STATE_SUCCESS.equals(order_trade_state)) {// 未支付成功，直接返回
PayResultVO tradePayResultVO = new PayResultVO(-1, ConstantUtil.REFUND_FAIL_MSG, null);
}
// 以下为订单已支付后续操作(只有order_trade_state为SUCCESS可获取如下参数)
String transaction_id = wxPayOrderQueryResult.getTransactionId();// 微信内部支付订单号
int total_fee = wxPayOrderQueryResult.getTotalFee();// 订单总金额
String sub_mch_id = wxPayOrderQueryResult.getSubMchId();// 订单子商户号
String out_trade_no = wxPayOrderQueryResult.getOutTradeNo();
WxPayRefundRequest wxPayRefundRequest = new WxPayRefundRequest();
wxPayRefundRequest.setAppid(wxPayProperties.getAppId());
wxPayRefundRequest.setMchId(wxPayProperties.getMchId());
wxPayRefundRequest.setSubMchId(sub_mch_id);// 从本系统通过orderId获取
wxPayRefundRequest.setNonceStr(DateUtil.get32UUIDMilli());
wxPayRefundRequest.setSignType(wxPayProperties.getSignType());
wxPayRefundRequest.setTransactionId(transaction_id);
wxPayRefundRequest.setOutTradeNo(out_trade_no);// 商户内部订单号
String refundNo = DateUtil.get32UUIDMilli();// 生成商户内部退款单号
wxPayRefundRequest.setOutRefundNo(refundNo);// 商户内部退款单号！！！
wxPayRefundRequest.setTotalFee(total_fee);
wxPayRefundRequest.setRefundFee(total_fee);// ！！！申请退款金额？？？？
wxPayRefundRequest.setNotifyUrl(wxPayProperties.getRefundNotifyUrl());// 退款结果通知url
WxPayRefundResult wxPayRefundResult = wxService.refund(wxPayRefundRequest);// 订单退款接口
String refund_return_code = wxPayRefundResult.getReturnCode();// 退款接口网络状态
if (ConstantUtil.PREPAYID_RETURN_CODE_NO.equals(refund_return_code)) {
PayResultVO refundExPayVO = new PayResultVO(-1, ConstantUtil.REFUND_FAIL_MSG, null);
return refundExPayVO;
}
String refund_result_code = wxPayRefundResult.getResultCode();// 退款接口结果状态
if (ConstantUtil.PREPAYID_RETURN_CODE_NO.equals(refund_result_code)) {
PayResultVO refundFailPayVO = new PayResultVO(-1, ConstantUtil.REFUND_FAIL_MSG, null);
return refundFailPayVO;
}
// 以下为退款成功操作
PayResultVO refundSuceesResultVO = new PayResultVO(0, "OK", wxPayRefundResult);
Map<String, Object> paramMap = new HashMap<>();
paramMap.put("refundNo", refundNo);// 内部退款单号
sealOrderImplService.updateOrderInfo(paramMap);
return refundSuceesResultVO;
} catch (Exception e) {
return null;
}
}
/**
* 退款回调通知地址
*
* @param xmlData
* @return
*/
public synchronized String parseRefundNotifyResult(String xmlData) {
try {
WxPayRefundNotifyResult result = wxService.parseRefundNotifyResult(xmlData);
String return_code = result.getReturnCode();
if (ConstantUtil.PREPAYID_RETURN_CODE_NO.equals(return_code)) {// 通信失败
return WxPayNotifyResponse.fail("FAIL");
}
// 以下为通信成功返回的字段信息
WxPayRefundNotifyResult.ReqInfo reqInfo = result.getReqInfo();// 获取结果中的加密信息
/**
* SUCCESS-退款成功
* CHANGE-退款异常
* REFUNDCLOSE—退款关闭
*/
String refund_status = reqInfo.getRefundStatus();// 退款状态
if (ConstantUtil.REFUND_STATUS_0.equals(refund_status)) {// 成功
refund_status = ConstantUtil.ORDER_PAYSTATUS_3_ + "";
}
if (ConstantUtil.REFUND_STATUS_1.equals(refund_status)) {// 异常
refund_status = ConstantUtil.ORDER_PAYSTATUS_4_ + "";
}
if (ConstantUtil.REFUND_STATUS_2.equals(refund_status)) {// 关闭
refund_status = ConstantUtil.ORDER_PAYSTATUS_4_ + "";
}
String out_trade_no = reqInfo.getOutTradeNo();// 内部订单号
Map<String, Object> paramMap = new HashMap<>();
paramMap.put("refundNo", out_trade_no);// 内部退款单号
paramMap.put("payStatus", refund_status);// 更新支付状态
sealOrderImplService.updateOrderInfo(paramMap);
orderRefundResultImplService.deleteByOrderdId(out_trade_no);// 删除订单
orderRefundResultImplService.addRefundInfo(result);// 添加退款 记录
return WxPayNotifyResponse.success("OK");
} catch (Exception e) {
return WxPayNotifyResponse.fail("FAIL");
}
}
//******************************************************************************************************************
/**
* 获取微信签名信息（预支付订单信息）
*
* @param payVO
* @param request
* @return
*/
public synchronized String getWxPaySign(PayVO payVO, HttpServletRequest request) {
try {
if (null == payVO) {
return null;
}
String orderId = payVO.getOrderId();
String wxCode = payVO.getCode();
if (StringUtils.isEmpty(orderId) || StringUtils.isEmpty(wxCode)) {
return null;
}
// 获取openId
JSONObject openIdJson = getAccess_tokenByCode(wxCode);
int errcode_openId = openIdJson.getInt("errcode");
if (errcode_openId != 0) {// 调用获取openId接口不成功
PayRespCodeMsg payRespCodeMsg = new PayRespCodeMsg(errcode_openId, openIdJson.getString("errmsg"));
PayResultVO payResultVO = new PayResultVO(payRespCodeMsg, null);
return JSON.toJSONString(payResultVO);
}
String openid = openIdJson.getString("openid");// 用户唯一标识
String session_key = openIdJson.getString("session_key");// 会话秘钥
// 获取本地订单相关信息
Map<String, Object> orderDetails = sealOrderImplService.getOrderMapById(orderId);
String siteName = (String) orderDetails.get("siteName");// 营业网点名称(刻章店名称)
int orderPrice = ((BigDecimal) orderDetails.get("ORDER_AMOUNT")).intValue() * 100;
String bodyName = siteName + "-" + ConstantUtil.ADVANCE_PAY_GOODS_NAME;// 商品名称严格按照规范-公众号支付-例如（商家名称-销售商品类目）
String orderno = orderId;// "1234567890";
Integer total_fee = orderPrice;// "8.88";// 订单总费用，不能有小数点，以分为单位
String nonce_str = create_nonce_str();
String timestamp = create_timestamp();
// 获取预支付订单prepayId
SortedMap<Object, Object> parameters = new TreeMap<Object, Object>();
String prepayIdResult = getPrepayId(request, bodyName, orderno, total_fee, openid);// 获取预支付订单id方法，返回的xml字符串结果
Map<String, String> prepayIdResultMap = doXMLParse(prepayIdResult);// xml字符串转map
String prepayId_return_code = prepayIdResultMap.get("return_code");// SUCCESS/FAIL,此字段是通信标识，非交易标识，交易是否成功需要查看result_code来判断
if (ConstantUtil.PREPAYID_RETURN_CODE_NO.equals(prepayId_return_code)) {// 获取prepayId接口通信异常
PayRespCodeMsg preRespCodeMsg = new PayRespCodeMsg(-1, ConstantUtil.WECHAT_INTERFACE_EX_MSG);//
PayResultVO preResultVO = new PayResultVO(preRespCodeMsg, null);
return JSON.toJSONString(preResultVO);
}
// 获取prepayId的接口调用通信成功后
String prepayId_result_code = prepayIdResultMap.get("result_code");// SUCCESS/FAIL，业务结果
if (ConstantUtil.PAY_RETURN_CODE_NO.equals(prepayId_result_code)) {// 获取prepayId失败
PayRespCodeMsg preNo = new PayRespCodeMsg(-1, "NO");
PayResultVO preNoVO = new PayResultVO(preNo, null);
return JSON.toJSONString(preNoVO);
}
// 微信预支付接口通信成功且业务结果成功
// 重新生成签名
parameters.put("appId", wechatPayConfigBean.getAppId());
parameters.put("timeStamp", timestamp);
parameters.put("nonceStr", nonce_str);
parameters.put("package", "prepay_id=" + prepayIdResultMap.get("prepay_id"));
parameters.put("signType", "MD5");
String sign = createSign("UTF-8", parameters);
parameters.put("prepay_id", "prepay_id=" + prepayIdResultMap.get("prepay_id"));
parameters.put("paySign", sign);
PayResultVO okResult = new PayResultVO(0, "OK", parameters);
return JSON.toJSONString(okResult);
} catch (Exception e) {
PayResultVO resultVO = new PayResultVO(-1, "FALSE", null);
return JSON.toJSONString(resultVO);
}
}
public SortedMap<Object, Object> WapSignSignatureAction (HttpServletRequest request)throws Exception {
SortedMap<Object, Object> parameters = new TreeMap<Object, Object>();
String code = request.getParameter("code");
System.out.println("code-------------" + code);
// code作为换取access_token的票据，每次用户授权带上的code将不一样，code只能使用一次，5分钟未被使用自动过期。
// 通过code换取网页授权access_token
Map<String, String> data = getAccess_tokenByCode(code);
String openid = data.get("openid");
String tName = "名称";
String orderno = "1234567890";
String total_fee = "8.88";
String nonce_str = create_nonce_str();
String timestamp = create_timestamp();
// 获取prepayId
try {
String result = getPrepayId(request, tName, orderno, Integer.parseInt(total_fee), openid);
Map<String, String> map = doXMLParse(result);
// 重新生成签名
parameters.put("appId", wechatPayConfigBean.getAppId()
);
parameters.put("timeStamp", timestamp);
parameters.put("nonceStr", nonce_str);
parameters.put("package", "prepay_id=" + map.get("prepay_id"));
parameters.put("signType", "MD5");
String sign = createSign("UTF-8", parameters);
parameters.put("prepay_id", "prepay_id=" + map.get("prepay_id"));
parameters.put("paySign", sign);
} catch (Exception e) {
e.printStackTrace();
}
return parameters;
}
/**
* 根据用户授权code获取access_token
*/
private JSONObject getAccess_tokenByCode(String code) {
Map<String, String> data = new HashMap<String, String>();
//String requestUrlMessageFormat = "https://api.weixin.qq.com/sns/oauth2/access_token?appid={0}&secret={1}&code={2}&grant_type=authorization_code";
String requestUrlMessageFormat = "https://api.weixin.qq.com/sns/oauth2/access_token?appid={0}&secret={1}&code={2}&grant_type=authorization_code";
String requestUrl = MessageFormat.format(requestUrlMessageFormat, wxPayProperties.getAppId()
, appSecret
, code);
String requestMethod = "GET";
String outputStr = "";
JSONObject json = httpRequest(requestUrl, requestMethod, outputStr);
//String access_token = (String) json.get("access_token");// 此参数最新接口文档没发现的
String openid = (String) json.get("openid");// 用户唯一标识
String session_key = json.getString("session_key");// 会话秘钥
String unionid = json.getString("unionid");// 用户在开放平台的唯一标识符，在满足 UnionID 下发条件的情况下会返回
int errcode = json.getInt("errcode");// 错误码
String errmsg = json.getString("errmsg");// 错误信息
//data.put("access_token", access_token);
data.put("openid", openid);
data.put("session_key", session_key);
data.put("unionid", unionid);
data.put("errcode", errcode + "");
data.put("errmsg", errmsg);
return json;
}
/**
* 发起https请求并获取结果
*
* @param requestUrl 请求地址
* @param requestMethod 请求方式（GET、POST）
* @param outputStr 提交的数据
* @return JSONObject(通过JSONObject.get ( key)的方式获取json对象的属性值)
*/
public static JSONObject httpRequest(String requestUrl, String requestMethod, String outputStr) {
JSONObject jsonObject = null;
StringBuffer buffer = new StringBuffer();
try {
// 创建SSLContext对象，并使用我们指定的信任管理器初始化
TrustManager[] tm = {new MyX509TrustManager()};
SSLContext sslContext = SSLContext.getInstance("SSL", "SunJSSE");
sslContext.init(null, tm, new java.security.SecureRandom());
// 从上述SSLContext对象中得到SSLSocketFactory对象
SSLSocketFactory ssf = sslContext.getSocketFactory();
URL url = new URL(requestUrl);
HttpsURLConnection httpUrlConn = (HttpsURLConnection) url.openConnection();
httpUrlConn.setSSLSocketFactory(ssf);
httpUrlConn.setDoOutput(true);
httpUrlConn.setDoInput(true);
httpUrlConn.setUseCaches(false);
// 设置请求方式（GET/POST）
httpUrlConn.setRequestMethod(requestMethod);
if ("GET".equalsIgnoreCase(requestMethod))
httpUrlConn.connect();
// 当有数据需要提交时
if (null != outputStr) {
OutputStream outputStream = httpUrlConn.getOutputStream();
// 注意编码格式，防止中文乱码
outputStream.write(outputStr.getBytes("UTF-8"));
outputStream.close();
}
// 将返回的输入流转换成字符串
InputStream inputStream = httpUrlConn.getInputStream();
InputStreamReader inputStreamReader = new InputStreamReader(inputStream, "utf-8");
BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
String str = null;
while ((str = bufferedReader.readLine()) != null) {
buffer.append(str);
}
bufferedReader.close();
inputStreamReader.close();
// 释放资源
inputStream.close();
inputStream = null;
httpUrlConn.disconnect();
jsonObject = JSONObject.fromObject(buffer.toString());
} catch (ConnectException ce) {
System.err.println("Weixin server connection timed out.");
} catch (Exception e) {
System.err.println("https request error");
}
return jsonObject;
}
/**
* 获取预支付订单id
*
* @param request
* @param name
* @param orderno
* @param total_fee
* @param openid
* @return
* @throws Exception
*/
public String getPrepayId(HttpServletRequest request, String name, String orderno, Integer total_fee,
String openid) throws Exception {
SortedMap<Object, Object> parameters = new TreeMap<Object, Object>();
parameters.put("appid", wechatPayConfigBean.getAppId()
);// 服务商id
parameters.put("mch_id", wechatPayConfigBean.getMchId()
);// 商户号
parameters.put("nonce_str", CreateNoncestr());// 随机字符串
parameters.put("body", name);// 商品描述
parameters.put("out_trade_no", orderno);// 商户系统内部订单号，要求32个字符内，只能是数字、大小写字母_-|*且在同一个商户号下唯一
parameters.put("total_fee", total_fee);// 支付金额单位：分
parameters.put("spbill_create_ip", getIp2(request));// 支持IPV4和IPV6两种格式的IP地址。调用微信支付API的机器IP
parameters.put("notify_url", wechatPayConfigBean.getPayResultNotifyUrl());// 接收微信支付异步通知回调地址，通知url必须为直接可访问的url，不能携带参数
parameters.put("trade_type", "JSAPI");// 交易类型，小程序取值如下：JSAPI，详细说明见
parameters.put("openid", openid);// 商户标识
parameters.put("time_expire", DateUtil.getTimeStamp());// (非必填)交易结束时间,需要动态传入,格式为yyyyMMddHHmmss-20190719114936
String sign = createSign("UTF-8", parameters);
parameters.put("sign", sign);
String requestXML = getRequestXml(parameters);
// 调用统一下单接口
String result = httpsRequest("https://api.mch.weixin.qq.com/pay/unifiedorder", "POST", requestXML);
System.out.println(result);
return result;
}
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;
}
public static String getIp2(HttpServletRequest request) {
String ip = request.getHeader("X-Forwarded-For");
if (!org.apache.commons.lang3.StringUtils.isEmpty(ip) && !"unKnown".equalsIgnoreCase(ip)) {
// 多次反向代理后会有多个ip值，第一个ip才是真实ip
int index = ip.indexOf(",");
if (index != -1) {
return ip.substring(0, index);
} else {
return ip;
}
}
ip = request.getHeader("X-Real-IP");
if (!org.apache.commons.lang3.StringUtils.isEmpty(ip) && !"unKnown".equalsIgnoreCase(ip)) {
return ip;
}
return request.getRemoteAddr();
}
@SuppressWarnings("rawtypes")
public 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=" + wechatPayConfigBean.getApiKey()
);
String sign = MD5Encode(sb.toString(), characterEncoding).toUpperCase();
return sign;
}
public static String MD5Encode(String origin, String charsetname) {
String resultString = null;
try {
resultString = new String(origin);
MessageDigest md = MessageDigest.getInstance("MD5");
if (charsetname == null || "".equals(charsetname))
resultString = byteArrayToHexString(md.digest(resultString.getBytes()));
else
resultString = byteArrayToHexString(md.digest(resultString.getBytes(charsetname)));
} catch (Exception exception) {
}
return resultString;
}
private static String byteArrayToHexString(byte b[]) {
StringBuffer resultSb = new StringBuffer();
for (int i = 0; i < b.length; i++)
resultSb.append(byteToHexString(b[i]));
return resultSb.toString();
}
private static String byteToHexString(byte b) {
int n = b;
if (n < 0)
n += 256;
int d1 = n / 16;
int d2 = n % 16;
return hexDigits[d1] + hexDigits[d2];
}
private static final String hexDigits[] = {"0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d",
"e", "f"};
@SuppressWarnings("rawtypes")
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) || "sign".equalsIgnoreCase(k)) {
sb.append("<" + k + ">" + "<![CDATA[" + v + "]]></" + k + ">");
} else {
sb.append("<" + k + ">" + v + "</" + k + ">");
}
}
sb.append("</xml>");
return sb.toString();
}
/**
* * 发送https请求
*
* @param requestUrl 请求地址
* @param requestMethod 请求方式（GET、POST）
* @param outputStr 提交的数据
* @return 返回微信服务器响应的信息
*/
public static String httpsRequest(String requestUrl, String requestMethod, String outputStr) {
try {
// 创建SSLContext对象，并使用我们指定的信任管理器初始化
TrustManager[] tm = {new MyX509TrustManager()};
SSLContext sslContext = SSLContext.getInstance("SSL", "SunJSSE");
sslContext.init(null, tm, new java.security.SecureRandom());
// 从上述SSLContext对象中得到SSLSocketFactory对象
SSLSocketFactory ssf = sslContext.getSocketFactory();
URL url = new URL(requestUrl);
HttpsURLConnection conn = (HttpsURLConnection) url.openConnection();
conn.setSSLSocketFactory(ssf);
conn.setDoOutput(true);
conn.setDoInput(true);
conn.setUseCaches(false);
// 设置请求方式（GET/POST）
conn.setRequestMethod(requestMethod);
conn.setRequestProperty("content-type", "application/x-www-form-urlencoded");
// 当outputStr不为null时向输出流写数据
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) {
System.out.println("连接超时");
} catch (Exception e) {
System.out.println("请求异常");
}
return null;
}
public static String create_nonce_str() {
return UUID.randomUUID().toString().replace("-", "");
}
public static String create_timestamp() {
return Long.toString(System.currentTimeMillis() / 1000);
}
/**
* 解析xml
*
* @param strxml
* @return
* @throws Exception
*/
@SuppressWarnings({"rawtypes", "unchecked"})
public static Map doXMLParse(String strxml) throws Exception {
strxml = strxml.replaceFirst("encoding=\".*\"", "encoding=\"UTF-8\"");
if (null == strxml || "".equals(strxml)) {
return null;
}
Map m = new HashMap();
InputStream in = new ByteArrayInputStream(strxml.getBytes("UTF-8"));
SAXBuilder builder = new SAXBuilder();
Document doc = builder.build(in);
Element root = doc.getRootElement();
List list = root.getChildren();
Iterator it = list.iterator();
while (it.hasNext()) {
Element e = (Element) it.next();
String k = e.getName();
String v = "";
List children = e.getChildren();
if (children.isEmpty()) {
v = e.getTextNormalize();
} else {
v = getChildrenText(children);
}
m.put(k, v);
}
// 关闭流
in.close();
return m;
}
/**
* 获取子结点的xml
*
* @param children
* @return
*/
@SuppressWarnings("rawtypes")
public static String getChildrenText(List children) {
StringBuffer sb = new StringBuffer();
if (!children.isEmpty()) {
Iterator it = children.iterator();
while (it.hasNext()) {
Element e = (Element) it.next();
String name = e.getName();
String value = e.getTextNormalize();
List list = e.getChildren();
sb.append("<" + name + ">");
if (!list.isEmpty()) {
sb.append(getChildrenText(list));
}
sb.append(value);
sb.append("</" + name + ">");
}
}
return sb.toString();
}
}