RocketMQ的消息重试包含了producer发送消息的重试和consumer消息消费的重试。
producer发送消息重试
producer在发送消息的时候如果发送失败了，RocketMQ会自动重试。
private SendResult sendDefaultImpl(
Message msg,
final CommunicationMode communicationMode,
final SendCallback sendCallback,
final long timeout
) throws MQClientException, RemotingException, MQBrokerException, InterruptedException {
this.makeSureStateOK();
Validators.checkMessage(msg, this.defaultMQProducer);
final long invokeID = random.nextLong();
long beginTimestampFirst = System.currentTimeMillis();
long beginTimestampPrev = beginTimestampFirst;
long endTimestamp = beginTimestampFirst;
TopicPublishInfo topicPublishInfo = this.tryToFindTopicPublishInfo(msg.getTopic());
if (topicPublishInfo != null && topicPublishInfo.ok()) {
MessageQueue mq = null;
Exception exception = null;
SendResult sendResult = null;
// 这是调用的总次数
int timesTotal = communicationMode == CommunicationMode.SYNC ? 1 + this.defaultMQProducer.getRetryTimesWhenSendFailed() : 1;
int times = 0;
String[] brokersSent = new String[timesTotal];
for (; times < timesTotal; times++) {
// 省略部分代码...
}
重试几次？
由上面可以看出发送消息的重试次数区分不同的情况：
- 同步发送：org.apache.rocketmq.client.producer.DefaultMQProducer#retryTimesWhenSendFailed + 1，默认retryTimesWhenSendFailed是2，所以除了正常调用一次外，发送消息如果失败了会重试2次
- 异步发送：不会重试（调用总次数等于1）
什么时候重试？
发生异常的时候，需要注意的是发送的时候并不是catch所有的异常，只有内部异常才会catch住并重试。
怎么重试？
每次重试都会重新进行负载均衡（会考虑发送失败的因素），重新选择MessageQueue，这样增大发送消息成功的可能性。
隔多久重试？
立即重试，中间没有单独的间隔时间。
consumer消费重试
消息处理失败之后，该消息会和其他正常的消息一样被broker处理，之所以能重试是因为consumer会把失败的消息发送回broker，broker对于重试的消息做一些特别的处理，供consumer再次发起消费 。
消息重试的主要流程：
- consumer消费失败，将消息发送回broker
- broker收到重试消息之后置换topic，存储消息
- consumer会拉取该topic对应的retryTopic的消息
- consumer拉取到retryTopic消息之后，置换到原始的topic，把消息交给listener消费
consumer发送重试消息给broker
以非顺序消息为例说明消息消费重试，首先，在消息消费失败后consumer会把消息发送回broker
// org.apache.rocketmq.client.impl.consumer.ConsumeMessageConcurrentlyService.ConsumeRequest#run
public void run() {
// 省略部分代码...
// 这个status是listener返回的，用户可以指定status，如果业务逻辑代码消费消息失败后可以返回org.apache.rocketmq.client.consumer.listener.ConsumeConcurrentlyStatus#RECONSUME_LATER
// 来告诉RocketMQ需要重新消费
// 如果是多个消息，用户还可以指定从哪一个消息开始需要重新消费
status = listener.consumeMessage(Collections.unmodifiableList(msgs), context);
} catch (Throwable e) {
log.warn("consumeMessage exception: {} Group: {} Msgs: {} MQ: {}",
RemotingHelper.exceptionSimpleDesc(e),
ConsumeMessageConcurrentlyService.this.consumerGroup,
msgs,
messageQueue);
hasException = true;
}
long consumeRT = System.currentTimeMillis() - beginTimestamp;
// 根据不同的status判断是否成功
if (null == status) {
if (hasException) {
returnType = ConsumeReturnType.EXCEPTION;
} else {
returnType = ConsumeReturnType.RETURNNULL;
}
} else if (consumeRT >= defaultMQPushConsumer.getConsumeTimeout() * 60 * 1000) {
returnType = ConsumeReturnType.TIME_OUT;
} else if (ConsumeConcurrentlyStatus.RECONSUME_LATER == status) {
returnType = ConsumeReturnType.FAILED;
} else if (ConsumeConcurrentlyStatus.CONSUME_SUCCESS == status) {
returnType = ConsumeReturnType.SUCCESS;
}
if (ConsumeMessageConcurrentlyService.this.defaultMQPushConsumerImpl.hasHook()) {
consumeMessageContext.getProps().put(MixAll.CONSUME_CONTEXT_TYPE, returnType.name());
}
// 用户返回null或者抛出未处理的异常，RocketMQ默认会重试
if (null == status) {
log.warn("consumeMessage return null, Group: {} Msgs: {} MQ: {}",
ConsumeMessageConcurrentlyService.this.consumerGroup,
msgs,
messageQueue);
status = ConsumeConcurrentlyStatus.RECONSUME_LATER;
}
if (!processQueue.isDropped()) {
// 上面的结果在这个方法中具体处理
ConsumeMessageConcurrentlyService.this.processConsumeResult(status, context, this);
} else {
log.warn("processQueue is dropped without process consume result. messageQueue={}, msgs={}", messageQueue, msgs);
}
}
上面这个方法区分出不同的消费结果：
- org.apache.rocketmq.client.consumer.listener.ConsumeConcurrentlyStatus#CONSUME_SUCCESS：消费成功，如果多个消息，用户可以指定从哪一个消息开始重试
- org.apache.rocketmq.client.consumer.listener.ConsumeConcurrentlyStatus#RECONSUME_LATER：重试所有的消息
- 用户返回status为RECONSUME_LATER
- 用户返回null
- 用户业务逻辑处理抛出异常
在确定是否需要重试的时候，进一步处理哪些消息需要重试，也就是哪些消息会发送回broker
public void processConsumeResult(
final ConsumeConcurrentlyStatus status,
final ConsumeConcurrentlyContext context,
final ConsumeRequest consumeRequest
) {
// 从哪里开始重试
// ackIndex默认是int最大值，除非用户自己指定了从哪些消息开始重试
int ackIndex = context.getAckIndex();
if (consumeRequest.getMsgs().isEmpty())
return;
switch (status) {
case CONSUME_SUCCESS:
// 即使是CONSUME_SUCCESS，也可能部分消息需要重试
if (ackIndex >= consumeRequest.getMsgs().size()) {
ackIndex = consumeRequest.getMsgs().size() - 1;
}
int ok = ackIndex + 1;
int failed = consumeRequest.getMsgs().size() - ok;
this.getConsumerStatsManager().incConsumeOKTPS(consumerGroup, consumeRequest.getMessageQueue().getTopic(), ok);
this.getConsumerStatsManager().incConsumeFailedTPS(consumerGroup, consumeRequest.getMessageQueue().getTopic(), failed);
break;
case RECONSUME_LATER:
// 如果status是RECONSUME_LATER的时候会所有消息都会重试所以ackIndex设为-1
ackIndex = -1;
this.getConsumerStatsManager().incConsumeFailedTPS(consumerGroup, consumeRequest.getMessageQueue().getTopic(),
consumeRequest.getMsgs().size());
break;
default:
break;
}
switch (this.defaultMQPushConsumer.getMessageModel()) {
case BROADCASTING:
// 广播的消息不会重试
for (int i = ackIndex + 1; i < consumeRequest.getMsgs().size(); i++) {
MessageExt msg = consumeRequest.getMsgs().get(i);
log.warn("BROADCASTING, the message consume failed, drop it, {}", msg.toString());
}
break;
case CLUSTERING:
// 集群消费的消息才会重试
List<MessageExt> msgBackFailed = new ArrayList<MessageExt>(consumeRequest.getMsgs().size());
for (int i = ackIndex + 1; i < consumeRequest.getMsgs().size(); i++) {
MessageExt msg = consumeRequest.getMsgs().get(i);
// 将消息发送回broker
boolean result = this.sendMessageBack(msg, context);
if (!result) {
msg.setReconsumeTimes(msg.getReconsumeTimes() + 1);
msgBackFailed.add(msg);
}
}
if (!msgBackFailed.isEmpty()) {
consumeRequest.getMsgs().removeAll(msgBackFailed);
// 如果上面发送失败后后面会重新发送
this.submitConsumeRequestLater(msgBackFailed, consumeRequest.getProcessQueue(), consumeRequest.getMessageQueue());
}
break;
default:
break;
}
long offset = consumeRequest.getProcessQueue().removeMessage(consumeRequest.getMsgs());
if (offset >= 0 && !consumeRequest.getProcessQueue().isDropped()) {
// 更新消费进度
this.defaultMQPushConsumerImpl.getOffsetStore().updateOffset(consumeRequest.getMessageQueue(), offset, true);
}
}
consumer发送消费失败的消息和普通的producer发送消息的调用路径前面不太一样，其中关键的区别是下面的方法
// org.apache.rocketmq.client.impl.consumer.DefaultMQPushConsumerImpl#sendMessageBack
public void sendMessageBack(MessageExt msg, int delayLevel, final String brokerName)
throws RemotingException, MQBrokerException, InterruptedException, MQClientException {
try {
String brokerAddr = (null != brokerName) ? this.mQClientFactory.findBrokerAddressInPublish(brokerName)
: RemotingHelper.parseSocketAddressAddr(msg.getStoreHost());
this.mQClientFactory.getMQClientAPIImpl().consumerSendMessageBack(brokerAddr, msg,
this.defaultMQPushConsumer.getConsumerGroup(), delayLevel, 5000, getMaxReconsumeTimes());
} catch (Exception e) {
log.error("sendMessageBack Exception, " + this.defaultMQPushConsumer.getConsumerGroup(), e);
// 如果消费失败的消息发送回broker失败了，会再重试一次，和try里面的方法不一样的地方是这里直接修改topic
// 为重试topic然后和producer发送消息的方法一样发送到broker
Message newMsg = new Message(MixAll.getRetryTopic(this.defaultMQPushConsumer.getConsumerGroup()), msg.getBody());
String originMsgId = MessageAccessor.getOriginMessageId(msg);
MessageAccessor.setOriginMessageId(newMsg, UtilAll.isBlank(originMsgId) ? msg.getMsgId() : originMsgId);
newMsg.setFlag(msg.getFlag());
MessageAccessor.setProperties(newMsg, msg.getProperties());
MessageAccessor.putProperty(newMsg, MessageConst.PROPERTY_RETRY_TOPIC, msg.getTopic());
MessageAccessor.setReconsumeTime(newMsg, String.valueOf(msg.getReconsumeTimes() + 1));
MessageAccessor.setMaxReconsumeTimes(newMsg, String.valueOf(getMaxReconsumeTimes()));
newMsg.setDelayTimeLevel(3 + msg.getReconsumeTimes());
this.mQClientFactory.getDefaultMQProducer().send(newMsg);
}
}
// org.apache.rocketmq.client.impl.MQClientAPIImpl#consumerSendMessageBack
public void consumerSendMessageBack(
final String addr,
final MessageExt msg,
final String consumerGroup,
final int delayLevel,
final long timeoutMillis,
final int maxConsumeRetryTimes
) throws RemotingException, MQBrokerException, InterruptedException {
ConsumerSendMsgBackRequestHeader requestHeader = new ConsumerSendMsgBackRequestHeader();
// 和普通的发送消息的RequestCode不一样，broker处理的方法也不一样
RemotingCommand request = RemotingCommand.createRequestCommand(RequestCode.CONSUMER_SEND_MSG_BACK, requestHeader);
requestHeader.setGroup(consumerGroup);
// 因为重试的消息被broker拿到后会修改topic，所以这里设置原始的topic
requestHeader.setOriginTopic(msg.getTopic());
// broker会根据offset查询原始的消息
requestHeader.setOffset(msg.getCommitLogOffset());
// 设置delayLevel，这个值决定了该消息是否会被延时消费、延时多久，
// 用户可以设置延时等级，默认是0，不延时(但是broker端会有逻辑：如果为0会加3)
requestHeader.setDelayLevel(delayLevel);
// 设置最初的msgId
requestHeader.setOriginMsgId(msg.getMsgId());
// 设置最多被重试的次数，默认是16
requestHeader.setMaxReconsumeTimes(maxConsumeRetryTimes);
RemotingCommand response = this.remotingClient.invokeSync(MixAll.brokerVIPChannel(this.clientConfig.isVipChannelEnabled(), addr),
request, timeoutMillis);
assert response != null;
switch (response.getCode()) {
case ResponseCode.SUCCESS: {
return;
}
default:
break;
}
throw new MQBrokerException(response.getCode(), response.getRemark());
}
发送重试的消息的时候有几个关键属性：
originTopic：因为重试的消息被broker拿到后会修改topic，投递到所以需要保留一个原始的topic
delayLevel：该消息是否会被延时消费
maxReconsumeTimes：这个消息最多可以重试（消费）多少次
broker接收重试消息
broker处理重试消息的方式和普通消息略有不同
- 检查是否配置了重试的消息队列，队列是否可写
- 查询原始消息
- 判断是否超过最大重试次数或者delayLevel小于0，消息不会被重试，而是会被投递到死信队列（不会再被消费），topic是%DLQ%+group
- 如果delayLevel是0，0表示会被延时10s（如果是默认的延时等级，关于延时消息的部分详见：这一篇）
- 根据原始消息构造新消息保存，差异字段为：
- topic：%RETRY%+group
- reconsumeTimes：原来的reconsumeTimes + 1，也就是说每重试一次就加1
- queueId：使用新的topic的queueId
- 新增properties：ORIGIN_MESSAGE_ID，RETRY_TOPIC（如果原来没有的话）
// 代码不再赘述，主要方法是
org.apache.rocketmq.broker.processor.SendMessageProcessor#consumerSendMsgBack
consumer拉取重试的消息
按照正常的消息消费流程，消息保存在broker之后，consumer就可以拉取消费了，和普通消息不一样的是拉取消息的并不是consumer本来订阅的topic，而是%RETRY%+group。
这里一直默认一开始retryTopic本身存在，这里说明一下retryTopic的来源，retryTopic创建的时机有以下几个：
-
consumer启动后会向broker发送heartbeat数据，如果broker中还没有对应的SubscriptionGroupConfig
信息，会创建对应topic的retryTopic：org.apache.rocketmq.broker.processor.ClientManageProcessor#heartBeatbroker
-
broker在接收到consumer发送回来的重试的时候，如果还没有创建retryTopic的topicConfig配置，则会新建：org.apache.rocketmq.broker.processor.AbstractSendMessageProcessor#msgCheck
-
broker在处理consumer发送回来的重试消息的时候会创建retryTopic：org.apache.rocketmq.broker.processor.SendMessageProcessor#consumerSendMsgBack
broker创建retryTopic之后，和正常的topic配置一样同步到namesrv，然后consumer就可以从namesrv获取到retryTopic配置了。
所以consumer会拉取%RETRY%+group对应的消息：
- consumer发送重试消息给broker以后，broker存储在新的retryTopic下，作为一个新的topic，consume会拉取这个新的topic的消息
- consumer拉取到这个retryTopic的消息之后再把topic换成原来的topic：org.apache.rocketmq.client.impl.consumer.ConsumeMessageConcurrentlyService#resetRetryTopic，然后交给consume的listener处理
总结
在业务处理出错的时候，常常需要重新处理，这个时候业务可以返回RECONSUME_LATER，RocketMQ就会重新将消息发送回broker，让consumer重试。而且，用户也可以根据实际情况，指定一些配置，比如：重试次数，是否延时消费等。但是需要注意的是如果业务抛出异常后无需重试，一定要catch住所有异常，避免把异常抛给RocketMQ，否则RocketMQ会认为该消息需要重试，当然也不能返回null。