秒杀功能(6)RabbitMQ

版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://blog.csdn.net/Serena0814/article/details/90137835

这篇讲解的内容较多。先解决业务问题再解决性能问题。

业务问题

之前的代码中有两类业务问题:

  1. 超卖;
  2. 若一个用户用两个平台同时秒杀某一商品,可能会出现该用户秒杀两件商品的情况。

这两个问题虽然业务问题很大,但代码改动特别小。

  • 超卖
    这里利用数据库本身的锁来解决,只需要改动dao层代码,修改GoodsDao的代码。
//改动前的代码
@Update("update miaosha_goods set stock_count = stock_count - 1 where goods_id = #{goodsId}")
public int reduceStock(MiaoshaGoods g);

//改动后的代码
@Update("update miaosha_goods set stock_count = stock_count - 1 where goods_id = #{goodsId} and stock_count > 0")
public int reduceStock(MiaoshaGoods g); //利用数据库的锁来保证不会卖超(数据库本身会保证不会有两个线程同时改一条记录)
  • 一个用户秒杀多件商品的情况
    在数据库层面:把用户id和商品id组合设置成唯一索引,来防止一个用户多秒杀商品的情况;
    在缓存中:把用户id和商品id组合成一个键,下单前查询该键是否存在,若不存在则下单,并在缓存里存入键值对(值是秒杀订单),这样比直接查询数据库要快些。
@Service
public class OrderService {

    @Autowired
    OrderDao orderDao;

    @Autowired
    RedisService redisService;

    public MiaoshaOrder getMiaoshaOrderByUserIdGoodsId(long userId, long goodsId) {
       // return orderDao.getMiaoshaOrderByUserIdGoodsId(userId, goodsId);
        //在缓存中查
        return redisService.get(OrderKey.getMiaoshaOrderByUidGid, "" + userId + "_" + goodsId, MiaoshaOrder.class);
    }

    @Transactional
    public OrderInfo createOrder(MiaoshaUser user, GoodsVo goods) {
        OrderInfo orderInfo = new OrderInfo();
        orderInfo.setCreateDate(new Date());
        orderInfo.setDeliveryAddrId(0L);
        orderInfo.setGoodsCount(1);
        orderInfo.setGoodsId(goods.getId());
        orderInfo.setGoodsName(goods.getGoodsName());
        orderInfo.setGoodsPrice(goods.getMiaoshaPrice());
        orderInfo.setOrderChannel(1);
        orderInfo.setStatus(0);
        orderInfo.setUserId(user.getId());
        orderDao.insert(orderInfo);
        MiaoshaOrder miaoshaOrder = new MiaoshaOrder();
        miaoshaOrder.setGoodsId(goods.getId());
        miaoshaOrder.setOrderId(orderInfo.getId());
        miaoshaOrder.setUserId(user.getId());
        orderDao.insertMiaoshaOrder(miaoshaOrder);
        //放入缓存中
        redisService.set(OrderKey.getMiaoshaOrderByUidGid, "" + user.getId() + "_" + goods.getId(), miaoshaOrder);
        return orderInfo;
    }
}

可以看到,代码中就改动了两点,一是查询重复订单时是在缓存中查,第二点是,在数据库中创建秒杀订单和订单详情后,会在缓存中插入用户id和商品id结合的键(值是秒杀订单),为之后在缓存中查找做准备。

性能问题

秒杀系统的性能瓶颈一般是在对数据库的访问上,若能减少对数据的访问,就能在很大程度上提高并发量。
大致的思路是:

  1. Redis预减库存减少数据库的访问;
  2. 内存标记减少Redis访问;
  3. 请求先入队缓冲,异步下单,增强用户体验。

具体的代码流程是:

  1. 系统初始化,把商品库存数量加载到Redis中;
  2. 收到请求,先在内存标记上判断商品是否秒杀完毕,若没有,则进入下一步;
  3. Redis预减库存,库存不足,直接返回,否则进入下一步;
  4. Redis中判断是否重复下单,若没有进入下一步;
  5. 请求入队,前端页面立即返回排队中;
  6. 请求出队,数据库中判断库存、缓存中判断是否重复秒杀,若都成功进入下一步;
  7. 数据库中减少库存,数据库中生成订单,在缓存中生成用户和商品的键以便之后验证是否重复下单;
  8. 客户端轮询(前端中实现),是否秒杀成功。

Controller层
在这部分主要完成:

  1. 系统的初始化,把秒杀商品的库存数量加载到Redis中;
  2. 内存中判断商品是否秒杀完、Redis预减库存、判断是否重复秒杀、入队操作。
@Controller
@RequestMapping("/miaosha")
public class MiaoshaController implements InitializingBean {

    @Autowired
    MiaoshaUserService userService;

    @Autowired
    RedisService redisService;

    @Autowired
    GoodsService goodsService;

    @Autowired
    OrderService orderService;

    @Autowired
    MiaoshaService miaoshaService;

    @Autowired
    MQSender sender;

    private HashMap<Long, Boolean> localOverMap = new HashMap<Long, Boolean>();

    /**
     * 系统初始化,初始化的时候把数据库中的库存加载进缓存中
     */
    public void afterPropertiesSet() throws Exception {
        List<GoodsVo> goodsList = goodsService.listGoodsVo();
        if (goodsList == null) {
            return;
        }
        for (GoodsVo goods : goodsList) {
            redisService.set(GoodsKey.getMiaoshaGoodsStock, "" + goods.getId(), goods.getStockCount());
            localOverMap.put(goods.getId(), false);
        }
    }

    //第三版,消息队列的方式
    @RequestMapping(value = "/do_miaosha", method = RequestMethod.POST)
    @ResponseBody
    public Result<Integer> miaosha(Model model, @RequestParam("goodsId") long goodsId, HttpServletResponse response,
                                     @CookieValue(value = MiaoshaUserService.COOKI_NAME_TOKEN,required = false) String cookieToken,
                                     @RequestParam(value = MiaoshaUserService.COOKI_NAME_TOKEN,required = false) String paramToken) {
        if (StringUtils.isEmpty(cookieToken) && StringUtils.isEmpty(paramToken)) {
            return Result.error(CodeMsg.SESSION_ERROR);//token不存在或失效
        }
        String token = StringUtils.isEmpty(paramToken) ? cookieToken : paramToken;
        MiaoshaUser user = userService.getByToken(response, token);//从token中读用户信息

        //内存标记,减少redis访问
        boolean over = localOverMap.get(goodsId);
        if (over) {//库存减去10后不必要访问redis,访问map即可
            return Result.error(CodeMsg.MIAO_SHA_OVER);
        }
        //预减库存
        long stock = redisService.decr(GoodsKey.getMiaoshaGoodsStock, "" + goodsId);
        if (stock < 0) {
            localOverMap.put(goodsId, true);
            return Result.error(CodeMsg.MIAO_SHA_OVER);
        }
        //判断是否已经秒杀到了
        MiaoshaOrder order = orderService.getMiaoshaOrderByUserIdGoodsId(user.getId(), goodsId);
        if (order != null) {
            return Result.error(CodeMsg.REPEATE_MIAOSHA);
        }
        //入队
        MiaoshaMessage mm = new MiaoshaMessage();
        mm.setUser(user);
        mm.setGoodsId(goodsId);
        sender.sendMiaoshaMessage(mm);
        return Result.success(0);//排队中
    }
}

其中,MiaoshaMessage的定义为:

public class MiaoshaMessage {
    private MiaoshaUser user;
    private long goodsId;
    //Getter and Setter...
}

RabbitMQ相关操作

  • MQSender:
@Service
public class MQSender {

    private static Logger log = LoggerFactory.getLogger(MQSender.class);

    @Autowired
    AmqpTemplate amqpTemplate; //操作queue的工具类

    public void sendMiaoshaMessage(MiaoshaMessage mm) {
        String msg = RedisService.beanToString(mm);
        log.info("send message:" + msg);
        amqpTemplate.convertAndSend(MQConfig.MIAOSHA_QUEUE, msg);
    }
}
  • MQReceiver
@Service
public class MQReceiver {

    private static Logger log = LoggerFactory.getLogger(MQReceiver.class);

    @Autowired
    RedisService redisService;

    @Autowired
    GoodsService goodsService;

    @Autowired
    OrderService orderService;

    @Autowired
    MiaoshaService miaoshaService;

    @RabbitListener(queues = MQConfig.MIAOSHA_QUEUE) //监听的指定的队列
    public void receive(String message) {
        log.info("receive message:" + message);
        MiaoshaMessage mm = RedisService.stringToBean(message, MiaoshaMessage.class);
        MiaoshaUser user = mm.getUser();
        long goodsId = mm.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);
    }
}

其中,miaoshaService.miaosha(user, goods)操作为:

@Service
public class MiaoshaService {

    @Autowired
    GoodsService goodsService;

    @Autowired
    OrderService orderService;

    @Autowired
    RedisService redisService;

    @Transactional
    public OrderInfo miaosha(MiaoshaUser user, GoodsVo goods) {
        //减库存 下订单 写入秒杀订单
        boolean success = goodsService.reduceStock(goods);
        if (success){
            //order_info maiosha_order
            return orderService.createOrder(user, goods);
        }else {
            setGoodsOver(goods.getId());
            return null;
        }
    }
}

目前,优化完成了。当用户请求到达Controller层,在到达数据库之前,内存map和redis会抵挡大部分的数据库访问操作,大概只有与秒杀商品个数差不多的请求会进入队列从而访问数据库。

压测

在之前写的秒杀功能(3)的压测中,初步版本的TPS = 808/sec;

本次的压测结果为:
在这里插入图片描述
TPS = 908/sec,略高一些,没有提高太多,这可能是和硬件条件有关,我的服务器性能不高。

数据库情况

  • 秒杀商品情况
    在这里插入图片描述
  • 秒杀订单情况
    在这里插入图片描述
    正好9个订单,没有出现卖超的现象了。

这篇写完我是奔溃的,,明明在几个小时前我就能写完。。中间开了个组会我掉网了。。我还没保存。。于是写了两遍。。又拖累了今天的进度,offer君又远离我一步。。

展开阅读全文

没有更多推荐了,返回首页