RabbitMQ 高级特性——消费者消费消息的确认及限流

最新推荐文章于 2023-05-13 12:20:01 发布

cj_eryue

最新推荐文章于 2023-05-13 12:20:01 发布

阅读量612

点赞数 1

分类专栏： rabbitmq 文章标签：队列 rabbitmq java spring

本文链接：https://blog.csdn.net/cj_eryue/article/details/113174748

版权

rabbitmq 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

1.消息的可靠性消费

2.消费端限流

1.消息的可靠性消费

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

共有三种确认方式：

自动确认：acknowledge="none"
手动确认：acknowledge="manual"
根据异常情况确认：acknowledge="auto"（这种方式使用比较麻烦，不作解释）

其中自动确认是指当消息一旦被Consumer接收到后，则自动确认收到，并将相应消息从rabbitmq的消息缓存中移除。但是在实际业务处理中，很可能消息接收正常，但是业务处理的时候出现了异常（其实别说出现异常了，说一个项目上的真实案例，消费者在消费消息的时候，我给服务重启了，如果使用的是自动确认模式，或者返回ack的位置不对，都会造成消息无法正常被消费），那么该消息就会丢失。如果设置了手动确认模式，则需要在业务处理成功后，调用channel.basicAck()，手动签收，如果出现异常，则调用channel.basicNack()，让其自动重发消息。

我们先来看demo，生产者我们继续使用上篇博客的例子（RabbitMQ 高级特性——消息的可靠性投递），我们来弄下消费者：

package com.cjian.rabbitmq.spring_rabbit;

import com.rabbitmq.client.Channel;

import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.listener.api.ChannelAwareMessageListener;

/**
 * @description: 消费者的ack机制
 *                 1.设置手动签收：acknowledge="manual"
 *                 2.让监听器实现ChannelAwareMessageListener接口
 *                 3.如果消息消费成功，则调用channel.basicAck()
 *                 4.如果消息消费失败，则调用channel.basicNack()拒绝签收，broker重新发送消息给消费者
 * @author: CJ
 * @time: 2021/1/26 11:25
 */
public class AckListener implements ChannelAwareMessageListener {
    @Override
    public void onMessage(Message message, Channel channel) throws Exception {
        long deliveryTag = message.getMessageProperties().getDeliveryTag();
        try {
            //接收消息
            System.out.println(new String(message.getBody()));
            //处理业务逻辑
            Thread.sleep(2000);
            //模拟异常
            //int bum = 1/0;
            //手动签收
            channel.basicAck(deliveryTag,true);
        } catch (Exception e) {
            System.out.println("消费消息出现异常");
            //拒绝签收
            //requeue参数的意思为是否重回队列
            channel.basicNack(deliveryTag,true,true);
            //该方法也是一样的，只是少一个multiple参数
            //channel.basicReject(deliveryTag,true);
        }
    }
}

消费者配置：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:rabbit="http://www.springframework.org/schema/rabbit"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       https://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/rabbit
       http://www.springframework.org/schema/rabbit/spring-rabbit.xsd">
    <!--加载配置文件-->
    <context:property-placeholder location="classpath:rabbitmq.properties"/>

    <!-- 定义rabbitmq connectionFactory -->
    <rabbit:connection-factory id="connectionFactory" host="${rabbitmq.host}"
                               port="${rabbitmq.port}"
                               username="${rabbitmq.username}"
                               password="${rabbitmq.password}"
                               virtual-host="${rabbitmq.virtual-host}"/>

    <!--手动-->
    <bean id = "springAckListener" class="com.cjian.rabbitmq.spring_rabbit.AckListener"/>


    <!--绑定监听器与队列的关系-->
    <rabbit:listener-container connection-factory="connectionFactory" auto-declare="true" acknowledge="manual">
        <rabbit:listener ref="springAckListener" queue-names="spring_confirm_queue"/>
    </rabbit:listener-container>

</beans>

启动后控制台输出：正常消费消息

再发一篇消息，然后我们把上面代码里的 int num=1/0注释打开，看下控制台：

每隔两秒输出一次，证明手动ack成功，且消息重回队列后会再次发送给消费者进行消费。

channel.basicReject(deliveryTag, true)：拒绝deliveryTag对应的消息，第二个参数是否requeue，true则重新入队列，否则丢弃或者进入死信队列。该方法reject后，该消费者还是会消费到该条被reject的消息。

channel.basicNack(deliveryTag, false, true)：不确认deliveryTag对应的消息，第二个参数是否应用于多消息，第三个参数是否requeue，与basic.reject区别就是同时支持多个消息，可以nack该消费者先前接收未ack的所有消息。nack后的消息也会被自己消费到。

channel.basicRecover(true)：是否恢复消息到队列，参数是是否requeue，true则重新入队列，并且尽可能的将之前recover的消息投递给其他消费者消费，而不是自己再次消费。false则消息会重新被投递给自己。

这里又会出现一个问题，如果是由于业务/数据的原因，消息不能被正确消费，这里不是一直在反复的“阻塞性”的消费了吗？这个问题我们放到后面的文章说（死信队列）

2.消费端限流

如果是高并发下，rabbitmq服务器上收到成千上万条消息，那么当打开消费端时，这些消息必定喷涌而来，导致消费端消费不过来甚至挂掉都有可能。

在非自动确认的模式下，可以采用限流模式，rabbitmq 提供了服务质量保障qos机制来控制一次消费消息数量。

之前说rabbitmq的工作模式的时候。我们在工作队列的公平调度里使用到了channel.basicQos(1);方法，这里我们看下spring整合中如何使用呢？

我们先简单得写个发送消息的方法：

@Test
    public void testSend(){
        for (int i = 0; i < 10; i++) {
            rabbitTemplate.convertAndSend("spring_confirm_exchange", "confirm", "hello rabbimq "+i);
        }
    }

消费者：

package com.cjian.rabbitmq.spring_rabbit;

import com.rabbitmq.client.Channel;

import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.listener.api.ChannelAwareMessageListener;

/**
 * @description: 消费者限流
 *              1.确保ack机制为手动模式
 *              2.listener-container配置perfetch=1 一次从队列中拉取一条消息进行消费，只有当该消息消费完毕后才会拉取第二条
 *
 * @author: CJ
 * @time: 2021/1/26 11:25
 */
public class QosListener implements ChannelAwareMessageListener {
    @Override
    public void onMessage(Message message, Channel channel) throws Exception {
        long deliveryTag = message.getMessageProperties().getDeliveryTag();
        try {
            //接收消息
            System.out.println(new Date().getSeconds()+" "+new String(message.getBody()));
            //处理业务逻辑
            Thread.sleep(1000);
            //手动签收
            channel.basicAck(deliveryTag,true);
        } catch (Exception e) {
            System.out.println("消费消息出现异常");
            //拒绝签收
            //requeue参数的意思为是否重回队列
            channel.basicNack(deliveryTag,true,true);
        }
    }
}

队列配置：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:rabbit="http://www.springframework.org/schema/rabbit"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       https://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/rabbit
       http://www.springframework.org/schema/rabbit/spring-rabbit.xsd">
    <!--加载配置文件-->
    <context:property-placeholder location="classpath:rabbitmq.properties"/>

    <!-- 定义rabbitmq connectionFactory -->
    <rabbit:connection-factory id="connectionFactory" host="${rabbitmq.host}"
                               port="${rabbitmq.port}"
                               username="${rabbitmq.username}"
                               password="${rabbitmq.password}"
                               virtual-host="${rabbitmq.virtual-host}"/>

    <!--消费者限流-->
    <bean id = "springQosListener" class="com.cjian.rabbitmq.spring_rabbit.QosListener"/>


    <!--绑定监听器与队列的关系-->
    <rabbit:listener-container connection-factory="connectionFactory" auto-declare="true" acknowledge="manual" prefetch="1">
        <rabbit:listener ref="springQosListener" queue-names="spring_confirm_queue"/>
    </rabbit:listener-container>

</beans>

具体的不做过多演示，我们直接看下效果：应该是一秒消费一条消息

这里又出现了一个问题：如何保证消息消费的顺序？我们后面的文章说

cj_eryue

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
RabbitMQ 高级特性——消费者消费消息的确认及限流

目录1.消息的可靠性消费2.消费端限流1.消息的可靠性消费ACK:指Acknowledge，确认。表示消费端接收到消息后的确认方式。共有三种确认方式：自动确认：acknowledge="none" 手动确认：acknowledge="manual" 根据异常情况确认：acknowledge="auto"（这种方式使用比较麻烦，不作解释）其中自动确认是指当消息一旦被Consumer接收到后，则自动确认收到，并将相应消息从rabbitmq的消息缓存中移除。但是在实际业务处理中..
复制链接

扫一扫