接口优化--Rabbit MQ异步下单

Rabbit MQ 消息队列了解一下

四种交换机模式：

1.Direct 模式 2.Topic 模式 3.Fanout模式（广播模式） 4.Header 模式 （根据header中的键值 进行消息匹配）

本项目中使用的是Direct模式。

思路：

1.当确认秒杀开始，（库存充足，且无重复秒杀）将秒杀请求需要的消息入队（封装），同时给前端返回一个code (0),

前端接收到数据后，显示排队中。

2.后端Rabbit MQ 监听 秒杀 queue 的这名字的通道，如果有消息过来，获取到传入的信息，执行真正的秒杀之前，要判断 数据库的库存，之前判断的是Redis 中的库存，判断是否重复秒杀，然后执行秒杀Service

3.此时，前端根据商品id 轮询请求 getResult ,如果请求到的商品生成了商品订单（userid,goodsId到数据库里查），说明秒杀成功，

前端会根据后端返回的值来判断 是秒杀成功还是继续轮询还是秒杀失败。

三种：-1 秒杀失败 0 排队中，继续轮询， >0 返回的是商品id ，说明秒杀成功
 

第一步：消息入队（并将用户信息和商品信息封装起来传入队列）

        /**秒杀接口优化之 ----第三步： 消息队列 异步下单
         *         1.将用户信息和商品Id 封装到 MiaoshaMessage
         *         2.发送Message
         *         3.返回前端一个0 ：表示"排队中"
         * */
        MiaoshaMessage mm = new MiaoshaMessage();
        mm.setMiaoshaUser(user);
        mm.setGoodsId(goodsId);
        sender.miaoshaSend(mm);
        return Result.success(0);// 0 表示等待中 ，排队


public class MiaoshaMessage {
    private MiaoshaUser miaoshaUser;
    private long goodsId;

    public MiaoshaUser getMiaoshaUser() {
        return miaoshaUser;
    }

    public void setMiaoshaUser(MiaoshaUser miaoshaUser) {
        this.miaoshaUser = miaoshaUser;
    }

    public long getGoodsId() {
        return goodsId;
    }

    public void setGoodsId(long goodsId) {
        this.goodsId = goodsId;
    }
}

注意：消息队列这里，消息只能传字符串，MiaoshaMessage 这里是 个Bean对象，是先用BeanToString 方法，将转换为String，放入队列，以MiaoshaConfig的队列名传输。

Direct 模式，监控队列名

第二步：监控该消息队列，一旦有消息进入，从该消息中获取对象进行秒杀操作（）

    /**监控MiaoshaQueue 消息队列
     * */
    @RabbitListener(queues = MQConfig.MIAOSHA_QUEUE)
    public void miaoShaReceive(String message){
        log.info("Receive message:");
        /* 通过 消息队列接收到的message  将秒杀的message中携带的 user 和 goodsId */
        MiaoshaMessage miaoshaMessage = RedisService.stringToBean(message,MiaoshaMessage.class);
        long goodsId = miaoshaMessage.getGoodsId();
        MiaoshaUser user = miaoshaMessage.getMiaoshaUser();
        GoodsVo goodsVo =goodsService.getGoodsById(goodsId);
        /*这里继续判断库存： 但是判断 的是数据库的库存 因为 前面 redis 预减已经拦截大部分并发请求*/
        long  stock =goodsVo.getStockCount();
        if (stock <= 0){ // 小于等于0 不能是==0 单线程没有问题
            return;//若没有库存就返回
        }
        /*判断重复秒杀
        * */
        MiaoshaOrder miaoshaOrder = orderService.getMiaoshaByUserAndGood(user.getId(),goodsId);
        if (miaoshaOrder != null){
            return;
        }
        /* 都过了 执行秒杀 */
        miaoshaService.miaosha(user,goodsVo);// 改一下，可能 减库存失败，若果失败就返回
    }

第三步：前端在入队的同时，发出轮询请求，后端处理秒杀逻辑，并向前端返回请求结果。

    @Transactional
    public OrderInfo miaosha(MiaoshaUser user, GoodsVo goodsVo) {
        /*减库存*/
        //该方法返回一个int型数值
        boolean succes = goodsService.reduceStock(goodsVo);
        if (succes){//减库存成功
                 /*下订单*/
            return orderService.insertOrder(user,goodsVo);
        }else {//失败 说明 商品已经被秒杀完了
            //秒杀完了，就做一个标记 通过这个标记来判断是不是因为卖完了，而没有记录
            setGoodsOver(goodsVo.getId());
            return null;
        }
    }

    private void setGoodsOver(long goodsId) {
        redisService.set(MiaoshaKey.getMiaoshaOver,""+goodsId,true);
    }


    private boolean getGoodsOver(long goodsId) {//看存不存在
        return redisService.exist(MiaoshaKey.getMiaoshaOver,""+goodsId);
    }

这里后端执行的时候为了判断请求失败和在轮询中，做一一次SetGoodOver处理。

如果减库存失败，说明商品没有了，即请求失败，在Redis 中标记一下

    public long getMiaoshaResult(MiaoshaUser user,long goodsId) {

        MiaoshaOrder miaoshaOrder = orderService.getMiaoshaByUserAndGood(user.getId(),goodsId);
        if (miaoshaOrder != null){//不为空，说明秒杀成功 能查到该秒杀订单
            return miaoshaOrder.getOrderId();
        }else {//为空有两种情况，1 还没完成秒杀 2 没秒杀到  从秒杀 业务中判断
            boolean isOver = getGoodsOver(goodsId);
            if (isOver){
                return -1;
            }else {
                return 0;
            }
        }
    }

然后轮询访问 getResult 这个接口，从数据库中拿订单，如果有。返回商品id,说明秒杀成功，

如果没有，2种情况，还在处理，已经失败。

通过从redis中拿到over标记来判断失败还是在请求，over返回-1,请求中，返回0，

前端拿到返回的数据，通过判断，进行显示，成功就跳转订单页面

0 就过几秒在请求轮询， -1 显示秒杀失败。