RabbitMQ的四种交换机使用及死信队列

最新推荐文章于 2024-01-23 17:14:16 发布
最新推荐文章于 2024-01-23 17:14:16 发布
阅读量2.4k 收藏 1
点赞数 2
分类专栏： java 文章标签： java rabbitmq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44301905/article/details/123871172
版权

RabbitMQ的四种交换机使用xulong_87231

一、Direct exchange---直连类型交换机

直连型交换机中绑定queue时需要指定路由key，发送消息时也需要指定路由key。当消息发送到对应的exchange中，rabbitMQ会到找到路由完全匹配的key的queue中。

1、定义exchange、queue、key 

 /**
     * 直连交换机
     * 根据消息发送的key，找到交换机中对应key的queue
     */
    String DIRECT_EXCHANGE = "direct_exchange";
    String DIRECT_EXCHANGE_ONE = "direct_exchange_one";
    String DIRECT_EXCHANGE_ONE_KEY = "direct_exchange_one_key";
    String DIRECT_EXCHANGE_TWO = "direct_exchange_two";
    String DIRECT_EXCHANGE_TWO_KEY = "direct_exchange_two_key";

2、绑定注册exchange、queue

//直连交换机
    @Bean
    public DirectExchange directExchange() {
        return new DirectExchange(RabbitmqDefinition.DIRECT_EXCHANGE);
    }
    @Bean
    public Queue directExchangeOneQueue() {
        return new Queue(RabbitmqDefinition.DIRECT_EXCHANGE_ONE, true);
    }
    @Bean
    public Binding directExchangeOneQueueBinding() {
        return BindingBuilder
                .bind(directExchangeOneQueue()).to(directExchange()).with(RabbitmqDefinition.DIRECT_EXCHANGE_ONE_KEY);
    }
    @Bean
    public Queue directExchangeTwoQueue() {
        return new Queue(RabbitmqDefinition.DIRECT_EXCHANGE_TWO, true);
    }
    @Bean
    public Binding directExchangeTwoQueueBinding() {
        return BindingBuilder
                .bind(directExchangeTwoQueue()).to(directExchange()).with(RabbitmqDefinition.DIRECT_EXCHANGE_TWO_KEY);
    }

3、定义消费者

 @RabbitHandler
    @RabbitListener(queues = RabbitmqDefinition.DIRECT_EXCHANGE_ONE)
    public void directExchangeOne(Message message, @Payload String payload, Channel channel) {
        log.info("当前queue：{},接受到消息：{}", "DIRECT_EXCHANGE_ONE", payload);
    }

    @RabbitHandler
    @RabbitListener(queues = RabbitmqDefinition.DIRECT_EXCHANGE_TWO)
    public void directExchangeTwo(Message message, @Payload String payload, Channel channel) {
        log.info("当前queue：{},接受到消息：{}", "DIRECT_EXCHANGE_TWO", payload);
    }

4、定义生产者

    @Resource
    private RabbitTemplate rabbitTemplate;

    @Scheduled(fixedRate = 5000)
    public void directExchangeMessage() {
        log.info("EXCHANGE {}", "DIRECT_EXCHANGE");
        Map<String, String> map = new HashMap<>();
        map.put("exchange", "DIRECT_EXCHANGE");
        map.put("key", "direct_exchange_one_key");
        rabbitTemplate.convertAndSend(RabbitmqDefinition.DIRECT_EXCHANGE,RabbitmqDefinition.DIRECT_EXCHANGE_ONE_KEY, JSONObject.toJSONString(map));
        map.put("key", "direct_exchange_two_key");
        rabbitTemplate.convertAndSend(RabbitmqDefinition.DIRECT_EXCHANGE,RabbitmqDefinition.DIRECT_EXCHANGE_TWO_KEY, JSONObject.toJSONString(map));
    }

5、消费者输出结果

当前queue：DIRECT_EXCHANGE_TWO,接受到消息：{"exchange":"DIRECT_EXCHANGE","key":"direct_exchange_two_key"}
当前queue：DIRECT_EXCHANGE_ONE,接受到消息：{"exchange":"DIRECT_EXCHANGE","key":"direct_exchange_one_key"}

二、Fanout Exchange---扇出类型交换机xulong_87231

扇出类型Exchange绑定queue时不需要指定路由key，当消费发送到交换机时，交换机会将消息发送到所以绑定当前 Exchange的queue。

1、定义exchange、queue、key 

 /**
     * 扇形交换机
     * 往改交换机发送的消息，绑定了当前交换机的queue都能接收到消息
     */
    String FANOUT_EXCHANGE = "fanout_exchange";
    String FANOUT_EXCHANGE_ONE = "fanout_exchange_one";
    String FANOUT_EXCHANGE_TWO = "fanout_exchange_two";

2、绑定注册exchange、queue

// 扇形交换机
    @Bean
    public FanoutExchange fanoutExchange() {
        return new FanoutExchange(RabbitmqDefinition.FANOUT_EXCHANGE);
    }
    @Bean
    public Queue fanoutExchangeOneQueue() {
        return new Queue(RabbitmqDefinition.FANOUT_EXCHANGE_ONE, true);
    }
    @Bean
    public Binding fanoutExchangeOneQueueBinding() {
        return BindingBuilder
                .bind(fanoutExchangeOneQueue()).to(fanoutExchange());
    }
    @Bean
    public Queue fanoutExchangeTwoQueue() {
        return new Queue(RabbitmqDefinition.FANOUT_EXCHANGE_TWO, true);
    }
    @Bean
    public Binding fanoutExchangeTwoQueueBinding() {
        return BindingBuilder
                .bind(fanoutExchangeTwoQueue()).to(fanoutExchange());
    }

3、定义消费者

@RabbitHandler
    @RabbitListener(queues = RabbitmqDefinition.FANOUT_EXCHANGE_ONE)
    public void fanoutExchangeOne(Message message, @Payload String payload, Channel channel) {
        log.info("当前queue：{},接受到消息：{}", "FANOUT_EXCHANGE_ONE", payload);
    }

    @RabbitHandler
    @RabbitListener(queues = RabbitmqDefinition.FANOUT_EXCHANGE_TWO)
    public void fanoutExchangeTwo(Message message, @Payload String payload, Channel channel) {
        log.info("当前queue：{},接受到消息：{}", "FANOUT_EXCHANGE_TWO", payload);
    }

4、定义生产者

    @Resource
    private RabbitTemplate rabbitTemplate;

    @Scheduled(fixedRate = 10000)
    public void fanoutExchangeMessage() {
        log.info("EXCHANGE {}", "FANOUT_EXCHANGE");
        Map<String, String> map = new HashMap<>();
        map.put("exchange", "FANOUT_EXCHANGE");
        rabbitTemplate.convertAndSend(RabbitmqDefinition.FANOUT_EXCHANGE,"", JSONObject.toJSONString(map));
    }

5、消费者输出结果

当前queue：FANOUT_EXCHANGE_ONE,接受到消息：{"exchange":"FANOUT_EXCHANGE"}
当前queue：FANOUT_EXCHANGE_TWO,接受到消息：{"exchange":"FANOUT_EXCHANGE"}

三、Topic Exchange---主题类型交换机

Topic Exchange与Direct exchange相似，不过Direct exchange消息接受需要全匹配路由key，Topic Exchange只需要模糊匹配，与绑定exchange的路由key相关，当不需要匹配时使用匹配符合*

1、定义exchange、queue、key 

/**
     * 主题交换机
     * 发送到交换机的消息指定规则，交换机将根据对应规则发送到对应的queue中
     * 类似于直连交换机的部分匹配
     */
    String TOPIC_EXCHANGE = "topic_exchange";
    String TOPIC_EXCHANGE_ONE = "topic_exchange_one";
    String TOPIC_EXCHANGE_TWO = "topic_exchange_two";
    String TOPIC_EXCHANGE_THREE = "topic_exchange_three";
    String TOPIC_EXCHANGE_ONE_KEY = "season.*.*";
    String TOPIC_EXCHANGE_TWO_KEY = "*.colour.*";
    String TOPIC_EXCHANGE_THREE_KEY = "*.*.action";

2、绑定注册exchange、queue

// 主题交换机
    @Bean
    public TopicExchange topicExchange() {
        return new TopicExchange(RabbitmqDefinition.TOPIC_EXCHANGE);
    }
    @Bean
    public Queue topicExchangeOneQueue() {
        return new Queue(RabbitmqDefinition.TOPIC_EXCHANGE_ONE, true);
    }
    @Bean
    public Queue topicExchangeTwoQueue() {
        return new Queue(RabbitmqDefinition.TOPIC_EXCHANGE_TWO, true);
    }
    @Bean
    public Queue topicExchangeThreeQueue() {
        return new Queue(RabbitmqDefinition.TOPIC_EXCHANGE_THREE, true);
    }
    @Bean
    public Binding topicExchangeOneQueueBinding() {
        return BindingBuilder
                .bind(topicExchangeOneQueue()).to(topicExchange()).with(RabbitmqDefinition.TOPIC_EXCHANGE_ONE_KEY);
    }
    @Bean
    public Binding topicExchangeTwoQueueBinding() {
        return BindingBuilder
                .bind(topicExchangeTwoQueue()).to(topicExchange()).with(RabbitmqDefinition.TOPIC_EXCHANGE_TWO_KEY);
    }
    @Bean
    public Binding topicExchangeThreeQueueBinding() {
        return BindingBuilder
                .bind(topicExchangeThreeQueue()).to(topicExchange()).with(RabbitmqDefinition.TOPIC_EXCHANGE_THREE_KEY);
    }

3、定义消费者

 @RabbitHandler
    @RabbitListener(queues = RabbitmqDefinition.TOPIC_EXCHANGE_ONE)
    public void topicExchangeOne(Message message, @Payload String payload, Channel channel) {
        log.info("当前queue：{},接受到消息：{}", "TOPIC_EXCHANGE_ONE", payload);
    }

    @RabbitHandler
    @RabbitListener(queues = RabbitmqDefinition.TOPIC_EXCHANGE_TWO)
    public void topicExchangeTwo(Message message, @Payload String payload, Channel channel) {
        log.info("当前queue：{},接受到消息：{}", "TOPIC_EXCHANGE_TWO", payload);
    }

    @RabbitHandler
    @RabbitListener(queues = RabbitmqDefinition.TOPIC_EXCHANGE_THREE)
    public void topicExchangeThree(Message message, @Payload String payload, Channel channel) {
        log.info("当前queue：{},接受到消息：{}", "TOPIC_EXCHANGE_THREE", payload);
    }

4、定义生产者

    @Scheduled(fixedRate = 10000)
    public void topicExchangeMessage() {
        log.info("EXCHANGE {}", "TOPIC_EXCHANGE");
        Map<String, String> map = new HashMap<>();
        map.put("exchange", "TOPIC_EXCHANGE");
        map.put("key", "season.colour.other");
        map.put("message", "春天里的树叶是绿色的");
        rabbitTemplate.convertAndSend(RabbitmqDefinition.TOPIC_EXCHANGE,"season.colour.other", JSONObject.toJSONString(map));
        map.put("key", "other.colour.action");
        map.put("message", "一只白色的兔子在草地上奔跑");
        rabbitTemplate.convertAndSend(RabbitmqDefinition.TOPIC_EXCHANGE,"other.colour.action", JSONObject.toJSONString(map));
        map.put("key", "other.colour.action");
        map.put("message", "冬天的动物似乎都不太愿意动起来，只有在扑食时才会追击猎物");
        rabbitTemplate.convertAndSend(RabbitmqDefinition.TOPIC_EXCHANGE,"season.other.action", JSONObject.toJSONString(map));
    }

5、消费者输出结果

当前queue：TOPIC_EXCHANGE_TWO,接受到消息：{"exchange":"TOPIC_EXCHANGE","message":"春天里的树叶是绿色的","key":"season.colour.other"}
当前queue：TOPIC_EXCHANGE_ONE,接受到消息：{"exchange":"TOPIC_EXCHANGE","message":"春天里的树叶是绿色的","key":"season.colour.other"}
当前queue：TOPIC_EXCHANGE_THREE,接受到消息：{"exchange":"TOPIC_EXCHANGE","message":"一只白色的兔子在草地上奔跑","key":"other.colour.action"}
当前queue：TOPIC_EXCHANGE_TWO,接受到消息：{"exchange":"TOPIC_EXCHANGE","message":"一只白色的兔子在草地上奔跑","key":"other.colour.action"}
当前queue：TOPIC_EXCHANGE_ONE,接受到消息：{"exchange":"TOPIC_EXCHANGE","message":"冬天的动物似乎都不太愿意动起来，只有在扑食时才会追击猎物","key":"other.colour.action"}
当前queue：TOPIC_EXCHANGE_THREE,接受到消息：{"exchange":"TOPIC_EXCHANGE","message":"冬天的动物似乎都不太愿意动起来，只有在扑食时才会追击猎物","key":"other.colour.action"}

四、Headers Exchanges---头部类型交换机

不处理路由键。而是根据发送的消息内容中的headers属性进行匹配。

1、定义exchange、queue、key 

    String HEADERS_EXCHANGE = "headers_exchange";
    String HEADERS_EXCHANGE_ONE = "headers_exchange_one";
    String HEADERS_EXCHANGE_TWO = "headers_exchange_two";

2、绑定注册exchange、queue

    @Bean
    public HeadersExchange headersExchange() {
        return new HeadersExchange(RabbitmqDefinition.HEADERS_EXCHANGE);
    }
    @Bean
    public Queue headersExchangeOneQueue() {
        return new Queue(RabbitmqDefinition.HEADERS_EXCHANGE_ONE);
    }
    @Bean
    public Queue headersExchangeTwoQueue() {
        return new Queue(RabbitmqDefinition.HEADERS_EXCHANGE_TWO);
    }

    /**
     * whereAny 只要符合其中一个请求头，queue可接受消息
     * whereAll 所有请求头符合，queue可以接受消息
     */
    @Bean
    public Binding headersExchangeOneQueueBinding() {
        Map<String, Object> map = new HashMap<>();
        map.put("exchange", "HEADERS_EXCHANGE");
        map.put("bindType", "whereAny");
        return BindingBuilder
                .bind(headersExchangeOneQueue()).to(headersExchange()).whereAny(map).match();
    }
    @Bean
    public Binding headersExchangeTwoQueueBinding() {
        Map<String, Object> map = new HashMap<>();
        map.put("exchange", "HEADERS_EXCHANGE");
        map.put("queue", "two");
        map.put("bindType", "whereAll");
        return BindingBuilder
                .bind(headersExchangeTwoQueue()).to(headersExchange()).whereAll(map).match();
    }

3、定义消费者

    @RabbitHandler
    @RabbitListener(queues = RabbitmqDefinition.HEADERS_EXCHANGE_ONE)
    public void headersExchangeOne(Message message, @Payload String payload, Channel channel) {
        log.info("当前queue：{},接受到消息：{}", "HEADERS_EXCHANGE_ONE", payload);
    }

    @RabbitHandler
    @RabbitListener(queues = RabbitmqDefinition.HEADERS_EXCHANGE_TWO)
    public void headersExchangeTwo(Message message, @Payload String payload, Channel channel) {
        log.info("当前queue：{},接受到消息：{}", "HEADERS_EXCHANGE_TWO", payload);
    }

4、定义生产者

    @Scheduled(fixedRate = 10000)
    public void headersExchangeMessage() {
        log.info("EXCHANGE {}", "HEADERS_EXCHANGE");
        MessageProperties messageProperties = new MessageProperties();
        messageProperties.setHeader("exchange", "HEADERS_EXCHANGE");
        messageProperties.setHeader("bindType", "whereAny");
        Message messageOne = new Message("第一次发送数据".getBytes(), messageProperties);
        rabbitTemplate.convertAndSend(RabbitmqDefinition.HEADERS_EXCHANGE,null, messageOne);

        messageProperties.setHeader("queue", "two");
        messageProperties.setHeader("bindType", "whereAll");
        Message messageTwo = new Message("第二次发送数据".getBytes(), messageProperties);
        rabbitTemplate.convertAndSend(RabbitmqDefinition.HEADERS_EXCHANGE,null, messageTwo);
    }

5、消费者输出结果

当前queue：HEADERS_EXCHANGE_ONE,接受到消息：第一次发送数据
当前queue：HEADERS_EXCHANGE_TWO,接受到消息：第二次发送数据
当前queue：HEADERS_EXCHANGE_ONE,接受到消息：第二次发送数据

死信队列

死信队列介绍

  • 死信队列：DLX，dead-letter-exchange
  • 利用DLX，当消息在一个队列中变成死信 (dead message) 之后，它能被重新publish到另一个Exchange，这个Exchange就是DLX

什么是死信队列

        顾名思义，死信队列就是当前队列死掉了就是死信队列。当被指定的死信队列因为以下原因，则会将消息转发到对应绑定的队列中

  • 消息被拒绝(basic.reject / basic.nack)，并且requeue = false
  • 消息TTL过期
  • 队列达到最大长度

死信队列有什么作用

  • 当消息处理异常，需要后续处理时可以使用死信队列
  • 延迟队列，比如订单提交后30分支未支付订单取消

代码演示

1、定义exchange、queue、key

  • 死信队列包括交换机及队列
  • 死信队列其实就是一个正常的队列
    /**
     * 死信队列相关
     */
    String DXL_EXCHANGE = "dxl_exchange";
    String DXL_QUEUE = "dxl_queue";
    String DXL_KEY = "dxl_key";
    // 业务相关
    String BUSINESS_EXCHANGE = "business_exchange";
    String BUSINESS_QUEUE_ONE = "business_queue_one";
    String BUSINESS_QUEUE_TWO = "business_queue_two";

2、绑定注册exchange、queue

/**
     * 死信队列其实就是一个正常的交换机及队列
     */
    @Bean
    public DirectExchange dxlExchange() {
        return new DirectExchange(RabbitmqDefinition.DXL_EXCHANGE);
    }
    @Bean
    public Queue dxlQueue() {
        return new Queue(RabbitmqDefinition.DXL_QUEUE, true);
    }
    @Bean
    public Binding dxlQueueBinding() {
        return BindingBuilder
                .bind(dxlQueue()).to(dxlExchange()).with(RabbitmqDefinition.DXL_KEY);
    }
    /**
     * 业务交换机及队列
     * BUSINESS_QUEUE_ONE 正常业务处理，参照组
     * BUSINESS_QUEUE_TWO 设置为死信的业务队列
     */
    @Bean
    public FanoutExchange businessExchange() {
        return new FanoutExchange(RabbitmqDefinition.BUSINESS_EXCHANGE);
    }
    @Bean
    public Queue businessQueueOneQueue() {
        return new Queue(RabbitmqDefinition.BUSINESS_QUEUE_ONE, true);
    }
    @Bean
    public Binding businessQueueOneQueueBinding() {
        return BindingBuilder
                .bind(businessQueueOneQueue()).to(businessExchange());
    }
    @Bean
    public Queue businessQueueTwoQueue() {
        Map<String, Object> map = new HashMap<>();
        // 声明当前死信队列绑定的死信交换机,可以是任何类型的交换机
        map.put("x-dead-letter-exchange", RabbitmqDefinition.DXL_EXCHANGE);
        // 声明当前队列的死信路由键
        map.put("x-dead-letter-routing-key", RabbitmqDefinition.DXL_KEY);
        // 设置队列消息的超时时间，单位毫秒，超过时间进入死信队列,也可以在发送消息处设置超时时间，都设置时，以最小超时时间为准
        map.put("x-message-ttl",3000);
        // 生命队列的最大长度，超过长度的消息进入死信队列
        map.put("x-max-length", 10);
        return new Queue(RabbitmqDefinition.BUSINESS_QUEUE_TWO, true, false, false, map);
    }
    @Bean
    public Binding businessQueueTwoQueueBinding() {
        return BindingBuilder
                .bind(businessQueueTwoQueue()).to(businessExchange());
    }

3、定义消费者

  • 做延迟队列业务操作时，可以不设置消费者
  • 如下消费者为模拟业务处理失败，转发到指定的死信队列
    @RabbitHandler
    @RabbitListener(queues = RabbitmqDefinition.DXL_QUEUE)
    public void dxlQueue(Message message, @Payload String payload, Channel channel) {
        log.info("当前queue为死信队列转发队列：{},接受到消息：{}", "DXL_QUEUE", payload);
    }

    @RabbitHandler
    @RabbitListener(queues = RabbitmqDefinition.BUSINESS_QUEUE_ONE)
    public void businessQueueOne(Message message, @Payload String payload, Channel channel) {
        log.info("当前queue为正常参照业务：{},接受到消息：{}", "BUSINESS_QUEUE_ONE", payload);
    }

    @RabbitHandler
    @RabbitListener(queues = RabbitmqDefinition.BUSINESS_QUEUE_TWO)
    public void businessQueueTwo(Message message, @Payload String payload, Channel channel) throws IOException {
        log.info("当前queue为业务死信队列：{},接受到消息：{}", "BUSINESS_QUEUE_TWO", payload);
        try {
            String str = null;
            str.equals("测试报错");
        }catch (Exception e) {
            // 第三个参数设置为false，则当前mq消息消费失败不会重新发送到当前mq
            channel.basicNack(message.getMessageProperties().getDeliveryTag(), true, false);
        }

    }

4、定义生产者

    @Scheduled(fixedRate = 10000)
    public void dxlExchangeMessage() {
        Map<String, String> map = new HashMap<>();
        map.put("exchange", "BUSINESS_EXCHANGE");
        map.put("content", "测试业务");
        rabbitTemplate.convertAndSend(RabbitmqDefinition.BUSINESS_EXCHANGE,"", JSONObject.toJSONString(map));
        // 在发送时设置消息超时时间
//        rabbitTemplate.convertAndSend(RabbitmqDefinition.BUSINESS_EXCHANGE,"", JSONObject.toJSONString(map), message -> {
//            // 发送消息时设置消息的超时时间
//            message.getMessageProperties().setExpiration("5000");
//            return message;
//        });
    }

5、消费者输出结果

  • 下方两个输出结果分别为处理业务异常及不配置消费者的延迟队列
2022-04-01 11:10:16.245  INFO 11200 --- [ntContainer#6-1] c.example.demo.rabbitmq.MessageListener  : 当前queue为正常参照业务：BUSINESS_QUEUE_ONE,接受到消息：{"exchange":"BUSINESS_EXCHANGE","content":"测试业务"}
2022-04-01 11:10:16.245  INFO 11200 --- [ntContainer#9-1] c.example.demo.rabbitmq.MessageListener  : 当前queue为业务死信队列：BUSINESS_QUEUE_TWO,接受到消息：{"exchange":"BUSINESS_EXCHANGE","content":"测试业务"}
2022-04-01 11:10:16.247  INFO 11200 --- [tContainer#10-1] c.example.demo.rabbitmq.MessageListener  : 当前queue为死信队列转发队列：DXL_QUEUE,接受到消息：{"exchange":"BUSINESS_EXCHANGE","content":"测试业务"}

2022-04-01 11:11:15.215  INFO 21016 --- [ntContainer#7-1] c.example.demo.rabbitmq.MessageListener  : 当前queue为正常参照业务：BUSINESS_QUEUE_ONE,接受到消息：{"exchange":"BUSINESS_EXCHANGE","content":"测试业务"}
2022-04-01 11:11:18.218  INFO 21016 --- [ntContainer#4-1] c.example.demo.rabbitmq.MessageListener  : 当前queue为死信队列转发队列：DXL_QUEUE,接受到消息：{"exchange":"BUSINESS_EXCHANGE","content":"测试业务"}

xulong_87231
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RabbitMQ 死信交换机&延迟队列
m0_58525944的博客
02-26 1148
一，死信队列(延迟队列) 死信，在官网中对应的单词为“Dead Letter”,它是 RabbitMQ 的一种消息机制。 一般来说，生产者将消息投递到 broker 或者直接到 queue 里了，consumer 从 queue 取出消息进行消费，如果它一直无法消费某条数据，那么可以把这条消息放入死信队列里面。等待 条件满足了再从死信队列中取出来再次消费，从而避免消息丢失。 死信消息来源： 消息 TTL 过期 队列满了，无法再次添加数据 消息被拒绝（reject 或 nack），并且 r
springboot整合rabbitmq使用死信队列
11-06
总的来说，Spring Boot整合RabbitMQ并使用死信队列是一种常见的消息处理策略，它能有效地处理异常消息，防止消息丢失，并为系统的健壮性提供保障。通过合理的配置和编程，我们可以构建出高效、可靠的分布式系统。
RabbitMQ之交换机总结（图文并茂讲解）
FlyingFish868的博客
08-24 918
1、简单模式和发布订阅模式 简单模式：使用的默认交换机，一个消费者（工作进程）只能被消费一次，消费者C1、C2…Cn之间是竞争关系。 发布订阅模式：通过指定的交换机，可以用多个队列实现一个消息由多个消费者来消费， 为了说明这种模式，我们将构建一个简单的日志系统。它将由两个程序组成:第一个程序将发出日志消息，第二个程序是消费者。其中我们会启动两个消费者，其中一个消费者接收到消息后把日志存储在磁盘，另外一个消费者接收到消息后把消息打印在屏幕上，事实上第一个程序发出的日志消息将广播给所有消费者。
RabbitMQ的死信队列详解及实现
doupengzp的博客
06-23 4903
死信队列概念 死信，顾名思义就是无法被消费的消息，字面意思可以这样理解，一般来说，producer将消息投递到broker或者直接到queue里了，consumer从queue取出消息进行消费，但某些时候由于特定的原因导致queue中的某些消息无法被消费，这样的消息如果没有后续的处理，就变成了死信，有死信，自然就有了死信队列； 以上是个人的通俗解释，专业术语解释的比较正规点大家可以参考，主要想搞清楚这个概念，不同的消息中间件大概都有自身对于死信或者死信队列的处理方式，下面重点要说说。 消息变成死信有以
RabbitMQ学习笔记（消息发布确认，死信队列，集群，交换机，持久化，生产者、消费者）
RuanFun的博客
10-02 1574
消息发布确认，死信队列，集群，交换机，持久化，生产者、消费者...
RabbitMQ 使用规范
王小明的专栏
12-01 5519
一、命名规范 1.Queue设计 A生产消息，指定由B消费，这样的话就定义一个队列。 A生产消息，由B和C共同消费，因B和C都为多个节点，故系统定义为两个不同队列，虽然消息是相同的。 A和B生产消息，由C消费，可定义一个队列，也可定义两个队列。为便于区分消息生产者和消费者，定义消息队列名为生产者模块简称_消息参数_消费者模块简称，按照此思路，此种场景也需定义两个队列。 如示例，...
别人家的团队怎么用RabbitMQ：我总结的5点规范
架构师小秘圈
01-28 283
大概从 2013 年开始，我就开始了自己和 RabbitMQ 的接触，到现在已经有七年多了。在这七年中，既有一些对 RabbitMQ 的深度体验，更有无数的血泪史。而根据我这么多年的使用...
Spring RabbitMQ死信机制原理实例详解
08-24
在 Spring RabbitMQ 中，可以通过配置死信队列和死信交换机来实现死信机制。例如： ```java @Bean public Queue deadQueue() { return new Queue(DEAD_QUEUE_NAME, true); } @Bean public DirectExchange ...
SpringBoot集成RabbitMQ的方法(死信队列)
08-26
死信队列是RabbitMQ中的一种特殊队列，用于存储没有被及时消费的消息。死信队列可以根据不同的场景进行配置，例如可以根据消息的TTL（Time To Live）来确定消息的存储时间。 在死信队列中，消息可以根据不同的原因...
rabbitMQ 死信队列 完整例子
03-19
死信队列是RabbitMQ中一种特殊机制，当消息无法正常路由到队列或者达到预设的TTL（Time To Live）限制时，这些消息会被转移到死信队列，以便于进行后续的分析、日志记录或手动处理。常见的导致消息成为死信的情况...
rabbitmq队列和交换机的实现
02-20
4. **死信队列（Dead Letter Queue）**：当消息无法投递到任何队列，或者队列已满，消息会进入死信队列。这提供了一种处理错误或异常情况的方法，使得这些消息不会丢失，而是可以被单独分析或处理。 在分布式环境中...
RabbitMQ使用案例
qq_40068304的博客
12-29 3028
一.简单模式(队列-->交换机) yml配置: server: port: 8088 spring: rabbitmq: host: 127.0.0.1 port: 5672 username: guest password: guest publisher-confirm-type: correlated #消息确认方式,通过 correlated 来确认(将来的消息中才会带 correlation_id,只有通过 correlation_
大白话讲解RabbitMQ四种交换机以及在管理页面中创建交换机、队列和绑定关系
曹举的个人博客
10-28 6625
RabbitMQ是目前应用非常广泛的一种消息队列之一，今天就来简单说一下RabbitMQ的四种交换机 以及在管理页面中创建交换机、队列、绑定关系 开始讲之前先来简单描述一下RabbitMQ中的几个关键的概念： Broker：可以简单的理解为安装了RabbitMQ服务的这台机器就可以称为一个Broker Exchange：交换机，类似于一个路由器的作用 Queue：队列，最终将消息投递到队列中，由消费端监听队列进行消费 Routingkey：路由键，交换机绑定队列时需要指定路由键或通配符路由键
RabbitMQ 几种交换机的使用场景
暴暴莉
11-12 1329
一：默认交换机 平均分配消息到custom, routing_key会将交换机的消息路由到指定的队列中 消费者 #!/usr/bin/env python import pika connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost')) channel = connection.channel() channel.queue_declare(queue='hello') def call
消息队列RabbitMQ.02.交换机的讲解与使用
d2916172682的博客
01-23 2490
1.直连交换机只能通过queue发送一个请求，如果需要发送多个请求那么就要进行多个配置；2.主题交换机可以通过配置多个路由键来实现不同的键进入不同的消费者，如：交换机a，交换机b，现在有一个包含a和b的键那么两个都能进入不同的消费者功能更加强大，并且可以配置通配符，根据通配符 * # 来实现进入不同的消费者；3.* 星号代表匹配一个单词，# 井号代表匹配一个或多个单词；4.扇形交换机可以统一发送请求，列入可以运用到，商城活动时统一给用户发送商城活动信息；
RabbitMQ实战之三种交换机（Direct、Topic和Fanout）
jike11231的博客
09-30 1210
一、消息推送到接收的流程图 首先先介绍一个简单的一个消息推送到接收的流程，提供一个简单的图： 黄色的圈圈就是我们的消息推送服务，将消息推送到 中间方框里面也就是 rabbitMq的服务器，然后经过服务器里面的交换机、队列等各种关系（后面会详细讲）将数据处理入列后，最终右边的蓝色圈圈消费者获取对应监听的消息。 常用的交换机有以下三种，因为消费者是从队列获取信息的，队列是绑定交换机的（一般），所以对应的消息推送/接收模式也会有以下几种： 1.Direct Exchange 直连型交换机，根据消息携带的路由键将
用RabbitMq的5种交换机类型实现发送和接收消息
Ciao's blog
02-10 325
用RabbitMq的5种交换机类型实现发送和接收消息
rabbitmq常用交换机入门案例
xiaomingboke的博客
01-14 597
fanout “无路由交换机”，说白了就是，使用这个交换机不需要routingkey绑定，和路由没有关系，它是直接绑定到队列的。 生产者 package com.test.rabbitmq.routing; import com.rabbitmq.client.Channel; import com.rabbitmq.client.Connection; import com.rabbitmq.client.ConnectionFactory; /** * fanout 发布与订阅模式 .
延迟队列
lei_lin的博客
12-27 422
1. 场景：“订单下单成功后，15分钟未支付自动取消” 1.传统处理超时订单 采取定时任务轮训数据库订单，并且批量处理。其弊端也是显而易见的；对服务器、数据库性会有很大的要求， 并且当处理大量订单起来会很力不从心,而且实时性也不是特别好。当然传统的手法还可以再优化一下， 即存入订单的时候就算出订单的过期时间插入数据库，设置定时任务查询数据库的时候就只需要查询过期了的订单， 然后再做其他的业务操作 ...
rabbitmq使用死信队列
最新发布
07-10
RabbitMQ中的死信队列是一种特殊类型的队列，它用于处理那些无法正常路由或者消费的消息。当消息满足某些特定条件时，比如超时未被消费、消费者取消订阅、或者是由于异常导致无法处理，RabbitMQ会将这些消息移动到...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值