RabbitMQ高级篇特性

RabbitMQ高级篇特性

1.消息可靠性投递

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

消息投递步骤：

1.生产者(channel)---->交换机------>队列中

为了确保消息的可靠性投递，提供了如下两种方式

1.confirm 确认模式

2.return 退回模式

1.1确认模式

confirm确认模式

spring:
  rabbitmq:
    host: 192.168.75.129
    #开启rabbitMQ的生产方确认模式
    publisher-confirm-type: correlated

设置RabbitTemplate的确认回调函数

 @Autowired
    private RabbitTemplate rabbitTemplate;
    
	/**
     * 保证发送到交换机的可靠性
     * 1.开启confirm模式，publisher-confirm-type: correlated
     * 2.设置rabbitTemplate的确认回调函数。 如果消息达到交换机则返回true，如果消息没有达到交换机则返回false
     */
    @Test
    public void testConfirm() {

        rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback() {
            @Override
            public void confirm(CorrelationData correlationData, boolean b, String s) {
                if (b == false) {//消息没有达到交换机 根据业务需求。
                    System.out.println("继续发送消息");
                    //取消订单
                }
            }
        });
        rabbitTemplate.convertAndSend("129ban_exchange1", "", "hello confirm");
    }

1.2退回模式

开启发布者的回退机制模式

server:
  port: 8001

spring:
  rabbitmq:
    host: 192.168.49.197
    #开启rabbitMQ的生产方确认模式
    publisher-confirm-type: correlated
    # 开启发布者退回模式
    publisher-returns: true

设置RabbitTemplate回调的函数

/**
     *  退回模式:
     *     1. 开启退回模式。
     *     2. 设置RabbitTemplate的退回回调函数。
     */
    @Test
    public void testReturn(){
            rabbitTemplate.setReturnsCallback(new RabbitTemplate.ReturnsCallback() {
                @Override
                public void returnedMessage(ReturnedMessage returnedMessage) {
                    //只要交换机到队列失败时才会触发该方法。 可以继续发送也可以取消相应的业务功能。
                    System.out.println("消息从交换机到队列失败"+returnedMessage.getReplyText());
                }
            });
        rabbitTemplate.convertAndSend("129ban_exchange_direct","error","hello confirm2");
    }

保证消息可靠性：

（1）保证消息从发送者到交换机的可靠性： 使用Confirm确认机制。
（2）保证消息从交换机到队列的可靠性; 使用return回退机制。
（3）消息在队列中的可靠性。  设置队列和消息的持久化。
（4）保证消息从队列到消费者的可靠性。  使用消费端的手动确认机制。

2. Consumer ACK

在RabbitMQ中指代的是消费者收到消息后确认的一种行为，关注点在于消费者能否实际接收到MQ发送的消息。
自动确认acknowledge="none"：当消费者接收到消息的时候，就会自动给到RabbitMQ一个回执，告诉MQ我已经收到消息了，不在乎消费者接收到消息之后业务处理的成功与否。

（1）消费端配置手动开启确认模式

spring:
  rabbitmq:
    host: 192.168.49.197
    listener:
      simple:
        #表示手动确认
        acknowledge-mode: manual
      # 表示自动确认模式
        # acknowledge-mode: none

（2）测试代码如下：

 @RabbitListener(queues = "129ban_queue_direct01")
    public void listener(Message message, Channel channel) throws Exception{
        long deliveryTag = message.getMessageProperties().getDeliveryTag();

        byte[] body = message.getBody();
        String msg=new String(body);

        System.out.println(msg);
        try {
//            int c = 10 / 0;
            System.out.println("处理业务逻辑");
            //消费端手动确认消息
            //long deliveryTag, 表示的标识。
            // boolean multiple:是否允许多确认
            channel.basicAck(deliveryTag,true); //从队列中删除该消息。
        }catch (Exception e){
            //(long deliveryTag, boolean multiple, boolean requeue: 是否让队列再次发送该消息。
            channel.basicNack(deliveryTag,true,true);
        }

    }

3. 消费端限流

（1）手动确认模式。

（2）配置限流的个数。

spring:
  rabbitmq:
    host: 192.168.49.197
    listener:
      simple:
        #表示手动确认
        acknowledge-mode: manual
      # 表示自动确认模式
        # acknowledge-mode: none
        # 设置每次消费的个数。
        prefetch: 100

测试代码：

package com.aaa.listener;

import com.rabbitmq.client.Channel;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;
@Component
public class MyListener {

    @RabbitListener(queues = "129ban_queue_direct01")
    public void listener(Message message, Channel channel) throws Exception{

        long deliveryTag = message.getMessageProperties().getDeliveryTag();

        byte[] body = message.getBody();
        String msg = new String(body);

        System.out.println(msg);
        try {
            System.out.println("处理业务逻辑");
             System.out.println("处理业务逻辑");
            //消费端手动确认消息
            //long deliveryTag, 表示的标识。
            // boolean multiple:是否允许多确认
            channel.basicAck(deliveryTag,true); //从队列中删除该消息。
        }catch (Exception e){

            //(long deliveryTag, boolean multiple, boolean requeue: 是否让队列再次发送该消息。
            channel.basicNack(deliveryTag,true,true);
        }
    }
}

4.TTL

TTL是一个ip协议的值，它告诉网络，数据包在网络中的时间是否太长而应被丢弃。有很多原因使包在一定时间内不能被传递到目的地。
1.设置队列过期;
2.设置消息的过期；该消息必须在队列的头部时才会被移除。

 //为队列设置过期时间  相当于该队列里面的消息都由过期时间
    @Test
    public void testSend(){
        rabbitTemplate.convertAndSend("myexchange","","hello xiaoxi");
    }

    //设置消息的过期时间 如果由设置了队列的过期时间 也设置了消息的过期时间 谁的过期时间短 以谁为准。
    //该消息必须在头部才能从队列中移除。
    @Test
    public void testSend02(){

        for(int i=0;i<10;i++) {
            if(i==3){
                MessagePostProcessor messagePostProcessor = new MessagePostProcessor() {
                    @Override
                    public Message postProcessMessage(Message message) throws AmqpException {
                        message.getMessageProperties().setExpiration("20000");
                        return message;
                    }
                };
                //String exchange, String routingKey, Object message, MessagePostProcessor messagePostProcessor
                rabbitTemplate.convertAndSend("myexchange", "", "hello xiaoxi"+i, messagePostProcessor);
            }else {

                //String exchange, String routingKey, Object message, MessagePostProcessor messagePostProcessor
                rabbitTemplate.convertAndSend("myexchange", "", "hello xiaoxi"+i);
            }
        }
    }

5. 通过代码创建队列和交换机以及绑定。

@Configuration
public class RabbitConfig {

    private final String exchange_name="myexchange";
    private final String queue_name="myqueue";
    //创建交换机对象
    @Bean
    public Exchange exchange(){
        Exchange exchange= ExchangeBuilder.fanoutExchange(exchange_name).durable(true).build();
        return exchange;
    }

    //创建队列
    @Bean(value = "queue")
    public Queue queue(){
        Queue queue= QueueBuilder.durable(queue_name).withArgument("x-message-ttl",20000).build();
        return queue;
    }

    //绑定交换机和队列
    @Bean
    public Binding binding(Queue queue,Exchange exchange){
        return BindingBuilder.bind(queue).to(exchange).with("").noargs();
    }
}

6. 死信队列

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

消息成为死信无非是以下几种情况：

1.消息被拒绝签收（Nack），并且不允许重回队列。
2.TTL设定的消息有效时间过期。
3.实际消息数大于队列最大限制数，那么超出最大限制的消息都将会是死信。

队列绑定死信交换机：
给队列设置参数： x-dead-letter-exchange 和 x-dead-letter-routing-key

如果出现死信队列的处理方式：
其实，我们可以把这些死信放到自定义的死信队列里去。
“死信队列”，顾名思义，就是存放死信的队列。其实它和普通的队列并没有太大差别，唯一的区别就是他的routingkey是"#"。也就是说：只要你路由到我这个死信队列，我都接收。

package com.aaa.config;

import org.springframework.amqp.core.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;


@Configuration
public class RabbitConfig {
    private final String EXCHANGE="exchange";
    private final String DEAD_EXCHANGE="dead_exchange";
    private final String QUEUE="queue";
    private final String DEAD_QUEUE="dead_queue";


    @Bean
    public Queue queue(){
        return QueueBuilder
                .durable(QUEUE)
                .withArgument("x-message-ttl",20000)
                .withArgument("x-max-length",10)
                .withArgument("x-dead-letter-exchange",DEAD_EXCHANGE)
                .withArgument("x-dead-letter-routing-key","error")
                .build()
                ;
    }

    @Bean
    public Queue dead_queue() {
        return QueueBuilder.durable(DEAD_QUEUE).build();
    }

    @Bean
    public Exchange exchange(){
        return ExchangeBuilder.directExchange(EXCHANGE).build();
    }

    @Bean
    public Exchange dead_exchange(){
        return ExchangeBuilder.directExchange(DEAD_EXCHANGE).build();
    }


    @Bean
    public Binding binding(){
        return BindingBuilder.bind(queue()).to(exchange()).with("error").noargs();
    }

    @Bean
    public Binding dead_binding(){
        return BindingBuilder.bind(dead_queue()).to(dead_exchange()).with("error").noargs();
    }

}

7. 延迟队列

顾名思义，延迟队列就是进入该队列的消息会被延迟消费的队列。而一般的队列，消息一旦入队了之后就会被消费者马上消费。

应用场景：

1、延迟消费。比如：
    用户生成订单之后，需要过一段时间校验订单的支付状态，如果订单仍未支付则需要及时地关闭订单。
    用户注册成功之后，需要过一段时间比如一周后校验用户的使用情况，如果发现用户活跃度较低，则发送邮件或者短信来提醒用户使用。

2、延迟重试。比如消费者从队列里消费消息时失败了，但是想要延迟一段时间后自动重试。
如果不使用延迟队列，那么我们只能通过一个轮询扫描程序去完成。这种方案既不优雅，也不方便做成统一的服务便于开发人员使用。但是使用延迟队列的话，我们就可以轻而易举地完成。

8.消息幂等性保障

什么是幂等？
一个操作任意执行多次与执行一次的结果相同，这个操作就是幂等

为保证消息的可达性，超时、重传、确认机制可能导致消息总线、或者业务方收到重复的消息，从而对业务产生影响。

幂等性: 无论执行多少次，得到的结果和第一次都是相同的。
保证消息不被重复消费。
1.消费者获取到消息后先根据id去查询redis/db是否存在该消息
2.如果不存在，则正常消费，消费完毕后写入redis/db
3.如果存在，则证明消息被消费过，直接丢弃。