目录
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>
具体的不做过多演示,我们直接看下效果:应该是一秒消费一条消息
这里又出现了一个问题:如何保证消息消费的顺序?我们后面的文章说