rabbitMQ高级特性

	1.消息可靠性投递
	2.Consumer ACK
	3.消费端限流
	4. TTL
	5. 死信队列
	6. 延迟队列
	7. 消息的幂等性

消息可靠性传递

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

消息投递步骤：

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

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

confirm 确认模式
return  退回模式

product的confirm模式

（1）在配置文件中开启rabbitmq生产方式

spring:
  rabbitmq:
    host: 192.168.31.243
    #开启rabbitMQ的生产方确认模式
    #correlated ：发布消息成功到交换机后触发回调方法
    #none:禁用发布确认模式（默认）
    publisher-confirm-type: correlated

(2) 代码实现

@SpringBootTest
public class RabbitLevel {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    public void productConfirm(){
        rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback() {
            @Override
            /*设置rabbitTemplate的确认回调函数。如果消息到达交换机则返回true,如果消息没有到达交换机则返回一个false*/
            public void confirm(CorrelationData correlationData, boolean ack, String cause) {
                if (ack){ //消息到达交换机
                    System.out.println("成功-->"+ack);
                }else {//消息未到达交换机
                    System.out.println("失败-->"+cause+","+ack);
                }
            }
        });
        //发送消息
        rabbitTemplate.convertAndSend("exchange1","","hello confirm");
    }
}

product的退回模式(returns)

（1）在配置文件中开启rabbitmq生产方式

 #开启发布者退回模式
    publisher-returns: true

（2）代码实现

@Test
    public void returnConfirm(){
        rabbitTemplate.setReturnsCallback(new RabbitTemplate.ReturnsCallback() {
            @Override
            //只要交换机到队列失败时才会触发该方法
            //可以继续发送也可以取消相应的业务功能
            public void returnedMessage(ReturnedMessage returned) {
                System.out.println("消息从交换机到队列发生了失败,错误是--->"+returned.getReplyText());
            }
        });
        // 发送消息                                                        //错误的路由
        rabbitTemplate.convertAndSend("exchangeDirct","qwertasdf","hello returns");
    }

Consumer ACK

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

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

server:
  port: 8081
spring:
  rabbitmq:
    host: 192.168.31.243
    listener:
      simple:
        #manual:用户必须通过具有频道意识的侦听器进行确认
        #none:自动提交 默认为ture
        #auto:容器将根据侦听器是否正常返回或引发异常来发出确认
        acknowledge-mode: manual

代码实现

@Component
public class ListenerConsumer {


    @RabbitListener(queues = "queue_Dirct02")
    public void consumerAck(Message message,Channel channel) throws Exception{

        //获取信息的唯一标识
        long deliveryTag = message.getMessageProperties().getDeliveryTag();

        //消费的消息
        byte[] body = message.getBody();
        String str = new String(body);
        System.out.println(str);

        try{
//            int c = 10/0;
            System.out.println("处理业务逻辑"); //此时如果这里出现一个异常,消息接收到，业务处理出现异常，那么该消息就会丢失
            // long deliveryTag, 表示的标识
            // boolean multiple:是否允许多确认
            channel.basicAck(deliveryTag,true);//处理完业务再消费掉
        }catch (Exception e){
            // long deliveryTag, 表示的标识
            // boolean multiple:是否允许多确认
            // requeue: 是否让队列再次发送该消息
            channel.basicNack(deliveryTag,true,true);
        }
    }
}

消费端限流

(1) 在配置文件中配置读取个数

 #prefetch:每个使用者可以处理的未确认消息的最大数量
        prefetch:5

(2)代码实现

@RabbitListener(queues = "queue_Dirct02")
    public void consumerAck(Message message,Channel channel) throws Exception{

        //获取信息的唯一标识
        long deliveryTag = message.getMessageProperties().getDeliveryTag();

        //消费的消息
        byte[] body = message.getBody();
        String str = new String(body);
        System.out.println(str);

        try{
//            int c = 10/0;
            System.out.println("处理业务逻辑"); //此时如果这里出现一个异常,消息接收到，业务处理出现异常，那么该消息就会丢失
            // long deliveryTag, 表示的标识
            // boolean multiple:是否允许多确认
//            channel.basicAck(deliveryTag,true);//处理完业务再消费掉
        }catch (Exception e){
            // long deliveryTag, 表示的标识
            // boolean multiple:是否允许多确认
            // requeue: 是否让队列再次发送该消息
            channel.basicNack(deliveryTag,true,true);
        }
    }

TTL 设置过期时间

(1) 设置消息的过期；该消息必须在队列的头部时才会被移除
(2) 代码实现

 @Test
    public void setTTl(){

        MessagePostProcessor messagePostProcessor = new MessagePostProcessor() {
            @Override
            public Message postProcessMessage(Message message) throws AmqpException {
                //设置消息过期时间
                message.getMessageProperties().setExpiration("20000");
                return message;
            }
        };
        //exchange:交换机
        //routingKey:路由 key
        //message:发消息
        //messagePostProcessor :消息后处理器
        rabbitTemplate.convertAndSend("myexchange","","hello returns",messagePostProcessor);

    }

增加

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

(1) 代码实现

@Configuration
public class RabbitConfig {
    private final String exchange_name="myExchange";
    private final String queue_name="myQueue";

    //交换机
    @Bean
    public Exchange exchange(){
        return new FanoutExchange(exchange_name,true,false);
    }

    //队列
    @Bean
    public Queue queue(){
                                                            //队列消息 过期时间
        return QueueBuilder.durable(queue_name).withArgument("x-message-ttl",20000).build();
    }

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

死信队列

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

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

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

队列绑定死信交换机：

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

（1）创建队列\交换机和死信队列和死信交换机

@Configuration
public class RabbitConfiguration {

    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 Exchange exchange(){
        return ExchangeBuilder.directExchange(EXCHANGE).build();
    }
    //死信交换机
    @Bean
    public Exchange deadExchange(){
        return ExchangeBuilder.directExchange(DEAD_EXCHANGE).build();
    }

    //队列
    @Bean
    public Queue queue(){
        return QueueBuilder.durable(QUEUE)
                .withArgument("x-message-ttl",10000) //设置队列消息超时时间
                .withArgument("x-max-length",10)  //队列最大长度
                .withArgument("x-dead-letter-exchange",DEAD_EXCHANGE) //队列连接的死信交换机
                .withArgument("x-dead-letter-routing-key","error") //与私信交换机的路由key
                .build();
    }

    //死信队列
    @Bean
    public Queue deadQueue(){
        return QueueBuilder.durable(DEAD_QUEUE).build();
    }

    //绑定
    @Bean
    public Binding binding(Exchange exchange,Queue queue){
        return BindingBuilder.bind(queue).to(exchange).with("error").noargs();
    }

    @Bean
    public Binding deadBinding(Exchange deadExchange,Queue deadQueue){
        return BindingBuilder.bind(deadQueue).to(deadExchange).with("error").noargs();
    }


}

第一种 超时未处理到达死信队列(测试)

@SpringBootTest
public class TestDead {

    @Resource
    private RabbitTemplate rabbitTemplate;

    @Test
    public void testDead(){
       for (int i = 0; i < 10; i++) {
            //发送消息                    //此时 因为未消费 加上队列有设置超时时间  所以 在10s之后进入到死信队列中
            rabbitTemplate.convertAndSend("exchange","error","hello 超市未消费滴");
        }
}

过了10s钟

用视图化界面读取一下

第二种 队列消息长度到达限制

(1.) 发送消息

@SpringBootTest
public class TestDead {

    @Resource
    private RabbitTemplate rabbitTemplate;

    @Test
    public void testDead(){
        //这里循环了15次  设置的最大长度为10  所以超出的5个会到死信队列里
        for (int i = 0; i < 15; i++) {
            //发送消息                    //此时 因为未消费 加上队列有设置超时时间  所以 在10s之后进入到死信队列中
            rabbitTemplate.convertAndSend("exchange","error","hello 超市未消费滴");
        }
    }
}

第三种 消费者拒接消费消息

basicNack/basicReject,并且不把消息重新放入原目标队列,requeue=false；

(1) 配置文件中配置手动接收

listener:
      simple:
        #设置手动接收
        acknowledge-mode: manual

(2) producer发送消息

@SpringBootTest
public class TestDead {

    @Resource
    private RabbitTemplate rabbitTemplate;

    @Test
    public void testDead(){
        //这里循环了15次  设置的最大长度为10  所以超出的5个会到死信队列里
        for (int i = 0; i < 20; i++) {
            //发送消息                    //此时 因为未消费 加上队列有设置超时时间  所以 在10s之后进入到死信队列中
            rabbitTemplate.convertAndSend("exchange","error","hello 超市未消费滴");
        }
    }
}

（2）消费者代码

@Component
public class ConsumerL {

    @RabbitListener(queues = "queue")
    public void send(Message message , Channel channel){
        //唯一标识
        long tag = message.getMessageProperties().getDeliveryTag();
        //获取消息
        byte[] body = message.getBody();
        String s = new String(body);
        System.out.println(s);

        try {
            //拒绝接收消息
            channel.basicNack(tag,false,false);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

延迟队列

虽然rabbitmq未提供延迟队列功能，但可以使用TTL+死信队列完成

@SpringBootTest
public class TestDead {

    @Resource
    private RabbitTemplate rabbitTemplate;

    @Test
    public void testDead(){
            //发送消息                    //此时 因为未消费 加上队列有设置超时时间  所以 在10s之后进入到死信队列中
            rabbitTemplate.convertAndSend("exchange","error","下单成功");
    }
}

过三十分钟后(比喻)

消息幂等性保障

幂等性：用户对于同一操作发起的一次请求或者多次请求的结果是一致的，不会因为多次点击而产生了副作用

让每个消息携带一个全局的唯一ID，即可保证消息的幂等性，具体消费过程为：

1.消费者获取到消息后先根据id去查询redis/db是否存在该消息
2.如果不存在，则正常消费，消费完毕后写入redis/db
3.如果存在，则证明消息被消费过，直接丢弃。

使用redis的缓存

<dependency> 
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-data-redisartifactId>
        dependency>

代码实现

@Component
public class ConsumerL {

    @Autowired
    private RedisTemplate redisTemplate;

    @RabbitListener(queues = "dead_queue")
    public void send(Message message , Channel channel){
        //得到信息的唯一标识
        long id = message.getMessageProperties().getDeliveryTag();
        //获取是否有id
        Object o = redisTemplate.opsForValue().get(id);
        //判断是否为空
        if (o==null){
            System.out.println("处理业务,完成业务功能");
            redisTemplate.opsForValue().set(id,"obj"); //设置到缓存 设置后 确认返回队列出现异常，再次消费时，已经有唯一id 则让队列直接删除
            try {
                channel.basicAck(id,true);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }else {
            try {
                channel.basicAck(id,true);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }


    }
}