java开发-微信支付

一、最近又做了微信公众号支付，前一次做支付没有好好记录，这次又浪费了不少时间，故完整的记录下，下次就可以直接用了。

1、准备工作（微信公众号、微信商户号申请）
2、域名购买、域名备案（微信支付必须是备案的域名，测试环境支付测试不了）
测试环境能测试授权等功能，扫描关注可获得微信管方测试、app_id、app_secret 有了两个就可以了

二、准备工作续

第一步：开通微信公众号支付功能后，就可以获得app_id、app_secret，这个地方还需要设置一个ip白名单，代码所放置的服务器ip地址

第二步：设置回调域名，必须是备案的域名，域名去掉 http

第三步：设置调起微信支付h5页面的地址，在微信商户平台设置

以上工作准备好了，接下来开始上代码。

微信支付重点在签名的生成，这块错一点就很麻烦。

主代码：

复制代码
package com.snp.app.controller;

import com.alibaba.fastjson.JSONObject;
import com.snp.app.domain.VO.PayVO;
import com.snp.common.controller.BaseController;
import com.snp.common.utils.ConfigUtil;
import com.snp.common.utils.StringUtil;
import com.snp.order.dao.FinancialClaimOrderDao;
import com.snp.order.domain.FinancialClaimOrderDO;
import com.snp.userManager.domain.UserWechatDO;
import com.snp.userManager.service.UserWechatService;
import com.snp.wechat.config.WechatConfig;
import com.snp.wechat.model.bean.*;
import com.snp.wechat.utils.AdvancedUtil;
import com.snp.wechat.utils.PayUtils;
import com.snp.wechat.utils.WeiXinOrderUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.Map;

/**

支付控制器
*/
@RestController
@RequestMapping("/interface/pay")
public class PayController extends BaseController{
private static Logger logger = LoggerFactory.getLogger(PayController.class);
@Autowired
private WeiXinOrderUtil weiXinOrderUtil;
@Autowired
private FinancialClaimOrderDao financialClaimOrderDao;
@Autowired
private WechatConfig wechatConfig;
@Autowired
private UserWechatService userWechatService;

@ResponseBody
@RequestMapping(value = “/createWechatOrder”, method ={ RequestMethod.GET,RequestMethod.POST})
public JSONObject createWechatOrder(PayVO payVO, HttpServletRequest request, HttpServletResponse response)
throws Exception{
payVO.setPayAmount(“1”);//1分钱
payVO.setRobbingOrderNo(PayUtils.getTransferNo16());
//ResultBody result = new ResultBody();
logger.info(“saveFinancialClaimOrder{}支付金额：”+payVO.getPayAmount());
logger.info(“saveFinancialClaimOrder{}订单号：”+payVO.getRobbingOrderNo());
UserWechatDO userWechatDO = userWechatService.getUserWechatByUserId(ConfigUtil.getUserId(request));
WechatOrder wechatOrder = new WechatOrder();
wechatOrder.setOpenid(userWechatDO.getWechatOpenid());
wechatOrder.setOrderName(“押金”);
//PayUtils.getTransferNo16()
wechatOrder.setOut_trade_no(payVO.getRobbingOrderNo());
wechatOrder.setNonce_str(PayUtils.getNonceStr());
//wechatOrder.setTotal_fee(MoneyUtil.getOrderMoney(payVO.getPayAmount()));
wechatOrder.setTotal_fee(Integer.parseInt(payVO.getPayAmount()));
//请求微信下单并返回参数
String resultOrderStr = weiXinOrderUtil.buildWechatOrderParam(wechatOrder,request);
JSONObject returnJson=JSONObject.parseObject(resultOrderStr);
//更新 openID prepay_id 到抢单表中
FinancialClaimOrderDO finaClaimDO = new FinancialClaimOrderDO();
finaClaimDO.setOpenId(userWechatDO.getWechatOpenid());
finaClaimDO.setPrepayId(returnJson.get(“pg”).toString());
//financialClaimOrderDao.update(finaClaimDO);
logger.info(“createWechatOrder{}支付结果:”+resultOrderStr);
//result.setData(resultOrderStr);
return returnJson;
}

//支付之前先去下单获取用户openID
@RequestMapping(value = “/getWechatOpenId”, method = RequestMethod.GET)
public void getWechatOpenId(PayVO payVO,HttpServletRequest request,HttpServletResponse response) throws IOException{
//静默授权只能获得openid
//获得微信公众号的唯一标识
String appID = wechatConfig.getWechatAppId();
String appSecret = wechatConfig.getWechatAppSecret();
```
 // 用户同意授权后，能获取到code
 String code = request.getParameter("code");
 WeixinOauth2Token weixinOauth2Token = AdvancedUtil.getOauth2AccessToken(appID, appSecret, code);
 String openId = null;
 String accessToken = null;
 if(null!=weixinOauth2Token){
     openId = weixinOauth2Token.getOpenId();
     accessToken = weixinOauth2Token.getAccessToken();
 }
 UserWechatDO userWechatDO = new UserWechatDO();
 userWechatDO.setUserId(ConfigUtil.getUserId(request));
 userWechatDO.setWechatOpenid(openId);
 userWechatDO.setAccessToken(accessToken);
 userWechatService.save(userWechatDO);
 //获取回调域名
 String url = wechatConfig.getRedirectUri();
 url=url+"/index.html";
 System.out.println(url);
 response.sendRedirect(url);
```
}

/**
- 支付下单之前先去判断是否需要静默授权获取openID
- @param request
- @param response
- @throws IOException
  */
  @RequestMapping(value = “/saveFinancialClaimOrder”, method = {RequestMethod.GET,RequestMethod.POST})
  public void saveFinancialClaimOrder(PayVO payVO,HttpServletRequest request,HttpServletResponse response)
  throws Exception{
  //查询数据库如果没有记录就是第一次登录，如果有数据判断token有没有失效
  if(ConfigUtil.getUserId(request) == 0L){
  throw new Exception(“用户id为空”);
  }
  UserWechatDO userWechatDO = userWechatService.getUserWechatByUserId(ConfigUtil.getUserId(request));
  int isLoginFirst = 0;
  if(StringUtil.isEmpty(userWechatDO)){//首次支付静默登录
  isLoginFirst = 1;
  }else{
  //第二次登录支付这里不用检查token失效 openid唯一的不会失效
  isLoginFirst = 0;
  }
  //获取回调域名
  String url = wechatConfig.getRedirectUri();
  //获得微信公众号的唯一标识
  String appID = wechatConfig.getWechatAppId();
  //微信本地中转站去获取token
  String reUrl = wechatConfig.getReUrl();
  reUrl = reUrl+"?userId="+ConfigUtil.getUserId(request);
  //微信静默授权地址
  String accreditUrlBase = wechatConfig.getAccreditUrlBase();
  
  if(isLoginFirst == 1){
  accreditUrlBase=accreditUrlBase.replace(“Redirect_UI”, reUrl).replace(“appId”, appID);
  response.sendRedirect(accreditUrlBase);//未授权的用户继续授权
  }
  //token effective 支付页面
  url=url+"/index.html";
  System.out.println(url);
  response.sendRedirect(url);
  }
  /**
- 提交支付后的微信异步返回接口
- @throws IOException
  */
  @RequestMapping(value="/weixinNotify")
  public void weixinNotify(HttpServletRequest request, HttpServletResponse response) throws IOException{
  String out_trade_no=null;
  String return_code =null;
  try {
  String resultNotify = weiXinOrderUtil.getOrderReturnStream(request);
  Map<String, String> resultMap = PayUtils.getH5PayMap(resultNotify,request);
  System.out.println(“支付回调参数：”+resultMap);
  out_trade_no = resultMap.get(“out_trade_no”);
  return_code = resultMap.get(“return_code”);
```
 //通知微信.异步确认成功.必写.不然微信会一直通知后台.八次之后就认为交易失败了.
 response.getWriter().write(PayUtils.setXML("SUCCESS", ""));
```
  } catch (Exception e) {
  logger.error(“微信回调接口出现错误：”,e);
  try {
  response.getWriter().write(PayUtils.setXML(“FAIL”, “error”));
  } catch (IOException e1) {
  e1.printStackTrace();
  }
  }
  FinancialClaimOrderDO fClaimDO = financialClaimOrderDao.getFinanClaimByOrderNo(out_trade_no);
  if(return_code.equals(“SUCCESS”)){
  //支付成功的业务逻辑
  fClaimDO.setStatus(1);
  }else{
  //支付失败的业务逻辑
  fClaimDO.setStatus(-1);
  }
  financialClaimOrderDao.update(fClaimDO);
  }
  }
  复制代码
  页面：

复制代码

微信安全支付复制代码工具类：

复制代码
package com.snp.wechat.utils;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.snp.wechat.config.WechatConfig;
import com.snp.wechat.model.bean.WechatOrder;
import com.snp.wechat.model.bean.WeixinOauth2Token;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.servlet.http.HttpServletRequest;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Date;
import java.util.Map;
import java.util.SortedMap;
import java.util.TreeMap;

/**

微信公用工具类
*/
@Component
public class WeiXinOrderUtil {

@Autowired
private WechatConfig wechatConfig;

/**
- 组装统一下单参数
- @return
  */
  public String buildWechatOrderParam(WechatOrder wechatOrder,HttpServletRequest request) throws Exception{
  String payKey = wechatConfig.getPaykey();
  String signType = wechatConfig.getSignType();
  SortedMap<String, String> signMap = new TreeMap<String, String>();
  long timeStamp = PayUtils.getUnixTime(new Date());
  wechatOrder.setAppid(wechatConfig.getWechatAppId());
  wechatOrder.setTrade_type(wechatConfig.getTradeType());
  //构建参数返回前台请求支付接口
  String prepayId = createWechatOrder(wechatOrder,request);
  signMap.put(“appId”,wechatOrder.getAppid());
  signMap.put(“timeStamp”, timeStamp+"");
  signMap.put(“nonceStr”, wechatOrder.getNonce_str());
  signMap.put(“package”, “prepay_id=”+prepayId);
  signMap.put(“signType”, signType);
  String paySign = PayUtils.getSign(signMap, payKey);
  signMap.put(“pg”, prepayId);
  signMap.put(“paySign”, paySign);
  signMap.put(“result”, “success”);
  String json = JSON.toJSONString(signMap);
  JSONObject returnJson=JSONObject.parseObject(json);
  return returnJson.toJSONString();
  }
/**
- 创建下单签名包含商品信息
- @return
  */
  public String createWechatSign(WechatOrder wechatOrder){
  String mch_id = wechatConfig.getMchId();
  String notify_url = wechatConfig.getNotifyUrl();
  String device_info = wechatConfig.getDeviceInfo();
  String payKey = wechatConfig.getPaykey();
  
  //将商品信息打包
  SortedMap<String, String> parameters = new TreeMap<String, String>();
  parameters.put(“appid”, wechatOrder.getAppid());//公众号id 这地方一定要小写并跟下面xml文件对应都是小写
  parameters.put(“mch_id”,mch_id);//商户ID
  parameters.put(“device_info”, device_info);
  parameters.put(“body”, wechatOrder.getOrderName());//名称
  parameters.put(“trade_type”, wechatOrder.getTrade_type());
  parameters.put(“nonce_str”, wechatOrder.getNonce_str());//随机数
  parameters.put(“notify_url”, notify_url);
  parameters.put(“out_trade_no”, wechatOrder.getOut_trade_no());
  parameters.put(“total_fee”, wechatOrder.getTotal_fee()+"");
  // parameters.put(“spbill_create_ip”, spbill_create_ip );
  parameters.put(“openid”, wechatOrder.getOpenid());
  //根据上述的数据生成预支付订单号的前面sign
  return PayUtils.getSign(parameters, payKey);
  }
/**
- 创建微信订单请求微信接口下单
- @return
  */
  public String createWechatOrder(WechatOrder wechatOrder,HttpServletRequest request) throws Exception{
  String mch_id = wechatConfig.getMchId();
  String notify_url = wechatConfig.getNotifyUrl();
  String device_info = wechatConfig.getDeviceInfo();
  String createOrderURL = wechatConfig.getCreateOrderUrl();
  
  //生成统一支付接口数据
  String xml = “”+
  “”+wechatOrder.getAppid()+""+
  “”+wechatOrder.getOrderName()+""+
  “<device_info>”+device_info+"</device_info>"+
  “<mch_id>”+mch_id+"</mch_id>"+
  “<nonce_str>”+wechatOrder.getNonce_str()+"</nonce_str>"+
  “<notify_url>”+notify_url+"</notify_url>"+
  “”+wechatOrder.getOpenid()+""+
  “<out_trade_no>”+wechatOrder.getOut_trade_no()+"</out_trade_no>"+
  “<total_fee>”+wechatOrder.getTotal_fee()+"</total_fee>"+
  “<trade_type>”+wechatOrder.getTrade_type()+"</trade_type>"+
  “”+createWechatSign(wechatOrder)+""+
  “”;
  //调用统一支付接口
  String result = PayUtils.httpsRequest(createOrderURL, “POST”, xml);
  System.out.println("-----------------------------统一下单结果---------------------------");
  System.out.println(result);
  Map<String, String> resultMap = null;
  resultMap=PayUtils.getH5PayMap(result,request);
  return resultMap.get(“prepay_id”); //预支付ID，保存到数据库中
  }
/**
- 解析微信支付回调的结果
- @return
  */
  public static String getOrderReturnStream(HttpServletRequest request) throws IOException {
  InputStream inStream = request.getInputStream();
  ByteArrayOutputStream outSteam = new ByteArrayOutputStream();
  byte[] buffer = new byte[1024];
  int len = 0;
  while ((len = inStream.read(buffer)) != -1) {
  outSteam.write(buffer, 0, len);
  }
  outSteam.close();
  inStream.close();
  return new String(outSteam.toByteArray(),“utf-8”);
  }
/**
- 获取 WeixinOauth2Token
- @return
  */
  public WeixinOauth2Token getWeixinOauth2Token(String code){
  //获得微信公众号的唯一标识
  String appId = wechatConfig.getWechatAppId();
  String appSecret = wechatConfig.getWechatAppSecret();
  return AdvancedUtil.getOauth2AccessToken(appId, appSecret, code);
  }
  }
  复制代码
  复制代码
  package com.snp.wechat.utils;

import com.snp.common.utils.StringUtil;
import com.snp.userManager.domain.UserWechatDO;
import com.snp.wechat.model.bean.WeixinOauth2Token;
import org.apache.commons.lang3.StringUtils;

import com.alibaba.fastjson.JSONObject;

import java.util.Date;

/**

@author yuwei
工具类
2016年12月21日下午1:58:38
*/
public class AdvancedUtil {

public AdvancedUtil() {
super();
// TODO Auto-generated constructor stub
}

/**
- 获取网页授权凭证
- @param appId 公众账号的唯一标识
- @param appSecret 公众账号的密钥
- @param code
- @return
- @return WeixinAouth2Token
  /
  public static WeixinOauth2Token getOauth2AccessToken(String appId, String appSecret, String code) {
  WeixinOauth2Token wat = null;
  // 拼接请求地址
  String requestUrl = “https://api.weixin.qq.com/sns/oauth2/access_token?appid=APPID&secret=SECRET&code=CODE&grant_type=authorization_code”;
  requestUrl = requestUrl.replace(“APPID”, appId);
  requestUrl = requestUrl.replace(“SECRET”, appSecret);
  requestUrl = requestUrl.replace(“CODE”, code);
  // 获取网页授权凭证
  JSONObject jsonObject = CommonUtil.httpsRequest(requestUrl, “GET”, null);
  if (null != jsonObject) {
  try {
  wat = new WeixinOauth2Token();
  wat.setAccessToken(jsonObject.getString(“access_token”));
  wat.setExpiresIn(jsonObject.getInteger(“expires_in”));
  wat.setRefreshToken(jsonObject.getString(“refresh_token”));
  wat.setOpenId(jsonObject.getString(“openid”));
  wat.setScope(jsonObject.getString(“scope”));
  } catch (Exception e) {
  wat = null;
  int errorCode = jsonObject.getInteger(“errcode”);
  String errorMsg = jsonObject.getString(“errmsg”);
  System.out.println(errorCode);
  System.out.println(errorMsg);
  // log.error(“获取网页授权凭证失败 errcode:{} errmsg:{}”, errorCode, errorMsg);
  }
  }
  return wat;
  }
  /*
- 通过网页授权获取用户信息
- @param accessToken 网页授权接口调用凭证
- @param openId 用户标识
- @return SNSUserInfo
  */
  public static UserWechatDO getWechatInfo(String accessToken, String openId,String refreshToken) {
  UserWechatDO userWechatDO = null;
  // 拼接请求地址
  String requestUrl = “https://api.weixin.qq.com/sns/userinfo?access_token=ACCESS_TOKEN&openid=OPENID”;
  requestUrl = requestUrl.replace(“ACCESS_TOKEN”, accessToken).replace(“OPENID”, openId);
  // 通过网页授权获取用户信息
  JSONObject jsonObject = CommonUtil.httpsRequest(requestUrl, “GET”, null);
  
  if (!StringUtil.isEmpty(jsonObject)) {
  try {
  userWechatDO = new UserWechatDO();
  // 用户的标识
  userWechatDO.setWechatOpenid(jsonObject.getString(“openid”));
  // 昵称
  String nickname = jsonObject.getString(“nickname”);
  nickname = filterEmoji(nickname);
  userWechatDO.setNickName(nickname);
  // 性别（1是男性，2是女性，0是未知）
  userWechatDO.setSex(jsonObject.getInteger(“sex”));
  // 用户所在国家
  userWechatDO.setCountry(jsonObject.getString(“country”));
  // 用户所在省份
  userWechatDO.setProvince(jsonObject.getString(“province”));
  // 用户所在城市
  userWechatDO.setCity(jsonObject.getString(“city”));
  // 用户头像
  userWechatDO.setHeadImgUrl(jsonObject.getString(“headimgurl”));
  //UnicodeID
  userWechatDO.setWechatUnionid(jsonObject.getString(“unionid”));
  //userWechatDO.setWin(0);
  //userWechatDO.setLose(0);
  //查询时间
  // Date date = new Date();
  // player.setJoinTime(date);
  //首次授权时间
  userWechatDO.setCreateTime(new Date());
  //更新时间
  userWechatDO.setUpdateTime(new Date());
  userWechatDO.setLasttIme(new Date());
  //凭证保存
  userWechatDO.setAccessToken(accessToken);
  //刷新凭证
  userWechatDO.setRefreshToken(refreshToken);
  // 用户特权信息
  // snsUserInfo.setPrivilegeList(JSONArray.parseObject(jsonObject.getJSONArray(“privilege”), List.class));
  } catch (Exception e) {
  userWechatDO = null;
  int errorCode = jsonObject.getInteger(“errcode”);
  String errorMsg = jsonObject.getString(“errmsg”);
  System.out.println(errorCode);
  System.out.println(errorMsg);
  // log.error(“获取用户信息失败 errcode:{} errmsg:{}”, errorCode, errorMsg);
  }
  }
  return userWechatDO;
  }
//检验凭证是否失效
@SuppressWarnings(“unused”)
public static boolean judgeToken(String accessToken, String openId){
// 拼接请求地址
String requestUrl = “https://api.weixin.qq.com/sns/auth?access_token=ACCESS_TOKEN&openid=OPENID”;
requestUrl = requestUrl.replace(“ACCESS_TOKEN”, accessToken).replace(“OPENID”, openId);
// 通过网页授权获取用户信息
JSONObject jsonObject = CommonUtil.httpsRequest(requestUrl, “GET”, null);
int errorCode = jsonObject.getInteger(“errcode”);
String errorMsg = jsonObject.getString(“errmsg”);//正确返回OK
errorMsg = errorMsg.toUpperCase();
if(errorMsg.equals(“OK”)){
return true;
}
return false;
}

//去掉ios特殊字符
public static String filterEmoji(String source) {
if (StringUtils.isBlank(source)) {
return source;
}
StringBuilder buf = null;
int len = source.length();
for (int i = 0; i < len; i++) {
char codePoint = source.charAt(i);
if (isNotEmojiCharacter(codePoint)) {
if (buf == null) {
buf = new StringBuilder(source.length());
}
buf.append(codePoint);
}
}
if (buf == null) {
return source;
} else {
if (buf.length() == len) {
buf = null;
return source;
} else {
return buf.toString();
}
}
}
//判断特殊字符串
private static boolean isNotEmojiCharacter(char codePoint) {
return (codePoint == 0x0) ||
(codePoint == 0x9) ||
(codePoint == 0xA) ||
(codePoint == 0xD) ||
((codePoint >= 0x20) && (codePoint <= 0xD7FF)) ||
((codePoint >= 0xE000) && (codePoint <= 0xFFFD)) ||
((codePoint >= 0x10000) && (codePoint <= 0x10FFFF));
}
}

java开发-微信支付

猜你喜欢