Java开源生鲜电商平台-支付模块的设计与架构(源码可下载）(1)- 惊觉

logger.info(“[AlipayController][alipayInvoke] 创建订单日志结果:” + (payLogsResult>0));

}else

{

logger.info(“[AlipayController][alipayInvoke] 创建重复订单”);

}

AlipayClient alipayClient = new DefaultAlipayClient(“https://openapi.alipay.com/gateway.do”,“”,“”, “json”,“UTF-8”,“”,“RSA2”);

AlipayTradeAppPayRequest request = new AlipayTradeAppPayRequest();

AlipayTradeAppPayModel model = new AlipayTradeAppPayModel();

model.setBody(“”);

model.setSubject(“xxx”);

model.setOutTradeNo(orderNumber);

model.setTimeoutExpress(“15m”);

model.setTotalAmount(payAmount.toString());

model.setProductCode(“QUICK_MSECURITY_PAY”);

request.setBizModel(model);

request.setNotifyUrl(NOTIFY_URL);

AlipayTradeAppPayResponse response = alipayClient.sdkExecute(request);

result=response.getBody();

logger.info("[AlipayController][alipayNotify] result: " +result);

} catch (AlipayApiException ex)

{

logger.error(“[AlipayController][alipayNotify] exception:”,ex);

return new JsonResult(JsonResultCode.FAILURE,“系统错误,请稍后重试”,“”);

}

return new JsonResult(JsonResultCode.SUCCESS,“操作成功”,result);

}

支付宝服务端回调代码

import java.io.IOException;

import java.math.BigDecimal;

import java.util.Date;

import java.util.Enumeration;

import java.util.HashMap;

import java.util.Iterator;

import java.util.Map;

import javax.servlet.ServletOutputStream;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import org.apache.commons.lang3.StringUtils;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Controller;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RequestMethod;

import com.alipay.api.AlipayApiException;

import com.alipay.api.internal.util.AlipaySignature;

/**

alipay 支付宝服务端回调
参考文档：https://docs.open.alipay.com/204/105301/
对于App支付产生的交易，支付宝会根据原始支付API中传入的异步通知地址notify_url，通过POST请求的形式将支付结果作为参数通知到商户系统。

@Controller

@RequestMapping(“/buyer”)

public class AlipayNotifyController extends BaseController {

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

private static final String ALIPAYPUBLICKEY = “”;

private static final String CHARSET = “UTF-8”;

/*支付成功/

private static final int PAY_LOGS_SUCCESS=1;

@Autowired

private OrderInfoService orderInfoService;

@RequestMapping(value = “/alipay/notify”, method = { RequestMethod.GET, RequestMethod.POST })

public void alipayNotify(HttpServletRequest request, HttpServletResponse response) throws IOException

{

String url=request.getRequestURL().toString();

logger.info(“AlipayNotifyController.alipayNotify.s+tart”);

logger.info(“[AlipayNotifyController][alipayNotify] url:” +url);

ServletOutputStream out = response.getOutputStream();

//支付宝交易号

String alipayTradeNo=this.getNotNull(“trade_no”, request);

//商户订单号

String outerTradeNo=this.getNotNull(“out_trade_no”, request);

//买家支付宝用户号

String buyerId=this.getNotNull(“buyer_id”, request);

//买家支付宝账号

String buyerLogonId=this.getNotNull(“buyer_logon_id”, request);

//交易状态

String tradeStatus=this.getNotNull(“trade_status”, request);

//订单金额,精确到小数点后2位

String money=getNotNull(“total_amount”, request);

logger.info(“[AlipayNotifyController][alipayNotify] tradeStatus:” +tradeStatus+" money:"+money);

StringBuffer buf = new StringBuffer();

if (request.getMethod().equalsIgnoreCase(“POST”))

{

Enumeration em = request.getParameterNames();

for (; em.hasMoreElements()😉

{

Object o = em.nextElement();

buf.append(o).append(“=”).append(request.getParameter(o.toString())).append(“,”);

}

logger.info(“回调 method:post]http://” + request.getServerName() + request.getServletPath() + " [<prams:" + buf + “>]”);

} else

{

buf.append(request.getQueryString());

logger.info(“回调 method:get]http://” + request.getServerName() + request.getServletPath() + “?” + request.getQueryString());

}

//检验支付宝参数

if(!verifyAlipay(request))

{

out.print(“fail”);

return;

}

//交易成功

if(“TRADE_SUCCESS”.equalsIgnoreCase(tradeStatus))

{

try

{

if(StringUtils.isNotBlank(outerTradeNo))

{

//查询当前订单信息

OrderInfo info=this.orderInfoService.getOrderInfoByOrderNumber(outerTradeNo);

if(info==null)

{

logger.error(“[AlipayNotifyController][alipayNotify] info:” +info);

out.print(“fail”);

return;

}

//订单信息

OrderInfo orderInfo=new OrderInfo();

orderInfo.setOrderNumber(outerTradeNo);

orderInfo.setCardCode(“alipay”);

orderInfo.setCardName(“支付宝”);

orderInfo.setCardNumber(buyerLogonId);

orderInfo.setCardOwner(buyerId);

orderInfo.setPayTime(new Date());

orderInfo.setOuterTradeNo(alipayTradeNo);

orderInfo.setPayStatus(PayStatus.PAY_SUCCESS);

orderInfo.setTradeStatus(TradeStatus.TRADE_PROGRESS);

orderInfo.setPayAmount(new BigDecimal(money));

orderInfo.setBuyerId(info.getBuyerId());

//付款日志

PayLogs payLogs=new PayLogs();

payLogs.setOrderNumber(outerTradeNo);

payLogs.setOuterTradeNo(alipayTradeNo);

payLogs.setStatus(PAY_LOGS_SUCCESS);

orderInfoService.payReturn(orderInfo,payLogs);

out.print(“success”);

return;

}

}catch(Exception ex)

{

logger.error(“[AlipayNotifyController][payReturn] 出现了异常:”,ex);

out.print(“success”);

return;

}

}else

{

out.print(“fail”);

return;

}

/**

检验支付宝
@param request
@return

@SuppressWarnings(“rawtypes”)

public boolean verifyAlipay(HttpServletRequest request)

{

boolean flag=true;

// 获取支付宝POST过来反馈信息

Map<String, String> params = new HashMap<String, String>();

Map requestParams = request.getParameterMap();

for (Iterator iter = requestParams.keySet().iterator(); iter.hasNext()😉 {

String name = (String) iter.next();

String[] values = (String[]) requestParams.get(name);

String valueStr = “”;

for (int i = 0; i < values.length; i++) {

valueStr = (i == values.length - 1) ? valueStr + values[i] : valueStr + values[i] + “,”;

}

params.put(name, valueStr);

}

try

{

flag= AlipaySignature.rsaCheckV1(params, ALIPAYPUBLICKEY, CHARSET, “RSA2”);

} catch (AlipayApiException e) {

e.printStackTrace();

flag=false;

}

return flag;

}

APP支付成功后，其实支付宝或者微信都会告诉你是否成功，只是这种通知是不可靠的，最可靠的的一种方式是支付宝或者微信的服务端回调。

根据回调处理相关的业务。

相应的微信回调代码如下：（注意，这个业务模块属于买家。）

APP调用微信：

/***

APP端调用请求微信

@RestController

@RequestMapping(“/buyer”)

public class WeiXinController extends BaseController

{

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

/*待支付/

private static final int PAY_LOGS_READY=0;

@Autowired

private OrderInfoService orderInfoService;

@Autowired

private BuyerService buyerService;

@Autowired

private PayLogsService payLogsService;

@Autowired

private CouponReceiveService couponReceiveService;

/**

APP端请求调用微信
@param request
@param response
@return

@RequestMapping(value=“/weixin/invoke”,method={RequestMethod.GET,RequestMethod.POST})

public JsonResult weixinInvoke(HttpServletRequest req, HttpServletResponse resp)

{

try

{

/*订单号/

String orderNumber=this.getNotNull(“orderNumber”, req);

/*金额/

String money=this.getNotNull(“money”, req);

/*优惠券id/

String couponReceiveId = req.getParameter(“couponReceiveId”);

if(StringUtils.isBlank(orderNumber) || StringUtils.isBlank(money))

{

return new JsonResult(JsonResultCode.FAILURE,“请求参数有误,请稍后重试”,“”);

}

//对比金额

OrderInfo orderInfo=this.orderInfoService.getOrderInfoByOrderNumber(orderNumber);

if(orderInfo==null)

{

return new JsonResult(JsonResultCode.FAILURE,“订单号不存在，请稍后重试”,“”);

}

//获取订单的金额

BigDecimal orderAmount=orderInfo.getOrderAmount();

//减余额

Long buyerId=orderInfo.getBuyerId();

Buyer buyer=this.buyerService.getBuyerById(buyerId);

//用户余额

BigDecimal balanceMoney=buyer.getBalanceMoney();

//计算最终需要给微信的金额

BigDecimal payAmount=orderAmount.subtract(balanceMoney);

//买家支付时抵扣优惠券

if(StringUtils.isNotBlank(couponReceiveId)){

Long id = Long.parseLong(couponReceiveId);

payAmount = couponReceiveService.deductionCouponMoney(id, orderNumber, payAmount);

}

logger.info(“[WeiXinController][weixinInvoke] orderNumber:” +orderNumber +" money:" +money+" orderAmount:“+orderAmount+” balanceMoney:“+balanceMoney+” payAmount:" +payAmount);

//考虑重复订单的问题，会产生重复日志

PayLogs payLogs=this.payLogsService.getPayLogsByOrderNumber(orderNumber);

if(payLogs==null)

{

//创建订单日志

PayLogs logs=new PayLogs();

logs.setUserId(buyerId);

logs.setOrderId(orderInfo.getOrderId());

logs.setOrderNumber(orderNumber);

logs.setOrderAmount(payAmount);

logs.setStatus(PAY_LOGS_READY);

logs.setCreateTime(new Date());

int payLogsResult=payLogsService.addPayLogs(logs);

logger.info(“[WeiXinController][weixinInvoke] 创建订单日志结果:” + (payLogsResult>0));

}else

{

logger.info(“[WeiXinController][weixinInvoke] 创建重复订单”);

}

//微信开始

SortedMap<Object,Object> paramMap = new TreeMap<Object,Object>();

paramMap.put(“appid”, WeiXinUtil.APPID);

paramMap.put(“mch_id”, WeiXinUtil.MCHID);

String nonceStr=RandomUtil.generateString(8);

// 随机字符串

paramMap.put(“nonce_str”, nonceStr);

paramMap.put(“body”,“魔笛食材”);// 商品描述

paramMap.put(“out_trade_no”, orderNumber);// 商户订单编号

paramMap.put(“total_fee”,Math.round(payAmount.doubleValue()*100));

//IP地址

String ip=IpUtils.getIpAddr(req);

paramMap.put(“spbill_create_ip”,ip);

paramMap.put(“notify_url”, WeiXinUtil.NOTIFYURL);// 回调地址

paramMap.put(“trade_type”,WeiXinUtil.TRADETYPE);// 交易类型APP

String sign=createSign(paramMap);

paramMap.put(“sign”, sign);// 数字签证

logger.info(“weixin支付请求IP:” +ip+ " sign:" +sign);

String xml = getRequestXML(paramMap);

String content = HttpClientUtil.getInstance().sendHttpPost(WeiXinUtil.URL,xml,“UTF-8”);

logger.info(“weixin支付请求的内容content:” +content);

JSONObject jsonObject = JSONObject.fromObject(XmltoJsonUtil.xml2JSON(content));

JSONObject resultXml = jsonObject.getJSONObject(“xml”);

//返回的编码

JSONArray returnCodeArray =resultXml.getJSONArray(“return_code”);

//返回的消息

JSONArray returnMsgArray =resultXml.getJSONArray(“return_msg”);

//结果编码

JSONArray resultCodeArray =resultXml.getJSONArray(“result_code”);

String returnCode= (String)returnCodeArray.get(0);

String returnMsg= (String)returnMsgArray.get(0);

String resultCode = (String)resultCodeArray.get(0);

logger.info(“[WeiXinController][weixinInvoke] returnCode: " +returnCode+” returnMsg:“+returnMsg +” resultCode:"+resultCode);

if(resultCode.equalsIgnoreCase(“FAIL”))

{

return new JsonResult(JsonResultCode.FAILURE,“微信统一订单下单失败”,“”);

}

if(resultCode.equalsIgnoreCase(“SUCCESS”))

{

JSONArray prepayIdArray =resultXml.getJSONArray(“prepay_id”);

String prepayId= (String)prepayIdArray.get(0);

WeiXinBean weixin=new WeiXinBean();

weixin.setAppid(WeiXinUtil.APPID);

weixin.setPartnerid(WeiXinUtil.MCHID);

weixin.setNoncestr(nonceStr);

weixin.setPrepayid(prepayId);

String timestamp=System.currentTimeMillis()/1000+“”;

weixin.setTimestamp(timestamp);

//最终返回签名

SortedMap<Object,Object> apiMap = new TreeMap<Object,Object>();

apiMap.put(“appid”, WeiXinUtil.APPID);

apiMap.put(“partnerid”, WeiXinUtil.MCHID);

apiMap.put(“prepayid”, prepayId);

apiMap.put(“package”,“Sign=WXPay”);

apiMap.put(“noncestr”,nonceStr);

apiMap.put(“timestamp”, timestamp);

//再次签名

weixin.setSign(createSign(apiMap));

return new JsonResult(JsonResultCode.SUCCESS,“微信统一订单下单成功”,weixin);

}

return new JsonResult(JsonResultCode.FAILURE,“操作失败”,“”);

} catch (Exception ex)

{

logger.error(“[WeiXinController][weixinInvoke] exception:”,ex);

return new JsonResult(JsonResultCode.FAILURE,“系统错误,请稍后重试”,“”);

}

//拼接xml 请求路径

@SuppressWarnings({“rawtypes”})

private String getRequestXML(SortedMap<Object, Object> parame){

StringBuffer buffer = new StringBuffer();

buffer.append(“”);

Set set = parame.entrySet();

Iterator iterator = set.iterator();

while(iterator.hasNext()){

Map.Entry entry = (Map.Entry) iterator.next();

String key =String.valueOf(entry.getKey());

String value = String.valueOf(entry.getValue());

//过滤相关字段sign

if(“sign”.equalsIgnoreCase(key)){

buffer.append(“<”+key+“>”+“<![CDATA["+value+"]]>”+“</”+key+“>”);

}else{

buffer.append(“<”+key+“>”+value+“</”+key+“>”);

}

buffer.append(“”);

return buffer.toString();

}

//创建md5 数字签证

@SuppressWarnings({“rawtypes”})

private String createSign(SortedMap<Object, Object> param){

StringBuffer buffer = new StringBuffer();

Set set = param.entrySet();

Iterator<?> iterator = set.iterator();

while(iterator.hasNext()){

Map.Entry entry = (Map.Entry) iterator.next();

String key = String.valueOf(entry.getKey());

Object value =String.valueOf(entry.getValue());

if(null != value && !“”.equals(value) && !“sign”.equals(key) && !“key”.equals(key)){

buffer.append(key+“=”+value+“&”);

}

buffer.append(“key=”+WeiXinUtil.APIKEY);

String sign =EncryptUtil.getMD5(buffer.toString()).toUpperCase();

return sign;

}

微信回调接口：

/**

weixin 微信服务端回调

@Controller

@RequestMapping(“/buyer”)

public class WeiXinNotifyController extends BaseController {

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

/*支付成功/

private static final int PAY_LOGS_SUCCESS=1;

@Autowired

private OrderInfoService orderInfoService;

@Autowired

private CouponReceiveService couponReceiveService;

@Autowired

private GroupsService groupsService;

@RequestMapping(value = “/weixin/notify”, method = { RequestMethod.GET, RequestMethod.POST })

public void weixinNotify(HttpServletRequest request, HttpServletResponse response) throws IOException

{

String url=request.getRequestURL().toString();

logger.info(“WeiXinNotifyController.weixinNotify.start–>url:” +url);

try

{

StringBuffer buf = new StringBuffer();

if (request.getMethod().equalsIgnoreCase(“POST”))

{

Enumeration em = request.getParameterNames();

for (; em.hasMoreElements()😉

{

Object o = em.nextElement();

buf.append(o).append(“=”).append(request.getParameter(o.toString())).append(“,”);

}

logger.info(“回调 method:post]http://” + request.getServerName() + request.getServletPath() + " [<prams:" + buf + “>]”);

} else

{

buf.append(request.getQueryString());

logger.info(“回调 method:get]http://” + request.getServerName() + request.getServletPath() + “?” + request.getQueryString());

}

request.setCharacterEncoding(“UTF-8”);

response.setCharacterEncoding(“UTF-8”);

response.setContentType(“text/html;charset=UTF-8”);

response.setHeader(“Access-Control-Allow-Origin”, “*”);

InputStream in=request.getInputStream();

ByteArrayOutputStream out=new ByteArrayOutputStream();

byte[] buffer =new byte[1024];

int len=0;

while((len=in.read(buffer))!=-1){

out.write(buffer, 0, len);

}

out.close();

in.close();
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）

最后

为什么我不完全主张自学？
①平台上的大牛基本上都有很多年的工作经验了，你有没有想过之前行业的门槛是什么样的，现在行业门槛是什么样的？以前企业对于程序员能力要求没有这么高，甚至十多年前你只要会写个“Hello World”，你都可以入门这个行业，所以以前要入门是完全可以入门的。
②现在也有一些优秀的年轻大牛，他们或许也是自学成才，但是他们一定是具备优秀的学习能力，优秀的自我管理能力（时间管理，静心坚持等方面）以及善于发现问题并总结问题。
如果说你认为你的目标十分明确，能做到第②点所说的几个点，以目前的市场来看，你才真正的适合去自学。

除此之外，对于绝大部分人来说，报班一定是最好的一种快速成长的方式。但是有个问题，现在市场上的培训机构质量参差不齐，如果你没有找准一个好的培训班，完全是浪费精力，时间以及金钱，这个需要自己去甄别选择。

我个人建议线上比线下的性价比更高，线下培训价格基本上没2W是下不来的，线上教育现在比较成熟了，此次疫情期间，学生基本上都感受过线上的学习模式。相比线下而言，线上的优势以我的了解主要是以下几个方面：
①价格：线上的价格基本上是线下的一半；
②老师：相对而言线上教育的师资力量比线下更强大也更加丰富，资源更好协调；
③时间：学习时间相对而言更自由，不用裸辞学习，适合边学边工作，降低生活压力；
④课程：从课程内容来说，确实要比线下讲的更加深入。

应该学哪些技术才能达到企业的要求？（下图总结）