RocketMQ源码分析——消息发送的高可用
消息的发送与接收 这一篇仅简单介绍了消息的发送流程，很多细节没有提及，这篇将详细介绍消息发送的高可用 RocketMQ 是怎么做的。
文章目录
-
-
-
- Topic 路由信息有什么用，里面包含什么，又是什么时候创建的？
- 消息怎么知道应该发到哪个 Broker 的哪个 queue 中？
- 故障规避是怎么做到的呢？
- 消息的主题究竟是什么时候创建的？
- NameServer 是如何完成 Broker 注册的？
- 消息发送者怎么感知消息的主题变化？
- 消息发送失败怎么进行重试？
-
-
Topic 路由信息有什么用，里面包含什么，又是什么时候创建的？
正式环境一般不允许发送消息的时候自动创建 Topic，会设置 autoCreateTopicEnable = false，然后需要提前通过控制台创建好相应的 Topic，这里做测试使用默认配置。那具体在源码中是在哪里，又是怎么创建的呢？
发送消息前先获取 Topic 发布信息
- List
：消息队列信息，表明 Topic 可以发往存储消息的 Master Broker 名称及队列序号 - TopicRouteData ：Topic 路由信息，消息过滤服务
- QueueData ：每个 Broker 可以读写的队列数量、权限
- BrokerData ：每个 Broker 的主从标识及IP地址
DefaultMQProducerImpl#sendDefaultImpl 发送消息
TopicPublishInfo topicPublishInfo = this.tryToFindTopicPublishInfo(msg.getTopic());
public class TopicPublishInfo {
private boolean orderTopic = false;
private boolean haveTopicRouterInfo = false;
private List<MessageQueue> messageQueueList = new ArrayList<MessageQueue>();
private volatile ThreadLocalIndex sendWhichQueue = new ThreadLocalIndex();
private TopicRouteData topicRouteData;
}
public class MessageQueue implements Comparable<MessageQueue>, Serializable {
private static final long serialVersionUID = 6191200464116433425L;
private String topic;
private String brokerName;
private int queueId;
}
public class TopicRouteData extends RemotingSerializable {
private String orderTopicConf;
private List<QueueData> queueDatas;
private List<BrokerData> brokerDatas;
private HashMap<String/* brokerAddr */, List<String>/* Filter Server */> filterServerTable;
}
public class QueueData implements Comparable<QueueData> {
private String brokerName;
private int readQueueNums;
private int writeQueueNums;
private int perm;
private int topicSynFlag;
}
public class BrokerData implements Comparable<BrokerData> {
private String cluster;
private String brokerName;
private HashMap<Long/* brokerId */, String/* broker address */> brokerAddrs;
}
准备获取路由信息
private TopicPublishInfo tryToFindTopicPublishInfo(final String topic) {
TopicPublishInfo topicPublishInfo = this.topicPublishInfoTable.get(topic);
if (null == topicPublishInfo || !topicPublishInfo.ok()) {
this.topicPublishInfoTable.putIfAbsent(topic, new TopicPublishInfo());
this.mQClientFactory.updateTopicRouteInfoFromNameServer(topic);
topicPublishInfo = this.topicPublishInfoTable.get(topic);
}
if (topicPublishInfo.isHaveTopicRouterInfo() || topicPublishInfo.ok()) {
return topicPublishInfo;
} else {
this.mQClientFactory.updateTopicRouteInfoFromNameServer(topic, true, this.defaultMQProducer);
topicPublishInfo = this.topicPublishInfoTable.get(topic);
return topicPublishInfo;
}
}
在主题没有创建的情况下，会进入到第4行，先从缓存中按照 topic 名称查找，找到就返回。然后执行 updateTopicRouteInfoFromNameServer 更新路由信息，这一步更新实际没啥用会打印错误日志，因为此时 NameServer 中没有此主题的信息。然后代码进入到第11行再次获取，此时传递了一个 true 的参数表明使用默认的主题。
public static final String AUTO_CREATE_TOPIC_KEY_TOPIC = "TBW102"; // Will be created at broker when isAutoCreateTopicEnable
从 NameServer 获取默认的 Topic#TBW102 路由信息来创建一个 TopicPublishInfo 对象。
MQClientInstance#updateTopicRouteInfoFromNameServer 更新主题路由信息
// 是否是需要按照默认主题创建新主题
if (isDefault && defaultMQProducer != null) {
// 再次进入这里获取默认主题 TBW102 的信息
topicRouteData = this.mQClientAPIImpl.getDefaultTopicRouteInfoFromNameServer(defaultMQProducer.getCreateTopicKey(),
1000 * 3);
if (topicRouteData != null) {
for (QueueData data : topicRouteData.getQueueDatas()) {
// 设置读写队列数量，默认读写数量都为4
int queueNums = Math.min(defaultMQProducer.getDefaultTopicQueueNums(), data.getReadQueueNums());
data.setReadQueueNums(queueNums);
data.setWriteQueueNums(queueNums);
}
}
} else {
// 第一次调用会进入这里，向 NameServer 获取主题信息，然后获取不到数据抛异常，在后面被捕获打印日志
topicRouteData = this.mQClientAPIImpl.getTopicRouteInfoFromNameServer(topic, 1000 * 3);
}
按照请求代码 RequestCode.GET_ROUTEINTO_BY_TOPIC 向 NameServer 发送查询主题路由信息请求。NameServer 调用 pickupTopicRouteData 方法返回结果。
public TopicRouteData pickupTopicRouteData(final String topic) {
TopicRouteData topicRouteData = new TopicRouteData();
...
// 从缓存中按照主题取队列数据
List<QueueData> queueDataList = this.topicQueueTable.get(topic);
...
// 从缓存中按照 Broker 名称取 Broker 详细信息（brokerId - address）
BrokerData brokerData = this.brokerAddrTable.get(brokerName);
...
// 将数据封装到 TopicRouteData 返回给客户端
}
获取到主题 TBW102 的路由信息后，更新客户端的路由缓存。
if (topicRouteData != null) {
// 获取之前的缓存
TopicRouteData old = this.topicRouteTable.get(topic);
// 判断是否发生改变
boolean changed = topicRouteDataIsChange(old, topicRouteData);
if (!changed) {
// 再次判断默认的客户端实例中的主题发布信息是否有效，如果是消费者则判断负载均衡中的缓存是否有变化
changed = this.isNeedUpdateTopicRouteInfo(topic);
} else {
log.info("the topic[{}] route info changed, old[{}] ,new[{}]", topic, old, topicRouteData);
}
if (changed) {
// 发生了变化，需要更新本地缓存
TopicRouteData cloneTopicRouteData = topicRouteData.cloneTopicRouteData();
// 更新 Broker 地址
for (BrokerData bd : topicRouteData.getBrokerDatas()) {
this.brokerAddrTable.put(bd.getBrokerName(), bd.getBrokerAddrs());
}
// 修改主题发布信息
{
// 转换下数据格式
TopicPublishInfo publishInfo = topicRouteData2TopicPublishInfo(topic, topicRouteData);
publishInfo.setHaveTopicRouterInfo(true);
Iterator<Entry<String, MQProducerInner>> it = this.producerTable.entrySet().iterator();
while (it.hasNext()) {
// 每个客户端实例都需要更新路由信息
Entry<String, MQProducerInner> entry = it.next();
MQProducerInner impl = entry.getValue();
if (impl != null) {
// 这里最终更新到本地的缓存表
impl.updateTopicPublishInfo(topic, publishInfo);
}
}
}
// Update sub info 省略消费者的信息，之后的文章再分析
...
log.info("topicRouteTable.put. Topic = {}, TopicRouteData[{}]", topic, cloneTopicRouteData);
// 放到缓存中
this.topicRouteTable.put(topic, cloneTopicRouteData);
return true;
}
}
为什么需要转换下数据格式，去执行 topicRouteData2TopicPublishInfo？这是为了创建发送负载队列，需要删除掉没有写权限的队列以及 Slave 节点，为之后发送消息选择队列做准备。
List<QueueData> qds = route.getQueueDatas();
// 默认按照 Broker 名称排序
Collections.sort(qds);
for (QueueData qd : qds) {
// 没有写权限不加入到队列
if (PermName.isWriteable(qd.getPerm())) {
BrokerData brokerData = null;
for (BrokerData bd : route.getBrokerDatas()) {
// QueueData 重写了 equals 方法，里面详细对比了属性信息
if (bd.getBrokerName().equals(qd.getBrokerName())) {
brokerData = bd;
break;
}
}
if (null == brokerData) {
continue;
}
// 非 MASTER 节点不加入到队列
if (!brokerData.getBrokerAddrs().containsKey(MixAll.MASTER_ID)) {
continue;
}
// 按照写队列个数创建多个 MessageQueue
for (int i = 0; i < qd.getWriteQueueNums(); i++) {
MessageQueue mq = new MessageQueue(topic, qd.getBrokerName(), i);
info.getMessageQueueList().add(mq);
}
}
}
消息怎么知道应该发到哪个 Broker 的哪个 queue 中？
上面准备好路由信息之后，开始选择 Broker 以及 queue。回到 sendDefaultImpl 方法，有这么一段代码获取队列 queue，lastBrokerName 代表上次发往的 Broker 名称。
MessageQueue mqSelected = this.selectOneMessageQueue(topicPublishInfo, lastBrokerName);
public MessageQueue selectOneMessageQueue(final TopicPublishInfo tpInfo, final String lastBrokerName) {
return this.mqFaultStrategy.selectOneMessageQueue(tpInfo, lastBrokerName);
}
调用了 mqFaultStrategy 容错策略，默认 sendLatencyFaultEnable = false 不开启，即容错策略不生效。
不开启的情况下会直接调用 selectOneMessageQueue 轮询队列返回一个 MessageQueue，若存在上个 lastBrokerName，尝试发往其他的 Broker，做到负载实现高可用。
public MessageQueue selectOneMessageQueue(final String lastBrokerName) {
if (lastBrokerName == null) {
return selectOneMessageQueue();
} else {
int index = this.sendWhichQueue.getAndIncrement();
for (int i = 0; i < this.messageQueueList.size(); i++) {
int pos = Math.abs(index++) % this.messageQueueList.size();
if (pos < 0)
pos = 0;
MessageQueue mq = this.messageQueueList.get(pos);
// 规避掉 lastBrokerName
if (!mq.getBrokerName().equals(lastBrokerName)) {
return mq;
}
}
return selectOneMessageQueue();
}
}
public MessageQueue selectOneMessageQueue() {
// 轮询，使用了 ThreadLocal
int index = this.sendWhichQueue.getAndIncrement();
int pos = Math.abs(index) % this.messageQueueList.size();
if (pos < 0)
pos = 0;
return this.messageQueueList.get(pos);
}
如果开启 sendLatencyFaultEnable，在随机递增取模的基础上，再过滤掉 not available 的 Broker 代理。
故障规避是怎么做到的呢？
适用场景：若向某个 Broker 发送消息失败，再次递增取模仍可能是原来的那个异常的 Broker，可否有一种策略能够在一定的时间内不向那个 Broker 发送消息。
latencyFaultTolerance 是指对之前失败的，按一定的时间做退避，它是实现消息发送高可用的核心关键所在。
public class LatencyFaultToleranceImpl implements LatencyFaultTolerance<String> {
private final ConcurrentHashMap<String, FaultItem> faultItemTable = new ConcurrentHashMap<String, FaultItem>(16);
}
class FaultItem implements Comparable<FaultItem> {
private final String name;
private volatile long currentLatency;
private volatile long startTimestamp;
}
若某一次发送消息失败，会记录失败的 Broker，调用 updateFaultItem 方法。
传递了三个参数：Broker 名称，本次发送的时间，是否隔离。
public void updateFaultItem(final String brokerName, final long currentLatency, boolean isolation) {
if (this.sendLatencyFaultEnable) {
long duration = computeNotAvailableDuration(isolation ? 30000 : currentLatency);
this.latencyFaultTolerance.updateFaultItem(brokerName, currentLatency, duration);
}
}
computeNotAvailableDuration 计算应该规避的时间
private long[] latencyMax = {
50L, 100L, 550L, 1000L, 2000L, 3000L, 15000L};
private long[] notAvailableDuration = {
0L, 0L, 30000L, 60000L, 120000L, 180000L, 600000L};
private long computeNotAvailableDuration(final long currentLatency) {
for (int i = latencyMax.length - 1; i >= 0; i--) {
if (currentLatency >= latencyMax[i])
return this.notAvailableDuration[i];
}
return 0;
}
例如，如果上次请求的 currentLatency 超过550Lms，就退避3000Lms；超过1000L，就退避60000L。
然后将本次计算的延迟时间进行缓存
LatencyFaultToleranceImpl#updateFaultItem
public void updateFaultItem(final String name, final long currentLatency, final long notAvailableDuration) {
FaultItem old = this.faultItemTable.get(name);
if (null == old) {
final FaultItem faultItem = new FaultItem(name);
faultItem.setCurrentLatency(currentLatency);
faultItem.setStartTimestamp(System.currentTimeMillis() + notAvailableDuration);
old = this.faultItemTable.putIfAbsent(name, faultItem);
if (old != null) {
old.setCurrentLatency(currentLatency);
old.setStartTimestamp(System.currentTimeMillis() + notAvailableDuration);
}
} else {
old.setCurrentLatency(currentLatency);
old.setStartTimestamp(System.currentTimeMillis() + notAvailableDuration);
}
}
判断缓存是否存在此 Broker 的延迟信息，有的话就更新，没有就创建一个 FaultItem。FaultItem.startTimestamp 代表下次可以使用的时间。
再发送新建消息请求的时候，执行规避策略。
public MessageQueue selectOneMessageQueue(final TopicPublishInfo tpInfo, final String lastBrokerName) {
if (this.sendLatencyFaultEnable) {
try {
int index = tpInfo.getSendWhichQueue().getAndIncrement();
for (int i = 0; i < tpInfo.getMessageQueueList().size(); i++) {
int pos = Math.abs(index++) % tpInfo.getMessageQueueList().size();
if (pos < 0)
pos = 0;
MessageQueue mq = tpInfo.getMessageQueueList().get(pos);
if (latencyFaultTolerance.isAvailable(mq.getBrokerName())) {
if (null == lastBrokerName || mq.getBrokerName().equals(lastBrokerName))
return mq;
}
}
final String notBestBroker = latencyFaultTolerance.pickOneAtLeast();
int writeQueueNums = tpInfo.getQueueIdByBroker(notBestBroker);
if (writeQueueNums > 0) {
final MessageQueue mq = tpInfo.selectOneMessageQueue();
if (notBestBroker != null) {
mq.setBrokerName(notBestBroker);
mq.setQueueId(tpInfo.getSendWhichQueue().getAndIncrement() % writeQueueNums);
}
return mq;
} else {
latencyFaultTolerance.remove(notBestBroker);
}
} catch (Exception e) {
log.error("Error occurred when selecting message queue", e);
}
// 策略失败就轮询选择一个
return tpInfo.selectOneMessageQueue();
}
}
步骤一：遍历消息发送队列，判断各个 Broker 是否可用。
LatencyFaultToleranceImpl.FaultItem#isAvailable
public boolean isAvailable() {
return (System.currentTimeMillis() - startTimestamp) >= 0;
}
步骤二：步骤一没有找到 Broker，可能此时 Broker 失效时间还没过去，执行 pickOneAtLeast 来选择延迟时间最近的 Broker。
步骤三：此 Broker 没有写队列就移除。
步骤四：上面没有找到 Broker，随机递增取模选择一个 Broker，保证消息要往外发送。
消息的主题究竟是什么时候创建的？
到这里其实 Topic 还没有创建，需要等到 Broker 接受到新消息，判断 Topic 配置信息是否存在，然后再进行创建。
AbstractSendMessageProcessor#msgCheck
protected RemotingCommand msgCheck(final ChannelHandlerContext ctx,
final SendMessageRequestHeader requestHeader, final RemotingCommand response) {
// 校验有没有写权限
// 校验此 Topic 是否是系统默认主题
// 获取缓存中此 Topic 的 TopicConfig
TopicConfig topicConfig =
this.brokerController.getTopicConfigManager().selectTopicConfig(requestHeader.getTopic());
// 没有 TopicConfig 就创建一个
topicConfig = this.brokerController.getTopicConfigManager().createTopicInSendMessageMethod(
requestHeader.getTopic(),
requestHeader.getDefaultTopic(),
RemotingHelper.parseChannelRemoteAddr(ctx.channel()),
requestHeader.getDefaultTopicQueueNums(), topicSysFlag);
// 校验写队列序号是否超出返回
}
TopicConfigManager#createTopicInSendMessageMethod
由默认主题创建，会校验是否开启 autoCreateTopicEnable。
TopicConfig defaultTopicConfig = this.topicConfigTable.get(defaultTopic);
if (defaultTopicConfig != null) {
if (defaultTopic.equals(MixAll.AUTO_CREATE_TOPIC_KEY_TOPIC)) {
if (!this.brokerController.getBrokerConfig().isAutoCreateTopicEnable()) {
// 修改默认主题的权限
defaultTopicConfig.setPerm(PermName.PERM_READ | PermName.PERM_WRITE);
}
}
...
// 校验权限
if (PermName.isInherited(defaultTopicConfig.getPerm())) {
// 新建一个 TopicConfig
topicConfig = new TopicConfig(topic);
...
topicConfig.setReadQueueNums(queueNums);
topicConfig.setWriteQueueNums(queueNums);
int perm = defaultTopicConfig.getPerm();
perm &= ~PermName.PERM_INHERIT;
topicConfig.setPerm(perm);
...
}
}
如果有创建一个 TopicConfig，更新缓存，更新缓存版本，持久化主题信息到 topics.json 本地文件。
if (topicConfig != null) {
log.info("Create new topic by default topic:[{}] config:[{}] producer:[{}]",
defaultTopic, topicConfig, remoteAddress);
this.topicConfigTable.put(topic, topicConfig);
this.dataVersion.nextVersion();
createNew = true;
this.persist();
}
强制向所有 NameServer 发送心跳，以 invokeOneway 方式，请求命令代码 RequestCode.REGISTER_BROKER。
if (createNew) {
this.brokerController.registerBrokerAll(false, true,true);
}
NameServer 接受注册请求，更新本地的缓存信息，其中就有 Topic 配置信息。
NameServer 是如何完成 Broker 注册的？
Broker 在启动后也会定期向 NameServer 发送心跳。
this.scheduledExecutorService.scheduleAtFixedRate(new Runnable() {
@Override
public void run() {
try {
BrokerController.this.registerBrokerAll(true, false, brokerConfig.isForceRegister());
} catch (Throwable e) {
log.error("registerBrokerAll Exception", e);
}
}
}, 1000 * 10, Math.max(10000, Math.min(brokerConfig.getRegisterNameServerPeriod(), 60000)), TimeUnit.MILLISECONDS);
关键看 NameServer 如何加入或者更新一个 Broker
RouteInfoManager#registerBroker
public RegisterBrokerResult registerBroker(
final String clusterName,//集群名称
final String brokerAddr,//Broker地址
final String brokerName,//Broker名称
final long brokerId,//主从标识
final String haServerAddr,//master地址
final TopicConfigSerializeWrapper topicConfigWrapper,//主题配置
final List<String> filterServerList,//消息过滤服务器列表
final Channel channel) {
...}
步骤一：上读写锁，串行处理心跳，更新缓存 clusterAddrTable，Broke 集群信息
this.lock.writeLock().lockInterruptibly();
Set<String> brokerNames = this.clusterAddrTable.get(clusterName);
if (null == brokerNames) {
brokerNames = new HashSet<String>();
this.clusterAddrTable.put(clusterName, brokerNames);
}
brokerNames.add(brokerName);
步骤二：更新缓存 brokerAddrTable，更新 Broker 的基础信息，brokerId 为0代表 Master
boolean registerFirst = false;
BrokerData brokerData = this.brokerAddrTable.get(brokerName);
if (null == brokerData) {
registerFirst = true;
brokerData = new BrokerData(clusterName, brokerName, new HashMap<Long, String>());
this.brokerAddrTable.put(brokerName, brokerData);
}
// 主从切换，先删除之前的地址记录
...
String oldAddr = brokerData.getBrokerAddrs().put(brokerId, brokerAddr);
// 是否第一次注册
registerFirst = registerFirst || (null == oldAddr);
步骤三：Master Broker 在主题配置被修改的情况下（通过比较 DataVersion）或者第一次注册，更新缓存 topicQueueTable 的消息队列
if (null != topicConfigWrapper
&& MixAll.MASTER_ID == brokerId) {
if (this.isBrokerTopicConfigChanged(brokerAddr, topicConfigWrapper.getDataVersion())
|| registerFirst) {
ConcurrentMap<String, TopicConfig> tcTable =
topicConfigWrapper.getTopicConfigTable();
if (tcTable != null) {
for (Map.Entry<String, TopicConfig> entry : tcTable.entrySet()) {
this.createAndUpdateQueueData(brokerName, entry.getValue());
}
}
}
}
步骤四：更新缓存 brokerLiveTable，Broker 是否存活
BrokerLiveInfo prevBrokerLiveInfo = this.brokerLiveTable.put(brokerAddr,
new BrokerLiveInfo(
System.currentTimeMillis(),
topicConfigWrapper.getDataVersion(),
channel,
haServerAddr));
步骤五：更新缓存 filterServerTable，消息过滤服务
if (filterServerList != null) {
if (filterServerList.isEmpty()) {
this.filterServerTable.remove(brokerAddr);
} else {
this.filterServerTable.put(brokerAddr, filterServerList);
}
}
步骤六：若是 Slave Broker，更新它的 Master 地址
if (MixAll.MASTER_ID != brokerId) {
String masterAddr = brokerData.getBrokerAddrs().get(MixAll.MASTER_ID);
if (masterAddr != null) {
BrokerLiveInfo brokerLiveInfo = this.brokerLiveTable.get(masterAddr);
if (brokerLiveInfo != null) {
result.setHaServerAddr(brokerLiveInfo.getHaServerAddr());
result.setMasterAddr(masterAddr);
}
}
}
消息发送者怎么感知消息的主题变化？
客户端启动后，消息生产者每隔30s定期向 NameServer 获取主题路由信息。
this.scheduledExecutorService.scheduleAtFixedRate(new Runnable() {
@Override
public void run() {
try {
MQClientInstance.this.updateTopicRouteInfoFromNameServer();
} catch (Exception e) {
log.error("ScheduledTask updateTopicRouteInfoFromNameServer exception", e);
}
}
}, 10, this.clientConfig.getPollNameServerInterval(), TimeUnit.MILLISECONDS);
生产者和消费者都是同一个实例，因此同时更新订阅的主题和创建的主题
private final ConcurrentMap<String/* group */, MQProducerInner> producerTable = new ConcurrentHashMap<String, MQProducerInner>();
private final ConcurrentMap<String/* group */, MQConsumerInner> consumerTable = new ConcurrentHashMap<String, MQConsumerInner>();
public void updateTopicRouteInfoFromNameServer() {
Set<String> topicList = new HashSet<String>();
...
// 从 producerTable 和 consumerTable 取出所有 Topic，放到 topicList 中
for (String topic : topicList) {
MQClientInstance#updateTopicRouteInfoFromNameServer(topic, false, null);
}
}
再调用 updateTopicRouteInfoFromNameServer 更新本地缓存，调整负载队列。
消息发送失败怎么进行重试？
- 同步消息：发送前读取应该重试的次数，然后进行循环发送，成功一次就返回，默认 retryTimesWhenSendFailed = 2，共发送三次。
int timesTotal = communicationMode == CommunicationMode.SYNC ? 1 + this.defaultMQProducer.getRetryTimesWhenSendFailed() : 1;
int times = 0;
for (; times < timesTotal; times++) {
...
sendResult = this.sendKernelImpl(msg, mq, communicationMode, sendCallback, topicPublishInfo, timeout - costTime);
...
return sendResult;
}
- 异步消息：这时 timesTotal = 1，异步发送失败重试的次数由 retryTimesWhenSendAsyncFailed 参数控制，默认也为2，重试逻辑在回调函数中，必须收到 Broker 的响应才会判断是否需要重试。
MQClientAPIImpl#sendMessageAsync
...
this.remotingClient.invokeAsync(addr, request, timeoutMillis, new InvokeCallback() {
...
// 获取到结果后就 return 了。
if (response != null) {
...
} else {
// times 初始为0 ，每次会加一，大于 retryTimesWhenSendFailed 就不会再执行
onExceptionImpl(brokerName, msg, 0L, request, sendCallback, topicPublishInfo, instance,
retryTimesWhenSendFailed, times, ex, context, true, producer);
}
}
);
- 单向发送：不关注发送结果，没有重试。
到这里分析完毕，对照官方文档来看更清晰。