SpringBoot+RabbitMQ+Redis实现秒杀功能

已于 2023-11-18 10:42:55 修改
阅读量386 收藏 1
点赞数 6
文章标签： java-rabbitmq spring boot rabbitmq
于 2023-11-17 16:53:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_68370356/article/details/134452199
版权

秒杀业务：秒杀就是在同一个时间段有大量请求争抢购买同一商品并完成交易的过程，秒杀系统本质是一个高性能、高一致、高可用的系统。

1.秒杀功需要注意的问题

  • 超卖问题：多个用户同时发起对同一个商品的下单请求时，先查询商品库存，再修改商品库存，会出现资源竞争问题，导致库存的最终结果出现异常。
  • 高并发的问题：秒杀活动通常会吸引大量用户同时进行抢购，这可能会导致系统并发量过高，应该减少对数据库的操作。
  • 用户体验：当用户发起抢购时时，应该及时给用户反馈当前订单的一个状态。
  • 限购问题：防止用户恶意抢购，可以对每个用户进行限购。
  • 库存控制：对于秒杀活动的库存控制，需要保证库存的强一致性。
  • 保证用户先进先出问题

2.实现思路

2.1.开启定时任务：

        1.将管理员发布参与秒杀的商品存入到redis中

        2.根据商品的库存数创建数量队列防止超卖

2.2在业务层 创建订单的方法里：

        1.利用redis的increment计数器防止用户恶意下单

        2.创建用户队列来保证用户的先进先出

        3.给每个用户创建一个状态及时返回给用户，提高用户的体验

2.3在秒杀的方法里：

        1.需要开启异步这是一个高并发操作

        2.获取商品数量队列的信息，如果没有队列就代表商品已被抢完，改用户状态信息，返回，程序结束，否则就代表还有库存继续执行。

        3.创建订单改变用户状态，判断库存队列的长度是否为0，是就去redis删除活动商品，不是0

就改redis的库存

        4.下单完成发送给把订单信息发送给mq,由mq监听用户支付。可以用mq的死性队列监控用户支付情况

        5.定义两个方法监控，一个监控用户抢购到商品需要删除该用户redis中的信息，一个监控死性队列，代表用户在指定的时间未支付订单，商品的信息需要回滚。

3.代码实现

商品类

/**
 * @ClassName TbSeckillGoodsModel
 * @Description 模型对象
 * @Author xm
 * @Date 2023/10/30 08:57
 **/
@Data
@EqualsAndHashCode(callSuper = false)
@NoArgsConstructor
@AllArgsConstructor
@Builder
@TableName("tb_seckill_goods")
public class TbSeckillGoodsModel implements Serializable {

    private static final long serialVersionUID = 1L;

    @TableId(value = "id", type = IdType.AUTO)
    private Long id;

    private Long goodsId;

    private Long itemId;

    private String title;

    private String smallPic;

    private BigDecimal price;

    private BigDecimal costPrice;

    private String sellerId;

    private Date createTime;

    private Date checkTime;

    private String status;

    private Date startTime;

    private Date endTime;

    private Integer num;

    private Integer stockCount;

    private String introduction;


}

订单类

@Data
@EqualsAndHashCode(callSuper = false)
@NoArgsConstructor
@AllArgsConstructor
@Builder
@TableName("tb_seckill_order")
public class TbSeckillOrderModel implements Serializable {

    private static final long serialVersionUID = 1L;

    @TableId(value = "id", type = IdType.UUID)
    private Long id;

    private Long seckillId;

    private BigDecimal money;

    private String userId;

    private String sellerId;

    private Date createTime;

    private Date payTime;

    private String status;

    private String receiverAddress;

    private String receiverMobile;

    private String receiver;

    private String transactionId;


}

 处理时间工具类

/**
 * 处理日期类型变量的工具类
 * @author donghai
 * @version v1.0
 * @since 2017/04/20
 */
public class DateUtil {
    /**
     * 获取两个日期之间的日期
     * @param start 开始日期
     * @param end 结束日期
     * @return 日期字符串格式的集合
     */
    public static List<Date> getBetweenDates(Date start, Date end) {
        List<Date> result = new ArrayList<Date>();
        Calendar tempStart = Calendar.getInstance();
        tempStart.setTime(start);

        Calendar tempEnd = Calendar.getInstance();
        tempEnd.setTime(end);
        while (tempStart.before(tempEnd) || tempStart.equals(tempEnd)) {
            result.add(tempStart.getTime());
            tempStart.add(Calendar.DAY_OF_YEAR, 1);
        }
        return result;
    }

    /**
     * 根据日期字符串返回日期
     * @param source
     * @param format
     * @return
     * @throws ParseException
     */
    public static final Date parse(String source,String format) throws ParseException {
        DateFormat df = new SimpleDateFormat(format);
        return df.parse(source);
    }

    /**
     * 根据日期获取格式化的日期字符串
     * @param date
     * @param format
     * @return
     * @throws ParseException
     */
    public static final String format(Date date,String format) throws ParseException {
        DateFormat df = new SimpleDateFormat(format);
        return df.format(date);
    }
    //时间格式
    public static final String PATTERN_YYYYMMDDHH = "yyyyMMddHH";
    public static final String PATTERN_YYYY_MM_DDHHMM = "yyyy-MM-dd HH:mm";

    /***
     * 从yyyy-MM-dd HH:mm格式转成yyyyMMddHH格式
     * @param dateStr
     * @return
     */
    public static String formatStr(String dateStr,String opattern,String npattern){
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat(opattern);
        try {
            Date date = simpleDateFormat.parse(dateStr);
            simpleDateFormat = new SimpleDateFormat(npattern);
            return simpleDateFormat.format(date);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return null;
    }

    /***
     * 获取指定日期的凌晨
     * @return
     */
    public static Date toDayStartHour(Date date){
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.set(Calendar.HOUR_OF_DAY, 0);
        calendar.set(Calendar.MINUTE, 0);
        calendar.set(Calendar.SECOND, 0);
        calendar.set(Calendar.MILLISECOND, 0);
        Date start = calendar.getTime();
        return start;
    }


    /***
     * 时间增加N分钟
     * @param date
     * @param minutes
     * @return
     */
    public static Date addDateMinutes(Date date,int minutes){
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.add(Calendar.MINUTE, minutes);// 24小时制
        date = calendar.getTime();
        return date;
    }

    /***
     * 时间递增N小时
     * @param hour
     * @return
     */
    public static Date addDateHour(Date date,int hour){
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.add(Calendar.HOUR, hour);// 24小时制
        date = calendar.getTime();
        return date;
    }

    /***
     * 获取时间菜单
     * @return
     */
    public static List<Date> getDateMenus(){
        //定义一个List<Date>集合，存储所有时间段
        List<Date> dates = getDates(12);
        //判断当前时间属于哪个时间范围
        Date now = new Date();
        for (Date cdate : dates) {
            //开始时间<=当前时间<开始时间+2小时
            if(cdate.getTime()<=now.getTime() && now.getTime()<addDateHour(cdate,2).getTime()){
                now = cdate;
                break;
            }
        }

        //当前需要显示的时间菜单
        List<Date> dateMenus = new ArrayList<Date>();
        for (int i = 0; i <5 ; i++) {
            dateMenus.add(addDateHour(now,i*2));
        }
        return dateMenus;
    }

    /***
     * 指定时间往后N个时间间隔
     * @param hours
     * @return
     */
    public static List<Date> getDates(int hours) {
        List<Date> dates = new ArrayList<Date>();
        //循环12次
        Date date = toDayStartHour(new Date()); //凌晨
        for (int i = 0; i <hours ; i++) {
            //每次递增2小时,将每次递增的时间存入到List<Date>集合中
            dates.add(addDateHour(date,i*2));
        }
        return dates;
    }

    /***
     * 时间转成yyyyMMddHH
     * @param date
     * @param pattern
     * @return
     */
    public static String data2str(Date date, String pattern){
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat(pattern);
        return simpleDateFormat.format(date);
    }
}

定时任务

    //定时任务注解，每30秒调用一次
    @Scheduled(cron = "0/10 * * * * ?")
    public void run() {
        try {
            System.out.println("开启定时任务....");
            List<Date> dateMenus = DateUtil.getDateMenus();
            for (Date date : dateMenus) {
                System.out.println(date);
                String extName = DateUtil.format(date, DateUtil.PATTERN_YYYYMMDDHH);
                QueryWrapper<TbSeckillGoodsModel> qw = new QueryWrapper<>();
                String start = DateUtil.format(date, "yyyy-MM-dd HH:mm:ss");
                String end = DateUtil.format(DateUtil.addDateHour(date, 2), "yyyy-MM-dd HH:mm:ss");

                Set keys = redisTemplate.boundHashOps("goods:" + extName).keys();

                qw.lambda().eq(TbSeckillGoodsModel::getStatus, "1")
                        .eq(TbSeckillGoodsModel::getStartTime, start)
                        .eq(TbSeckillGoodsModel::getEndTime, end)
                        .gt(TbSeckillGoodsModel::getStockCount, 0);
                if (keys != null && keys.size() > 0) {
                    qw.lambda().notIn(TbSeckillGoodsModel::getId, keys);
                }
                List<TbSeckillGoodsModel> list = tbSeckillGoodsService.list(qw);
                if (list == null || list.size() <= 0) {
                    continue;
                }
                for (TbSeckillGoodsModel goodsModel : list) {
                    //商品的信息存储到redis
                    redisTemplate.boundHashOps("goods:" + extName).put(goodsModel.getId().toString(), goodsModel);
                    Long[] ids = this.ids(goodsModel.getId(), goodsModel.getStockCount());
                    //创建商品数量的队列
                    redisTemplate.boundListOps("goodsCountList:" + goodsModel.getId()).leftPushAll(ids);
                }
            }
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }

    private Long[] ids(Long id, Integer num) {
        Long[] arr = new Long[num];
        for (Integer i = 0; i < num; i++) {
            arr[i] = id;
        }
        return arr;
    }

  服务层定义创建订单方法

    @Override
    public Integer create(String id, String time, String username) {
        SeckillStatus seckillStatus = new SeckillStatus(id, username, time, "1");
        Long userClickCount = redisTemplate.boundHashOps("userClickCount").increment(username, 1);
        if (userClickCount>1){
            return 2;
        }
        redisTemplate.boundListOps("userSeckillQueue").leftPush(seckillStatus);
        redisTemplate.boundHashOps("userSeckillStatus").put(username,seckillStatus);
        multiThreadingCreateOrder.asycnCreateOrder();
        return 1;
    }

秒杀方法

    @Async
    public void asycnCreateOrder() {

        //获取队列中的信息
        SeckillStatus userQueue = (SeckillStatus) redisTemplate.boundListOps("userSeckillQueue").rightPop();
        String id = userQueue.getSkuId();
        String time = userQueue.getTime();
        String username = userQueue.getUsername();
        //获取用户的状态， 用户状态变化
        SeckillStatus userSeckillStatus = (SeckillStatus) redisTemplate.boundHashOps("userSeckillStatus").get(username);

        //获取商品数量队列中的信息，进入程序内的令牌
        Object obj = redisTemplate.boundListOps("goodsCountList:" + id).rightPop();
        if (ObjectUtils.isEmpty(obj)) {
            System.out.println("商品没有库存");
            //没有秒杀到的状态变化
            userSeckillStatus.setStatus("4");
            redisTemplate.boundHashOps("userSeckillStatus").put(username, userSeckillStatus);
            return;
        }
        try {
            while (!lockUtil.lock("lock:" + id)) {
                Thread.sleep(500);
            }
            //获取秒杀的商品信息
            TbSeckillGoodsModel goodsModel = (TbSeckillGoodsModel) redisTemplate.boundHashOps("goods:" + time).get(id);
            System.out.println("2.异步开始");
            if (ObjectUtils.isEmpty(goodsModel) || goodsModel.getStockCount() <= 0) {
                System.out.println("商品不存在，或者是没有库存");
                //没有秒杀到的状态变化
                userSeckillStatus.setStatus("4");
                redisTemplate.boundHashOps("userSeckillStatus").put(username, userSeckillStatus);
                return;
            }
            TbSeckillOrderModel orderModel = new TbSeckillOrderModel();
            orderModel.setId(IdWorker.getId());
            orderModel.setSeckillId(Long.parseLong(id));
            orderModel.setMoney(goodsModel.getPrice());
            orderModel.setUserId(username);
            orderModel.setCreateTime(new Date());
            orderModel.setStatus("1");
            //创建用户订单
            redisTemplate.boundHashOps("order").put(username, orderModel);
            //状态变化成带支付状态
            userSeckillStatus.setStatus("2");
            redisTemplate.boundHashOps("userSeckillStatus").put(username, userSeckillStatus);

            goodsModel.setStockCount(goodsModel.getStockCount() - 1);
            if (redisTemplate.boundListOps("goodsCountList:" + id).size() <= 0) {
                goodsModel.setStockCount(0);
                //同步数据库
                goodsService.updateById(goodsModel);
                redisTemplate.boundHashOps("goods:" + time).delete(id);
            } else {
                redisTemplate.boundHashOps("goods:" + time).put(id, goodsModel);
            }

            rabbitTemplate.convertAndSend(MQConfig.oneSeckillExchange, MQConfig.oneSeckillRouting, JSON.toJSONString(userQueue), new MessagePostProcessor() {
                @Override
                public Message postProcessMessage(Message message) throws AmqpException {
                    message.getMessageProperties().setExpiration("10000");
                    return message;
                }
            });
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lockUtil.unlock("lock:" + id);
        }
        System.out.println("3.异步结束");
    }

加锁

@Component
public class LockUtil {
    @Autowired
    private RedisTemplate redisTemplate;

    public boolean lock(String key) {
        RedisConnectionFactory connectionFactory = redisTemplate.getConnectionFactory();
        RedisConnection connection = connectionFactory.getConnection();
        byte[] keyBytes = key.getBytes();
        byte[] valBytes = "lock".getBytes();
        Boolean aBoolean = connection.setNX(keyBytes, valBytes);
        if (aBoolean) {
            //防止出现死锁
            connection.expire(keyBytes, 60);
        }
        return aBoolean;
    }

    public void unlock(String key) {
        redisTemplate.delete(key);
    }
}

mq监控用户支付情况

@Component
public class OrderMessage {

    @Autowired
    private RedisTemplate redisTemplate;

    @Autowired
    private TbSeckillOrderService tbSeckillOrderService;

    @Autowired
    private TbSeckillGoodsService tbSeckillGoodsService;

    @RabbitListener(queues = "seckillPaySuccessQu")
    public void paySuccessMsg(Map<String, String> map) {
        String name = map.get("attach").split("-")[1];
        TbSeckillOrderModel order = (TbSeckillOrderModel) redisTemplate.boundHashOps("order").get(name);
        order.setStatus("2");
        tbSeckillOrderService.save(order);
        redisTemplate.boundHashOps("order").delete(name);
        redisTemplate.boundHashOps("userClickCount").delete(name);
        SeckillStatus userSeckillStatus = (SeckillStatus) redisTemplate.boundHashOps("userSeckillStatus").get(name);
        userSeckillStatus.setStatus("5");
        redisTemplate.boundHashOps("userSeckillStatus").put(name, userSeckillStatus);
        System.out.println("支付成功完成！");
    }

//    @RabbitListener(queues = "twoSeckillQueue")
    public void twoSeckillQueue(String json){
        System.out.println("秒杀订单数据回滚");
        SeckillStatus seckillStatus = JSON.parseObject(json, SeckillStatus.class);
        TbSeckillGoodsModel goodsModel = (TbSeckillGoodsModel) redisTemplate.boundHashOps("goods:" + seckillStatus.getTime()).get(seckillStatus.getSkuId());
        if (ObjectUtils.isEmpty(goodsModel)) {
            System.out.println("修改数据库");
            TbSeckillGoodsModel goodsServiceById = tbSeckillGoodsService.getById(seckillStatus.getSkuId());
            goodsServiceById.setStockCount(1);
            tbSeckillGoodsService.updateById(goodsServiceById);
            //存储存储到redis 中
            redisTemplate.boundHashOps("goods:" + seckillStatus.getTime()).put(seckillStatus.getSkuId(), goodsServiceById);
        } else {
            //修改
            System.out.println("修改redis...");
            goodsModel.setStockCount(goodsModel.getStockCount() + 1);
            //存储存储到redis 中
            redisTemplate.boundHashOps("goods:" + seckillStatus.getTime()).put(seckillStatus.getSkuId(), goodsModel);
            tbSeckillGoodsService.updateById(goodsModel);
        }
        //添加队列
        redisTemplate.boundListOps("goodsCountList:" + seckillStatus.getSkuId()).leftPush(seckillStatus.getSkuId());
        //修改订单
        TbSeckillOrderModel orderModel = (TbSeckillOrderModel) redisTemplate.boundHashOps("order").get(seckillStatus.getUsername());
        orderModel.setStatus("3");
        redisTemplate.boundHashOps("order").put(seckillStatus.getUsername(), orderModel);
        //删除点击次数
        redisTemplate.boundHashOps("userClickCount").delete(seckillStatus.getUsername());
        //修改订单状态为超时
        SeckillStatus userStatus = (SeckillStatus) redisTemplate.boundHashOps("userSeckillStatus").get(seckillStatus.getUsername());
        userStatus.setStatus("3");
        redisTemplate.boundHashOps("userSeckillStatus").put(seckillStatus.getUsername(), userStatus);
        System.out.println("数据回滚完毕！");
    }

归 有 ʕ ᵔᴥᵔ ʔ
关注
  • 6
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
spring boot redis实现秒杀
joy_pan的博客
05-16 638
spring boot redis实现秒杀
springboot集成redis实现简单秒杀系统
08-25
主要为大家详细介绍了springboot集成redis实现简单秒杀系统，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
基于SpringBoot+RabbitMQ+Redis开发的秒杀系统（异步下单、热点数据缓存、解决超卖）
热门推荐
jike11231的博客
09-12 1万+
本项目是参考网上资料，整理开发而成，项目代码中加入了自己的理解和实现。​基于SpringBoot框架开发，实现的功能主要是登录、商品列表、商品详情、秒杀商品，订单详情等功能。在系统业务处理中，使用到分布式session维持会话、Redis预减库存降低数据库访问压力，消息队列异步下单（削峰）、客户端轮询结果、接口限流防刷等技术。
Springboot 使用redis实现秒杀
无情编码工具人的博客
03-17 377
Redis 同一请求只会成功一个：为解决超卖问题，200个请求同时访问只会有一个请求成功 @GetMapping("seckill") public void seckill(){ Object o = redisTemplate.execute(new SessionCallback<Object>() { @Override public Object execute(RedisOperations redisOpe
springboot整合redis实现秒杀功能
睡竹的博客
03-30 1080
springboot整合redis实现秒杀功能
Springboot Redis模拟商品秒杀场景
weixin_43365083的博客
08-12 536
Springboot Redis模拟商品秒杀场景
Seckill:基于SpringBoot + Mybatis + Redis + RabbitMQ秒杀系统
03-11
基于SpringBoot + Mybatis + Redis + RabbitMQ秒杀系统 开发工具 想法2017.2 开发环境 JDK 玛文 MySQL的 弹簧靴 Redis 兔子MQ 1.8 3.2.2 5.7 1.5.10发布 3.2 4倍 项目启动说明 1，启动前，请配置application....
seckill:基于SpringBoot+Reds+RabbitMQ实现的分布式秒杀系统
04-14
seckill基于SpringBoot+Reds+RabbitMQ实现的分布式秒杀系统整体流程前端页面采用隐藏秒杀地址和使用随机秒杀地址来防止用户恶意刷接口，点击秒杀时会让用户输入数字计算验证码，输入正确后进入后端业务逻辑。...
基于SpringBoot+MyBatis+Redis+RabbitMQ 实现的秒杀系统.zip
最新发布
10-16
基于SpringBoot+MyBatis+Redis+RabbitMQ 实现的秒杀系统 基于SpringBoot+MyBatis+Redis+RabbitMQ 实现的秒杀系统 基于SpringBoot+MyBatis+Redis+RabbitMQ 实现的秒杀系统 基于SpringBoot+MyBatis+Redis+RabbitMQ ...
springboot-seckill:基于SpringBoot + MySQL + Redis + RabbitMQ + Guava开发的高并发商品限时秒杀系统
03-11
本系统是使用SpringBoot开发的高并发限时抢购秒杀系统，除了实现基本的登录，查看商品列表，秒杀，下单等功能，项目中还针对高并发情况实现了系统缓存，降级和限流。 开发工具 IntelliJ IDEA + Navicat + Sublime ...
Spring Boot + redis解决商品秒杀库存超卖
06-11
在众多抢购活动中，在有限的商品数量的限制下如何保证抢购到商品的用户数不能大于商品数量，也就是不能出现超卖的问题；还有就是抢购时会出现大量用户的访问，如何提高用户体验效果也是一个问题，也就是要解决秒杀系统的性能问题。本文主要介绍基于redis 实现商品秒杀功能。先来跟大家讲下大概思路
秒杀系统(SpringBoot + Redis + RabbitMq)
04-16
业务和异常因为时间关系就直接写在了controller，根据需要修改位置，另外RabbitMq的异步处理和多线程业务，看需要也可以开启。秒杀系统(SpringBoot + Redis + RabbitMq)
RabbitMQ实现抢购秒杀服务
01-01
通过rabbitmq消息队列，处理抢购秒杀服务。模拟订单产生的过程，首先判断用户登录信息状态，模拟产生订单。发送方发送订单消息到消息队列，消费者通过消息队列接受订单消息，处理订单。
基于 SpringBoot+Mybatis+Redis+RabbitMQ 秒杀系统
05-29
**基于 SpringBoot+Mybatis+Redis+RabbitMQ 秒杀系统** ...SpringBoot提供了快速开发框架，Mybatis简化了数据库操作，Redis提供了高效缓存，RabbitMQ实现了异步处理和消息队列，共同构建了一个强大的秒杀解决方案。
基于SpringBoot+RabbitMQ+Redis开发的秒杀系统源码+数据库.zip
02-03
基于SpringBoot+RabbitMQ+Redis开发的秒杀系统源码+数据库.zip 下载即用无需修改。 基于SpringBoot+RabbitMQ+Redis开发的秒杀系统源码+数据库.zip 下载即用无需修改。基于SpringBoot+RabbitMQ+Redis开发的秒杀...
高并发秒杀——SpringBoot集成redis
weixin_30216561的博客
06-20 185
shop--13.升级--Redis缓存技术 集成Redis 1.添加Jedis依赖 2.添加Fastjson依赖 1.安装redishttp://www.runoob.com/redis/redis-install.html 1.引入redis依赖 <!--redis客户端：jedis--> <dependency> <gro...
SpringBoot使用Redisson实现分布式锁秒杀
小海龟的博客
05-18 4344
本篇文章采用的是单机模式，具体可以参考官网redisson介绍。 Redisson介绍 Redisson是Lock的子类，对比Lock而言，是可重入锁。 用代码举例子 public static void main(String[] args) { Config config = new Config(); config.useSingleServer().setAddress("redis://118.190.55.83:6379"); RedissonClient cl
springboot简单实现redis商品秒杀功能，成功解决商品超售问题
我的青春一去不复返
10-19 1448
redis成功实现商品秒杀，避免出现超卖现象
Spring Boot使用Redis阻塞队列实现异步秒杀下单
t194978的博客
07-23 342
中没有这条记录，则将userId和优惠卷存入到redis中，并且返回0，整个过程需要保证是原子性的，我们可以。当以上逻辑走完后，我们可以根据返回的结果来判断是否是0，如果是0，则可以下单，，如果不充足，则直接结束，如果充足，继续在redis中判断用户是否可以下单，，然后返回，前端可以通过返回的订单id来判断是否下单成功。在以上6个步骤中，我们可以采用怎样的方式来优化呢？文章知识点与官方知识档案匹配，可进一步学习相关知识。整体思路：当用户下单之后，测试成功，查看Redis。当用户发起请求，此时。
springboot+rabbitmq的mqtt 实现消息推送
09-20
Spring Boot 是一个开发框架，它简化了 Java 开发过程，提供了一种便捷的方式来构建独立的、...这种方式可以使得消息的发送和接收更加简单和方便，并且可以与 RabbitMQ 的其他功能和特性相结合，实现更多的应用场景。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值