RabbitMQ订单超时笔记

已于 2024-06-14 22:06:11 修改
阅读量1.3k 收藏 22
点赞数 20
分类专栏： 笔记 文章标签： rabbitmq 笔记
于 2023-12-22 11:28:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_67154380/article/details/135115276
版权

使用RabbitMQ实现订单超时管理

方案分析

  1. JDK延迟队列
  2. 定时任务
  3. 被动取消
  4. Redis Sorted Set
  5. Redis事件通知
  6. 时间轮算法
  7. RabbitMQ

JDK延迟队列

该方案是利用JDK自带的JUC包中的DelayQueue队列。

pubilc class DelayQueue<E extend Delay> extends AbstractQueue<E> implements BlockingQueue<E>

这是一个无界阻塞队列，该队列只有在延迟期满的时候才能从中获取元素，放入DelayQueue中的对象，必须实现Delayed接口
在这里插入图片描述

  • offer(): 添加元素
  • poll(): 获取并移出队列的超时元素，没有则返回空
  • take(): 获取并移出队列的超时元素，没有则wait当前线程，直到有元素满足超时条件时返回结果

定时任务

这种方式是最简单的，启动一个计划任务，每隔一定时间（假设1分钟)去扫描数据库一次，通过订单时间来判断是否超时，然后进行UPDATE 或DELETE操作。如Quartz

被动取消

利用懒加载的思想，当用户或商户查询订单时，再判断该订单是否超时，超时则进行业务处理。
这种方式依赖于用户的查询操作触发，如果用户不进行查询订单的操作，该订单就永远不会被取消。所以，实际应用中，也是被动取消＋定时任务的组合方式来实现。这种情况下定时任务的时间可以设置的稍微“长”一点。

Redis Sorted Set

Redis有序集合(Sorted Set)每个元素都会关联一个double类型的分数score。Redis可以通过分数来为集合中的成员进行从小到大的排序。

添加元素: ZADD key score member [[score member] [score member]...]
按顺序查询元素: ZRANGE key start end [WITHSCORES]
查询元素score: ZSCORE key member
移出元素: ZREM key member [member ...]

该方案可以将订单超时时间戳与订单编号分别设置为score和member。系统扫描第一个元素判断是否超时，超时则进行业务处理。
然而，这一版存在一个致命的硬伤，在高并发条件下，多个消费者会取到同一个订单编号，又需要编写Lua脚本保证原子性或使用分布式锁，用了分布式锁性能又下降了。

RabbitMQ

RabbitMQ is the most widely deployed open source message broker

延迟队列

队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front)进行删除操作，而在表的后端（rear)进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。
延迟队列，最重要的特性就体现在它的延时属性上，跟普通队列不一样的是，普通队列中的元素总是等着希望被早点取出消费，而延迟队列中的元素则是希望在指定时间被取出消费，所以延迟队列中的元素是都是带时间属性的。
简单来说，延迟队列就是用来存放需要在指定时间被处理的元素的队列。
本文使用RabbitMQ也是通过延迟队列的机制来实现订单超时的处理。然而 RabbitMg自身并没有延迟队列这个功能，实现该功能一般有以下两种方式:

  • 利用TTL(Time To Live) 和 DLX(Dead Letter Exchanges)实现延迟队列
  • 利用延迟队列插件rabbitmq_delayed_message_exchange实现

RabbitMQ延迟队列实现

实现方案一

在这里插入图片描述

  • RabbitMQ配置类
@Configuration
public class RabbitMQConfig {
    // 声明 4个路由key 4个队列 2个交换机 属性
    // 延迟交换机
    public static final String DELAY_EXCHANGE_NAME = "delay.exchange";
    // 延迟队列
    public static final String DELAY_Queue_A_NAME = "delay.queue.a";
    public static final String DELAY_Queue_B_NAME = "delay.queue.b";
    // 延迟队列路由key
    public static final String DELAY_Queue_A_ROUTING_KEY = "delay.queue.a.routingkey";
    public static final String DELAY_Queue_B_ROUTING_KEY = "delay.queue.b.routingkey";

    // 死信交换机
    public static final String DEAD_LETTER_EXCHANGE_NAME = "dead.letter.exchange";
    // 死信队列
    public static final String DEAD_LETTER_Queue_A_NAME = "dead.letter.queue.a";
    public static final String DEAD_LETTER_Queue_B_NAME = "dead.letter.queue.b";
    // 死信队列路由key
    public static final String DEAD_LETTER_Queue_A_ROUTING_KEY = "dead.letter.delay_10s.routingkey";
    public static final String DEAD_LETTER_Queue_B_ROUTING_KEY = "dead.letter.delay_60s.routingkey";


    // 声明延迟交换机
    @Bean
    public DirectExchange delayExchange() {
        return new DirectExchange(DELAY_EXCHANGE_NAME);
    }

    // 声明死信交换机
    @Bean
    public DirectExchange deadLetterExchange() {
        return new DirectExchange(DEAD_LETTER_EXCHANGE_NAME);
    }

    // 声明延迟队列A 延迟10s 并且绑定到对应的死信交换机中
    @Bean
    public Queue delayQueueA() {
        Map<String, Object> args = new HashMap<>();
        args.put("x-dead-letter-exchange", DEAD_LETTER_EXCHANGE_NAME);
        args.put("x-dead-letter-routing-key", DEAD_LETTER_Queue_A_ROUTING_KEY);
        args.put("x-message-ttl", 10000);
        return QueueBuilder.durable(DELAY_Queue_A_NAME).withArguments(args).build();
    }

    // 声明延迟队列A 延迟60s 并且绑定到对应的死信交换机中
    @Bean
    public Queue delayQueueB() {
        Map<String, Object> args = new HashMap<>();
        args.put("x-dead-letter-exchange", DEAD_LETTER_EXCHANGE_NAME);
        args.put("x-dead-letter-routing-key", DEAD_LETTER_Queue_B_ROUTING_KEY);
        args.put("x-message-ttl", 60000);
        return QueueBuilder.durable(DELAY_Queue_B_NAME).withArguments(args).build();
    }

    // 声明延迟队列A的绑定关系
    @Bean
    public Binding delayBindingA(@Qualifier("delayQueueA") Queue queue,
                                 @Qualifier("delayExchange") DirectExchange exchange) {
        return BindingBuilder.bind(queue).to(exchange).with(DELAY_Queue_A_ROUTING_KEY);
    }

    // 声明延迟队列A的绑定关系
    @Bean
    public Binding delayBindingB(@Qualifier("delayQueueB") Queue queue,
                                 @Qualifier("delayExchange") DirectExchange exchange) {
        return BindingBuilder.bind(queue).to(exchange).with(DELAY_Queue_B_ROUTING_KEY);
    }

    // 声明死信队列A，用于接收延迟10s处理的消息
    @Bean
    public Queue deadLetterQueueA() {
        return new Queue(DEAD_LETTER_Queue_A_NAME);
    }

    // 声明死信队列B，用于接收延迟60s处理的消息
    @Bean
    public Queue deadLetterQueueB() {
        return new Queue(DEAD_LETTER_Queue_B_NAME);
    }

    // 声明死信队列A的绑定关系
    @Bean
    public Binding deadLetterBindingA(@Qualifier("deadLetterQueueA") Queue queue,
                                      @Qualifier("deadLetterExchange") DirectExchange exchange) {
        return BindingBuilder.bind(queue).to(exchange).with(DEAD_LETTER_Queue_A_ROUTING_KEY);
    }

    // 声明死信队列B的绑定关系
    @Bean
    public Binding deadLetterBindingB(@Qualifier("deadLetterQueueB") Queue queue,
                                      @Qualifier("deadLetterExchange") DirectExchange exchange) {
        return BindingBuilder.bind(queue).to(exchange).with(DEAD_LETTER_Queue_B_ROUTING_KEY);
    }
}
  • 枚举类
@Getter
@AllArgsConstructor
public enum DelayTypeEnum {
    DELAY_10s(1),
    DELAY_60s(2);

    private Integer type;

    public static DelayTypeEnum getDelayTypeEnum(Integer type) {
        if (Objects.equals(type, DELAY_10s.type)) {
            return DELAY_10s;
        }
        if (Objects.equals(type, DELAY_60s.type)) {
            return DELAY_60s;
        }
        return null;
    }
}
  • 生产者
@Component
public class DelayMsgProducer {
    @Resource
    private RabbitTemplate rabbitTemplate;

    public void send(String msg, DelayTypeEnum type) {
        switch (type) {
            case DELAY_10s:
                rabbitTemplate.convertAndSend(DELAY_EXCHANGE_NAME, DELAY_Queue_A_ROUTING_KEY, msg);
                break;
            case DELAY_60s:
                rabbitTemplate.convertAndSend(DELAY_EXCHANGE_NAME, DELAY_Queue_B_ROUTING_KEY, msg);
                break;
            default:
        }
    }
}
  • 消费者
@Component
@Slf4j
public class DeadLetterQueueConsumer {
    // 监听死信队列A
    @RabbitListener(queues = DEAD_LETTER_Queue_A_NAME)
    public void receiveA(Message message) {
        // 获取消息
        String msg = new String(message.getBody());
        // 记录日志
        log.info("当前时间: {}, 死信队列A收到消息: {}", LocalDateTime.now(), msg);
    }

    // 监听死信队列B
    @RabbitListener(queues = DEAD_LETTER_Queue_B_NAME)
    public void receiveB(Message message) {
        // 获取消息
        String msg = new String(message.getBody());
        // 记录日志
        log.info("当前时间: {}, 死信队列B收到消息: {}", LocalDateTime.now(), msg);
    }
}
  • 测试
    在这里插入图片描述
    在这里插入图片描述

实现方案二

方案一的问题可以通过将TTL设置在消息属性里来解决，然后添加一个延迟队列，用于接收设置为任意延迟时长的消息，再添加一个相应的死信队列和routingkey 即可，如下图:

在这里插入图片描述

  • RabbitMQ配置文件
@Configuration
public class RabbitMQConfig {
    // 声明 2个交换机  2个队列 2个路由key  属性
    // 延迟交换机
    public static final String DELAY_EXCHANGE_NAME = "delay.exchange";
    // 延迟队列
    public static final String DELAY_Queue_NAME = "delay.queue";
    // 延迟队列路由key
    public static final String DELAY_Queue_ROUTING_KEY = "delay.queue.routingkey";

    // 死信交换机
    public static final String DEAD_LETTER_EXCHANGE_NAME = "dead.letter.exchange";
    // 死信队列
    public static final String DEAD_LETTER_Queue_NAME = "dead.letter.queue";
    // 死信队列路由key
    public static final String DEAD_LETTER_Queue_ROUTING_KEY = "dead.letter.routingkey";


    // 声明延迟交换机
    @Bean
    public DirectExchange delayExchange() {
        return new DirectExchange(DELAY_EXCHANGE_NAME);
    }

    // 声明死信交换机
    @Bean
    public DirectExchange deadLetterExchange() {
        return new DirectExchange(DEAD_LETTER_EXCHANGE_NAME);
    }

    // 声明延迟队列 并且绑定到对应的死信交换机中
    @Bean
    public Queue delayQueue() {
        Map<String, Object> args = new HashMap<>();
        args.put("x-dead-letter-exchange", DEAD_LETTER_EXCHANGE_NAME);
        args.put("x-dead-letter-routing-key", DEAD_LETTER_Queue_ROUTING_KEY);
        return QueueBuilder.durable(DELAY_Queue_NAME).withArguments(args).build();
    }


    // 声明延迟队列的绑定关系
    @Bean
    public Binding delayBinding(@Qualifier("delayQueue") Queue queue,
                                 @Qualifier("delayExchange") DirectExchange exchange) {
        return BindingBuilder.bind(queue).to(exchange).with(DELAY_Queue_ROUTING_KEY);
    }


    // 声明死信队列
    @Bean
    public Queue deadLetterQueue() {
        return new Queue(DEAD_LETTER_Queue_NAME);
    }


    // 声明死信队列的绑定关系
    @Bean
    public Binding deadLetterBindingA(@Qualifier("deadLetterQueue") Queue queue,
                                      @Qualifier("deadLetterExchange") DirectExchange exchange) {
        return BindingBuilder.bind(queue).to(exchange).with(DEAD_LETTER_Queue_ROUTING_KEY);
    }
}
  • 生产者
@Component
public class DelayMsgProducer {
    @Resource
    private RabbitTemplate rabbitTemplate;

    public void send(String message, String delayTime) {
        rabbitTemplate.convertAndSend(DELAY_EXCHANGE_NAME, DELAY_Queue_ROUTING_KEY, message, msg -> {
            // 设置消息到期时间
            msg.getMessageProperties().setExpiration(delayTime);
            return msg;
        });
    }
}
  • 消费者
@Component
@Slf4j
public class DeadLetterQueueConsumer {
    // 监听死信队列
    @RabbitListener(queues = DEAD_LETTER_Queue_NAME)
    public void receiveA(Message message) {
        // 获取消息
        String msg = new String(message.getBody());
        // 记录日志
        log.info("当前时间: {}, 死信队列收到消息: {}", LocalDateTime.now(), msg);
    }

}
  • controller
@RestController
@Slf4j
@RequestMapping("/rabbitmq")
public class RabbitMQController {
    @Resource
    private DelayMsgProducer producer;

    @ApiOperation(value = "发送消息")
    @GetMapping("/send/{msg}/{delayTime}")
    public void send(@PathVariable String msg,
                     @PathVariable String delayTime) {
        log.info("当前时间: {}, 消息: {}, 延迟时间: {}", LocalDateTime.now(), msg, delayTime);
        producer.send(msg, delayTime);
    }
}
  • 测试
    在这里插入图片描述
    问题:10秒的消息没有被提前释放，发送两条消息，如果后面的消息过期时间比前面的短，则要等着前面消息的过期时间到了再一起被释放

实现方案三(插件)

linux环境docker安装rabbitmq插件

  1. 下载插件
  2. docker run -d --name rabbitmq -p 5672:5672 -p 15672:15672 --hostname myRabbit -e RABBITMQ_DEFAULT_VHOST=my_vhost -e RABBITMQ_DEFAULT_USER=admin -e RABBITMQ_DEFAULT_PASS=admin rabbitmq:3.8.5
  3. docker cp rabbitmq_delayed_message_exchange-3.8.17.8f537ac.ez b40e96969299:/plugins/rabbitmq_delayed_message_exchange-3.8.17.8f537ac.ez
  4. docker exec -it rabbitmq /bin/bash
  5. rabbitmq-plugins enable rabbitmq_delayed_message_exchange

方案二的问题可以通过安装RabbitMQ的社区插件rabbitmq_delayed_message_exchange来解决。
安装插件后会生成新的Exchange类型x-delayed-message，该类型消息支持延迟投递机制，接收到消息后并未立即将消息投递至目标队列，而是存储在mnesia (一个分布式数据库)中，随后监测消息延迟时间，如达到可投递时间时将其通过x-delayed-type类型标记的交换机投递至目标队列。
在这里插入图片描述
在这里插入图片描述

  • 配置类
@Configuration
public class RabbitMQConfig {
    // 声明 1个交换机  1个队列 1个路由key  属性
    // 延迟交换机
    public static final String DELAY_EXCHANGE_NAME = "delay.exchange";
    // 延迟队列
    public static final String DELAY_Queue_NAME = "delay.queue";
    // 延迟队列路由key
    public static final String DELAY_Queue_ROUTING_KEY = "delay.queue.routingkey";


    // 声明延迟交换机
    @Bean
    public CustomExchange delayExchange() {
        Map<String, Object> args = new HashMap<>();
        args.put("x-delayed-type", "direct");
        return new CustomExchange(DELAY_EXCHANGE_NAME, "x-delayed-message", true, false, args);
    }


    // 声明延迟队列
    @Bean
    public Queue delayQueue() {
        return QueueBuilder.durable(DELAY_Queue_NAME).build();
    }


    // 声明延迟队列的绑定关系
    @Bean
    public Binding delayBinding(@Qualifier("delayQueue") Queue queue,
                                 @Qualifier("delayExchange") CustomExchange exchange) {
        return BindingBuilder.bind(queue).to(exchange).with(DELAY_Queue_ROUTING_KEY).noargs();
    }
}
  • 生产者
@Component
public class DelayMsgProducer {
    @Resource
    private RabbitTemplate rabbitTemplate;

    public void send(String message, Integer delayTime) {
        rabbitTemplate.convertAndSend(DELAY_EXCHANGE_NAME, DELAY_Queue_ROUTING_KEY, message, msg -> {
            // 设置消息到期时间
            msg.getMessageProperties().setDelay(delayTime);
            return msg;
        });
    }
}
  • 消费者
@Component
@Slf4j
public class DeadLetterQueueConsumer {
    // 监听死信队列
    @RabbitListener(queues = RabbitMQConfig.DELAY_Queue_NAME)
    public void receiveA(Message message) {
        // 获取消息
        String msg = new String(message.getBody());
        // 记录日志
        log.info("当前时间: {}, 延迟队列收到消息: {}", LocalDateTime.now(), msg);
    }

}
  • 测试
    -在这里插入图片描述
    没有因为前面一条消息延迟时间长而影响下一条消息

订单超时实战

  • yml
spring:
  rabbitmq:
    host: 192.168.183.139
    port: 5672
    username: admin
    password: admin
    virtual-host: my_vhost

  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&characterEncoding=utf-8&useSSL=false
    username: root
    password: 123456

mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
    map-underscore-to-camel-case: true
  mapper-locations: classpath:mapper/*.xml
  type-aliases-package: com.zdz.entity
  global-config:
    db-config:
      id-type: auto

# 自定义配置
order:
  delay:
    time: 60000 # 1分钟 单位毫秒
  • enum
@Getter
@AllArgsConstructor
public enum OrderStatus {
    //0待确定 1已确定 2已收获 3已取消 4已完成 5已作废
    no_confirm(0, "待确定"),
    has_confirm(1, "已确定"),
    has_receive(2, "已收获"),
    cancel(3, "已取消 "),
    complete(4, "已完成"),
    discard(5, "已作废");

    private Integer status;
    private String message;
}

@Getter
@AllArgsConstructor
public enum PayStatus {
    //0 等待支付 1 已支付 2 部分支付
    no_pay(0, "等待支付"),
    has_pay(1, "已支付"),
    part_pay(2, "部分支付");

    private Integer status; //状态
    private String message; //描述
}
  • 配置类
@Configuration
public class RabbitMQConfig {
    // 声明 1个交换机  1个队列 1个路由key  属性
    // 延迟交换机
    public static final String DELAY_EXCHANGE_NAME = "delay.exchange";
    // 延迟队列
    public static final String DELAY_Queue_NAME = "delay.queue";
    // 延迟队列路由key
    public static final String DELAY_Queue_ROUTING_KEY = "delay.queue.routingkey";


    // 声明延迟交换机
    @Bean
    public CustomExchange delayExchange() {
        Map<String, Object> args = new HashMap<>();
        args.put("x-delayed-type", "direct");
        return new CustomExchange(DELAY_EXCHANGE_NAME, "x-delayed-message", true, false, args);
    }


    // 声明延迟队列
    @Bean
    public Queue delayQueue() {
        return QueueBuilder.durable(DELAY_Queue_NAME).build();
    }


    // 声明延迟队列的绑定关系
    @Bean
    public Binding delayBinding(@Qualifier("delayQueue") Queue queue,
                                 @Qualifier("delayExchange") CustomExchange exchange) {
        return BindingBuilder.bind(queue).to(exchange).with(DELAY_Queue_ROUTING_KEY).noargs();
    }
}
  • service
@Service
public class OrderServiceImpl extends ServiceImpl<OrderMapper, Order>
    implements OrderService{
    @Resource
    private OrderMapper orderMapper;

    @Resource
    private DelayMsgProducer producer;

    @Value("${order.delay.time}")
    private Integer orderDelayTime;

    /**
     * 新增订单
     * @param order
     * @return
     */
    @Transactional
    @Override
    public Map<String, Object> saveOrder(Order order) {
        // 订单编号
        order.setOrderSn(IdUtil.getSnowflake(1, 1).nextIdStr());
        // 订单状态 0 待支付
        order.setOrderStatus(OrderStatus.no_confirm.getStatus());
        // 支付状态 0 等待支付
        order.setPayStatus(PayStatus.no_pay.getStatus());
        // 下单时间
        order.setOrderTime(new Date());
        // 新增订单
        int insert = orderMapper.insert(order);
        Map<String, Object> map = new HashMap<>();
        if (insert > 0) {
            map.put("code", 200);
            map.put("msg", "订单已提交");
            // 发送消息到队列， 设置消息延迟时间
            producer.send(order.getOrderSn(), orderDelayTime);
        }else {
            map.put("code", 400);
            map.put("msg", "订单提交失败");
        }
        return map;
    }

    /**
     * 根据用户id查询订单列表
     * @param userId
     * @return
     */
    public List<Order> getAllByUserId(Integer userId) {
        QueryWrapper<Order> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("user_id", userId);
        return orderMapper.selectList(queryWrapper);
    }
}
  • controller
	@PostMapping("/save")
    @ApiOperation(value = "提交订单")
    public Map<String, Object> saveOrder(@RequestBody Order order) {
        log.info("订单信息: {}", order);
        return orderService.saveOrder(order);
    }
  • producer
@Component
@Slf4j
public class DelayMsgProducer {
    @Resource
    private RabbitTemplate rabbitTemplate;

    public void send(String message, Integer delayTime) {
        log.info("发送订单编号到队列，当前时间: {}, 订单编号: {}", LocalDateTime.now(), message);
        rabbitTemplate.convertAndSend(DELAY_EXCHANGE_NAME, DELAY_Queue_ROUTING_KEY, message, msg -> {
            // 设置消息到期时间
            msg.getMessageProperties().setDelay(delayTime);
            return msg;
        });
    }
}
  • consumer
@Component
@Slf4j
public class DeadLetterQueueConsumer {
    @Resource
    private OrderMapper orderMapper;
    @Resource
    private OrderActionMapper orderActionMapper;

    // 监听延迟队列
    @RabbitListener(queues = RabbitMQConfig.DELAY_Queue_NAME)
    public void receiveA(Message message) {
        // 获取消息
        String orderSn = new String(message.getBody());
        // 记录日志
        log.info("当前时间: {}, 订单编号: {}", LocalDateTime.now(), orderSn);
        // 根据订单编号查询订单
        QueryWrapper<Order> wrapper = new QueryWrapper<>();
        wrapper.eq("order_sn", orderSn);
        Order order = orderMapper.selectOne(wrapper);
        log.info("订单信息: {}", order);
        // 如果订单不为空并且支付状态是未支付并且订单状态是待确认
        if (order != null && OrderStatus.no_confirm.getStatus().equals(order.getOrderStatus())
                && PayStatus.no_pay.getStatus().equals(order.getPayStatus())) {
            // 设置订单状态为3 已取消
            order.setOrderStatus(OrderStatus.cancel.getStatus());
            // 根据订单编写修改订单
            int result = orderMapper.updateById(order);
            if (result > 0) {
                OrderAction orderAction = new OrderAction();
                orderAction.setOrderSn(orderSn);
                orderAction.setOrderStatus(OrderStatus.cancel.getStatus());
                orderAction.setPayStatus(PayStatus.no_pay.getStatus());
                orderAction.setActionNote("支付超时，订单已取消");
                orderAction.setActionTime(new Date());
                orderAction.setStatusDesc("支付超时，订单已取消");
                // 新增订单操作
                orderActionMapper.insert(orderAction);
            }
        }
    }
}
  • 测试
    在这里插入图片描述
富贵135
关注
专栏目录
RabbitMQ延时任务：订单超时取消
Tan_xiong的博客
04-02 709
在电商项目中，我们经常会遇到这样的需求：客户下单成功后，在一定的时间内未能按时（具体时间由业务规则决定）支付，需要将订单自动取消，释放占用的商品库存。类似于这样的需求（延时任务），我们该怎样解决呢？
记录使用rabbit mq处理订单超时业务
weixin_43864927的博客
04-01 1964
记录使用rabbit mq处理订单超时业务 前言：这几天在收尾项目，发现对订单超时的业务做的不够细致(下单15分钟后未付款则订单失效)，我们选择的是最为简单的定时任务来跑缓存中的订单，并筛选出超时的订单进行数据库更新操作，但是这样太消耗服务器的性能了，所以思考是否有别的解决方案 方案当然是有的，就我个人而言，就知道三种方案 就是我们现在所使用的方法，将订单存在redis缓存中，再模糊查询出...
rabbitMQ实现订单超时未支付自动取消订单
晨风若曦的博客
10-21 2956
rabbitMQ实现订单超时未支付自动取消订单
采用RabbitMQ的延迟队列和死信队列实现订单超时取消功能（自用）
最新发布
qq_45713664的博客
09-16 519
延迟队列指的是存储对应的延迟消息，消息被发送以后，并不想让消费者立刻拿到消息，而是等待特定时间后，消费者才能拿到这个消息进行消费。RabbitMQ 本身是没有延迟队列的，要实现延迟消息，一般有两种方式：1.使用 RabbitMQ 的死信交换机（Exchange）和消息的存活时间 TTL（消息存活时间）。生产者将消息发送到一个特定的交换器，该交换器将这些消息路由到一个具有TTL属性的队列。当消息在队列中的时间超过设定的TTL值时，消息会被发送到死信队列。消费者可以从死信队列中获取这些消息并进行相应的处理。
RabbitMQ实现订单30分钟超时自动关闭
我这孩子从小记性就不好，什么东西都要写下来才放心
04-29 4355
订单30分钟未支付,系统自动超时关闭有哪些实现方案? 1.基于任务调度实现,效率是非常低,耗服务器性能 2.基于redis过期key实现.用户下单的时候,生成一个令牌(有效期)30分钟,存放到我们redis; redis.set(orderToken ,orderID) 下单时候存放到redis,并存储id入库,30分钟过期, redis客户端监听,过期获取到orderId,拿orderId去查订单,没有支付则,订单关闭,库存增加 缺点:非常冗余 ,会在表中存放一个冗余字段 3.基于redis延迟队列
RabbitMQ消息队列（二）：业务实战订单超时处理
m0_64106946的博客
11-14 992
本文主要讲解RabbitMq如何处理超时业务，默认您已经对消息队列RabbitMq已经有了基础了解。声明一个延时交换机，一个死信交换机，一个延时队列，一个处理死信队列，并绑定。🤞我是小酥肉 ，喜欢简单 ，期待您的留言👌。我们可以配置队列TTL或者消息TTL。声明一个生产者，一个消费者，并绑定。❤️弱水三千，只取一瓢饮❤️。在控制器注入生产者，发送消息。❤️弱水三千，只取一瓢饮❤️。后，若该订单超过1天没有被。现在有一个需求：订单被。，则手动处理该超时订单。可以看我之前写的博客。
RabbitMQ死信队列实战——解决订单超时未支付
weixin_39555954的博客
10-09 6309
一、死信队列 二、产生原因 三、解决订单超时
基于RabbitMQ实现的订单超时功能-记录备查
hu10131013的博客
12-14 2751
背景 做过电商系统的人都会遇到一个场景，就是下了订单之后，订单支付会有一个有效期，超时订单自动关闭。实现的技术有很多，再次讨论基于RabbitMQ进行实现 思路 这个是基于RabbitMQ的延迟队列实现的，那需要讨论下什么是延迟队列 延迟队列 延迟队列存储的对象是对应的延迟消息，所谓“延迟消息”是指当消息被发送以后，并不 想让消费者立刻拿到消息，而是等待特定时间后，消费者才能拿到这个消息进行消费 。 PS: 在 AMQP 协议中，或者 RabbitMQ 本身没有直接支持延迟队列的功...
Java秒杀系统实战系列~RabbitMQ死信队列处理超时未支付的订单
weixin_30583563的博客
07-31 1171
摘要：本篇博文是“Java秒杀系统实战系列文章”的第十篇，本篇博文我们将采用RabbitMQ的死信队列的方式处理“用户秒杀成功生成订单后，却迟迟没有支付”的情况，一起来见识一下RabbitMQ死信队列在实际业务环境下的强大之处！内容：对于消息中间件RabbitMQ，Debug其实在前面的篇章中已经简单分享介绍过了，在这里就不再赘述了！在本文我们将采用RabbitMQ的死信队列实现这样的业务需求：“...
RabbitMQ-笔记
09-18
队列是无界的，可以存储无限数量的消息，直到它们被消费或超时。 **1.2 生产者** 生产者是创建并发送消息的组件。它们不关心消息何时或如何被消费，只需确保消息被正确地放入队列即可。 **1.3 消费者** 消费者是从...
RabbitMQ笔记.zip
07-01
4. **TTL和死信队列**：可以设置消息存活时间，超时后自动放入死信队列。 5. **多语言客户端**：RabbitMQ提供了多种编程语言的客户端库，如Python、Java、JavaScript等。 **应用场景** RabbitMQ常用于解耦系统组件...
springboot结合rabbitmq实现订单超时自动关闭
02-05
springboot结合rabbitmq实现订单超时自动关闭
rabbitmq笔记
weixin_45563356的博客
08-22 1939
建立TCP连接需要三次握手，反复确认。所以如果每一次访问RabbitMQ服务器都建立一个Connection开销会极大，效率低下。所以Channel就是在一个已经建立的Connection中建立的逻辑连接。如果应用程序支持多线程，那么每个线程创建一个单独的Channel进行通讯。每个Channel都有自己的id，Channel之间是完全隔离的。
2021最新版RabbitMQ完整教程学习笔记
super_song的博客
05-15 5226
文章目录一、中间件1. 什么是中间件2. 中间件技术及架构的概述3. 基于消息中间件的分布式系统的架构4. 消息队列协议5. 消息队列持久化6. 消息的分发策略7. 消息队列高可用和高可靠二、入门及安装 RabbitMQ1. RabbitMQ入门及安装概述下载RabbitMQ安装Erlang安装socat安装rabbitmq2. RabbitMQWeb管理界面及授权操作RabbitMQ管理界面授权账号和密码小结：3. RabbitMQ之Docker安装Dokcer安装RabbitMQ4. RabbitMQ的
RabbitMq学习笔记
weixin_43971312的博客
03-17 3493
RabbitMQ 1 简介 1.1 介绍 RabbitMQ是一个由erlang语言编写的、开源的、在AMQP基础上完整的、可复用的企业消息系统。支持多种语言，包括java、Python、ruby、PHP、C/C++等。 本质是个队列，FIFO 先入先出，只不过队列中存放的内容是message 而已，还是一种跨进程的通信机制，用于上下游传递消息。 (1)MQ：MQ是 message queue 的简称，是应用程序和应用程序之间通信的方法。 (2)AMQP：advanced message queuing.
RabbitMQ订单超时(面试问答)
qq_40946177的博客
11-08 1412
订单系统下单后，MQ会立刻发送一条消息到一个正常的交换机Exchange中，交换机会把消息路由到队列Queue中，我们给这个队列设置一个30分钟的过期时间，当30分钟后，此时消息称为死信队列，将此死信队列绑定一个死信交换机，那么这个死信交换机会把这个消息在路由到它绑定的一个队列queue中，然后用一个库存系统监听一个队列，当订单系统发一条消息之后，过了30分钟库存系统收到这条消息。收到消息后判断订单状态，是否支付，支付了就什么也不做，未支付，取消订单，回滚库存。
RabbitMQ实现商城订单超时处理
一只渣渣程序猿
01-06 2923
背景 为什么需要使用延迟队列？适用于什么场景？ 场景一：订单下单之后30分钟后，如果用户没有付钱，则系统自动取消订单。 这样类似的需求是我们经常会遇见的问题。最常用的方法是定期轮训数据库，设置状态。在数据量小的时候并没有什么大的问题，但是数据量一大轮训数据库的方式就会变得特别耗资源。当面对千万级、上亿级数据量时，本身写入的IO就比较高，导致长时间查询或者根本就查不出来。通过使用延迟队列来解决这种...
RabbitMQ实现订单超时未支付取消订单_mq消息超时未消费(2)
2401_84159813的博客
04-17 383
1、创建两个交换机和两个队列（一个普通的交换机和一个普通队列，一个死信交换机和一个死信队列），死信顾名思义就是普通队列未消费的东西就到了死信队列进行消费。(img-fJSZwiFK-1713321025391)]RabbitMQ控制台的变化。
解决方案：rabbitmq使用场景-超时未支付订单处理
chuanchengdabing的博客
08-30 4322
解决方案：rabbitmq使用场景-超时未支付订单处理 消息的TTL（Time To Live） 消息的TTL就是消息的存活时间。RabbitMQ可以对队列和消息分别设置TTL。对队列设置就是队列没有消费者连着的保留时间，也可以对每一个单独的消息做单独的设置。超过了这个时间，我们认为这个消息就死了，称之为死信。 死信交换器 Dead Letter Exchanges 一个消息在满足如下条件下，会进死信路由，记住这里是路由而不是队列，一个路由可以对应很多队列。 （1） 一个消息被Consumer拒收了，并且
rabbitmq 连接超时
09-06
您好！关于 RabbitMQ 连接超时的问题，可能有几个原因导致： 1. 网络问题：确保您的网络连接正常，RabbitMQ 服务器是可访问的。您可以尝试使用 `ping` 命令来测试与 RabbitMQ 服务器之间的网络连通性。 2. 配置问题：检查您的 RabbitMQ 配置文件，确保连接超时设置合理。配置文件通常位于 `/etc/rabbitmq/rabbitmq.conf` 或者 `/etc/rabbitmq/rabbitmq-env.conf`。 3. 防火墙问题：确保您的防火墙允许从客户端到 RabbitMQ 服务器的连接。如果防火墙设置不正确，可能会导致连接超时。 4. 连接池问题：如果您使用了连接池来管理 RabbitMQ 连接，检查连接池的配置和参数是否正确。有时候连接池中的连接可能被过早关闭或者过多使用导致连接超时。 如果您能提供更多的细节或错误信息，我可以帮助更准确地诊断问题。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值