rabbitMQ高级

1.如何保证消息的可靠性

1.1消息的可靠投递

        在生产环境中由于一些不明原因，导致 rabbitmq 重启，在 RabbitMQ 重启期间生产者消息投递失败，导致消息丢失，需要手动处理和恢复。于是，我们开始思考，如何才能进行 RabbitMQ 的消息可靠投递呢？特别是在这样比较极端的情况，RabbitMQ 集群不可用的时候，无法投递的消息该如何处理呢？

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

• confirm 确认模式

• return 退回模式

消息从 producer 到 exchange 则会返回一个 confirmCallback 。

消息从 exchange-->queue 投递失败则会返回一个 returnCallback 。

默认rabbitmq不开启上面两种模式。

我们将利用这两个 callback 控制消息的可靠性投递 。 

消息从生产者到消费者的经历哪些组件:

生产者--交换机---队列---消费者

1.2confirm和return的实现

1. 设置ConnectionFactory的publisher-confirm-type: correlated开启 确认模式。

2. 使用rabbitTemplate.setConfirmCallback设置回调函数。当消息发送到exchange后回调confirm方法。在方法中判断ack，如果为true，则发送成功，如果为false，则发送失败，需要处理。

3. 设置ConnectionFactory的publisher-returns="true" 开启 退回模式。

4. 使用rabbitTemplate.setReturnCallback设置退回函数，当消息从exchange路由到queue失败后执行回调函数returnedMessage。

1.2.1confirm机制

（1）在application.properties开启confirm

#开启confirm机制 默认为none
spring.rabbitmq.publisher-confirm-type=correlated

 (2)设置rabbitTemplate的confirmCallback回调函数

/*
    * 使用confirm机制
    * （1）需要开启confirm机制。---配置文件
    * spring.rabbitmq.publisher-confirm-type=correlated
    * （2）为rabbitTemplate指定回调函数ConfirmCallback
    * */
    @Test
    public void test01(){
        rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback() {
            @Override
            public void confirm(CorrelationData correlationData, boolean ack, String cause) {
                //触发该方法
                if (!ack){
                    System.out.println("这个是confirm机制");
                    System.out.println("-----------"+ack);
                }
            }
        });
        rabbitTemplate.convertAndSend("topic_exchange021","lazy.aaa", "hahahahaha");
  }

 1.2.2return机制

（1）在application.properties开启confirm

#开启return机制
spring.rabbitmq.publisher-returns=true

（2）设置回调

  /*
    * 使用confirm机制
    * （1）需要开启confirm机制。---配置文件
     * spring.rabbitmq.publisher-returns=true
     * （2）为rabbitTemplate指定Return回调函数
    * */
    @Test
    public void test02(){
        rabbitTemplate.setReturnCallback(new RabbitTemplate.ReturnCallback() {
            @Override
            public void returnedMessage(Message message, int i, String s, String s1, String s2) {
                //当交换机到队列发消息失败时会触发
                System.out.println("replyCode:"+i);
                System.out.println("replyText:"+s);
                System.out.println("Message:"+message);
                System.out.println("===============================");
            }
        });
        rabbitTemplate.convertAndSend("topic_exchange02", "yxq.aaa", "hehehehehe");
    }

2.如何保证消息在队列中不丢失

(1)设置队列为持久化

(2)设置消息的持久化

3. 确保消息能可靠的被消费掉

ACK确认机制

多个消费者同时收取消息，收取消息到一半，突然某个消费者挂掉，要保证此条消息不丢失，就需要acknowledgement机制，就是消费者消费完要通知服务端，服务端才将数据删除

这样就解决了，即使一个消费者出了问题，没有同步消息给服务端，还有其他的消费端去消费，保证了消息不丢的case。

ACK的实现

ack指Acknowledge，确认。 表示消费端收到消息后的确认方式。 有三种确认方式： 自动确认：acknowledge="none" 手动确认：acknowledge="manual" 根据异常情况确认：acknowledge="auto"，（这种方式使用麻烦，并且不常用，不作讲解）

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

 （1）在application.properties开启confirm

#修改消费端，手动确认消息，默认为自动确定：none
spring.rabbitmq.listener.simple.acknowledge-mode=manual

（2）修改代码

@Component //交由容器创建并管理
public class MyListener {
    //basicAck:确认信息---rabbit服务端删除
    //basicNack:服务继续发送信息
    @RabbitListener(queues = {"topic_queue02"})//queues:表示监听的队列名字
    public void hello(Message message, Channel channel) throws IOException { //把监听的消息封装到Message类对象中
        long deliveryTag = message.getMessageProperties().getDeliveryTag();
        byte[] body = message.getBody();
        String s = new String(body);
        System.out.println("消息内容：" + s);
        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：是否要求rabbitmq服务重新发送消息
             * */
            channel.basicNack(deliveryTag, true, true);
        }
    }

总结: 如何保证消息的可靠性?

[1] 保证消息的可靠性投递: confirm机制和return机制

[2] 队列中:---持久化

[3]使用ack机制保证消费者的可靠性消费。

4.延迟队列

4.1 TTL

TTL 全称 Time To Live（存活时间/过期时间）。

当消息到达存活时间后，还没有被消费，会被自动清除。

RabbitMQ可以对消息设置过期时间，也可以对整个队列（Queue）设置过期时间。

 /**
     * 队列设置了过期时间而消息也设置了过期时间---按照时间段的执行。
     */
    @Test
    public void test04(){

        /**
         * String exchange, String routingKey, Object message,
         * CorrelationData correlationData
         */
        Message message =new Message("咻咻咻".getBytes());
        message.getMessageProperties().setExpiration("10000");
        rabbitTemplate.send("topic_exchange","lazy.aaaa",message);
    }

小结:

1. 设置队列过期时间使用参数：x-message-ttl，单位：ms(毫秒)，会对整个队列消息统一过期。
2. 设置消息过期时间使用参数：expiration。单位：ms(毫秒)，当该消息在队列头部时（消费时），会单独判断这一消息是否过期。

        如果两者都进行了设置，以时间短的为准。

4.2 死信队列

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

什么样的消息会成为死信消息

1. 队列消息长度到达限制；

2. 消费者拒接消费消息，basicNack/basicReject,并且不把消息重新放入原目标队列,requeue=false；

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

队列绑定死信交换机：

4.3 延迟队列

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

需求：

1. 下单后，30分钟未支付，取消订单，回滚库存。

2. 新用户注册成功7天后，发送短信问候。

实现方式：

1. 定时器：性能差---每隔一段时间要进行数据库查询。

2. 延迟队列

通过消息队列完成延迟队列的功能

很可惜，在RabbitMQ中并未提供延迟队列功能。

但是可以使用：TTL+死信队列 组合实现延迟队列的效果。