Spring Boot RabbitMQ 消息确认

引言

我们知道，如果要保证消息的可靠性，需要对消息进行持久化处理，然后消息持久化处理，然而消息持久化除了需要代码的设置之外，还有一个重要步骤是至关重要的，那就是保证你的消息顺利进入BroKer（代理服务器）如图所示：

此图是我转载的，如有侵权请告知

正常情况下，如果消息经过交换器进入队列就可以完成消息的持久化，但如果消息在没有到达broker之前出现意外，那就造成消息丢失，有没有办法可以解决这个问题？

RabbitMQ有两种方式解决这个问题：

我这里呢只讲第二种，关于第一种大家可以自行百度，个人觉得第一种基本用不到，缺点太明显，不用我说都知道，使用了事务太影响速度，非事务模式比事务模式快大约150倍，大家也可以自己去尝试下。

Comfirm模式（消息发送确认）

发送的消息怎么样才算失败或成功呢？我们又如何确认？

• 当消息无法路由到队列时，确认消息路由失败，消息成功路由时，当需要发送的队列都发送成功后，进行确认消息，对于持久化队列意味着写入磁盘，对于镜像队列以为着所有镜像接收成功。

ConfirmCallback

•    通过实现ConfirmCallback接口，消息发送到Broker后触发回调，确认消息是否到达Borker服务器，也就是只确认是否正确到达Exchange中。

ReturnCallback

•   通过实现ReturnCallBack接口，启动消息失败返回，比如路由不到队列时触发回调。

代码实现

• 配置文件

      默认情况下消息消费者是自动确认消息的，如果要手动确认消息则需要修改确认模式为manual

spring:
  rabbitmq:
    listener:
      simple:
        acknowledge-mode: manual

• 配置类

@Slf4j
@Component
public class CallBackProducer implements RabbitTemplate.ConfirmCallback, RabbitTemplate.ReturnCallback {


    private RabbitTemplate rabbitTemplate;

    @Autowired
    public CallBackProducer(RabbitTemplate rabbitTemplate) {
        this.rabbitTemplate = rabbitTemplate;
        this.rabbitTemplate.setConfirmCallback(this);
    }
    //这是发送的方法，封装在这里面了，外面我们需要发送信息给Exchange直接调用这个方法
    public void send(String exchange, String routingKey, Object object, CorrelationData correlationData) {
        this.rabbitTemplate.convertAndSend(exchange, routingKey, object, correlationData);
    }

    /**
     * 发送后的回调函数
     *
     * @param correlationData
     * @param ack
     * @param cause
     */
    @Override
    public void confirm(CorrelationData correlationData, boolean ack, String cause) {
        if(ack){
            log.info("消息发送exchange成功,id:{}",correlationData.getId());
        }else{
           log.info("消息发送exchange失败,id:{},原因:{}" ,correlationData.getId(), cause);
        }
    }

    /**
     * 消息发送失败的回调函数
     *
     * @param message
     * @param replyCode
     * @param replyText
     * @param exchange
     * @param routingKey
     */
    @Override
    public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
        String correlationId = message.getMessageProperties().getCorrelationId();
        log.info("消息:{}发送失败，应答码:{} 原因:{} 交换机:{} 路由键:{}", correlationId, replyCode, replyText, exchange, routingKey);
    }
}

• 发送者

/**
 * 发送者
 * 路由消息模式（可具有模式匹配符的routing-key绑定起来）
 */
@Component
public class TopicSender {

    @Autowired
    CallBackProducer callBackProducer;

    /**
     * topic
     * 1.交换机
     * 2.routingkey
     * 3.消息内容
     *
     * @param user
     */
    public void topicSend(User user) {
        CorrelationData correlationData = new CorrelationData(UUID.randomUUID().toString());
        callBackProducer.send("topic-exchange", "topic.receiver", user, correlationData);
        callBackProducer.send("topic-exchange", "topic.receivers", user, correlationData);
    }

}

• 消费者 

@Slf4j
@Component
public class TopicReceiver2 {

    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(value = "user-topics", durable = "true"),
            exchange = @Exchange(name = "topic-exchange", durable = "true", type = "topic"),
            key = "topic.*"))
    @RabbitHandler
    public void topicProcess2(@Payload User user,
                              @Headers Map<String, Object> headers,
                              Channel channel) throws Exception {
        //出现错误拒绝消息
        if (headers.get("error") != null) {
            channel.basicReject((Long) headers.get(AmqpHeaders.DELIVERY_TAG), false);
            return;
        }
        //确认消息
        Long deli = (Long) headers.get(AmqpHeaders.DELIVERY_TAG);
        channel.basicAck(deli, false);
        log.info(user + "topics消息被消费");
    }
}

• 消费者二 

@Slf4j
@Component
public class TopicReceiver1 {

    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(value = "user-topic", durable = "true"),
            exchange = @Exchange(name = "topic-exchange", durable = "true", type = "topic"),
            key = "topic.receiver"))
    @RabbitHandler
    public void topicProcess1(User user){
          log.info(user+"topic消息被消费");
    }
}

 

 basicAck方法是确认消息的，它有两个参数：

1. deliveryTag（唯一标识ID）：当一个消费者向RabbitMQ注册后，会建立起一个Channel，RabbitMQ会用basic.deliver方法向消费者推送消息，这个方法携带了一个delivery tag，他代表了RabbitMQ向该Channel投递的这条消息的唯一标识ID，是一个单调递增的正整数，delivery tag的范围也仅仅局限于Channel。
2. multiple：为了减少网络流量，手动确认可以批量处理，当该参数为true时，则可以一次性确认delivery_tag小于等于传入值的所有消息。
3.  

 

•  执行结果

     我们看这个执行结果 ，有两条显示消费了，其实并没有，我们的消费者二没有确认消息，所以我们只消费了一条

 

      

     我里面原先有十条 ，我执行了一次变成十一条，说明我们没有进行消息确认他就不会发送。

     我太菜了  只能讲成这样。谢谢，麻烦看到的点个小心，让我能继续写下去。帮助更多的小白。

       Spring Boot RabbitMQ 五种模式

       Spring Boot RabbitMQ 工作原理