RabbitMQ高级特性-CSDN博客

本文链接：https://blog.csdn.net/m0_48639280/article/details/108437510

消息的可靠投递

概念

在使用 RabbitMQ 的时候，作为消息发送方希望杜绝任何消息丢失或者投递失败场景。RabbitMQ 为我们提
供了两种方式用来控制消息的投递可靠性模式。

confirm 确认模式
return 退回模式

rabbitmq 整个消息投递的路径为：
producer—>rabbitmq broker—>exchange—>queue—>consumer

消息从 producer 到 exchange 则会返回一个 confirmCallback 。
消息从 exchange–>queue 投递失败则会返回一个 returnCallback 。
我们将利用这两个 callback 控制消息的可靠性投递

步骤：

设置ConnectionFactory的publisher-confirms=“true” 开启确认模式
使用rabbitTemplate.setConfirmCallback设置回调函数。当消息发送到exchange后回调confirm方法。在方法中判断ack，如果为true，则发送成功，如果为false，则发送失败，需要处理。
设置ConnectionFactory的publisher-returns=“true” 开启退回模式。
使用rabbitTemplate.setReturnCallback设置退回函数，当消息从exchange路由到queue失败后，如果设置了rabbitTemplate.setMandatory(true)参数，则会将消息退回给producer。并执行回调函数returnedMessage。
在RabbitMQ中也提供了事务机制，但是性能较差。

Consumer Ack

概念

ack指Acknowledge，确认。表示消费端收到消息后的确认方式。

有三种确认方式：

自动确认：acknowledge=“none” 默认方式
手动确认：acknowledge=“manual”
根据异常情况确认：acknowledge=“auto”，（这种方式使用麻烦）

其中自动确认是指，当消息一旦被Consumer接收到，则自动确认收到，并将相应 message 从 RabbitMQ 的
消息缓存中移除。但是在实际业务处理中，很可能消息接收到，业务处理出现异常，那么该消息就会丢失。如
果设置了手动确认方式，则需要在业务处理成功后，调用channel.basicAck()，手动签收，如果出现异常，则
调用channel.basicNack()方法，让其自动重新发送消息。

步骤：

在rabbit:listener-container标签中设置acknowledge属性，设置ack方式 none：自动确认，manual：手
动确认
如果在消费端没有出现异常，则调用channel.basicAck(deliveryTag,false);方法确认签收消息
如果出现异常，则在catch中调用 basicNack或 basicReject，拒绝消息，让MQ重新发送消息。
在application.yml配置文件中设置消息回退模式即可

spring:
  rabbitmq:
    host: 172.16.98.133 #主机ip
    port: 5672 #端口
    username: guest
    password: guest
    virtual-host: /
    publisher-confirms: true
    publisher-returns: true
    listener:
      simple:
        acknowledge-mode: manual  # 设置确认模式

消费者代码：

@Component
public class RabbimtMQListener {

    @RabbitListener(queues = "boot_queue")
    public void ListenerQueue(Message message, Channel channel) throws IOException {
        // 消息的标签
        long deliveryTag = message.getMessageProperties().getDeliveryTag();

        try {
            //System.out.println(message);
            System.out.println(new String(message.getBody()));
            System.out.println("处理业务逻辑");
            // 第二个参数 为是否签收多条消息
            channel.basicAck(deliveryTag,true);
        } catch (Exception e) {
            // 第三个参数：如果设置为true，则消息重新回到queue，broker会重新发送消息到消费端
            channel.basicNack(deliveryTag,true,true);
            //e.printStackTrace();
        }
    }

}

消费端限流

步骤

在<rabbit:listener-container> 中配置 prefetch属性设置消费端一次拉取多少消息(spring 设置) springboot在yml文件中设置
消费端的确认模式一定为手动确认。acknowledge=“manual”，只有手动签收之后才会拉去下一条消息

spring:
  rabbitmq:
    listener:
      simple:
        prefetch: 1  # 一次拉去多少消息
        acknowledge-mode: manual  # 设置确认模式

TTL

TTL 全称 Time To Live（存活时间/过期时间）。
当消息到达存活时间后，还没有被消费，会被自动清除。
RabbitMQ可以对消息设置过期时间，也可以对整个队列（Queue）设置过期时间。

步骤

设置队列过期时间使用参数：x-message-ttl，单位：ms(毫秒)，会对整个队列消息统一过期。
设置消息过期时间使用参数：expiration。单位：ms(毫秒)，当该消息在队列头部时（消费时），会单独判断这一消息是否过期。
如果两者都进行了设置，以时间短的为准。
队列过期后，会将队列所有消息全部消除。消息过期后，只有消息在队列顶端，才会判断其是否过期（提高效率）

死信队列

死信队列，英文缩写：DLX 。Dead Letter Exchange（死信交换机），当消息成为Dead message后，可以被重新发送到另一个交换机，这个交换机就是DLX。
在这里插入图片描述

消息成为死信的三种情况：

队列消息长度到达限制；（比如设置了只能存10条，那么第11条就会成为死信）
消费者拒接消费消息，basicNack/basicReject，并且不把消息重新放入原目标队列,requeue=false；

channel.basicNack(deliveryTag,true,false);   // requeue=false； 第三个参数

原队列存在消息过期设置，消息到达超时时间未被消费；

队列绑定死信交换机：

给队列设置参数： x-dead-letter-exchange 和 x-dead-letter-routing-key

死信交换机和死信队列和普通的没有区别，当消息成为死信后，如果该队列绑定了死信交换机，则消息会被死信交换机重新路由到死信队列。否则就会丢弃获取重发(丢弃还是重发看自己设置)。

延迟队列

延迟队列，即消息进入队列后不会立即被消费，只有到达指定时间后，才会被消费。

在这里插入图片描述

-------------------------------------------------------------基于SpringBoot演示------------------------------------------------------

消息生产端：

pom.xml

<!--1. 父工程依赖-->
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.1.4.RELEASE</version>
</parent>

<dependencies>
    <!--2. rabbitmq-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-amqp</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
    </dependency>
</dependencies>

application.yml

# 配置RabbitMQ的基本信息  ip 端口 username  password..
spring:
  rabbitmq:
    host: 192.168.93.129 # ip
    port: 5672
    username: xiao
    password: xiao
    virtual-host: /test

    publisher-confirms: true  # 开启生产端 到broker 的消息确认模式
    publisher-returns: true  #开启 交换机到 队列的消息确认

RabbitMQConfig.java 配置类


@Configuration
public class RabbitMQConfig {

    public static final String EXCHANGE_NAME = "boot_topic_exchange";
    public static final String QUEUE_NAME = "boot_queue";

    //1.交换机
    @Bean("bootExchange")
    public Exchange bootExchange(){
        // 需要什么类型就 . 什么类型，传入交换机名称
        // 是否持久化，其他设置可以 一直链式编程 .  调用，最后build 方法返回
        return ExchangeBuilder.topicExchange(EXCHANGE_NAME).durable(true).build();
    }

    //1.死信交换机-----------------------------------------
    @Bean("deadExchange")
    public Exchange deadExchange(){
        // 需要什么类型就 . 什么类型，传入交换机名称
        // 是否持久化，其他设置可以 一直链式编程 .  调用，最后build 方法返回
        return ExchangeBuilder.topicExchange("dead_topic_exchange").durable(true).build();
    }


    //2.Queue 队列  设置整个队列的过期时间------------------
    @Bean("bootQueue")
    public Queue bootQueue(){
        // withArgument("x-message-ttl","5000") 设置队列的过期时间
        return QueueBuilder.durable(QUEUE_NAME).withArgument("x-message-ttl",10000)
        .withArgument("x-dead-letter-exchange", "dead_topic_exchange") // 将队列和死信交换机进行绑定 
        .withArgument("x-dead-letter-routing-key", "dead.letter-routing-key") // 声明死信路由key，
        .build();
    }
    //2.Queue 队列-------------死信队列
    @Bean("deadQueue")
    public Queue deadQueue(){
        // withArgument("x-message-ttl","5000") 设置队列的过期时间
        return QueueBuilder.durable("dead_queue").withArgument("x-message-ttl","10000").build();
    }

    //3. 队列和交互机绑定关系 Binding
    /*基于队列绑定交换机，noargs不传入参数。with 路由规则
        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();
    }


    //  绑定 死信交换机 和死信队列--------------------死信交换机 和死信队列
    @Bean
    public Binding bindDeadExchange(@Qualifier("deadQueue") Queue queue, @Qualifier("deadExchange") Exchange exchange){
        return BindingBuilder.bind(queue).to(exchange).with("dead.#").noargs();
    }

}

ProviderTest.java 测试类

@SpringBootTest
@RunWith(SpringRunner.class)
public class ProviderTest {

    //1.注入RabbitTemplate
    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    public void testSend01(){
        //定义发送消息的回调------------------------------生产端到交换机
        rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback() {
            @Override
            public void confirm(CorrelationData correlationData, boolean ack, String cause) {
            	// correlationData 相关配置信息
            	// ack exchange 交换机是否成功收到了消息，true为成功  false 为失败
            	// cause 失败原因
                if (ack == true){
                    System.out.println("confirm方法执行了,,,,,,发送成功");
                }else{
                    System.out.println("confirm方法执行了,,,,,,,,,发送失败");
                    //  做一些处理 保证消息发送成功
                }
            }
        });
        rabbitTemplate.convertAndSend(RabbitMQConfig.EXCHANGE_NAME,"boot.haha","boot mq hello~~~");
    }


	/**
	*	1、开启回退模式
	*	2、设置ReturnCallback
	*	3、设置Exchange处理消息的模式
	*		1、如果消息没有路由到Queue，则丢弃消息（默认）
	*		2、如果消息没有路由到Queue，返回给消息发送方ReturnCallback
	*/
    @Test
    public void testSend02(){

        // 设置消息不丢弃  才会调用ReturnCallback方法
        rabbitTemplate.setMandatory(true);

        //定义发送消息的回调----------------------------------交换机到队列
        rabbitTemplate.setReturnCallback(new RabbitTemplate.ReturnCallback() {
            // 消息对象 错误码 错误信息 交换机名称 路由键
            @Override
            public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
                System.out.println("交换机到队列发送消息失败");
            }
        });
        rabbitTemplate.convertAndSend(RabbitMQConfig.EXCHANGE_NAME,"boot.haha","boot mq hello~~~");
    }


    @Test
    public void testSend03(){
        // 设置单个消息过期时间----------------------------------ttl
        rabbitTemplate.convertAndSend(RabbitMQConfig.EXCHANGE_NAME, "boot.haha", "boot mq hello~~~", new MessagePostProcessor() {
            @Override
            public Message postProcessMessage(Message message) throws AmqpException {
                //1.设置message的信息
                message.getMessageProperties().setExpiration("5000");//消息的过期时间
                return message;
            }
        });
    }
}