消息的可靠投递
概念
在使用 RabbitMQ 的时候,作为消息发送方希望杜绝任何消息丢失或者投递失败场景。RabbitMQ 为我们提
供了两种方式用来控制消息的投递可靠性模式。
- confirm 确认模式
- return 退回模式
rabbitmq 整个消息投递的路径为:
producer—>rabbitmq broker—>exchange—>queue—>consumer
- 消息从 producer 到 exchange 则会返回一个 confirmCallback 。
- 消息从 exchange–>queue 投递失败则会返回一个 returnCallback 。
我们将利用这两个 callback 控制消息的可靠性投递
步骤:
- 设置ConnectionFactory的publisher-confirms=“true” 开启 确认模式
- 使用rabbitTemplate.setConfirmCallback设置回调函数。当消息发送到exchange后回调confirm方法。在方法中判断ack,如果为true,则发送成功,如果为false,则发送失败,需要处理。
- 设置ConnectionFactory的publisher-returns=“true” 开启 退回模式。
- 使用rabbitTemplate.setReturnCallback设置退回函数,当消息从exchange路由到queue失败后,如果设置了rabbitTemplate.setMandatory(true)参数,则会将消息退回给producer。并执行回调函数returnedMessage。
- 在RabbitMQ中也提供了事务机制,但是性能较差。
Consumer Ack
概念
ack指Acknowledge,确认。 表示消费端收到消息后的确认方式。
有三种确认方式:
- 自动确认:acknowledge=“none” 默认方式
- 手动确认:acknowledge=“manual”
- 根据异常情况确认:acknowledge=“auto”,(这种方式使用麻烦)
其中自动确认是指,当消息一旦被Consumer接收到,则自动确认收到,并将相应 message 从 RabbitMQ 的
消息缓存中移除。但是在实际业务处理中,很可能消息接收到,业务处理出现异常,那么该消息就会丢失。如
果设置了手动确认方式,则需要在业务处理成功后,调用channel.basicAck(),手动签收,如果出现异常,则
调用channel.basicNack()方法,让其自动重新发送消息。
步骤:
- 在rabbit:listener-container标签中设置acknowledge属性,设置ack方式 none:自动确认,manual:手
动确认 - 如果在消费端没有出现异常,则调用channel.basicAck(deliveryTag,false);方法确认签收消息
- 如果出现异常,则在catch中调用 basicNack或 basicReject,拒绝消息,让MQ重新发送消息。
在application.yml配置文件中设置消息回退模式即可
spring:
rabbitmq:
host: 172.16.98.133 #主机ip
port: 5672 #端口
username: guest
password: guest
virtual-host: /
publisher-confirms: true
publisher-returns: true
listener:
simple:
acknowledge-mode: manual # 设置确认模式
消费者代码:
@Component
public class RabbimtMQListener {
@RabbitListener(queues = "boot_queue")
public void ListenerQueue(Message message, Channel channel) throws IOException {
// 消息的标签
long deliveryTag = message.getMessageProperties().getDeliveryTag();
try {
//System.out.println(message);
System.out.println(new String(message.getBody()));
System.out.println("处理业务逻辑");
// 第二个参数 为是否签收多条消息
channel.basicAck(deliveryTag,true);
} catch (Exception e) {
// 第三个参数:如果设置为true,则消息重新回到queue,broker会重新发送消息到消费端
channel.basicNack(deliveryTag,true,true);
//e.printStackTrace();
}
}
}
消费端限流
步骤
- 在<rabbit:listener-container> 中配置 prefetch属性设置消费端一次拉取多少消息(spring 设置) springboot在yml文件中设置
- 消费端的确认模式一定为手动确认。acknowledge=“manual”,只有手动签收之后才会拉去下一条消息
spring:
rabbitmq:
listener:
simple:
prefetch: 1 # 一次拉去多少消息
acknowledge-mode: manual # 设置确认模式
TTL
- TTL 全称 Time To Live(存活时间/过期时间)。
- 当消息到达存活时间后,还没有被消费,会被自动清除。
- RabbitMQ可以对消息设置过期时间,也可以对整个队列(Queue)设置过期时间。
步骤
- 设置队列过期时间使用参数:x-message-ttl,单位:ms(毫秒),会对整个队列消息统一过期。
- 设置消息过期时间使用参数:expiration。单位:ms(毫秒),当该消息在队列头部时(消费时),会单独判断这一消息是否过期。
- 如果两者都进行了设置,以时间短的为准。
- 队列过期后,会将队列所有消息全部消除。 消息过期后,只有消息在队列顶端,才会判断其是否过期(提高效率)
死信队列
死信队列,英文缩写:DLX 。Dead Letter Exchange(死信交换机),当消息成为Dead message后,可以被重新发送到另一个交换机,这个交换机就是DLX。
消息成为死信的三种情况:
- 队列消息长度到达限制;(比如设置了只能存10条,那么第11条就会成为死信)
- 消费者拒接消费消息,basicNack/basicReject,并且不把消息重新放入原目标队列,requeue=false;
channel.basicNack(deliveryTag,true,false); // requeue=false; 第三个参数
- 原队列存在消息过期设置,消息到达超时时间未被消费;
队列绑定死信交换机:
给队列设置参数: x-dead-letter-exchange 和 x-dead-letter-routing-key
死信交换机和死信队列和普通的没有区别,当消息成为死信后,如果该队列绑定了死信交换机,则消息会被死信交换机重新路由到死信队列。否则就会丢弃获取重发(丢弃还是重发看自己设置)。
延迟队列
延迟队列,即消息进入队列后不会立即被消费,只有到达指定时间后,才会被消费。
-------------------------------------------------------------基于SpringBoot演示------------------------------------------------------
消息生产端:
pom.xml
<!--1. 父工程依赖-->
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.1.4.RELEASE</version>
</parent>
<dependencies>
<!--2. rabbitmq-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
</dependency>
</dependencies>
application.yml
# 配置RabbitMQ的基本信息 ip 端口 username password..
spring:
rabbitmq:
host: 192.168.93.129 # ip
port: 5672
username: xiao
password: xiao
virtual-host: /test
publisher-confirms: true # 开启生产端 到broker 的消息确认模式
publisher-returns: true #开启 交换机到 队列的消息确认
RabbitMQConfig.java 配置类
@Configuration
public class RabbitMQConfig {
public static final String EXCHANGE_NAME = "boot_topic_exchange";
public static final String QUEUE_NAME = "boot_queue";
//1.交换机
@Bean("bootExchange")
public Exchange bootExchange(){
// 需要什么类型就 . 什么类型,传入交换机名称
// 是否持久化,其他设置可以 一直链式编程 . 调用,最后build 方法返回
return ExchangeBuilder.topicExchange(EXCHANGE_NAME).durable(true).build();
}
//1.死信交换机-----------------------------------------
@Bean("deadExchange")
public Exchange deadExchange(){
// 需要什么类型就 . 什么类型,传入交换机名称
// 是否持久化,其他设置可以 一直链式编程 . 调用,最后build 方法返回
return ExchangeBuilder.topicExchange("dead_topic_exchange").durable(true).build();
}
//2.Queue 队列 设置整个队列的过期时间------------------
@Bean("bootQueue")
public Queue bootQueue(){
// withArgument("x-message-ttl","5000") 设置队列的过期时间
return QueueBuilder.durable(QUEUE_NAME).withArgument("x-message-ttl",10000)
.withArgument("x-dead-letter-exchange", "dead_topic_exchange") // 将队列和死信交换机进行绑定
.withArgument("x-dead-letter-routing-key", "dead.letter-routing-key") // 声明死信路由key,
.build();
}
//2.Queue 队列-------------死信队列
@Bean("deadQueue")
public Queue deadQueue(){
// withArgument("x-message-ttl","5000") 设置队列的过期时间
return QueueBuilder.durable("dead_queue").withArgument("x-message-ttl","10000").build();
}
//3. 队列和交互机绑定关系 Binding
/*基于队列绑定交换机,noargs不传入参数。with 路由规则
1. 知道哪个队列
2. 知道哪个交换机
3. routing key
*/
@Bean
public Binding bindQueueExchange(@Qualifier("bootQueue") Queue queue, @Qualifier("bootExchange") Exchange exchange){
return BindingBuilder.bind(queue).to(exchange).with("boot.#").noargs();
}
// 绑定 死信交换机 和死信队列--------------------死信交换机 和死信队列
@Bean
public Binding bindDeadExchange(@Qualifier("deadQueue") Queue queue, @Qualifier("deadExchange") Exchange exchange){
return BindingBuilder.bind(queue).to(exchange).with("dead.#").noargs();
}
}
ProviderTest.java 测试类
@SpringBootTest
@RunWith(SpringRunner.class)
public class ProviderTest {
//1.注入RabbitTemplate
@Autowired
private RabbitTemplate rabbitTemplate;
@Test
public void testSend01(){
//定义发送消息的回调------------------------------生产端到交换机
rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback() {
@Override
public void confirm(CorrelationData correlationData, boolean ack, String cause) {
// correlationData 相关配置信息
// ack exchange 交换机是否成功收到了消息,true为成功 false 为失败
// cause 失败原因
if (ack == true){
System.out.println("confirm方法执行了,,,,,,发送成功");
}else{
System.out.println("confirm方法执行了,,,,,,,,,发送失败");
// 做一些处理 保证消息发送成功
}
}
});
rabbitTemplate.convertAndSend(RabbitMQConfig.EXCHANGE_NAME,"boot.haha","boot mq hello~~~");
}
/**
* 1、开启回退模式
* 2、设置ReturnCallback
* 3、设置Exchange处理消息的模式
* 1、如果消息没有路由到Queue,则丢弃消息(默认)
* 2、如果消息没有路由到Queue,返回给消息发送方ReturnCallback
*/
@Test
public void testSend02(){
// 设置消息不丢弃 才会调用ReturnCallback方法
rabbitTemplate.setMandatory(true);
//定义发送消息的回调----------------------------------交换机到队列
rabbitTemplate.setReturnCallback(new RabbitTemplate.ReturnCallback() {
// 消息对象 错误码 错误信息 交换机名称 路由键
@Override
public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
System.out.println("交换机到队列发送消息失败");
}
});
rabbitTemplate.convertAndSend(RabbitMQConfig.EXCHANGE_NAME,"boot.haha","boot mq hello~~~");
}
@Test
public void testSend03(){
// 设置单个消息过期时间----------------------------------ttl
rabbitTemplate.convertAndSend(RabbitMQConfig.EXCHANGE_NAME, "boot.haha", "boot mq hello~~~", new MessagePostProcessor() {
@Override
public Message postProcessMessage(Message message) throws AmqpException {
//1.设置message的信息
message.getMessageProperties().setExpiration("5000");//消息的过期时间
return message;
}
});
}
}