0%

秒杀解决方案

秒杀业务分析

需求分析

所谓“秒杀”,就是网络卖家发布一些超低价格的商品,所有买家在同一时间网上抢购的一种销售方式。通俗一点讲就是网络商家为促销等目的组织的网上限时抢购活动。由于商品价格低廉,往往一上架就被抢购一空,有时只用一秒钟。

秒杀商品通常有两种限制:库存限制、时间限制。

需求:

(1)商家提交秒杀商品申请,录入秒杀商品数据,主要包括:商品标题、原价、秒杀价、商品图片、介绍等信息

(2)运营商审核秒杀申请

(3)秒杀频道首页列出秒杀商品(进行中的)点击秒杀商品图片跳转到秒杀商品详细页。

(4)商品详细页显示秒杀商品信息,点击立即抢购实现秒杀下单,下单时扣减库存。当库存为0或不在活动期范围内时无法秒杀。

(5)秒杀下单成功,直接跳转到支付页面(微信扫码),支付成功,跳转到成功页,填写收货地址、电话、收件人等信息,完成订单。

(6)当用户秒杀下单5分钟内未支付,取消预订单,调用微信支付的关闭订单接口,恢复库存

数据库表分析

Tb_seckill_goods 秒杀商品表

Tb_seckill_order 秒杀订单表

秒杀实现思路

秒杀技术实现核心思想是运用缓存减少数据库瞬间的访问压力!读取商品详细信息时运用缓存,当用户点击抢购时减少缓存中的库存数量,当库存数为0时或活动期结束时,同步到数据库。 产生的秒杀订单也不会立刻写到数据库中,而是先写到缓存,当用户付款成功后再写入数据库。

秒杀商品后台管理

商家后台

(1)秒杀商品列表

(2)秒杀商品申请

(3)秒杀订单查询

运营商后台

(1)待审核秒杀商品列表

(2)秒杀商品审核

(3)秒杀订单查询

秒杀频道首页

需求分析

秒杀频道首页,显示正在秒杀的商品(已经开始,未结束的商品)

后端代码

服务接口层

1
2
3
4
5
/**
* 返回当前正在参与秒杀的商品
* @return
*/
public List<TbSeckillGoods> findList();

服务实现层

1
2
3
4
5
6
7
8
9
10
@Override
public List<TbSeckillGoods> findList() {
TbSeckillGoodsExample example=new TbSeckillGoodsExample();
Criteria criteria = example.createCriteria();
criteria.andStatusEqualTo("1");//审核通过
criteria.andStockCountGreaterThan(0);//剩余库存大于0
criteria.andStartTimeLessThanOrEqualTo(new Date());//开始时间小于等于当前时间
criteria.andEndTimeGreaterThan(new Date());//结束时间大于当前时间
return seckillGoodsMapper.selectByExample(example);
}

控制层

1
2
3
4
5
6
7
8
/**
* 当前秒杀的商品
* @return
*/
@RequestMapping("/findList")
public List<TbSeckillGoods> findList(){
return seckillGoodsService.findList();
}

前端代码实现

服务层

1
2
3
4
5
6
7
//服务层
app.service('seckillGoodsService',function($http){
//读取列表数据绑定到表单中
this.findList=function(){
return $http.get('seckillGoods/findList.do');
}
});

控制层

1
2
3
4
5
6
7
8
9
10
11
//控制层 
app.controller('seckillGoodsController' ,function($scope,seckillGoodsService){
//读取列表数据绑定到表单中
$scope.findList=function(){
seckillGoodsService.findList().success(
function(response){
$scope.list=response;
}
);
}
});

缓存处理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
@Autowired
private RedisTemplate redisTemplate;

@Override
public List<TbSeckillGoods> findList() {
//获取秒杀商品列表
List<TbSeckillGoods> seckillGoodsList = redisTemplate.boundHashOps("seckillGoods").values();
if(seckillGoodsList==null || seckillGoodsList.size()==0){
TbSeckillGoodsExample example=new TbSeckillGoodsExample();
Criteria criteria = example.createCriteria();
criteria.andStatusEqualTo("1");//审核通过
criteria.andStockCountGreaterThan(0);//剩余库存大于0
criteria.andStartTimeLessThanOrEqualTo(new Date());//开始时间小于等于当前时间
criteria.andEndTimeGreaterThan(new Date());//结束时间大于当前时间
seckillGoodsList= seckillGoodsMapper.selectByExample(example);
//将商品列表装入缓存
System.out.println("将秒杀商品列表装入缓存");
for(TbSeckillGoods seckillGoods:seckillGoodsList){
redisTemplate.boundHashOps("seckillGoods").put(seckillGoods.getId(), seckillGoods);
}
}
return seckillGoodsList;
}

秒杀详细页

需求分析

商品详细页显示秒杀商品信息。

显示详细页信息

后端代码

1
2
3
4
/**
* 根据ID获取实体(从缓存中读取)
*/
public TbSeckillGoods findOneFromRedis(Long id);
1
2
3
4
@Override
public TbSeckillGoods findOneFromRedis(Long id) {
return (TbSeckillGoods)redisTemplate.boundHashOps("seckillGoods").get(id);
}
1
2
3
4
@RequestMapping("/findOneFromRedis")
public TbSeckillGoods findOneFromRedis(Long id){
return seckillGoodsService.findOneFromRedis(id);
}

增加超时时间设置

1
2
@Reference(timeout=10000)
private SeckillGoodsService seckillGoodsService;

前端代码

1
2
3
this.findOne=function(id){
return $http.get('seckillGoods/findOneFromRedis.do?id='+id);
}
1
2
3
4
5
6
7
8
//查询实体 
$scope.findOne=function(){
seckillGoodsService.findOne($location.search()['id']).success(
function(response){
$scope.entity= response;
}
);
}

秒杀倒计时效果

$interval服务简介

在AngularJS中$interval服务用来间歇性处理一些事情

格式为:

1
$interval(执行的函数,间隔的毫秒数,运行次数);

运行次数可以缺省,如果缺省则无限循环执行,取消执行用cancel方法

我先现在先做一个简单的例子:10秒倒计时 ,首先引入$interval , 控制层编写代码如下:

1
2
3
4
5
6
7
8
9
$scope.second = 10; 
time= $interval(function(){
if($scope.second>0){
$scope.second =$scope.second-1;
}else{
$interval.cancel(time);
alert("秒杀服务已结束");
}
},1000);

页面用表达式显示$scope.second的值

秒杀倒计时

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
$scope.findOne=function(){	
seckillGoodsService.findOne($location.search()['id']).success(
function(response){
$scope.entity= response;
allsecond =Math.floor( ( new Date($scope.entity.endTime).getTime()- (new Date().getTime())) /1000); //总秒数
time= $interval(function(){
if(second>0){
second =second-1;
$scope.timeString=convertTimeString(allsecond);//转换时间字符串
}else{
$interval.cancel(time);
alert("秒杀服务已结束");
}
},1000);
}
);
}

//转换秒为 天小时分钟秒格式 XXX天 10:22:33
convertTimeString=function(allsecond){
var days= Math.floor( allsecond/(60*60*24));//天数
var hours= Math.floor( (allsecond-days*60*60*24)/(60*60) );//小数数
var minutes= Math.floor( (allsecond -days*60*60*24 - hours*60*60)/60 );//分钟数
var seconds= allsecond -days*60*60*24 - hours*60*60 -minutes*60; //秒数
var timeString="";
if(days>0){
timeString=days+"天 ";
}
return timeString+hours+":"+minutes+":"+seconds;
}

Math.floor()用于对小数取整,直接丢弃小数位数

修改页面seckill-item.html ,显示time的值

1
<span class="overtime"> 距离结束:{{timeString}}</span>

秒杀下单

需求分析

商品详细页点击立即抢购实现秒杀下单,下单时扣减库存。当库存为0或不在活动期范围内时无法秒杀。

后端代码

服务接口层

1
2
3
4
5
6
/**
* 提交订单
* @param seckillId
* @param userId
*/
public void submitOrder(Long seckillId,String userId);

服务实现层

Spring配置文件注入IdWorker

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
@Autowired
private RedisTemplate redisTemplate;

@Autowired
private IdWorker idWorker;

@Override
public void submitOrder(Long seckillId, String userId) {
//从缓存中查询秒杀商品
TbSeckillGoods seckillGoods =(TbSeckillGoods) redisTemplate.boundHashOps("seckillGoods").get(seckillId);
if(seckillGoods==null){
throw new RuntimeException("商品不存在");
}
if(seckillGoods.getStockCount()<=0){
throw new RuntimeException("商品已抢购一空");
}
//扣减(redis)库存
seckillGoods.setStockCount(seckillGoods.getStockCount()-1);
redisTemplate.boundHashOps("seckillGoods").put(seckillId, seckillGoods);//放回缓存
if(seckillGoods.getStockCount()==0){//如果已经被秒光
seckillGoodsMapper.updateByPrimaryKey(seckillGoods);//同步到数据库
redisTemplate.boundHashOps("seckillGoods").delete(seckillId);
}
//保存(redis)订单
long orderId = idWorker.nextId();
TbSeckillOrder seckillOrder=new TbSeckillOrder();
seckillOrder.setId(orderId);
seckillOrder.setCreateTime(new Date());
seckillOrder.setMoney(seckillGoods.getCostPrice());//秒杀价格
seckillOrder.setSeckillId(seckillId);
seckillOrder.setSellerId(seckillGoods.getSellerId());
seckillOrder.setUserId(userId);//设置用户ID
seckillOrder.setStatus("0");//状态
redisTemplate.boundHashOps("seckillOrder").put(userId, seckillOrder);
}

控制层

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
@RequestMapping("/submitOrder")
public Result submitOrder(Long seckillId){
String userId = SecurityContextHolder.getContext().getAuthentication().getName();
if("anonymousUser".equals(userId)){//如果未登录
return new Result(false, "用户未登录");
}
try {
seckillOrderService.submitOrder(seckillId, userId);
return new Result(true, "提交成功");
}catch (RuntimeException e) {
e.printStackTrace();
return new Result(false, e.getMessage());
} catch (Exception e) {
e.printStackTrace();
return new Result(false, "提交失败");
}
}

前端代码

前端服务层

1
2
3
4
//提交订单
this.submitOrder=function(seckillId){
return $http.get('seckillOrder/submitOrder.do?seckillId='+seckillId);
}

前端控制层

1
2
3
4
5
6
7
8
9
10
11
12
13
//提交订单
$scope.submitOrder=function(){
seckillGoodsService.submitOrder($scope.entity.id).success(
function(response){
if(response.success){
alert("下单成功,请在1分钟内完成支付");
location.href="pay.html";
}else{
alert(response.message);
}
}
);
}

页面

1
<a ng-click="submitOrder()" target="_blank" class="sui-btn  btn-danger addshopcar">秒杀抢购</a>

秒杀支付

需求分析

用户成功下单后,跳转到支付页面。支付页显示微信支付二维码。用户完成支付后,保存订单到数据库。

生成支付二维码

后端代码

1
2
3
4
5
/**
* 根据用户名查询秒杀订单
* @param userId
*/
public TbSeckillOrder searchOrderFromRedisByUserId(String userId);
1
2
3
4
@Override
public TbSeckillOrder searchOrderFromRedisByUserId(String userId) {
return (TbSeckillOrder) redisTemplate.boundHashOps("seckillOrder").get(userId);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
/**
* 支付控制层
* @author Administrator
*
*/
@RestController
@RequestMapping("/pay")
public class PayController {

@Reference
private WeixinPayService weixinPayService;

@Reference
private SeckillOrderService seckillOrderService;

/**
* 生成二维码
* @return
*/
@RequestMapping("/createNative")
public Map createNative(){
//获取当前用户
String userId=SecurityContextHolder.getContext().getAuthentication().getName();
//到redis查询秒杀订单
TbSeckillOrder seckillOrder = seckillOrderService.searchOrderFromRedisByUserId(userId);
//判断秒杀订单存在
if(seckillOrder!=null){
long fen= (long)(seckillOrder.getMoney().doubleValue()*100);//金额(分)
return weixinPayService.createNative(seckillOrder.getId()+"",+fen+"");
}else{
return new HashMap();
}
}
}

支付成功保存订单

后端代码

1
2
3
4
5
6
7
8
9
10
11
/**

* 支付成功保存订单

* @param userId

* @param orderId

*/

public void saveOrderFromRedisToDb(String userId,Long orderId,String transactionId);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
@Override
public void saveOrderFromRedisToDb(String userId, Long orderId, String transactionId) {
System.out.println("saveOrderFromRedisToDb:"+userId);
//根据用户ID查询日志
TbSeckillOrder seckillOrder = (TbSeckillOrder) redisTemplate.boundHashOps("seckillOrder").get(userId);
if(seckillOrder==null){
throw new RuntimeException("订单不存在");
}
//如果与传递过来的订单号不符
if(seckillOrder.getId().longValue()!=orderId.longValue()){
throw new RuntimeException("订单不相符");
}
seckillOrder.setTransactionId(transactionId);//交易流水号
seckillOrder.setPayTime(new Date());//支付时间
seckillOrder.setStatus("1");//状态
seckillOrderMapper.insert(seckillOrder);//保存到数据库
redisTemplate.boundHashOps("seckillOrder").delete(userId);//从redis中清除
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
/**
* 查询支付状态
* @param out_trade_no
* @return
*/
@RequestMapping("/queryPayStatus")
public Result queryPayStatus(String out_trade_no){
//获取当前用户
String userId=SecurityContextHolder.getContext().getAuthentication().getName();
Result result=null;
int x=0;
while(true){
//调用查询接口
Map<String,String> map = weixinPayService.queryPayStatus(out_trade_no);
if(map==null){//出错
result=new Result(false, "支付出错");
break;
}
if(map.get("trade_state").equals("SUCCESS")){//如果成功
result=new Result(true, "支付成功");
seckillOrderService.saveOrderFromRedisToDb(userId, Long.valueOf(out_trade_no), map.get("transaction_id"));
break;
}
try {
Thread.sleep(3000);//间隔三秒
} catch (InterruptedException e) {
e.printStackTrace();
}
x++;//设置超时时间为5分钟
if(x>100){
result=new Result(false, "二维码超时");
break;
}
}
return result;
}

前端代码

1
queryPayStatus(response.out_trade_no);//查询支付状态

订单超时处理

当用户下单后5分钟尚未付款应该释放订单,增加库存

删除缓存中的订单

1
2
3
4
5
6
/**
* 从缓存中删除订单
* @param userId
* @param orderId
*/
public void deleteOrderFromRedis(String userId,Long orderId);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
@Override
public void deleteOrderFromRedis(String userId, Long orderId) {
//根据用户ID查询日志
TbSeckillOrder seckillOrder = (TbSeckillOrder) redisTemplate.boundHashOps("seckillOrder").get(userId);
if(seckillOrder!=null &&
seckillOrder.getId().longValue()== orderId.longValue() ){
redisTemplate.boundHashOps("seckillOrder").delete(userId);//删除缓存中的订单
//恢复库存
//1.从缓存中提取秒杀商品
TbSeckillGoods seckillGoods=(TbSeckillGoods)redisTemplate.boundHashOps("seckillGoods").get(seckillOrder.getSeckillId());
if(seckillGoods!=null){
seckillGoods.setStockCount(seckillGoods.getStockCount()+1);
redisTemplate.boundHashOps("seckillGoods").put(seckillOrder.getSeckillId(), seckillGoods);//存入缓存
}
}
}

关闭微信订单

1
2
3
4
5
6
/**
* 关闭支付
* @param out_trade_no
* @return
*/
public Map closePay(String out_trade_no);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
@Override
public Map closePay(String out_trade_no) {
Map param=new HashMap();
param.put("appid", appid);//公众账号ID
param.put("mch_id", partner);//商户号
param.put("out_trade_no", out_trade_no);//订单号
param.put("nonce_str", WXPayUtil.generateNonceStr());//随机字符串
String url="https://api.mch.weixin.qq.com/pay/closeorder";
try {
String xmlParam = WXPayUtil.generateSignedXml(param, partnerkey);
HttpClient client=new HttpClient(url);
client.setHttps(true);
client.setXmlParam(xmlParam);
client.post();
String result = client.getContent();
Map<String, String> map = WXPayUtil.xmlToMap(result);
System.out.println(map);
return map;
} catch (Exception e) {
e.printStackTrace();
return null;
}
}

超时调用服务

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
/**
* 查询支付状态
* @param out_trade_no
* @return
*/
@RequestMapping("/queryPayStatus")
public Result queryPayStatus(String out_trade_no){
//获取当前用户
String userId=SecurityContextHolder.getContext().getAuthentication().getName();
Result result=null;
int x=0;
while(true){
........
try {
Thread.sleep(3000);//间隔三秒
} catch (InterruptedException e) {
e.printStackTrace();
}
//不让循环无休止地运行定义变量,如果超过了这个值则退出循环,设置时间为1分钟
x++;
if(x>20){
result=new Result(false, "二维码超时");
//1.调用微信的关闭订单接口(学员实现)
Map<String,String> payresult = weixinPayService.closePay(out_trade_no);
if( !"SUCCESS".equals(payresult.get("result_code")) ){//如果返回结果是正常关闭
if("ORDERPAID".equals(payresult.get("err_code"))){
result=new Result(true, "支付成功");
seckillOrderService.saveOrderFromRedisToDb(userId, Long.valueOf(out_trade_no), map.get("transaction_id"));
}
}
if(result.isSuccess()==false){
System.out.println("超时,取消订单");
//2.调用删除
seckillOrderService.deleteOrderFromRedis(userId, Long.valueOf(out_trade_no));
}
break;
}
}
return result;
}

前端代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
//查询支付状态 
queryPayStatus=function(out_trade_no){
payService.queryPayStatus(out_trade_no).success(
function(response){
if(response.success){
location.href="paysuccess.html#?money="+$scope.money;
}else{
if(response.message=='二维码超时'){
location.href="payTimeOut.html";
}else{
location.href="payfail.html";
}
}
}
);
}
鼓励一下~