秒杀系统之四：消息队列异步处理订单(RabbitMQ消息队列)

5. 消息队列异步处理订单

我们之前通过数据库中的乐观锁来控制超卖的问题，并且也通过Jmeter压力测试，那么如果并发量足够大，而且不对其进行限制那么对于接口，对于数据库和服务器都是一个很大的压力，此时，我们需要接口限流，我们通常使用令牌桶算法+乐观锁进行对高并发的限制，但是如果遇到爬虫进行不断的发送数据，这样也会比正常用户大概率秒杀到商品，此时我们需要隐藏接口、带MD5进行双向验证，和单用户限制发送请求的频率。

除了这些方法，实际上我们还可以对于下单的异步处理，我们之前提过，用户进行对商品秒杀的时候会在同一时间进行高并发的请求流量到服务器中，如果每个请求都立即访问数据库进行扣减库存+写入订单的操作，对数据库的压力是巨大的。

那这样我们可以通过RabbitMQ （消息队列）对我们数据库减轻压力：当"幸运儿"成功的将其的秒杀请求放到消息队列中，给其返回抢购成功，实际上用户并不关心自己的订单号马上返回，用户只关心自己是否能够成功抢购，所以对于生成订单号，减少库存等操作我们可以通过异步处理订单将数据写入数据库，比起多线程同步修改数据库的操作，大大缓解了数据库的连接压力，最主要的好处就表现在数据库连接的减少

同步方式：大量请求快速占满数据库框架开启的数据库连接池，同时修改数据库，导致数据库读写性能骤减。
异步方式：一条条消息以顺序的方式写入数据库，连接数几乎不变（当然，也取决于消息队列消费者的数量）。

image-20200930102122309.png

5.1 配置RabbitMQ

导入RabbitMQ依赖和fastJson

<!--spring boot stater data rabbitMQ-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.73</version>
</dependency>

使用Docker在服务器上安装rabbitMQ

# 获取最新的指定版本，该版本包含了web控制页面
docker pull rabbitmq:management

# 默认guest 用户，密码也是guest
docker run -d --name rabbit -p 15672:15672 -p 5672:5672 rabbitmq:management

5672与15672的区别

5672：基于此协议的客户端与消息中间件之间可以传递消息
15672：web控制页面

5.2 properties配置文件

spring.rabbitmq.host=127.0.0.1
spring.rabbitmq.port=5672
spring.rabbitmq.username=guest
spring.rabbitmq.password=guest
# ms为虚拟主机
spring.rabbitmq.virtual-host=/ms

5.3 配置config类

@Component
@Slf4j
public class OrderMqReceiver {
    @Autowired
    private StockDao stockDao;

    @Autowired
    private OrderDao orderDao;

    @Autowired
    private UserDao userDao;

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    @RabbitListener(queuesToDeclare = @Queue("orderQueue"))
    public void process(String msg){
        JSONObject jsonObject = JSONObject.parseObject(msg);
        log.info("OrderMqReceiver收到消息开始用户下单流程：" + msg);
        //校验库存
        Stock stock = checkStock(jsonObject.getInteger("id"));
        //更新库存
        updateSale(stock);
        //创建订单
        Integer order = createOrder(stock);
        log.info("订单号为："+order);
        // 将订单号和用户id放入redis缓存
        stringRedisTemplate.opsForValue().set("orderId_"+ jsonObject.getInteger("id"),""+jsonObject.getInteger("userid"));
    }

    //校验库存
    private Stock checkStock(Integer id){
        Stock stock = stockDao.checkStock(id);
        if(stock.getSale().equals(stock.getCount())){
            throw  new RuntimeException("库存不足!!!");
        }
        return stock;
    }

    //扣除库存
    private void updateSale(Stock stock){
        //在sql层面完成销量的+1  和 版本号的+1 并且根据商品id和版本号同时查询更新的商品
        int value = stockDao.updateSale(stock);
        // 更新失败
        if (value == 0){
            throw new RuntimeException("购买失败，请稍后重试");
        }
    }

    //创建订单
    private Integer createOrder(Stock stock){
        // 因为Java是传递值，所以order对象地址传给了Mybatis
        // mybatis根据表的创建id规则赋值飞order对象id
        // 所以当创建订单号的时候order就会得到一个id，我们可以直接获取
        Order order = new Order();
        order.setSid(stock.getId()).setName(stock.getName()).setCreateDate(new Date());
        orderDao.createOrder(order);
        return order.getId();
    }
}

5.4 配置Service层

@Override
public void killMQ(Integer id, Integer userid, String md5) {

    //校验redis中秒杀商品是否超时
    //        if(!stringRedisTemplate.hasKey("kill"+id))
    //            throw new RuntimeException("当前商品的抢购活动已经结束啦~~");

    //先验证签名
    String hashKey = "KEY_"+userid+"_"+id;
    String s = stringRedisTemplate.opsForValue().get(hashKey);
    if (s==null) throw  new RuntimeException("没有携带验证签名,请求不合法!");
    if (!s.equals(md5)) throw  new RuntimeException("当前请求数据不合法,请稍后再试!");
    // 先从redis获取该用户订单号的数量

    JSONObject object = new JSONObject();
    // 将商品id和用户id放入JSON中，以至于多个参数进行传递下
    object.put("id", id);
    object.put("userid", userid);
    // 定义一个消费者,异步调用订单操作
    // convertSendAndReceive可以接收返回值
    rabbitTemplate.convertAndSend("orderQueue",object.toJSONString());
}

测试调用

image-20200930112039095.png

5.4 限制购买数量

如果我们想要限制购买数量的话，我们应该在redis中存储用户购买信息，每次下单前获取当前已购买的数量，如果达到一定的数量则抛出异常，但是抛出异常我们必须捕获，或者设置死信队列

@RabbitListener(queuesToDeclare = @Queue("orderQueue"))
public void process(String msg){
    JSONObject jsonObject = JSONObject.parseObject(msg);
    Long numbers = stringRedisTemplate.opsForHash().size("order_userId_" + jsonObject.getInteger("userid"));
    // 验证购买次数有没有超过5次
    // 如果不捕获RuntimeException异常
    // 如果抛出异常，则消息消耗不掉，rabbitmq会一直不停的投送消息
    try {
        if (numbers < 5) {
            log.info("OrderMqReceiver收到消息开始用户下单流程：" + msg);
            //校验库存
            Stock stock = checkStock(jsonObject.getInteger("id"));
            //更新库存
            updateSale(stock);
            //创建订单
            Integer order = createOrder(stock);
            log.info("订单号为："+order);
            // 如果想要一人限购一次将订单号和用户id放入redis缓存
            // 用户id-订单号-商品id
            stringRedisTemplate.opsForHash().put("order_userId_" + jsonObject.getInteger("userid"),order.toString(),jsonObject.getInteger("id").toString());
        };
        throw new RuntimeException("超过购买的数量!!!");
    }catch (RuntimeException e){

    }
}

测试调用

image-20200930112921807.png

数据库查看确实只限制了5个购买

image-20200930112958778.png

image-20200930113019702.png

结束语：实际上秒杀系统并没有那么简单，还有很多复杂的东西，这里只是提供思路，每一步做什么，下一步该做什么提供了思路，不至于到时候乱加中间件