(12)SprintBoot 2.X 使用RabbitMQ实现高并发秒杀接口优化
- 1. 高并发秒杀接口优化思路:减少数据库访问
- 1.1具体实现流程:
- 1.2 技术实现细节:本地标记 + redis预处理 + RabbitMQ异步下单 + 客户端轮询
- 1.2.1 细节描述:
- 2.代码实现
- 2.1 系统初始化,把商品库存数量加载到Redis
- 2.2 RabbitMQ队列的实现
- 2.2.1 MQConfig,使用Direct交换机模式
- 2.2.2 MQSender 将用户信息和商品信息封装起来传入队列
- 2.2.3 MQReceiver 请求出队,生成订单,减少库存
- 2.2.4 MiaoshaMessage 消息的封装类,将user和goodsId封装进行传输
- 2.3 Controller层:本地标记 + redis预处理 + RabbitMQ异步下单
- 2.4 客户端轮询
- 2.4.1 前端代码修改 设置200ms轮询一次服务端,获取秒杀结果
- 2.4.2 后端Controller层
- 2.4.3 后端Service层
1. 高并发秒杀接口优化思路:减少数据库访问
1.1具体实现流程:
- 系统初始化,把商品库存数量加载到Redis
- 收到请求,Redis预减库存,库存不足,直接返回,否则3
- 请求入队,立即返回排队中
- 请求出队,生成订单,减少库存
- 客户端轮询,是否秒杀成功
1.2 技术实现细节:本地标记 + redis预处理 + RabbitMQ异步下单 + 客户端轮询
1.2.1 细节描述:
- 通过三级缓冲保护,1、本地标记 2、redis预处理 3、RabbitMQ异步下单,最后才会访问数据库,这样做是为了最大力度减少对数据库的访问。
- 实现:
- 系统初始化,把商品库存数量stock加载到Redis
- 服务器接收秒杀请求,在秒杀阶段使用本地标记localOverMap(goodsId,boolean)对秒杀商品做标记,若被标记为true,表明商品秒杀完毕,直接返回秒杀结束,未被标记为true才查询redis,通过本地标记来减少对redis的访问
- Redis预减库存,如果库存已经到达临界值的时候,直接返回失败,即后面的大量请求无需给系统带来压力,通过Redis预减少库存减少数据库访问
- 通过redis缓存判断这个秒杀订单形成没有,避免同一用户重复秒杀。如果是重复秒杀,则需要对Redis的预减库存进行回增,并重重置本地标记localOverMap为false。
- 为了保护系统不受高流量的冲击而导致系统崩溃的问题,使用RabbitMQ用异步队列处理下单,实际做了一层缓冲保护,做了一个窗口模型,窗口模型会实时的刷新用户秒杀的状态。
- 后端RabbitMQ监听秒杀MIAOSHA_QUEUE的这名字的通道,如果有消息过来,获取到传入的信息,执行真正的秒杀之前,要判断数据库的库存,判断是否重复秒杀,然后执行秒杀事务(减库存,下订单,写入秒杀订单),秒杀订单还需要写到Redis中,方便判断是否重复秒杀。
- 客户端根据商品id用js轮询接口,用来获取处理状态
2.代码实现
2.1 系统初始化,把商品库存数量加载到Redis
- 通过重写InitializingBean接口中的一个方法:afterPropertiesSet(),系统初始化会首先调用该函数:
/**
* 系统初始化时,加载秒杀商品库存到redis
* 如果商品库存不为0,则让本地内存标记为false,
* @throws Exception
*/
@Override
public void afterPropertiesSet() throws Exception {
List<GoodsVo> goodList = goodsService.listGoodsVo();
if(goodList == null){
return ;
}
for(GoodsVo goodsVo : goodList){
redisService.set(GoodsKey.getMiaoshaGoodsStock,"" + goodsVo.getId(), goodsVo.getStockCount());
if(goodsVo.getStockCount() > 0) {
localOverMap.put(goodsVo.getId(), false);
}else{
localOverMap.put(goodsVo.getId(), true);
}
}
}
@Service
public class GoodsService {
@Autowired
GoodsDao goodsDao;
public List<GoodsVo> listGoodsVo() {
return goodsDao.listGoodsVo();
}
public GoodsVo getGoodsVoByGoodsId(long goodsId) {
return goodsDao.getGoodsVoByGoodsId(goodsId);
}
public boolean reduceStock(GoodsVo goods) {
MiaoshaGoods g = new MiaoshaGoods();
g.setGoodsId(goods.getId());
return goodsDao.reduceStock(g) > 0 ;
}
}
@Mapper
public interface GoodsDao {
//连接查询
@Select("select g.*,mg.stock_count,mg.start_date,mg.end_date,mg.miaosha_price from miaosha_goods mg left join goods g on mg.goods_id=g.id")
public List<GoodsVo> getGoodsVoList();
}
2.2 RabbitMQ队列的实现
2.2.1 MQConfig,使用Direct交换机模式
@Configuration
public class MQConfig {
public static final String MIAOSHA_QUEUE = "miaosha.queue";
@Bean
public Queue queue() {
return new Queue(MIAOSHA_QUEUE, true);
}
2.2.2 MQSender 将用户信息和商品信息封装起来传入队列
- 消息队列这里,消息只能传字符串,MiaoshaMessage 这里是个Bean对象,是先用beanToString方法,将转换为String,放入队列,使用AmqpTemplate传输
@Service
public class MQSender {
@Autowired
AmqpTemplate amqpTemplate;
private static Logger log = LoggerFactory.getLogger(MQSender.class);
public void sendMiaoshaMessage(MiaoshaMessage message) {
String msg = RedisService.beanToString(message);
log.info("send message:"+msg);
amqpTemplate.convertAndSend(MQConfig.MIAOSHA_QUEUE,msg);
}
}
2.2.3 MQReceiver 请求出队,生成订单,减少库存
- 是先用stringToBean方法,将转换为MiaoshaMessage 的Bean,然后从Bean中获取use和goodsId
@Service
public class MQReceiver {
@Autowired
MiaoshaUserService userService;
@Autowired
RedisService redisService;
@Autowired
GoodsService goodsService;
@Autowired
OrderService orderService;
@Autowired
MiaoshaService miaoshaService;
private static Logger log = LoggerFactory.getLogger(MQReceiver.class);
@RabbitListener(queues=MQConfig.MIAOSHA_QUEUE)
public void receive(String message){
log.info("receive message :" + message);
MiaoshaMessage message1 = RedisService.stringToBean(message,MiaoshaMessage.class);
MiaoshaUser user = message1.getUser();
long goodsId = message1.getGoodsId();
//判断库存
GoodsVo goods = goodsService.getGoodsVoByGoodsId(goodsId);
int stock = goods.getStockCount();
if(stock <=0){
return ;
}
//判断是否重复秒杀到
MiaoshaOrder order = orderService.getMiaoshaOrderByUserIdGoodsId(user.getId(),goodsId);
if(order != null){
return ;
}
减库存 下订单 写入秒杀订单
miaoshaService.miaosha(user, goods);
}
}
2.2.4 MiaoshaMessage 消息的封装类,将user和goodsId封装进行传输
public class MiaoshaMessage {
private MiaoshaUser user;
private long goodsId;
public MiaoshaUser getUser() {
return user;
}
public void setUser(MiaoshaUser user) {
this.user = user;
}
public long getGoodsId() {
return goodsId;
}
public void setGoodsId(long goodsId) {
this.goodsId = goodsId;
}
}
2.3 Controller层:本地标记 + redis预处理 + RabbitMQ异步下单
@RequestMapping(value = "/{path}/do_miaosha", method = RequestMethod.POST)
@ResponseBody
public Result<Integer> miaosha(Model model, MiaoshaUser user,
@RequestParam("goodsId")long goodsId,
@PathVariable("path")String path) {
if(user == null){
return Result.error(CodeMsg.SESSION_ERROR);//return "login";
}
model.addAttribute("user", user);
//内存标记,减少redis访问
boolean isOver = localOverMap.get(goodsId);
if(isOver){
return Result.error(CodeMsg.MIAOSHA_OVER);
}
//reids预减库存
long stock = redisService.decr(GoodsKey.getMiaoshaGoodsStock,""+goodsId);
if(stock < 0){
localOverMap.put(goodsId,true);
return Result.error(CodeMsg.MIAOSHA_OVER);
}
logger.info("判断是否重复秒杀次数:"+ time++);
//判断是否重复秒杀到
MiaoshaOrder order = orderService.getMiaoshaOrderByUserIdGoodsId(user.getId(),goodsId);
if(order != null){
//重复秒杀时需要把预减的库存加回去,并重置localOverMap
redisService.incr(GoodsKey.getMiaoshaGoodsStock,"" + goodsId);
localOverMap.put(goodsId,false);
return Result.error(CodeMsg.REPEATE_MIAOSHA);
}
//压入RabbitMQ队列
MiaoshaMessage message = new MiaoshaMessage();
message.setUser(user);
message.setGoodsId(goodsId);
sender.sendMiaoshaMessage(message);
return Result.success(0); //排队中
}
2.4 客户端轮询
2.4.1 前端代码修改 设置200ms轮询一次服务端,获取秒杀结果
function getMiaoshaResult(goodsId){
g_showLoading();
$.ajax({
url:"/miaosha/result",
type:"GET",
data:{
goodsId:$("#goodsId").val(),
},
success:function(data){
if(data.code == 0){
var result = data.data;
if(result < 0){
layer.msg("对不起,秒杀失败");
}else if(result == 0){//继续轮询
setTimeout(function(){
getMiaoshaResult(goodsId);
}, 200);
}else{
layer.confirm("恭喜你,秒杀成功!查看订单?", {btn:["确定","取消"]},
function(){
window.location.href="/order_detail.htm?orderId="+result;
},
function(){
layer.closeAll();
});
}
}else{
layer.msg(data.msg);
}
},
error:function(){
layer.msg("客户端请求有误");
}
});
}
2.4.2 后端Controller层
- 成功返回orderId,失败返回-1,排队中返回0
/**
* @return orderId:成功
* @return -1:秒杀失败
* @return 0: 排队中
*/
@RequestMapping(value = "/result", method = RequestMethod.GET)
@ResponseBody
public Result<Long> miaoshaResult(Model model, MiaoshaUser user,
@RequestParam("goodsId") long goodsId) {
model.addAttribute("user", user);
if (user == null) {
return Result.error(CodeMsg.SESSION_ERROR);
}
long orderId = miaoshaService.getMiaoshaResult(user.getId(), goodsId);
return Result.success(orderId);
}
2.4.3 后端Service层
- miaosha中若果商品库存为0,则在缓存中写入setGoodsOver(goods.getId());
- 获取秒杀结果时,如果通过userId和goodsId在缓存中查询到订单,则返回订单,如果订单为空,则getGoodsOver(goodsId)判断库存是否为空,如果为空,返回-1,否则返回0
//保证这三个操作,减库存 下订单 写入秒杀订单是一个事物
@Transactional
public OrderInfo miaosha(MiaoshaUser user, GoodsVo goods) {
boolean success = goodsService.reduceStock(goods);
if (success){
//下订单 写入秒杀订单
return orderService.createOrder(user, goods);
}else {
setGoodsOver(goods.getId());
return null;
}
}
public long getMiaoshaResult(Long userId, long goodsId) {
MiaoshaOrder order = orderService.getMiaoshaOrderByUserIdGoodsId(userId,goodsId);
if(order != null){
return order.getOrderId();
}else{
boolean isOver = getGoodsOver(goodsId);
if(isOver){
return -1;
}else{
return 0;
}
}
}
private void setGoodsOver(Long goodsId) {
redisService.set(MiaoshaKey.isGoodsOver,""+goodsId,true);
}
private boolean getGoodsOver(Long goodsId) {
return redisService.exists(MiaoshaKey.isGoodsOver,""+goodsId);
}
public MiaoshaOrder getMiaoshaOrderByUserIdGoodsId(long userId, long goodsId) {
return redisService.get(OrderKey.getMiaoshaOrderByUidGid,""+userId+"_"+goodsId,MiaoshaOrder.class);
}