java微信APP支付v3版服务端开发

先在微信开发平台注册并认证开发者账号，创建一个APP应用，申请支付功能，创建商户平台账号

开始开发

配置Configure文件



APPID就是微信开放平台审核通过的应用APPID

key是https://pay.weixin.qq.com/index.php/core/cert/api_cert里的API秘钥
最多最多只能三十二位

CERTLOCALPATH 先访问https://pay.weixin.qq.com/index.php/core/cert/api_cert 下载证书 java需要.p12的

CERTPASSWORD是商户号



下面是部分代码

统一下单代码

public class UnifiedOrderService extends BaseService{
private static Logger logger = LoggerFactory.getLogger(UnifiedOrderService.class);

public UnifiedOrderService() throws ResponseException {
try {
httpsRequestService = new HttpsRequestService(Configure.UNIFIED_ORDER_URI);
} catch (Exception e) {
logger.error("初始化orderService失败{},{}", e.getMessage(), e);
throw new ResponseException(ResponseCode.ERROR_000001);
}
}

private HttpsRequestService httpsRequestService;

/**
* app下单
* @param orderReqData
* @return
* @throws ResponseException
* @author sourny
* @data 2017年4月1日
*/
public Map<String, Object> createAppOrder(UnifiedOrderReqData orderReqData) throws ResponseException {
logger.info("微信支付创建预支付订单------>");
// 接受API返回
String payServiceResponseString = "";

long costTimeStart = System.currentTimeMillis();

try {
payServiceResponseString = httpsRequestService.sendPost(orderReqData);
} catch (Exception e) {
logger.error("【微信创建支付订单失败】请求支付API系统失败");
throw new ResponseException(ResponseCode.ERROR_000002);
}

long costTimeEnd = System.currentTimeMillis();

logger.info("api请求总耗时：{}ms", costTimeEnd - costTimeStart);

// 打印回包数据
logger.info("微信API返回的数据：{}", payServiceResponseString);

// 将从API返回的XML数据映射到Java对象
UnifiedOrderResData resData = (UnifiedOrderResData) XMLParser.getObjectFromXML(payServiceResponseString,
UnifiedOrderResData.class);

Map<String, Object> map = new HashMap<String, Object>();

processResString(resData, payServiceResponseString, new ProcessEventInterface() {

@Override
public void processSuccessEvent() {
logger.info("【微信创建支付订单成功】开始给返回app参数加签");
map.put("appid", resData.getAppid());
map.put("partnerid", resData.getMch_id());
map.put("prepayid", resData.getPrepay_id());
map.put("package", "Sign=WXPay");
map.put("noncestr", RandomStringGenerator.getRandomStringByLength(32));
map.put("timestamp", (Calendar.getInstance().getTimeInMillis() / 1000) + "");
Wxsign.buildRequestPara(map);
logger.info("【微信创建支付订单成功】app参数加签完成：{}", map);
}
});
logger.info("<------微信支付创建预支付订单");
return map;
}
}

查询支付订单代码

public class OrderQueryService extends BaseService {

private static Logger logger = LoggerFactory.getLogger(OrderQueryService.class);

public OrderQueryService() throws ResponseException {
try {
httpsRequestService = new HttpsRequestService(Configure.ORDER_QUERY_URI);
} catch (Exception e) {
logger.error("初始化orderService失败{},{}", e.getMessage(), e);
throw new ResponseException(ResponseCode.ERROR_000001);
}
}

private HttpsRequestService httpsRequestService;

/**
* 查询订单
* @param queryReqData
* @return
* @throws ResponseException
* @author sourny
* @data 2017年4月1日
*/
public OrderQueryResData queryOrder(OrderQueryReqData queryReqData) throws ResponseException {
logger.info("微信支付查询支付订单------>");
// 接受API返回
String queryResponseString = "";

long costTimeStart = System.currentTimeMillis();

try {
queryResponseString = httpsRequestService.sendPost(queryReqData);
} catch (Exception e) {
logger.error("【微信支付查询订单失败】请求支付API系统失败");
throw new ResponseException(ResponseCode.ERROR_000007);
}

long costTimeEnd = System.currentTimeMillis();

logger.info("api请求总耗时：{}ms", costTimeEnd - costTimeStart);

// 打印回包数据
logger.info("微信API返回的数据：{}", queryResponseString);

// 将从API返回的XML数据映射到Java对象
OrderQueryResData resData = (OrderQueryResData) XMLParser.getObjectFromXML(queryResponseString,
OrderQueryResData.class);
processResString(resData, queryResponseString, new ProcessEventInterface() {

@Override
public void processSuccessEvent() {
// TODO Auto-generated method stub

}
});
logger.info("<------微信支付查询支付订单");
return resData;
}
}

微信回调代码

public class NotifyService extends BaseService {

private static Logger logger = LoggerFactory.getLogger(NotifyService.class);

public NotifyResData checkNotify(String xml) throws ResponseException {
logger.info("微信支付通知返回参数：{}", xml);
logger.info("微信支付通知检查参数------>");
NotifyResData reqData = (NotifyResData) XMLParser.getObjectFromXML(xml, NotifyResData.class);
processResString(reqData, xml, new ProcessEventInterface() {

@Override
public void processSuccessEvent() {
// TODO Auto-generated method stub
}
});
logger.info("<------微信支付通知检查参数通过");
return reqData;
}
}

baseService代码

public class BaseService {

private static Logger logger = LoggerFactory.getLogger(BaseService.class);

/**
* 验证签名
*
* @param resData
*            转换后的xml对象
* @param responseString
*            返回的String
* @param p
*            校验成功后处理模板
* @throws ResponseException
* @author sourny
* @data 2017年3月31日
*/
protected void processResString(BaseResData resData, String responseString, ProcessEventInterface p)
throws ResponseException {
logger.info("resData:{}", resData);
if (resData == null || resData.getReturn_code() == null) {
// logger.error("【微信支付查询订单失败】请求逻辑错误，请仔细检测传过去的每一个参数是否合法，或是看API能否被正常访问");
throw new ResponseException(ResponseCode.ERROR_000010);
}

if (resData.getReturn_code().equals("FAIL")) {
// 注意：一般这里返回FAIL是出现系统级参数错误，请检测Post给API的数据是否规范合法
// logger.error("【微信支付查询订单失败】API系统返回失败，请检测Post给API的数据是否规范合法");
throw new ResponseException(ResponseCode.ERROR_000011);
} else {
logger.info("支付API系统成功返回数据");
// --------------------------------------------------------------------
// 收到API的返回数据的时候得先验证一下数据有没有被第三方篡改，确保安全
// --------------------------------------------------------------------
if (!Wxsign.checkIsSignValidFromResponseString(responseString)) {
// logger.error("【微信支付查询订单失败】请求API返回的数据签名验证失败，有可能数据被篡改了");
throw new ResponseException(Response
d055
Code.ERROR_000012);
}

// 获取错误码
String errorCode = resData.getErr_code();
// 获取错误描述
String errorCodeDes = resData.getErr_code_des();

if (resData.getResult_code().equals("SUCCESS")) {
logger.info("【微信支付】返回参数校验成功开始执行成功方法--->");
p.processSuccessEvent();
} else {
// 出现业务错误
logger.error("业务返回失败err_code:{},err_code_des:{}", errorCode, errorCodeDes);
throw new ResponseException(ResponseCode.ERROR_000013);
}
}
}

public interface ProcessEventInterface {
/**
* 校验成功触发事件
*
* @author sourny
* @data 2017年3月31日
*/
void processSuccessEvent();
}
}

统一调用类

/**
* SDK总入口
*/
public class WXPay {

/**
* 初始化SDK依赖的几个关键配置
*
* @param key
*            签名算法需要用到的秘钥
* @param appID
*            公众账号ID
* @param mchID
*            商户ID
* @param sdbMchID
*            子商户ID，受理模式必填
* @param certLocalPath
*            HTTP证书在服务器中的路径，用来加载证书用
* @param certPassword
*            HTTP证书的密码，默认等于MCHID
*/
public static void initSDKConfiguration(String key, String appID, String mchID, String sdbMchID,
String certLocalPath, String certPassword) {
//如果有多个就可以通过init方法进行配置
/*
* Configure.setKey(key); Configure.setAppID(appID);
* Configure.setMchID(mchID); Configure.setSubMchID(sdbMchID);
* Configure.setCertLocalPath(certLocalPath);
* Configure.setCertPassword(certPassword);
*/
}

/**
* 创建APP预付订单
* @param orderReqData
* @return
* @throws ResponseException
* @author sourny
* @data 2017年3月30日
*/
public static Map<String, Object> createOrder(UnifiedOrderReqData orderReqData) throws ResponseException {
return new UnifiedOrderService().createAppOrder(orderReqData);
}

/**
* 校验app支付异步通知
* @param xml
* @return
* @throws ResponseException
* @author sourny
* @data 2017年3月30日
*/
public static NotifyResData checkAppNotify(String xml) throws ResponseException {
return new NotifyService().checkNotify(xml);
}

public static OrderQueryResData queryOrder(OrderQueryReqData queryReqData) throws ResponseException{
return new OrderQueryService().queryOrder(queryReqData);
}

}

部分业务引用代码

logger.info("开始为支付订单设值--->");
PaymentOrder paymentOrder = setPaymentOrder(PaymentMethod.WEIXIN.value, PaymentDevice.APP.value, payVO);
logger.info("完成支付订单设值：{}" + paymentOrder);

logger.info("-----开始保存支付订单信息-----");
paymentOrderService.save(paymentOrder);
logger.info("-----完成保存支付订单信息-----");
//构建统一下单请求参数
UnifiedOrderReqData order = new UnifiedOrderReqData(paymentOrder.getSubject(), paymentOrder.getPkId(),
paymentOrder.getMoney(), paymentOrder.getClientIp(), 30, Configure.NOTIFY_URL,
Configure.TRADE_TYPE_APP);

Map<String, Object> map = new HashMap<String, Object>();

map = WXPay.createOrder(order);

return new Response<Map<String, Object>>(map);

代码下载http://download.csdn.net/detail/sourny/9801156

如果有不懂得地方可以给我留言