RabbitMQ快速入门之进阶

已于 2023-02-18 08:46:34 修改
阅读量1.1k 收藏 2
点赞数
分类专栏： RabbitMQ 文章标签： java-rabbitmq rabbitmq java
于 2023-01-13 15:23:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_54963748/article/details/128606297
版权
本文详细介绍了RabbitMQ的高级特性，包括confirm模式确保消息送达、return模式处理路由失败、消费者手动确认(Ack)、消费端限流、TTL过期策略以及如何设置死信队列和延迟队列，提供了一整套消息可靠传输和管理的方法。
摘要由CSDN通过智能技术生成

RabbitMQ快速入门之进阶

进阶

1、confirm 模式的设置

*confirm 确认模式
*return 退回模式

  • 消息从生产者到交换机会返回一个confirmCallback
  • 消息从交换机 -->队列投递失败会返回一个returnCallback

1、confirm 模式的设置

注意：本文使用的是springboot来进行处理的，springboot配置RabbitMQ可去观看：RabbitMQ快速入门

 1、配置文件 publisher-confirm-type: correlated
 2、在rabbitTemplate上定义ConfirmCallBack回调函数
 confirm中的参数：
       /**
         * @param correlationData 相关的配置信息
         * @param ack  交换机是否成功收到消息 true：成功
         * @param cause 失败的原因，用ack来判断，来进行输出错误信息
         */

配置文件：

spring:
  rabbitmq:
    host: 192.168.92.134
    port: 5672
    username: zww
    password: 123456
    virtual-host: /
    # Add this sentence
    publisher-confirm-type: correlated

1.1生产者配置：

@Configuration
public class RabbitMQConfig {
    public static final String QUEUE_NAME = "boot_queue_confirm";
    public static final String EXCHANGE_NAME="boot_exchange_confirm";

    // 1、交换机的配置
    @Bean("bootExchange")
    public Exchange exchange(){
        //durable(true) 持久化，mq重启之后交换机还在
        return ExchangeBuilder.topicExchange(EXCHANGE_NAME).durable(true).build();
    }
    // 2、队列的配置
    @Bean("bootQueue")
    public Queue bootQueue(){
        return QueueBuilder.durable(QUEUE_NAME).build();
    }

    // 3、绑定关系  Binging
    /**
     * 1、知道哪个队列
     * 2、知道哪个交换机
     * 3、设置对应的 routing key
     */

    @Bean
    public Binding bindQueueExchange(@Qualifier("bootQueue") Queue queue,@Qualifier("bootExchange") Exchange exchange){
        return BindingBuilder.bind(queue).to(exchange).with("boot.#").noargs();
    }
}

1.2生产者测试模块

    /**
     * 确认模式
     * 1、配置文件 publisher-confirm-type: correlated
     * 2、在rabbitTemplate上定义ConfirmCallBack回调函数
     */
    @Test
    public void testConfirm(){
        rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback() {
            /**
             * @param correlationData 相关的配置信息
             * @param ack  交换机是否成功收到消息 true：成功
             * @param cause 失败的原因
             */
            @Override
            public void confirm(CorrelationData correlationData, boolean ack, String cause) {
                System.out.println("confirm方法被执行了....");
                // 接收成功
                if (ack){
                    System.out.println("消息接收成功");
                }else {
                    // 接收失败（把交换机的名字，改成不存在的，然后在运行）
                    System.out.println("接收失败，原因："+cause );
                    // 对于失败，做一些处理
                }
            }
        });

        // EXCHANGE_NAME
        rabbitTemplate.convertAndSend(EXCHANGE_NAME,"boot.confirm","传的信息:message confirm");
    }

1.3：运行结果(把交换机名称换成不存在的，打印错误信息)

在这里插入图片描述

在这里插入图片描述

2、return 退回模式的处理

2、return 退回模式的处理

 *  回退模式：当消息发送给Exchange后，路由器路由到Queue失败之后，才会执行ReruenCallBack
 *  1、开启回退模式
 *  publisher-returns: true
 *  2、设置ReturnCallBack
 *  3、设置Exchange处理消息的模式
 *   3.1、如果消息没有路由到Queue，则丢弃(默认)
 *   3.2、如果消息没有路由到Queue，返回给消息发送方
 *      rabbitTemplate.setMandatory(true);

2.1、生产者测试模块

    /**
     * 回退模式：当消息发送给Exchange后，路由器路由到Queue失败之后，才会执行ReruenCallBack
     *  1、开启回退模式
     *  publisher-returns: true
     *  2、设置ReturnCallBack
     *  3、设置Exchange处理消息的模式
     *   3.1、如果消息没有路由到Queue，则丢弃(默认)
     *   3.2、如果消息没有路由到Queue，返回给消息发送方
     *      rabbitTemplate.setMandatory(true);
     */
    @Test
    public void testReturn(){
        // 设置交换机处理失败消息模式
        rabbitTemplate.setMandatory(true);
        rabbitTemplate.setReturnCallback(new RabbitTemplate.ReturnCallback(){
            /**
             * 消息失败了，会调用这个方法
             * 注意：要进行处理失败的处理  rabbitTemplate.setMandatory(true);
             * @param message 消息对象
             * @param replyCode 错误码
             * @param replyText 错误信息
             * @param exchange 交换机
             * @param routingKey 路由键
             */
            @Override
            public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
                System.out.println("return 执行了");
                System.out.println(message);
                System.out.println(replyCode);
                System.out.println(replyText);
                System.out.println(exchange);
                System.out.println(routingKey);
                // 失败的话，就要进行想对应的处理
            }
        });
        // 这里的key填的是错误的，这样就不能到Queue
        rabbitTemplate.convertAndSend(EXCHANGE_NAME,"boot1.confirm","传的信息:message confirm");
    }

2.2、运行结果

这里我们把错误的对应信息都给打印出来了。

在这里插入图片描述

3、消费者 Ack，手动确认

3、消费者 Ack

     * Consumer Ack: 消费端收到消息之后的确认方式
     * 1、自动确认 acknowledge = "none"
     * 2、手动确认 acknowledge = "manual"
     * 3、根据异常情况确认： acknowledge = "auto"

3.1、ACK机制：

ACK机制：
 1、设置手动签收。配置文件中添加：
    listener:
    direct:
     acknowledge-mode: manual
 2、@RabbitListener注解中，要进行ackMode = "MANUAL"的设置
 3、监听器类实现： ChannelAwareMessageListener接口
 4、处理成功，调用channel的basicNack()签收
 5、如果消息处理失败，调用channel的basicNack()拒绝签收

3.2 消费者类

/**
 * 没有出现异常就使用basicAck来进行手动签收
 * 出现异常就进行basicNack来进行重新尝试
 */
@Component
public class AckListener implements ChannelAwareMessageListener {
    /**
     * ackMode = "MANUAL"要进行这个的设置，不然就还是自动的，那么就会有冲突，会出现错误
     * @param message
     * @param channel
     * @throws Exception
     */
    @org.springframework.amqp.rabbit.annotation.RabbitListener(queues = "boot_queue_confirm"
    ,ackMode = "MANUAL")
    @Override
    public void onMessage(Message message, Channel channel) throws Exception {
        long deliveryTag = message.getMessageProperties().getDeliveryTag();
        try {
            // 1、接收消息
            System.out.println(message.getBody().toString());
            // 2、处理业务逻辑
            System.out.println("处理业务逻辑");
            // 失败的处理
            int i = 3/0;
            // 手动签收
            channel.basicAck(deliveryTag,true);
        } catch (Exception e) {
            // 拒接签收 第三个参数：requeue：重回队列，设置成true，那么消息会回到queue，会重新发送消息给消费端。
            // 出错的话，就会一直进行执行，重新尝试
            channel.basicNack(deliveryTag,true,true);
        }
    }
}

3.3 运行结果

运行int i = 3/0; 会一直出错，然后就会进行报错的处理

在这里插入图片描述

4、消费端限流 (流量削缝)

4、消费端限流
在这里插入图片描述
当我们处理信息的A系统每秒只能处理1000个请求，但是用户真正的请求每秒可以达到5000次，为了防止A系统宕机，我们先把数据存放在MQ中，然后A系统每秒从MQ中拉取1000个来进行处理。

4.1、概述

  1、配置文件中要设置成手动： acknowledge-mode: manual
  2、配置文件中要设置拉取条数： prefetch: 1
  3、消费者进行签收处理：channel.basicAck

4.2、配置文件

spring:
  rabbitmq:
    host: 192.168.92.134
    port: 5672
    username: zww
    password: 123456
    listener:
      direct:
        acknowledge-mode: manual
        prefetch: 1

4.3、生产者发送10条数据

    /**
     * 发送10条消息的处理
     */
    @Test
    public void testReturn1(){
        // 设置交换机处理失败消息模式
        rabbitTemplate.setMandatory(true);
        rabbitTemplate.setReturnCallback(new RabbitTemplate.ReturnCallback(){
            /**
             * 消息失败了，会调用这个方法
             * 注意：要进行处理失败的处理  rabbitTemplate.setMandatory(true);
             */
            @Override
            public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
                // 失败的话，就要进行想对应的处理
            }
        });
        // 这里的key填的是错误的，这样就不能到Queue
        // 10条消息
        for (int i = 0; i < 10; i++) {
            rabbitTemplate.convertAndSend(EXCHANGE_NAME,"boot.confirm","传的信息:message confirm，第"+i);
        }
    }

4.4、消费者

/**
 * 服务质量保证
 * 限流机制： Consumer
 * 1、ack设置为手动确认
 * 2、listener-container配置属性
 * prefetch = 1，表示消费端每次从mq拉取1条消息进行消费，消费完毕之后，在拉取下一条
 * prefetch: 1
 */
@Component
public class QosListener implements ChannelAwareMessageListener {
    /**
     * ackMode = "MANUAL"要进行这个的设置，不然就还是自动的，那么就会有冲突，会出现错误
     * @param message
     * @param channel
     * @throws Exception
     */
    @org.springframework.amqp.rabbit.annotation.RabbitListener(queues = "boot_queue_confirm"
    ,ackMode = "MANUAL")
    @Override
    public void onMessage(Message message, Channel channel) throws Exception {

        Thread.sleep(1000);
        System.out.println("使用prefetch获取消息为: "+new String(message.getBody()));

        // 签收处理(如果没有签收，那么就只能消费一个信息)
        channel.basicAck(message.getMessageProperties().getDeliveryTag(),true);
    }
}

4.5、结果
一个一个的进行接收处理：
在这里插入图片描述

5、TTL存活时间过期时间

5、TTL存活时间过期时间

  1、把队列设置成带有ttl时间的队列，对整个队列消息统一过期
  2、消息的单独过期处理，当消息在队列头部时，会单独判断这一消息是否过期
  3、如果两者都进行设置了，会选择时间短的那个

5.1、生产者

配置文件：


@Configuration
public class RabbitMQConfigTTL {
    public static final String QUEUE_NAME = "boot_queue_confirm";
    public static final String EXCHANGE_NAME="boot_exchange_confirm";

    // 1、交换机的配置
    @Bean("bootExchange")
    public Exchange exchange(){
        //durable(true) 持久化，mq重启之后交换机还在
        return ExchangeBuilder.topicExchange(EXCHANGE_NAME).durable(true).build();
    }
    // 2、队列的配置
    @Bean("bootQueue")
    public Queue bootQueue(){
        // 消息10s之后，会自动过期
        return QueueBuilder.durable(QUEUE_NAME).ttl(10000).build();
    }

    // 3、绑定关系  Binging
    /**
     * 1、知道哪个队列
     * 2、知道哪个交换机
     * 3、设置对应的 routing key
     */
    @Bean
    public Binding bindQueueExchange(@Qualifier("bootQueue") Queue queue,@Qualifier("bootExchange") Exchange exchange){
        return BindingBuilder.bind(queue).to(exchange).with("boot.#").noargs();
    }
}

生产者无单独过期处理：

    @Test
    public void testReturnttl(){
        for (int i = 0; i < 10; i++) {
            rabbitTemplate.convertAndSend(EXCHANGE_NAME,"boot.confirm","ttl的处理："+i);
        }
    }

生产者队列过期处理：


    @Test
    public void testReturnttl(){
        // 消息后处理对象，设置一些消息的参数信息
        MessagePostProcessor messagePostProcessor = new MessagePostProcessor() {
            @Override
            public Message postProcessMessage(Message message) throws AmqpException {
                // 1、设置message的信息(消息的过期时间)
                message.getMessageProperties().setExpiration("5000");
                // 2、返回该消息
                return message;
            }
        };
        // 消息单独过期
        rabbitTemplate.convertAndSend(EXCHANGE_NAME,"boot.confirm","ttl的处理：",messagePostProcessor);
    }
}

5.2、显示结果

在这里插入图片描述

6、死信队列DLX

6、死信队列

6.1、消息成为死信队列的三种情况

 1、队列消息长度达到限制
 2、消费者拒接消费消息，basicNack/basicReject,并且不把消息重新放入原目标队列，requeue = false；
 3、原队列存在消息过期设置，消息到达超时时间未被消费

6.2、实现以下在这里插入图片描述

生产者 --> 正常交换机 —>正常队列（消息死信后）---->死信交换机---->死信队列 ---->消费者

6.3分析：

  // 正常队列和交换机
public static final String QUEUE_NAME = "boot_queue";
public static final String EXCHANGE_NAME="boot_exchange";
// 配置死信队列和死信交换机
public static final String QUEUE_NAME_DLX = "boot_queue_dlx";
public static final String EXCHANGE_NAME_DLX="boot_exchange_dlx";
配置：
    两个交换机正常配置，死信队列正常配置，正常队列配置时需要和死信交换机绑定。
绑定：
    交换机和队列进行绑定。

 队列核心配置：
  Map<String, Object> args = new HashMap<>(4);
    // 1、死信交换机名称
    args.put("x-dead-letter-exchange", EXCHANGE_NAME_DLX);
    // 2、死信交换机的key
    args.put("x-dead-letter-routing-key", "boot.dlx.hh");
    // 3、设置队列的过期时间
    args.put("x-message-ttl", 10000);
    // 4、设置队列的长度限制
    args.put("x-max-length",10);

生产者配置文件：

spring:
  rabbitmq:
    host: 192.168.92.134
    port: 5672
    username: zww
    password: 123456
    virtual-host: /
    publisher-confirm-type: correlated
    listener:
      direct:
        acknowledge-mode: manual
    publisher-returns: true

生产者配置类：

@Configuration
public class RabbitMQConfigDLX {
    // 正常队列和交换机
    public static final String QUEUE_NAME = "boot_queue";
    public static final String EXCHANGE_NAME="boot_exchange";

    // 配置死信队列和死信交换机
    public static final String QUEUE_NAME_DLX = "boot_queue_dlx";
    public static final String EXCHANGE_NAME_DLX="boot_exchange_dlx";

    // 1、交换机的配置
    @Bean("bootExchange")
    public Exchange exchange(){
        //durable(true) 持久化，mq重启之后交换机还在
        return ExchangeBuilder.topicExchange(EXCHANGE_NAME).durable(true).build();
    }

    // 死信交换机
    @Bean("ExchangeDLX")
    public Exchange exchangeDlx(){
        return ExchangeBuilder.topicExchange(EXCHANGE_NAME_DLX).durable(true).build();
    }


    // 2、正常队列和死信交换机
    @Bean("bootQueue")
    public Queue bootQueue(){
        Map<String, Object> args = new HashMap<>(4);
        // 1、死信交换机名称
        args.put("x-dead-letter-exchange", EXCHANGE_NAME_DLX);
        // 2、死信交换机的key
        args.put("x-dead-letter-routing-key", "boot.dlx.hh");
        // 3、设置队列的过期时间
        args.put("x-message-ttl", 10000);
        // 4、设置队列的长度限制
        args.put("x-max-length",10);
        return QueueBuilder.durable(QUEUE_NAME).withArguments(args).build();
    }

    // 死信队列配置
    @Bean("bootQueueDLX")
    public Queue bootQueueDLX(){
        return QueueBuilder.durable(QUEUE_NAME_DLX).build();
    }


    /**
     * 正常交换机绑定正常队列
     * 1、知道哪个队列
     * 2、知道哪个交换机
     * 3、设置对应的 routing key
     */
    @Bean
    public Binding bindQueueExchange(@Qualifier("bootQueue") Queue queue,@Qualifier("bootExchange") Exchange exchange){
        return BindingBuilder.bind(queue).to(exchange).with("boot.dlx.#").noargs();
    }

    // 死信交换机，和死信队列
    @Bean
    public Binding bindQueueExchangeDlx(@Qualifier("bootQueueDLX") Queue queue,@Qualifier("ExchangeDLX") Exchange exchange){
        return BindingBuilder.bind(queue).to(exchange).with("boot.dlx.#").noargs();
    }
}

生产者测试类：（测试3种死信）

    @Test
    public void test10(){
        // 1、测试过期时间 (10s，之后会跑到死信队列中)
        rabbitTemplate.convertAndSend("boot_exchange","boot.dlx.hh","死信测试：");

        // 2、测试长度，有10个消息在正常队列，有10个在死信队列
        for (int i = 0; i < 20; i++) {
            rabbitTemplate.convertAndSend("boot_exchange","boot.dlx.hh","死信测试："+i);
        }

        // 3、消息拒收 (让消费者不接受，)
        rabbitTemplate.convertAndSend("boot_exchange","boot.dlx.hh","死信测试：");
    }

消费者处理(接收的队列为死信):

@Component
public class DLXListener implements ChannelAwareMessageListener {
    /**
     * ackMode = "MANUAL"要进行这个的设置，不然就还是自动的，那么就会有冲突，会出现错误
     * @param message
     * @param channel
     * @throws Exception
     */
    @org.springframework.amqp.rabbit.annotation.RabbitListener(queues = "boot_queue_dlx"
    ,ackMode = "MANUAL")
    @Override
    public void onMessage(Message message, Channel channel) throws Exception {
        long deliveryTag = message.getMessageProperties().getDeliveryTag();
        try {
            // 1、接收消息
            System.out.println("获取到： "+new String(message.getBody()));
            // 2、处理业务逻辑
            System.out.println("处理业务逻辑");
            // 手动签收
            channel.basicAck(deliveryTag,true);
        } catch (Exception e) {
            // 拒接签收 第三个参数：requeue：重回队列，设置成true，那么消息会回到queue，会重新发送消息给消费端。
            System.out.println("出现异常，拒绝接收。。不重回队列");
            // 出错的话，就会一直进行执行，重新尝试
            channel.basicNack(deliveryTag,true,false);
        }
    }
}

运行结果测试：

1、测试过期时间 (10s，之后会跑到死信队列中)

在这里插入图片描述
10s之后(死信队列中多一条):

在这里插入图片描述

2、测试长度，有10个消息在正常队列，有10个在死信队列

在这里插入图片描述
3、消息拒收 (让消费者不接受,消费者出现错误然后不重回队列)
在这里插入图片描述

7、延迟队列 （TTL + DLX）

7、延迟队列

7.1、概述

  * 延迟队列：消息进入队列后不会立即被消费，只有到达指定时间后，才会被消费
  *  处理：TTL + 死信队列
  *   1、下单后，30min未支付，取消订单，回滚库存
  *   2、新用户注册成功7min后，发短信问候

流程： 订单系统->MQ延迟队列(30min后消费)->库存系统->判断订单状态->支付，未支付

MQ延迟队列：
交换机 ->TTL队列->死信交换机->死信队列->库存系统

在这里插入图片描述
7.2、生产者配置类

/**
 * 延迟队列：
 * 1、正常交换机和正常队列
 * 2、死信交换机和死信队列
 * 3、正常队列和死信交换机（核心配置）
 */
@Configuration
public class RabbitMQConfigDLXTTL {
    // 正常队列和交换机
    public static final String QUEUE_NAME = "order_queue";
    public static final String EXCHANGE_NAME="order_exchange";

    // 配置死信队列和死信交换机
    public static final String QUEUE_NAME_DLX = "order_queue_dlx";
    public static final String EXCHANGE_NAME_DLX="order_exchange_dlx";

    // 1、交换机的配置
    @Bean("bootExchange")
    public Exchange exchange(){
        return ExchangeBuilder.topicExchange(EXCHANGE_NAME).durable(true).build();
    }

    // 死信交换机
    @Bean("ExchangeDLX")
    public Exchange exchangeDlx(){
        return ExchangeBuilder.topicExchange(EXCHANGE_NAME_DLX).durable(true).build();
    }


    // 2、正常队列和死信交换机
    @Bean("bootQueue")
    public Queue bootQueue(){
        Map<String, Object> args = new HashMap<>(4);
        // 1、死信交换机名称
        args.put("x-dead-letter-exchange", EXCHANGE_NAME_DLX);
        // 2、死信交换机的key
        args.put("x-dead-letter-routing-key", "dlx.order.cancel");
        // 3、设置队列的过期时间
        args.put("x-message-ttl", 10000);
        // 4、设置队列的长度限制
        args.put("x-max-length",1000);
        return QueueBuilder.durable(QUEUE_NAME).withArguments(args).build();
    }

    // 死信队列配置
    @Bean("bootQueueDLX")
    public Queue bootQueueDLX(){
        return QueueBuilder.durable(QUEUE_NAME_DLX).build();
    }


    /**
     * 正常交换机绑定正常队列
     * 1、知道哪个队列
     * 2、知道哪个交换机
     * 3、设置对应的 routing key
     */
    @Bean
    public Binding bindQueueExchange(@Qualifier("bootQueue") Queue queue,@Qualifier("bootExchange") Exchange exchange){
        return BindingBuilder.bind(queue).to(exchange).with("order.#").noargs();
    }

    // 死信交换机，和死信队列
    @Bean
    public Binding bindQueueExchangeDlx(@Qualifier("bootQueueDLX") Queue queue,@Qualifier("ExchangeDLX") Exchange exchange){
        return BindingBuilder.bind(queue).to(exchange).with("dlx.order.#").noargs();
    }
}

    // 生产者测试类
    @Test
    public void test11(){
        // 延迟队列，10s之后，才会进行接收处理
        rabbitTemplate.convertAndSend("order_exchange","order.message","延迟队列信息：id=1,time=2001");
    }

7.3、消费者

/**
 * 延迟队列
 */
@Component
public class OrderListener implements ChannelAwareMessageListener {
    /**
     * ackMode = "MANUAL"要进行这个的设置，不然就还是自动的，那么就会有冲突，会出现错误
     * @param message
     * @param channel
     * @throws Exception
     */
    @org.springframework.amqp.rabbit.annotation.RabbitListener(queues = "order_queue_dlx"
    ,ackMode = "MANUAL")
    @Override
    public void onMessage(Message message, Channel channel) throws Exception {
        long deliveryTag = message.getMessageProperties().getDeliveryTag();
        try {
            // 1、接收消息
            System.out.println("获取到： "+new String(message.getBody()));
            // 2、处理业务逻辑
            System.out.println("数据库处理");
            // 手动签收
            channel.basicAck(deliveryTag,true);
        } catch (Exception e) {
            // 拒接签收 第三个参数：requeue：重回队列，设置成true，那么消息会回到queue，会重新发送消息给消费端。
            System.out.println("出现异常，拒绝接收。。不重回队列");
            // 出错的话，就会一直进行执行，重新尝试
            channel.basicNack(deliveryTag,true,false);
        }
    }
}

运行结果(10s后会进行消费处理)：

在这里插入图片描述
10s后：
在这里插入图片描述

智慧的猪-
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RabbitMQ从入门到进阶
01-30
7. 伸缩性：能够快速扩展或收缩以适应性能需求变化。 8. 吞吐量：衡量系统能处理的最大并发消息数量。 RabbitMQ基于AMQP（Advanced Message Queuing Protocol）协议，这是一种二进制协议，提供了标准化的消息服务。...
关于@RabbitListener注解自动ack的一些猜测
风吹草动
06-27 604
从网上获取到的信息@RabbitListener采用的是自动ack。
RabbitMQ进阶
qq_47910339的博客
05-18 1460
本文从四个方面来学习RabbitMQ进阶的知识,将会从问题的引出与解决递进学习 消息可靠性 死信交换机 惰性队列 MQ集群 我们会发现在消息传递的过程中是通过网络传输的, 那么只要是通过网络传输就会存在消息丢失的问题,那么如何解决消息的可靠性就是我们需要考虑的一个重要的问题. 其次对于一些消息我们就是想要延迟发送,这种场景我们在实际的开发中也是较长使用,比如:延迟发送短信、用户下单，如果用户在15 分钟内未支付，则自动取消、预约工作会议，20分钟后自动通知所有参会人员，等等
RabbitMQ进阶篇
最新发布
水蓝
07-02 971
> 开启生产者确认比较消耗MQ性能，一般不建议开启。而且大家思考一下触发确认的几种情况： > - 路由失败：一般是因为RoutingKey错误导致，往往是编程导致 > - 交换机名称错误：同样是编程错误导致 > - MQ内部故障：这种需要处理，但概率往往较低。因此只有对消息可靠性要求非常高的业务才需要开启，而且仅仅需要开启ConfirmCallback处理nack就可以了
SpringBoot 整合 RabbitMQ 使用direct交换机
m0_50163856的博客
09-03 290
依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> </dependency> 配置文件 # 连接地址 spring.rabbitmq.host=127.0.0.1 # 端口号 spring.rabbitmq.port=5672 # 账号 spring.
RabbitMq应答模式、配置简介、常见阻塞场景
weixin_50569525的博客
08-03 2693
rabbitmq应答模式、rabbitmq阻塞原因、配置prefetch count.前言、最近在生产上遇到一些消息队列的问题，翻阅了很多资料文档发现有不少的都是错误的，于是把自己从实践中得到的一些分享、记录在此；acknowledge-mode: none(无应答模式)在这种模式下，不管消费者异常消费，还是正常消费，MQ服务器中的队列都会自动删除已消费的消息acknowledge-mode: auto(自动应答模式)当mq的应答模式配置为auto,或者没有进行配置时，系统会默认为自动应答模式。...
RabbitMQ入门到进阶
qq_45464560的博客
04-04 1093
RabbitMQ入门到进阶
RabbitMQ入门到进阶(Spring整合RabbitMQ&SpringBoot整合RabbitMQ).doc
07-08
RabbitMQ入门到进阶(Spring整合RabbitMQ&SpringBoot整合RabbitMQ).doc
rabbitmq视频
09-21
- **交换机（Exchange）**：交换机是RabbitMQ的核心组件之一，它的作用是接收来自生产者的消息，并根据配置的规则将消息发送到一个或多个队列。 - **队列（Queue）**：队列用于存储消息，直到消费者获取这些消息。...
rabbitMQ_Demo_rabbitMQ_Demo_rabbitmq_boyyeu_DEMO_中间件_
10-04
**RabbitMQ 消息中间件详解** RabbitMQ 是一个开源的消息代理...以上就是关于 RabbitMQ 的入门到进阶知识，通过学习这些内容，开发者可以有效地利用 RabbitMQ 解决分布式系统中的通信问题，构建健壮和高效的软件架构。
GO语言进阶.docx
10-10
4-6 编码实战：“云存储”系统之快速实现访问鉴权接口+小结.mp4 4-7 关于静态资源访问404的问题【补漏.mp4 第05章 “云存储”系统之基于Hash计算实现秒传 5-1 Hash算法对比及秒传原理.mp4 5-2 用户文件表设计与...
rabbitMQ高级篇
DUAN_Y_Heng的博客
05-06 130
消息可靠性投递 在使用 RabbitMQ 的时候，作为消息发送方希望杜绝任何消息丢失或者投递失败场景。RabbitMQ 为我们提供了两种方式用来控制消息的投递可靠性模式。 消息传递： 生产到交换机到队列 两种方式：confirm 确认模式 return 退回模式 确认模式 spring: rabbitmq: host: 192.168.247.129 #开启rabbitMQ的生产方确认模式 publisher-confirm-type: correlated ..
RabbitMQ 消息确认机制（二）——消费端确认机制
qq_40438883的博客
10-22 5182
前言：上篇文章说了发送端消息确认机制，该篇介绍消费端消息确认机制。 消费端确认（在确保每个消息被正确消费的情况，此时才可以将broker 删除这个消息） 消费端消息机制默认是自动确认的，只要消息接收到，客户端会自动确认，服务端就会移除这个消息，但是该情况下存在问题： 当 ...
RabbitMq 消息确认机制详解
weixin_52278591的博客
02-01 5030
消息从发送，到消费者接收，会经理多个过程,其中的每一步都可能导致消息丢失，常见的丢失原因包括： 生产者发送的消未送达exchange 消息到达exchange后未到达queue 针对这些问题，RabbitMQ分别给出了解决方案： 生产者确认机制 mq持久化消费者确认机制 失败重试机制 ​
RabbitMQ手动确认模式(项目开发常用模式)
weixin_43822632的博客
08-11 8864
RabbitMQ 手动确认模式（日常项目开发常用模式）借鉴导言架构及工作原理项目实战 借鉴导言 此文借鉴多名CSDN用户博客，并将其博文中关于MQ常用的点，进行了归纳整理 借鉴博文来源：[小目标青年][爱吃烤面筋的鱼][dreamboycs][交换机] 架构及工作原理 MQ架构图 名词解释 Producer/Consumer producer 消息生产者 consumer 消息消费者 Queue(消息队列) 消息队列，提供了FIFO的处理机制，具有缓存消息的能力。rabbitmq中，队列消
RabbitMQ - 2
weixin_39505091的博客
10-23 986
Rabbitmq 高级特性
RabbitMQ中消息确认机制
李嘉图呀李嘉图的博客
01-27 4750
概要：RabbitMQ中间件的引入对于整个系统来说是一把双刃剑，在对系统进行解耦的同时也降低了消息的可靠性，但是对于某些系统来说我们又必须保证我们的消息是不会丢失的，因此rabbitmq给提供了以下一些功能来保证消息的可靠性，本文我们主要讲解消息可靠性中的 发送端确认机制以及 消费端确认机制 发送端确认机制 RabbitMQ引入了一种轻量量级的方式，叫发送方确认(publisher confirm)机制。生产者将信道设置成confirm(确认)模式，一旦信道进入confirm 模式...
RabbitMQ 消息Ack确认机制
hanbingge123的博客
01-14 1892
确认种类 RabbitMQ的消息确认有两种。 环境配置 消息发送确认：这种是用来确认生产者将消息发送给交换器，交换器传递给队列的过程中，消息是否成功投递。发送确认分为两步，一是确认是否到达交换器，二是确认是否到达队列。 消费接收确认。这种是确认消费者是否成功消费了队列中的消息。 为了测试，我们先配置rabbit环境 引入Maven依赖 <dependencies> <dependency> ...
SpringBoot集成RabbitMQ消息队列搭建与ACK消息确认入门
热门推荐
屎壳郎情调-成长日记
05-30 4万+
1.Windows下安装RabbitMQ的步骤详解+图解（erlang+RabbitMQ）2.SpringBoot集成RabbitMQ参考文章1.RabbitMQ介绍RabbitMQ是实现AMQP（高级消息队列协议）的消息中间件的一种，最初起源于金融系统，用于在分布式系统中存储转发消息，在易用性、扩展性、高可用性等方面表现不俗。RabbitMQ主要是为了实现系统之间的双向解耦而实现的。当生产者大量...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值