基于Redis的Stream结构作为消息队列，实现异步秒杀下单

最新推荐文章于 2024-06-27 08:26:19 发布
最新推荐文章于 2024-06-27 08:26:19 发布
阅读量559 收藏
点赞数 1
分类专栏： java 文章标签： redis 数据库 缓存
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51438138/article/details/129348883
版权

需求：

  • 创建一个Stream类型的消息队列，名为stream.orders

  • 修改之前的秒杀下单Lua脚本，在认定有抢购资格后，直接向stream.orders中添加消息，内容包含voucherId、userId、orderId

  • 项目启动时，开启一个线程任务，尝试获取stream.orders中的消息，完成下单

导入依懒

 <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
            <exclusions>
                <exclusion>
                    <artifactId>spring-data-redis</artifactId>
                    <groupId>org.springframework.data</groupId>
                </exclusion>
                <exclusion>
                    <artifactId>lettuce-core</artifactId>
                    <groupId>io.lettuce</groupId>
                </exclusion>
            </exclusions>
        </dependency>

        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-redis</artifactId>
            <version>2.6.2</version>
        </dependency>
        <dependency>
            <groupId>io.lettuce</groupId>
            <artifactId>lettuce-core</artifactId>
            <version>6.1.6.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
            <version>5.1.46</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.4.3</version>
        </dependency>
        <!--hutool-->
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.7.17</version>
        </dependency>
       <!-- 分布式锁-Redission -->
        <dependency>
            <groupId>org.redisson</groupId>
            <artifactId>redisson</artifactId>
            <version>3.13.6</version>
        </dependency>

    </dependencies>

编写Controller

package com.hmdp.controller;


import com.hmdp.dto.Result;
import com.hmdp.service.IVoucherOrderService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;


/**
 * @author 24412
 */
@RestController
@RequestMapping("/voucher-order")
public class VoucherOrderController {
    @Autowired
    private IVoucherOrderService voucherOrderService;
    @PostMapping("seckill/{id}")
    public Result seckillVoucher(@PathVariable("id") Long voucherId) {
        return voucherOrderService.seckillVoucher(voucherId);
    }
}

编写service

package com.hmdp.service.impl;

import cn.hutool.core.bean.BeanUtil;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.hmdp.dto.Result;
import com.hmdp.entity.VoucherOrder;
import com.hmdp.mapper.VoucherOrderMapper;
import com.hmdp.service.ISeckillVoucherService;
import com.hmdp.service.IVoucherOrderService;
import com.hmdp.utils.RedisIdWorker;
import com.hmdp.utils.UserHolder;
import lombok.extern.slf4j.Slf4j;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.aop.framework.AopContext;
import org.springframework.core.io.ClassPathResource;
import org.springframework.data.redis.connection.stream.*;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.script.DefaultRedisScript;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.PostConstruct;
import javax.annotation.Resource;
import java.time.Duration;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @author 24412
 */
@Service
@Slf4j
public class VoucherOrderServiceImpl extends ServiceImpl<VoucherOrderMapper, VoucherOrder> implements IVoucherOrderService {
    @Resource
    private ISeckillVoucherService deskillVoucherService;


    @Resource
    private StringRedisTemplate stringRedisTemplate;

    @Resource
    private RedissonClient redissonClient;

    /**
     *  代理对象
     */
    private IVoucherOrderService currentProxy;

    // Lua 脚本
    private static final DefaultRedisScript<Long> SECKILL_SCRIPT;

    static {
        SECKILL_SCRIPT = new DefaultRedisScript<>();
        // 设置 Lua 脚本
        SECKILL_SCRIPT.setLocation(new ClassPathResource("SeckillVoucher.lua"));
        SECKILL_SCRIPT.setResultType(Long.class);
    }

    /**
     *   异步处理线程池
     */
    private static final ExecutorService SECKILL_ORDER_EXECUTOR = Executors.newSingleThreadExecutor();

    /**
     *  在当前类初始完毕后执行 VoucherOrderHandler 中的 run 方法
     */

    @PostConstruct
    public void init() {
        SECKILL_ORDER_EXECUTOR.submit(new VoucherOrderHandler());
    }

    /**
     *  项目启动时，开启一个线程任务，尝试获取stream.orders中的消息，完成下单
     */
    public class VoucherOrderHandler implements Runnable {
        String queueName = "stream.orders";
        String groupName = "orderGroup";
        String consumerName = "ConsumerOne";

        @Override
        public void run() {
            while (true) {
                try {
                    // 1. 获取消息队列中的订单信息
                    // XREAD GROUP orderGroup consumerOne COUNT 1 BLOCK 2000 STREAMS stream.orders >
                    // 队列 stream.orders、消费者组 orderGroup、消费者 consumerOne、每次读 1 条消息、阻塞时间 2s、从下一个未消费的消息开始。
                    List<MapRecord<String, Object, Object>> readingList = stringRedisTemplate.opsForStream().read(
                            Consumer.from(groupName, consumerName),
                            StreamReadOptions.empty().count(1).block(Duration.ofSeconds(2)),
                            StreamOffset.create(queueName, ReadOffset.lastConsumed()));

                    // 2. 判断消息是否获取成功
                    if (readingList.isEmpty() || readingList == null) {
                        // 获取失败说明没有消息，则继续下一次循环
                        continue;
                    }

                    // 3. 解析消息中的订单信息
                    // MapRecord：String 代表 消息ID；两个 Object 代表 消息队列中的 Key-Value
                    MapRecord<String, Object, Object> record = readingList.get(0);
                    Map<Object, Object> recordValue = record.getValue();
                    VoucherOrder voucherOrder = BeanUtil.fillBeanWithMap(recordValue, new VoucherOrder(), true);

                    // 4. 获取成功则下单
                    handleVoucherOrder(voucherOrder);

                    // 5. 确认消息 XACK stream.orders orderGroup id
                    stringRedisTemplate.opsForStream().acknowledge(groupName, consumerName, record.getId());
                } catch (Exception e) {
                    log.error("订单处理异常", e);
                    handlePendingMessages();
                }
            }
        }

         /**
         *  处理 pending-list 中的消息
         */
        private void handlePendingMessages() {
            while (true) {
                try {
                    // 1. 获取 pending-list 中的订单信息
                    // XREAD GROUP orderGroup consumerOne COUNT 1 STREAM stream.orders 0
                    List<MapRecord<String, Object, Object>> readingList = stringRedisTemplate.opsForStream().read(
                            Consumer.from(groupName, consumerName),
                            StreamReadOptions.empty().count(1),
                            StreamOffset.create(queueName, ReadOffset.from("0"))
                    );

                    // 2. 判断消息是否获取成功
                    if (readingList.isEmpty() || readingList == null) {
                        // 获取失败 pending-list 中没有异常消息，结束循环
                        break;
                    }

                    // 3. 解析消息中的订单信息并下单
                    MapRecord<String, Object, Object> record = readingList.get(0);
                    Map<Object, Object> recordValue = record.getValue();
                    VoucherOrder voucherOrder = BeanUtil.fillBeanWithMap(recordValue, new VoucherOrder(), true);
                    handleVoucherOrder(voucherOrder);

                    // 4. XACK
                    stringRedisTemplate.opsForStream().acknowledge(queueName, groupName, record.getId());
                } catch (Exception e) {
                    log.error("订单处理异常（pending-list）", e);
                    try {
                        // 稍微休眠一下再进行循环
                        Thread.sleep(20);
                    } catch (Exception ex) {
                        ex.printStackTrace();
                    }
                }
            }
        }
    }


    /**
     * 创建代金券订单
     * @param voucherOrder
     * @return
     */
    private void handleVoucherOrder(VoucherOrder voucherOrder) {
        Long userId = voucherOrder.getUserId();
        RLock lock = redissonClient.getLock("lock:order:" + userId);
        boolean isLocked = lock.tryLock();
        if (!isLocked) {
            log.error("不允许重复下单！");
            return;
        }
        try {
            // 该方法非主线程调用，代理对象需要在主线程中获取。
            currentProxy.createVoucherOrder(voucherOrder);
        } finally {
            lock.unlock();
        }
    }


    /**
     * 秒杀代金券
     * @param voucherId
     * @return
     */
    @Override
    public Result seckillVoucher(Long voucherId) {
        // 1. 执行 Lua 脚本（有购买资格：向 stream.orders 中添加消息，内容包括 voucherId、userId、orderId）
        Long userId = UserHolder.getUser().getId();
        long orderId = RedisIdWorker.nextId("order");
        Long executeResult = stringRedisTemplate.execute(
                SECKILL_SCRIPT,
                Collections.emptyList(),
                voucherId.toString(), userId.toString(), String.valueOf(orderId)
        );

        // 2. Lua 脚本的执行结果0则有购买资格
        int result = executeResult.intValue();
        if (result != 0) {
            return Result.fail(result == 1 ? "库存不足！" : "请勿重复下单！");
        }

        // 4. 获取代理对象
        currentProxy = (IVoucherOrderService) AopContext.currentProxy();

        // 5. 返回订单号（告诉用户下单成功，业务结束；执行异步下单操作数据库）
        return Result.ok(orderId);
    }

    /**
     * 异步下单
     * @param voucherOrder
     */
    @Transactional
    @Override
    public void createVoucherOrder(VoucherOrder voucherOrder) {
        Long userId = voucherOrder.getUserId();
        // 1. 一人一单
        Integer count = query()
                .eq("voucher_id", voucherOrder.getVoucherId())
                .eq("user_id", userId)
                .count();
        if (count > 0) {
            log.error("不可重复下单！");
            return;
        }

        // 2. 减扣库存
        boolean isAccomplished = deskillVoucherService.update()
                .setSql("stock = stock - 1")
                .eq("voucher_id", voucherOrder.getVoucherId()).gt("stock", 0)
                .update();
        if (!isAccomplished) {
            log.error("库存不足！");
            return;
        }

        // 3. 下单
        boolean isSaved = save(voucherOrder);
        if (!isSaved) {
            log.error("下单失败！");
            return;
        }
    }
}

lua脚本

---
--- Created by sun.
--- DateTime: 2022/10/18 17:10
---

local voucherId = ARGV[1]
local userId = ARGV[2]
local orderId = ARGV[3]

local stockKey = "seckill:stock:" .. voucherId
local orderKey = "seckill:order:" .. voucherId

-- 判断库存是否充足（不足，返回 1）
if (tonumber(redis.call('GET', stockKey)) <= 0) then
    return 1;
end;

-- 判断用户是否下单（重复下单，返回 2）
if (redis.call('SISMEMBER', orderKey, userId) == 1) then
    return 2;
end;

-- 下单成功：扣减库存、保存用户。
redis.call('INCRBY', stockKey, -1);
redis.call('SADD', orderKey, userId);
-- 发送消息到 stream.orders 队列中（*：消息的唯一ID 由 Redis 自动生成）：XADD stream.orders * key field ...
redis.call('XADD', 'stream.orders', '*', 'userId', userId, 'voucherId', voucherId, 'id', orderId);
return 0;

获取用户id工具类

package com.hmdp.utils;

import com.hmdp.dto.UserDTO;

/**
 * @author 24412
 */
public class UserHolder {
    private static final ThreadLocal<UserDTO> tl = new ThreadLocal<>();

    public static void saveUser(UserDTO user){
        tl.set(user);
    }

    public static UserDTO getUser(){
        return tl.get();
    }

    public static void removeUser(){
        tl.remove();
    }
}

配置Redisson客户端

package com.hmdp.config;

import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @BelongsProject: hm-dianping
 * @BelongsPackage: com.hmdp.config
 * @Author: wang fei
 * @CreateTime: 2023-02-14  16:09
 * @Description: TODO 配置Redisson客户端
 * @Version: 1.0
 */
@Configuration
public class RedissonConfig {
    @Bean
    public RedissonClient redisson() {
        // 配置类
        Config config = new Config();
        // 添加 Redis 地址：此处是单节点地址，也可以通过 config.useClusterServers() 添加集群地址
        config.useSingleServer().setAddress("redis://xxxxxx").setPassword("wangf");
        // 创建客户端
        return Redisson.create(config);

    }
}

 VoucherOrder

package com.hmdp.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;

import java.io.Serializable;
import java.time.LocalDateTime;


/**
 * @author 24412
 */
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@TableName("tb_voucher_order")
public class VoucherOrder implements Serializable {

    private static final long serialVersionUID = 1L;

    /**
     * 主键
     */
    @TableId(value = "id", type = IdType.INPUT)
    private Long id;

    /**
     * 下单的用户id
     */
    private Long userId;

    /**
     * 购买的代金券id
     */
    private Long voucherId;

    /**
     * 支付方式 1：余额支付；2：支付宝；3：微信
     */
    private Integer payType;

    /**
     * 订单状态，1：未支付；2：已支付；3：已核销；4：已取消；5：退款中；6：已退款
     */
    private Integer status;

    /**
     * 下单时间
     */
    private LocalDateTime createTime;

    /**
     * 支付时间
     */
    private LocalDateTime payTime;

    /**
     * 核销时间
     */
    private LocalDateTime useTime;

    /**
     * 退款时间
     */
    private LocalDateTime refundTime;

    /**
     * 更新时间
     */
    private LocalDateTime updateTime;


}

Traveler飞
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
redis stream 实现消息队列
m0_61083409的博客
08-02 1337
Redis5.0带来了Stream类型。从字面上看是流类型，但其实从功能上看，应该是Redis对消息队列（MQ，MessageQueue）的完善实现。
基于redis stream实现一个可靠的消息队列
tlxamulet的博客
07-03 1358
追求可靠性，则须封装XACK命令。引入ACK之后，自然要考虑对那些ACK超时的消息如何补救。由于我们打算实现kafka那样的consumer group机制，所以，读操作要用RStream.readGroup函数（XREADGROUP命令），该命令有阻塞和非阻塞版本，简单起见，我们使用非阻塞版本（不带BLOCK参数），由应用层来定时轮询。最后，stream的定时清理动作，解决内存占用过大的问题，使用lua脚本包装XTRIM命令，根据上一次清理时的stream size，计算本次要保留的元素个数。
分享一个使用 redisson 实现 redis 消费队列只消费一次的实现方法
bay233的博客
04-02 3980
因为 redis 的消费队列并没有提供多消费只消费一次的功能，如果想要实现多消费（实例）保证只消费一次，则需要自己在消费端去实现。 简单封装一下 Redisson 中的 RTopic 的监听方法: public class RedisMessageUnrepeatable { private static final String INDEX_SUFFIX = "_unrepeatable"; private static final String RW_SUFFIX = "_rwLoc
RedisTemplate-opsForStream实现消息队列，主要演示 xgroup，xreadgroup，xpending，xack，xinfo的用法
小哇
04-26 490
【代码】RedisTemplate-opsForStream实现消息队列api使用。
RedissonClient中Stream流的简单使用
坐看云起时_雨宣
10-09 925
分组的好处是，假如有10个订阅者同时在一个分组，那么分组中的消息只会给其中某一个订阅者。3、调用readGroup方法。2、调用range方法。1、调用read方法。
Redis使用Stream实现消息队列
weixin_42113716的博客
08-22 839
Redis使用Stream实现消息队列
微服务SpringBoot整合Redis基于Redis的Stream消息队列实现异步秒杀下单
11-10
【微服务SpringBoot整合Redis基于Redis的Stream消息队列实现异步秒杀下单】这篇文章主要讲解了如何在微服务架构中使用SpringBoot整合Redis来构建一个基于Redis Stream的消息队列，以此来实现实时、高效的异步秒杀...
利用redis rightPop 和 redis stream 实现消息队列
03-15
在提供的`redis-stream-demo-master`压缩包中，可能包含了一个示例项目，演示了如何使用Redis Stream和`rightPop`操作来实现消息队列的完整流程。通过阅读源代码，你可以了解到如何在实际应用中设置和使用这些功能。...
redis-stream-queue：redis流v5 +上的消息队列。 双流延迟队列
02-15
Redis流v5 +上的消息队列。 redis v5 +流，ES6 __keyevent@5__:expired保证__keyevent@5__:expired消息（ __keyevent@5__:expired ）不丢失 采用ES6 +异步/等待+面向对象设计 达到易读懂，方便修改。 vscode上有...
Redis实战代码演示，异步秒杀解决策略为redis stream！-RedisPractie.zip
01-30
在秒杀系统中，Redis Stream提供了一种有序、持久化的消息存储机制，可以实现消息的发布与订阅。Stream由一系列消息组成，每个消息都有一个唯一的ID和一组字段-值对。在秒杀场景下，用户请求可以转化为消息发布到...
Redis实战——消息队列
qq_59212867的博客
12-12 2088
Redis实战——消息队列，基于Redis实现的三种队列的实现方法
微服务Spring Boot 整合Redis 基于Redis的Stream 消息队列 实现异步秒杀下单
m0_71777195的博客
04-26 655
字面意思就是。使用队列的好处在于解除数据之间的耦合性这里最好的是使用MQ、RabbitMQ、RocketMQ、Kafka等消息队列，我们本节主要介绍 Redis 的消息队列。
Redis Stream & Redisson Stream
最新发布
罗小爬的技术宝书
06-27 1188
子命令式可选的，表示无需确认消息，NOACK子命令适用于对可靠性要求不高、偶尔的消息丢失是可以接受的情况，使用NOACK子命令可以避免将消息添加到PEL（ Pending Entries List），相当于在读取消息后自动确认消息，后续无需再调用XACK命令进行确认，通过XPENDING查询出PEL消息（已投递未确认）后，若原先消息对应的consumer已经挂掉，没有能力继续处理消息，则可通过XCLIAM将对应的消息转移给同分组下的其他consumer进行处理，
Redis入门到精通(十一),Redission操作Redis
热门推荐
weixin_62319133的博客
07-12 2万+
Redis入门到精通 专栏会分几期介绍Redis的概念操作，以及生产过程中频繁出现的一些问题及解决方案，在几期内逐渐深入带你全面了解Reids 本文为该专栏第十一期，主要介绍Redis的几种主流框架之Redisson............
基于Redis的Stream类型的完美消息队列解决方案
混血王子的博客
09-22 1530
1 概述 Redis5.0带来了Stream类型。从字面上看是流类型，但其实从功能上看，应该是Redis对消息队列（MQ，Message Queue）的完善实现。用过Redis做消息队列的都了解，基于Reids的消息队列实现有很多种，例如： PUB/SUB，订阅/发布模式 基于List的 LPUSH+BRPOP 的实现 基于Sorted-Set的实现 每一种实现，都有典型的特点和问题，这个在 Redis 实现消息队列一文中有介绍。基于Redis实现消息队列http://www.hellokang.n
Redis客户端Redisson使用示例
快乐江小鱼的博客
05-03 2635
介绍了Redis客户端Redisson及其应用场景。
【redis】stream消息队列
王佑辉的博客
06-29 1481
***/@Slf4j@Override//TODO 消费异常时处理逻辑log.error("发生了异常", e);/*** 消息队列自定义注解*//*** 消息队列的 key* @return*//*** 消费者组* @return*//*** 消息反序列化类型* @return*//*** 是否自动 acknowledge* @return*//*** 每次拉取的消息数,线程池每秒拉取一次* @return*//**
SSM秒杀系统（十一）消息队列RabbitMQ实现异步订单
张毅的博客
05-10 3094
SSM秒杀系统（十一）消息队列RabbitMQ实现异步订单十五、消息队列RabbitMQ15.1 rabbitMQ的安装与使用15.2 消息队列使用1.订单模块优化--redis缓存2.订单和支付异步处理2.1 将订单信息和支付信息放到消息队列2.2 MS_YF_ORDER项目中处理消息队列，将数据存放到数据库 RabbitMQ 是实现 AMQP（高级消息队列协议）的消息中间件的一种，最初起源于金融系统，用于在分布式系统中存储转发消息，在易用性、扩展性、高可用性等方面表现不俗。消息中间件主要用于组件之间的
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Traveler飞

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值