原文:https://blog.csdn.net/linpeng_1/article/details/80505828
AmqpTemplate,RabbitTemplate
Spring AMQP提供了一个发送和接收消息的操作模板类AmqpTemplate。 AmqpTemplate它定义包含了发送和接收消息等的一些基本的操作功能。RabbitTemplate是AmqpTemplate的一个实现。
RabbitTemplate支持消息的确认与返回,为了返回消息,RabbitTemplate 需要设置mandatory 属性为true,并且CachingConnectionFactory 的publisherReturns属性也需要设置为true。返回的消息会根据它注册的RabbitTemplate.ReturnCallback setReturnCallback 回调发送到给客户端,
一个RabbitTemplate仅能支持一个ReturnCallback 。
为了确认Confirms消息, CachingConnectionFactory 的publisherConfirms 属性也需要设置为true,确认的消息会根据它注册的RabbitTemplate.ConfirmCallback setConfirmCallback回调发送到给客户端。一个RabbitTemplate也仅能支持一个ConfirmCallback.
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
SpringBoot集成RabbitMQ
server.port=8083
#服务器配置
spring.application.name=rabbitmq-hello-sending
#rabbitmq连接参数
spring.rabbitmq.addresses:ip1:port1,ip2:port2,ip3:port3 #集群或单机 都可配置
spring.rabbitmq.username=linpeng
spring.rabbitmq.password=123456
# rabbitmq服务器的虚拟主机名,可以在后台管理系统上查看和新建
spring.rabbitmq.virtual-host=/test
# 连接超时
spring.rabbitmq.connection-timeout=5s
# 发送方
# 开启发送确认(未到达MQ服务器)
spring.rabbitmq.publisher-confirms=true
# 开启发送失败退回(未找到对应queue)
spring.rabbitmq.publisher-returns=true
spring.rabbitmq.template.mandatory=true
# 消费方 开启手动ACK(坑:当序列化为JSON时,此配置会失效,见下文)
spring.rabbitmq.listener.direct.acknowledge-mode=manual
spring.rabbitmq.listener.simple.acknowledge-mode=manual
# 消费方
spring.rabbitmq.listener.concurrency=1 //最小消息监听线程数
spring.rabbitmq.listener.max-concurrency=2 //最大消息监听线程数
#消费者每次从队列获取的消息数量 (默认一次250个)
#通过查看后台管理器中queue的unacked数量
spring.rabbitmq.listener.simple.prefetch= 5
#消费者自动启动
spring.rabbitmq.listener.simple.auto-startup=true
#消费失败,自动重新入队
spring.rabbitmq.listener.simple.default-requeue-rejected= true
#启用发送重试
spring.rabbitmq.template.retry.enabled=true
#第一次与第二次发布消息的时间间隔
spring.rabbitmq.template.retry.initial-interval=1000
#尝试发布消息的最大数量
spring.rabbitmq.template.retry.max-attempts=3
#尝试发布消息的最大时间间隔
spring.rabbitmq.template.retry.max-interval=10000
#上一次尝试时间间隔的乘数
spring.rabbitmq.template.retry.multiplier=1.0
属性名 说明 默认值
spring.rabbitmq.address 客户端连接的地址,有多个的时候使用逗号分隔,该地址可以是IP与Port的结合
spring.rabbitmq.cache.channel.checkout-timeout 当缓存已满时,获取Channel的等待时间,单位为毫秒
spring.rabbitmq.cache.channel.size 缓存中保持的Channel数量
spring.rabbitmq.cache.connection.mode 连接缓存的模式 CHANNEL
spring.rabbitmq.cache.connection.size 缓存的连接数
spring.rabbitmq.connnection-timeout 连接超时参数单位为毫秒:设置为“0”代表无穷大
spring.rabbitmq.dynamic 默认创建一个AmqpAdmin的Bean true
spring.rabbitmq.host RabbitMQ的主机地址 localhost
spring.rabbitmq.listener.acknowledge-mode 容器的acknowledge模式
spring.rabbitmq.listener.auto-startup 启动时自动启动容器 true
spring.rabbitmq.listener.concurrency 消费者的最小数量
spring.rabbitmq.listener.default-requeue-rejected 投递失败时是否重新排队 true
spring.rabbitmq.listener.max-concurrency 消费者的最大数量
spring.rabbitmq.listener.prefetch 在单个请求中处理的消息个数,他应该大于等于事务数量
spring.rabbitmq.listener.retry.enabled 不论是不是重试的发布 false
spring.rabbitmq.listener.retry.initial-interval 第一次与第二次投递尝试的时间间隔 1000
spring.rabbitmq.listener.retry.max-attempts 尝试投递消息的最大数量 3
spring.rabbitmq.listener.retry.max-interval 两次尝试的最大时间间隔 10000
spring.rabbitmq.listener.retry.multiplier 上一次尝试时间间隔的乘数 1.0
spring.rabbitmq.listener.retry.stateless 不论重试是有状态的还是无状态的 true
spring.rabbitmq.listener.transaction-size 在一个事务中处理的消息数量。为了获得最佳效果,该值应设置为小于等于每个请求中处理的消息个数,即spring.rabbitmq.listener.prefetch的值
spring.rabbitmq.password 登录到RabbitMQ的密码
spring.rabbitmq.port RabbitMQ的端口号 5672
spring.rabbitmq.publisher-confirms 开启Publisher Confirm机制 false
spring.rabbitmq.publisher-returns 开启publisher Return机制 false
spring.rabbitmq.requested-heartbeat 请求心跳超时时间,单位为秒
spring.rabbitmq.ssl.enabled 启用SSL支持 false
spring.rabbitmq.ssl.key-store 保存SSL证书的地址
spring.rabbitmq.ssl.key-store-password 访问SSL证书的地址使用的密码
spring.rabbitmq.ssl.trust-store SSL的可信地址
spring.rabbitmq.ssl.trust-store-password 访问SSL的可信地址的密码
spring.rabbitmq.ssl.algorithm SSL算法,默认使用Rabbit的客户端算法库
spring.rabbitmq.template.mandatory 启用强制信息 false。当mandatory标志位设置为true时,如果exchange根据自身类型和消息routingKey无法找到一个合适的queue存储消息,那么broker会调用basic.return方法将消息返还给生产者;当mandatory设置为false时,出现上述情况broker会直接将消息丢弃;通俗的讲,mandatory标志告诉broker代理服务器至少将消息route到一个队列中,否则就将消息return给发送者;
spring.rabbitmq.template.receive-timeout receive()方法的超时时间 0
spring.rabbitmq.template.reply-timeout sendAndReceive()方法的超时时间 5000
spring.rabbitmq.template.retry.enabled 设置为true的时候RabbitTemplate能够实现重试 false
spring.rabbitmq.template.retry.initial-interval 第一次与第二次发布消息的时间间隔 1000
spring.rabbitmq.template.retry.max-attempts 尝试发布消息的最大数量 3
spring.rabbitmq.template.retry.max-interval 尝试发布消息的最大时间间隔 10000
spring.rabbitmq.template.retry.multiplier 上一次尝试时间间隔的乘数 1.0
spring.rabbitmq.username 登录到RabbitMQ的用户名
spring.rabbitmq.virtual-host 连接到RabbitMQ的虚拟主机
RabbitTemplate
默认一个RabbitTemplate在RabbitMQ中相当于一个connection,每发送一次消息相当于channel,MQ接收消息后释放channel。每个connection最多支持2048个channel,假如从一个connection同时超过2048个线程并发发送,channel超过2048,会报错org.springframework.amqp.AmqpResourceNotAvailableException: The channelMax limit is reached. Try later。
测试启动publisher-confirms后,500个线程并发发送,部分消息报AmqpResourceNotAvailableException。400个线程通过一个RabbitTemplate并发发送10000消息,同时就可能产生1000左右的channel。因为发送端channel等待confirm回调所以没有释放。10000消息全部投递在几秒内完成,此时线程已释放。10000消息全部confirm异步回调完成用时22秒,此时所有channel全部释放。(测试机/测试服务器配置都很低)每个connection最多支持2048个channel。
后台管理页面查看connection+channel
图中一个connection中有10个线程并发发送消息,监控到10个channel生成,MQ完成接收后释放channel。如果是publisher-confirms模式,channel会保持到confirm回调完成再释放,影响并发性能。如果想提高confirm回调性能,请不要在confirm回调方法中执行业务逻辑,confirm方法直接将回调任务投递到线程池后结束。由线程池异步执行回调逻辑,这样会大大提高confirm模式并发性能。
绑定队列
若在rabbitmq的管理页面手动创建队列和交换机,则可以不再代码中声明
package com.example.demo;
import com.rabbitmq.client.Channel;
import org.springframework.amqp.core.*;
import org.springframework.amqp.rabbit.connection.CachingConnectionFactory;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.core.ChannelAwareMessageListener;
import org.springframework.amqp.rabbit.listener.SimpleMessageListenerContainer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class RabbitConfig {
@Bean
public Queue QueueA() {
return new Queue("hello");
}
@Bean
public Queue QueueB() {
return new Queue("helloObj");
}
/**
* Fanout 就是我们熟悉的广播模式或者订阅模式,给Fanout交换机发送消息,绑定了这个交换机的所有队列都收到这个消息。
* @return
*/
@Bean
FanoutExchange fanoutExchange() {
return new FanoutExchange("ABExchange");
}
@Bean
DirectExchange Exchange() {
return new DirectExchange("DExchange");
}
@Bean
Binding bindingExchangeA(Queue QueueA, FanoutExchange fanoutExchange) {
return BindingBuilder.bind(QueueA).to(fanoutExchange);
}
@Bean
Binding bindingExchangeB(Queue QueueB, FanoutExchange fanoutExchange) {
return BindingBuilder.bind(QueueB).to(fanoutExchange);
}
@Bean
Binding bindingExchange() {
return BindingBuilder.bind(QueueA()).to(Exchange()).with("TEST");//routingKey
}
}
消息发送者
ConfirmCallback :ACK=true仅仅标示消息已被Broker接收到,并不表示已成功投放至消息队列中, ACK=false标示消息由于Broker处理错误,消息并未处理成功。如未找到对应交换机返回ACK=false。
ReturnCallback:当消息发送出去找不到对应路由队列时,将会把消息退回 。如果有任何一个路由队列接收投递消息成功,则不会退回消息。MQ成功接收,但是未找到对应队列触发
通过以上异步确认机制,增加降级、补偿处理。比如发送时保存信息和消息ID,ConfirmCallback 通过ID找到对应信息重发,注意要保证幂等性。
package com.example.demo;
import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.amqp.rabbit.support.CorrelationData;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;
import java.util.Date;
//RabbitTemplate.ConfirmCallback
@Service
public class HelloSender implements RabbitTemplate.ReturnCallback {
@Autowired
private RabbitTemplate rabbitTemplate;
public void send() {
String context = "你好现在是 " + new Date() +"";
System.out.println("HelloSender发送内容 : " + context);
//消息序列化设置
//rabbitTemplate.setMessageConverter(new Jackson2JsonMessageConverter());
//自身实现ReturnCallback接口 设置异步回调对象为this
this.rabbitTemplate.setReturnCallback(this);
//若是当前类实现RabbitTemplate.ConfirmCallback接口,则可以设置为this
//发送前给RabbitTemplate设置一个异步回调对象 RabbitTemplate.ConfirmCallback接口的匿名类
this.rabbitTemplate.setConfirmCallback((correlationData, confirm, cause) -> {
//若发送时没有CorrelationData,则这里correlationData==null
if (!confirm) {
System.out.println("HelloSender消息发送失败" + cause + correlationData.getId() );
//correlationData.getReturnedMessage(); Message
//correlationData.toString();
} else {
System.out.println("HelloSender 消息发送成功 ");
}
});
//this.rabbitTemplate.setConfirmCallback(this);
//rabbitTemplate.convertAndSend("hello", context);
//这里指定路由键,注意不是队列名
//发送时 可以指定消息ID,方便在ConfirmCallback时候二次处理消息
rabbitTemplate.convertAndSend("DExchange","QueueRoutingKey", context, new CorrelationData("自定义消息ID"));
}
public void sendObj() {
MessageObj obj = new MessageObj();
obj.setACK(false);
obj.setId(123);
obj.setName("zhangsan");
obj.setValue("data");
System.out.println("发送 : " + obj);
this.rabbitTemplate.convertAndSend("helloObj", obj);
}
@Override
public void returnedMessage(Message message, int i, String cause, String exchange, String queue) {
//没有找到queue
//Message中的成员,Body为消息内容
//(Body:'hello' MessageProperties [headers={}, contentType=text/plain, contentEncoding=UTF-8, contentLength=0, receivedDeliveryMode=PERSISTENT, priority=0, deliveryTag=0])
}
// @Override
// public void confirm(CorrelationData correlationData, boolean confirm, String cause) {
// System.out.println("sender success");
// }
}
测试发送:
使用Spring默认的rabbitTemplate发送消息,CorrelationData可以重复。
交换机+路由键+消息Object+CorrelationData
rabbitTemplate.convertAndSend("TEST.EX","TEST","String:message",new CorrelationData("111"));
在rabbitmq控制台上getmessage查看 ,rabbitTemplate默认发送deliverymode=2消息,已经设置了消息持久化。
测试速度:
测试100个线程同时并发向同一队列发送简单消息(15左右长度的字符串)。从发送到100个消息全部完成ConfirmCallback,用时为600ms左右。此过程不计入消费速度。
400个线程通过一个RabbitTemplate并发发送10000消息,同时就可能产生1000左右的channel。因为channel等在confirm。10000消息全部发送在几秒内完成,10000消息全部confirm回调完成用时22秒。
测试ConfirmCallback回调:
public void confirm(CorrelationData correlationData, boolean confirm, String cause) ;
confirm==true仅仅标示消息已被Broker接收到,并不表示已成功投放至消息队列中, confirm==false标示消息由于Broker处理错误,消息并未处理成功。如未找到对应交换机返回confirm==false。
在此方法中针对confirm==false的消息实现降级/补偿处理:重发、本地缓存、计入数据库/Redis等、更新状态.....
测试环境:实例化一个ConfirmCallback接口对象,作为rabbitTemplate共用回调处理对象。
回调测试结果:
1 先发送到MQ的消息,先完成confirm回调。
2 ConfirmCallback默认是由同一个线程执行回调,打印线程名可以看到线程名为【AMQP Connection rabbitmqIp:port】
为了提高效率ConfirmCallback可以把任务提交到线程池,避免阻塞后边的Confirm任务。
3 若发送时没有携带CorrelationData,回调时这里correlationData==null
4.设置消息确认会影响并发性能,每个线程发送生成一个channel,channel会保持到confirm回调完成再释放。因为每个connection最多支持2048个channel,当channel达到2048时,会报错org.springframework.amqp.AmqpResourceNotAvailableException: The channelMax limit is reached. Try later。
测试ReturnCallback 回调:
public void returnedMessage(Message message, int i, String cause, String exchange, String queue) ;
MQ成功接收消息,但是未找到对应路由键的队列后回调。实现降级/补偿处理。
测试环境:实例化一个ReturnCallback接口对象,作为rabbitTemplate共用回调处理对象。
回调测试结果:
默认是由同一个线程执行回调,打印线程名可以看到线程名为【AMQP Connection rabbitmqIp:port】
message=返回的Message对象中的成员,Body为发送时的消息内容 ,receivedDeliveryMode=PERSISTENT=2 为持久化消息。spring_returned_message_correlation=发送时的CorrelationData
(Body:'String:message' MessageProperties [headers={spring_returned_message_correlation=111}, contentType=text/plain, contentEncoding=UTF-8, contentLength=0, receivedDeliveryMode=PERSISTENT, priority=0, deliveryTag=0])
cause=NO_ROUTE
exchange、queue 为发送时的配置
消息消费者
设置QOS,避免触发流控机制
#消费者每次从队列获取的消息数量 (默认一次250个)
spring.rabbitmq.listener.simple.prefetch= 5
当QUEUE达到5条Unacked消息时,不会再推送消息给Consumer。查看后台管理器中queue的unacked数量
package com.example.demo;
import com.rabbitmq.client.Channel;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.amqp.rabbit.annotation.RabbitListenerConfigurer;
import org.springframework.amqp.rabbit.core.ChannelAwareMessageListener;
import org.springframework.amqp.rabbit.listener.RabbitListenerEndpointRegistrar;
import org.springframework.amqp.support.AmqpHeaders;
import org.springframework.beans.factory.annotation.Configurable;
import org.springframework.context.annotation.Bean;
import org.springframework.messaging.handler.annotation.Headers;
import org.springframework.stereotype.Component;
import java.io.IOException;
import java.util.Date;
import java.util.Map;
@Component
public class HelloReceiver {
@RabbitListener(queues = "hello") //这里是队列名,不是路由键
public void process(String msg,Channel channel, Message message) throws IOException {
System.out.println("HelloReceiver收到 : " + msg +"收到时间"+new Date());
try {
//告诉MQ服务器收到这条消息 已经被我消费了 可以在队列删掉 这样以后就不会再发了 否则消息服务器以为这条消息没处理掉 后续还会在发
channel.basicAck(message.getMessageProperties().getDeliveryTag(),false);
System.out.println("receiver success");
} catch (IOException e) {
e.printStackTrace();
//丢弃这条消息
//channel.basicNack(message.getMessageProperties().getDeliveryTag(), false,false);
System.out.println("receiver fail");
}
}
}
msg是消息内容,相当于Message对象中的body。
Message对象的成员:
可以看到有消息信息BODY,发送方生成的消息CorrelationData,还有执行的Method对象(@RabbitListener标注的方法),目标BEAN
备注:我们用注解的方式来接受消息 就不要用 自己创建对象实现ChannelAwareMessageListener的方式来接受消息 这种方式还要去全局里面配置麻烦,直接用@RabbitListener(queues = "hello")最简单
消息确认 因为我在属性配置文件里面开启了ACK确认 所以如果代码没有执行ACK确认 你在RabbitMQ的后台会看到消息会一直留在队列里面未消费掉 只要程序一启动开始接受该队列消息的时候 又会收到
方法参数详解:https://www.cnblogs.com/piaolingzxh/p/5448927.html
channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
deliveryTag:该消息的index,由发送方生成
multiple:是否批量.true:将一次性ack所有小于deliveryTag的消息。
channel.basicNack(message.getMessageProperties().getDeliveryTag(), false, true);
deliveryTag:该消息的index
multiple:是否批量.true:将一次性拒绝所有小于deliveryTag的消息。
requeue:被拒绝的是否重新入队列,true 放在队首,false 消息进入绑定的DLX。一定注意:若此消息一直Nack重入队会导致的死循环
channel.basicNack 与 channel.basicReject 的区别在于basicNack可以拒绝多条消息,而basicReject一次只能拒绝一条消息
channel.basicReject(message.getMessageProperties().getDeliveryTag(), true);
deliveryTag:该消息的index
requeue:被拒绝的是否重新入队列。false 消息进入绑定的DLX
ShutdownSignalException
1 队列名找不到
2 代码中有ack,但是没有配置手动ACK
消费超时
消费超时,queue中unacked的消息会退回到queue中,且消费者ACK时会失败。
使用@Payload和@Headers注解
@Component
public class MessageHandler {
//获取消息的头属性和body属性
@RabbitListener(queues = "zhihao.miao.order")
public void handleMessage(@Payload String body, @Headers Map<String,Object> headers){
System.out.println("====消费消息===handleMessage");
System.out.println(headers);
System.out.println(body);
}
}
@RabbitListener 和 @RabbitHandler 搭配使用
- @RabbitListener 可以标注在类上面,需配合 @RabbitHandler 注解一起使用
- @RabbitListener 标注在类上面表示当有收到消息的时候,就交给 @RabbitHandler 的方法处理,具体使用哪个方法处理,根据 MessageConverter 转换后的参数类型
@Component
@RabbitListener(queues = "consumer_queue")
public class Receiver {
@RabbitHandler
public void processMessage1(String message) {
System.out.println(message);
}
@RabbitHandler
public void processMessage2(byte[] message) {
System.out.println(new String(message));
}
}
序列化
当中默认的序列化类为SimpleMessageConverter。
仅仅有调用了convertAndSend方法才会使用对应的MessageConvert进行消息的序列化与反序列化。
SimpleMessageConverter对于要发送的消息体body为字节数组时。不进行处理。
对于假设是String。则将String转成字节数组。
对于假设是Java对象,则使用jdk序列化Serializable将消息转成字节数组。转出来的结果较大,含class类名。类对应方法等信息。因此性能较差。
当使用RabbitMq作为中间件时,数据量比較大,此时就要考虑使用类似Jackson2JsonMessageConverter。hessian等序列化形式。以此提高性能。
使用 JSON 序列化与反序列化
https://www.jianshu.com/p/911d987b5f11
发送
@Bean
public RabbitTemplate rabbitTemplate(ConnectionFactory connectionFactory) {
RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);
rabbitTemplate.setMessageConverter(new Jackson2JsonMessageConverter());
return rabbitTemplate;
}
User user = new User("linyuan");
rabbitTemplate.convertAndSend("topic.exchange","queue1",user);
接收
@Bean
public RabbitListenerContainerFactory<?> rabbitListenerContainerFactory(ConnectionFactory connectionFactory){
SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
factory.setConnectionFactory(connectionFactory);
factory.setMessageConverter(new Jackson2JsonMessageConverter());
factory.setAcknowledgeMode(AcknowledgeMode.MANUAL);//json序列化时,若想手动ACK,则必须配置
return factory;
}
@Component
@RabbitListener(queues = "queue1")
public class Receiver {
@RabbitHandler
public void processMessage1(@Payload User user) {
System.out.println(user.getName());
}
}
消费者+json反序列化 造成手动ACK配置失效
解决方案: https://blog.csdn.net/m912595719/article/details/83787486
这是springboot集成RabbitMQ的一个大坑。当消费者配置JSON反序列化时,配置文件中的手动ACK会失效,消费者会变成自动ACK模式。spring.rabbitmq.listener.direct.acknowledge-mode=manual,spring.rabbitmq.listener.simple.acknowledge-mode=manual 配置失效。
解决方法是消费者配置RabbitListenerContainerFactory这个Bean时(见上),设置factory.setAcknowledgeMode(AcknowledgeMode.MANUAL)。把消费者强制转换为手动ACK。
如果配置失效切换为自动ACK,但是代码中又使用channel.basicAck手动ACK。这样会造成双ACK的ERROR,接着信道会重启重连。如下:
o.s.a.r.c.CachingConnectionFactory : Channel shutdown: channel error; protocol method: #method<channel.close>(reply-code=406, reply-text=PRECONDITION_FAILED - unknown delivery tag 1, class-id=60, method-id=80)
unknown delivery tag 1表示当前Channel中找不到delivery-tag=1的消息,其实是这个消息已经自动ACK了,basicAck时就会出错。测试显示,消息并不会丢失而是在出现ERROR异常后走向Nack后重新入队,再多次重复消费后最终ACK成功,严重降低消费者的执行效率。
Delivery Tags投递的标识
当一个消费者向RabbitMQ注册后,RabbitMQ会用 basic.deliver 方法向消费者推送消息,这个方法携带了一个 delivery tag, 它在一个channel中唯一代表了一次投递。delivery tag的唯一标识范围限于channel. delivery tag是单调递增的正整数,客户端获取投递的方法用用dellivery tag作为一个参数。
检查队列中消息数量
DeclareOk declareOk = amqpAdmin.getRabbitTemplate().execute(
new ChannelCallback<DeclareOk>() {
public DeclareOk doInRabbit(Channel channel)
throws Exception {
return channel.queueDeclarePassive(name);
}
});
return declareOk.getMessageCount();
TestController测试
@Autowired
private HelloSender helloSender;
/**
* 单生产者-单个消费者
*/
@RequestMapping("/test")
public void hello() throws Exception {
helloSender.send();
}
发送消息
ACK场景测试
我们把HelloReceiver的ACK确认代码注释掉 ,那消息就算程序收到了, 但是未确认ACK导致消息服务器以为他是未成功消费的,若此时消费者断开则消息返回队列,后续还会再发。