springboot+微信小程序实现微信支付【统一下单】

public final class WxConfig {
public final static String appId="wxe86f60xxxxxxx"; // 小程序appid
public final static String mchId="15365xxxxx";// 商户ID
public final static String key="Ucsdfl782167bjslNCJD129863skkqoo"; // 跟微信支付约定的密钥
public final static String notifyPath="/admin/wxnotify"; // 回调地址
public final static String payUrl="https://api.mch.weixin.qq.com/pay/unifiedorder"; // 统一下单地址
public final static String tradeType="JSAPI"; // 支付方式 }

import lombok.extern.slf4j.Slf4j;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.client.HttpClient;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.config.RegistryBuilder;
import org.apache.http.conn.socket.ConnectionSocketFactory;
import org.apache.http.conn.socket.PlainConnectionSocketFactory;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.impl.conn.BasicHttpClientConnectionManager;
import org.apache.http.util.EntityUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList; import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import javax.xml.XMLConstants;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
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 java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.io.StringWriter;
import java.security.MessageDigest;
import java.security.SecureRandom;
import java.time.Instant;
import java.util.*; @Slf4j
public class WxUtil {
private static final String WXPAYSDK_VERSION = "WXPaySDK/3.0.9";
private static final String USER_AGENT = WXPAYSDK_VERSION +
" (" + System.getProperty("os.arch") + " " + System.getProperty("os.name") + " " + System.getProperty("os.version") +
") Java/" + System.getProperty("java.version") + " HttpClient/" + HttpClient.class.getPackage().getImplementationVersion(); private static final String SYMBOLS = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
private static final Random RANDOM = new SecureRandom();
// 统一下单接口
public static Map<String, String> unifiedOrder(Map<String, String> reqData) throws Exception {
// map格式转xml 方法在下面
String reqBody = mapToXml(reqData);
// 发起一次统一下单的请求 方法内容在下面
String responseBody = requestOnce(WxConfig.payUrl, reqBody);
// 将得到的结果由xml格式转为map格式 方法内容在下面
Map<String,String> response= processResponseXml(responseBody);
// 得到prepayId
String prepayId = response.get("prepay_id");
// 组装参数package_str 为什么这样？ 因为二次签名微信规定这样的格式
String package_str = "prepay_id="+prepayId;
Map<String,String> payParameters = new HashMap<>();
long epochSecond = Instant.now().getEpochSecond();
payParameters.put("appId",WxConfig.appId);
payParameters.put("nonceStr", WxUtil.generateNonceStr());
payParameters.put("package", package_str);
payParameters.put("signType", SignType.MD5.name());
payParameters.put("timeStamp", String.valueOf(epochSecond));
// 二次签名
payParameters.put("paySign", WxUtil.generateSignature(payParameters, WxConfig.key, SignType.MD5));
// 返回签名后的map
return payParameters;
} /**
* 生成签名. 注意，若含有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结果
*/
private static String MD5(String data) throws Exception {
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();
} public static String generateNonceStr() {
char[] nonceChars = new char[32];
for (int index = 0; index < nonceChars.length; ++index) {
nonceChars[index] = SYMBOLS.charAt(RANDOM.nextInt(SYMBOLS.length()));
}
return new String(nonceChars);
} public static String mapToXml(Map<String, String> data) throws Exception {
Document document = newDocument();
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();
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;
} // 判断签名是否有效
private static Map<String, String> processResponseXml(String xmlStr) throws Exception {
String RETURN_CODE = "return_code";
String return_code;
Map<String, String> respData = xmlToMap(xmlStr);
if (respData.containsKey(RETURN_CODE)) {
return_code = respData.get(RETURN_CODE);
} else {
throw new Exception(String.format("No `return_code` in XML: %s", xmlStr));
} if (return_code.equals("FAIL")) {
return respData;
}
else if (return_code.equals("SUCCESS")) {
if (isResponseSignatureValid(respData)) {
return respData;
}
else {
throw new Exception(String.format("Invalid sign value in XML: %s", xmlStr));
}
}
else {
throw new Exception(String.format("return_code value %s is invalid in XML: %s", return_code, xmlStr));
}
}
// 判断签名
private static boolean isResponseSignatureValid(Map<String, String> data) throws Exception {
String signKeyword = "sign";
if (!data.containsKey(signKeyword) ) {
return false;
}
String sign = data.get(signKeyword);
return generateSignature(data, WxConfig.key, SignType.MD5).equals(sign);
} // 发起一次请求
private static String requestOnce(String payUrl, String data) throws Exception {
BasicHttpClientConnectionManager connManager;
connManager = new BasicHttpClientConnectionManager(
RegistryBuilder.<ConnectionSocketFactory>create()
.register("http", PlainConnectionSocketFactory.getSocketFactory())
.register("https", SSLConnectionSocketFactory.getSocketFactory())
.build(),
null,
null,
null
); HttpClient httpClient = HttpClientBuilder.create()
.setConnectionManager(connManager)
.build();
HttpPost httpPost = new HttpPost(payUrl); RequestConfig requestConfig = RequestConfig.custom().setSocketTimeout(8000).setConnectTimeout(6000).build();
httpPost.setConfig(requestConfig); StringEntity postEntity = new StringEntity(data, "UTF-8");
httpPost.addHeader("Content-Type", "text/xml");
httpPost.addHeader("User-Agent", USER_AGENT + " " + WxConfig.mchId);
httpPost.setEntity(postEntity); HttpResponse httpResponse = httpClient.execute(httpPost);
HttpEntity httpEntity = httpResponse.getEntity();
return EntityUtils.toString(httpEntity, "UTF-8"); } private 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();
} private static DocumentBuilder newDocumentBuilder() throws ParserConfigurationException {
DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
documentBuilderFactory.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
documentBuilderFactory.setFeature("http://xml.org/sax/features/external-general-entities", false);
documentBuilderFactory.setFeature("http://xml.org/sax/features/external-parameter-entities", false);
documentBuilderFactory.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", false);
documentBuilderFactory.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, true);
documentBuilderFactory.setXIncludeAware(false);
documentBuilderFactory.setExpandEntityReferences(false); return documentBuilderFactory.newDocumentBuilder();
} private static Document newDocument() throws ParserConfigurationException {
return newDocumentBuilder().newDocument();
} public static Map<String, String> xmlToMap(String strXML) throws Exception {
try {
Map<String, String> data = new HashMap<String, String>();
DocumentBuilder documentBuilder = newDocumentBuilder();
InputStream stream = new ByteArrayInputStream(strXML.getBytes("UTF-8"));
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) {
// do nothing
}
return data;
} catch (Exception ex) {
getLogger().warn("Invalid XML, can not convert to map. Error message: {}. XML content: {}", ex.getMessage(), strXML);
throw ex;
} }
/**
* 日志
* @return
*/
private static Logger getLogger() {
Logger logger = LoggerFactory.getLogger("wxpay java sdk");
return logger;
} /**
* 判断签名是否正确
*
* @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,SignType.MD5).equals(sign);
} }

@PostMapping("/recharge/wx")
public Map recharge(HttpServletRequest request, @RequestParam(value = "vipType",required = true) VipType vipType) throws Exception {
// 本案例是充值会员 用的时候根据实际情况改成自己的需求
Integer loginDealerId = MySecurityUtil.getLoginDealerId();
// 获取ip地址 发起统一下单必要的参数
String ipAddress = HttpUtil.getIpAddress(request);
// 生成预付订单 存入数据库 回调成功在对订单状态进行修改
PrepaidOrder prepaidOrder = payService.recharge(loginDealerId, vipType, ipAddress);
// 组装统一下单需要的数据map
Map<String, String> stringStringMap = prepaidOrder.toWxPayParameters();
// 调起统一支付
Map<String, String> payParameters =WxUtil.unifiedOrder(stringStringMap);
return payParameters;
}

@Service("WXPayService")
@Slf4j
public class PayServiceImpl implements PayService { @Resource
PrepaidOrderDao prepaidOrderDao; @Resource
VipDao vipDao; @Resource
DealerDao dealerDao; @Resource
ApplicationContext applicationContext;
@Override
@Transactional
public PrepaidOrder recharge(Integer dealerId, VipType vipType, String userIp) {
Dealer dealer = dealerDao.getDealerById(dealerId);
SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmss");
String newDate = sdf.format(new Date());
Random random = new Random();
String orderNumber = newDate + random.nextInt(1000000);
BigDecimal amount = null;
// 如果不是生产环境 付一分钱
if (!applicationContext.getEnvironment().getActiveProfiles()[0].contains("prod")){
amount = BigDecimal.valueOf(0.01);
}else if (vipType.equals(VipType.YEAR)){
amount= BigDecimal.valueOf(999);
}else {
amount = BigDecimal.valueOf(365);
}
PrepaidOrder prepaidOrder = new PrepaidOrder();
prepaidOrder.setDealerId(dealerId);
prepaidOrder.setOpenId(dealer.getOpenId()); // 这个是微信需要的 openid
prepaidOrder.setVipType(vipType);
prepaidOrder.setUserIp(userIp); // 这个是微信需要的参数 userIp
prepaidOrder.setOrderStatus(OrderStatus.ONGOING);
prepaidOrder.setAmount(amount); // 这个是微信需要的参数 total_fee
prepaidOrder.setOrderNumber(orderNumber); // 这个是微信需要的参数 out_trade_no
// 添加预付订单
prepaidOrderDao.addPrepaidOrder(prepaidOrder);
return prepaidOrder;// 返回预付订单

} }

@Data
public class PrepaidOrder extends BaseModel {
private String orderNumber;
private Integer dealerId;
private Integer versionNum;
private BigDecimal amount;
private OrderStatus orderStatus=OrderStatus.ONGOING;
private LocalDateTime successTime;
private String userIp;
private String openId;
private VipType vipType; public Map<String, String> toWxPayParameters() throws Exception {
Map map = new HashMap();
map.put("body",getBody()); // 商品名字
map.put("appid", WxConfig.appId); // 小程序appid
map.put("mch_id", WxConfig.mchId); // 商户id
map.put("nonce_str", WxUtil.generateNonceStr()); // 随机字符串
map.put("notify_url", AppConst.host+WxConfig.notifyPath); // 回调地址
map.put("openid",this.openId); // 发起微信支付的用户的openid
map.put("out_trade_no",this.orderNumber); // 订单号
map.put("spbill_create_ip",this.userIp); // 发起微信支付的用户的ip地址
map.put("total_fee",parseAmount()); // 金额 （单位分）
map.put("trade_type",WxConfig.tradeType); // 支付类型
// 数据签名 也是第一次签名
map.put("sign", WxUtil.generateSignature(map, WxConfig.key, SignType.MD5 ));
return map;
} public String getBody(){
if (vipType.equals(VipType.YEAR)){
return "年度会员";
}else {
return "季度会员";
}
} public String parseAmount(){
BigDecimal multiply = amount.multiply(BigDecimal.valueOf(100));
BigDecimal result = multiply;
if (multiply.compareTo(BigDecimal.valueOf(1))==0){
result = BigDecimal.valueOf(1);
}
return result.toString();
} @Override
public String toString() {
return "PrepaidOrder{" +
"orderNumber='" + orderNumber + '\'' +
", dealerId=" + dealerId +
", versionNum=" + versionNum +
", amount=" + amount +
", orderStatus=" + orderStatus +
", successTime=" + successTime +
", userIp='" + userIp + '\'' +
", openId='" + openId + '\'' +
", vipType=" + vipType +
'}';
}
}

public static String getIpAddress(HttpServletRequest request) {
String ip = request.getHeader("x-forwarded-for");
if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
ip = request.getHeader("Proxy-Client-IP");
}
if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
ip = request.getHeader("WL-Proxy-Client-IP");
}
if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
ip = request.getHeader("HTTP_CLIENT_IP");
}
if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
ip = request.getHeader("HTTP_X_FORWARDED_FOR");
}
if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
ip = request.getRemoteAddr();
}
return ip;
}