SYSTEM
Producer
src/content/notes/system/Producer.md Producer
生产者类
生产者类
DefaultMQProducer 是生产者的默认实现类
成员变量:
-
生产者实现类:
protected final transient DefaultMQProducerImpl defaultMQProducerImpl -
生产者组:发送事务消息,Broker 端进行事务回查(补偿机制)时,选择当前生产者组的下一个生产者进行事务回查
private String producerGroup; -
默认主题:isAutoCreateTopicEnable 开启时,当发送消息指定的 Topic 在 Namesrv 未找到路由信息,使用该值创建 Topic 信息
private String createTopicKey = TopicValidator.AUTO_CREATE_TOPIC_KEY_TOPIC; // 值为【TBW102】,Just for testing or demo program -
消息重投:系统特性消息重试部分详解了三个参数的作用
private int retryTimesWhenSendFailed = 2; // 同步发送失败后重试的发送次数,加上第一次发送,一共三次 private int retryTimesWhenSendAsyncFailed = 2; // 异步 private boolean retryAnotherBrokerWhenNotStoreOK = false; // 消息未存储成功,选择其他 Broker 重试 -
消息队列:
private volatile int defaultTopicQueueNums = 4; // 默认 Broker 创建的队列数 -
消息属性:
private int sendMsgTimeout = 3000; // 发送消息的超时限制 private int compressMsgBodyOverHowmuch = 1024 * 4; // 压缩阈值,当 msg body 超过 4k 后使用压缩 private int maxMessageSize = 1024 * 1024 * 4; // 消息体的最大限制,默认 4M private TraceDispatcher traceDispatcher = null; // 消息轨迹
构造方法:
-
构造方法:
public DefaultMQProducer(final String namespace, final String producerGroup, RPCHook rpcHook) { this.namespace = namespace; this.producerGroup = producerGroup; // 创建生产者实现对象 defaultMQProducerImpl = new DefaultMQProducerImpl(this, rpcHook); }
成员方法:
-
start():启动方法
public void start() throws MQClientException { // 重置生产者组名,如果传递了命名空间,则 【namespace%group】 this.setProducerGroup(withNamespace(this.producerGroup)); // 生产者实现对象启动 this.defaultMQProducerImpl.start(); if (null != traceDispatcher) { // 消息轨迹的逻辑 traceDispatcher.start(this.getNamesrvAddr(), this.getAccessChannel()); } } -
send():发送消息:
public SendResult send(Message msg){ // 校验消息 Validators.checkMessage(msg, this); // 设置消息 Topic msg.setTopic(withNamespace(msg.getTopic())); return this.defaultMQProducerImpl.send(msg); } -
request():请求方法,需要消费者回执消息
public Message request(final Message msg, final MessageQueue mq, final long timeout) { msg.setTopic(withNamespace(msg.getTopic())); return this.defaultMQProducerImpl.request(msg, mq, timeout); }
实现者类
DefaultMQProducerImpl 类是默认的生产者实现类
成员变量:
-
实例对象:
private final DefaultMQProducer defaultMQProducer; // 持有默认生产者对象,用来获取对象中的配置信息 private MQClientInstance mQClientFactory; // 客户端实例对象,生产者启动后需要注册到该客户端对象内 -
主题发布信息映射表:key 是 Topic,value 是发布信息
private final ConcurrentMap<String, TopicPublishInfo> topicPublishInfoTable = new ConcurrentHashMap<String, TopicPublishInfo>(); -
异步发送消息:相关信息
private final BlockingQueue<Runnable> asyncSenderThreadPoolQueue;// 异步发送消息,异步线程池使用的队列 private final ExecutorService defaultAsyncSenderExecutor; // 异步发送消息默认使用的线程池 private ExecutorService asyncSenderExecutor; // 异步消息发送线程池,指定后就不使用默认线程池了 -
定时器:执行定时任务
private final Timer timer = new Timer("RequestHouseKeepingService", true); // 守护线程 -
状态信息:服务的状态,默认创建状态
private ServiceState serviceState = ServiceState.CREATE_JUST; -
压缩等级:ZIP 压缩算法的等级,默认是 5,越高压缩效果好,但是压缩的更慢
private int zipCompressLevel = Integer.parseInt(System.getProperty..., "5")); -
容错策略:选择队列的容错策略
private MQFaultStrategy mqFaultStrategy = new MQFaultStrategy(); -
钩子:用来进行前置或者后置处理
ArrayList<SendMessageHook> sendMessageHookList; // 发送消息的钩子,留给用户扩展使用 ArrayList<CheckForbiddenHook> checkForbiddenHookList; // 对比上面的钩子,可以抛异常,控制消息是否可以发送 private final RPCHook rpcHook; // 传递给 NettyRemotingClient
构造方法:
-
默认构造:
public DefaultMQProducerImpl(final DefaultMQProducer defaultMQProducer) { // 默认 RPC HOOK 是空 this(defaultMQProducer, null); } -
有参构造:
public DefaultMQProducerImpl(final DefaultMQProducer defaultMQProducer, RPCHook rpcHook) { // 属性赋值 this.defaultMQProducer = defaultMQProducer; this.rpcHook = rpcHook; // 创建【异步消息线程池任务队列】,长度是 5w this.asyncSenderThreadPoolQueue = new LinkedBlockingQueue<Runnable>(50000); // 创建默认的异步消息任务线程池 this.defaultAsyncSenderExecutor = new ThreadPoolExecutor( // 核心线程数和最大线程数都是 系统可用的计算资源(8核16线程的系统就是 16)... }
实现方法
-
start():启动方法,参数默认是 true,代表正常的启动路径
public void start(final boolean startFactory)-
this.serviceState = ServiceState.START_FAILED:先修改为启动失败,成功后再修改,这种思想很常见 -
this.checkConfig():判断生产者组名不能是空,也不能是 default_PRODUCER -
if (!getProducerGroup().equals(MixAll.CLIENT_INNER_PRODUCER_GROUP)):条件成立说明当前生产者不是内部产生者,内部生产者是处理消息回退的这种情况使用的生产者this.defaultMQProducer.changeInstanceNameToPID():修改生产者实例名称为当前进程的 PID -
this.mQClientFactory = ...:获取当前进程的 MQ 客户端实例对象,从 factoryTable 中获取 key 为 客户端 ID,格式是ip@pid,一个 JVM 进程只有一个 PID,也只有一个 MQClientInstance -
boolean registerOK = mQClientFactory.registerProducer(...):将生产者注册到 RocketMQ 客户端实例内 -
this.topicPublishInfoTable.put(...):添加一个主题发布信息,key 是 TBW102 ,value 是一个空对象 -
mQClientFactory.start():启动 RocketMQ 客户端实例对象 -
this.mQClientFactory.sendHeartbeatToAllBrokerWithLock():RocketMQ 客户端实例向已知的 Broker 节点发送一次心跳(也是定时任务) -
this.timer.scheduleAtFixedRate(): request 发送的消息需要消费着回执信息,启动定时任务每秒一次删除超时请求- 生产者 msg 添加信息关联 ID 发送到 Broker
- 消费者从 Broker 拿到消息后会检查 msg 类型是一个需要回执的消息,处理完消息后会根据 msg 关联 ID 和客户端 ID 生成一条响应结果消息发送到 Broker,Broker 判断为回执消息,会根据客户端ID 找到 channel 推送给生产者
- 生产者拿到回执消息后,读取出来关联 ID 找到对应的 RequestFuture,将阻塞线程唤醒
-
-
sendDefaultImpl():发送消息
//参数1:消息;参数2:发送模式(同步异步单向);参数3:回调函数,异步发送时需要;参数4:发送超时时间, 默认 3 秒 private SendResult sendDefaultImpl(msg, communicationMode, sendCallback,timeout) {}-
this.makeSureStateOK():校验生产者状态是运行中,否则抛出异常 -
topicPublishInfo = this.tryToFindTopicPublishInfo(msg.getTopic()):获取当前消息主题的发布信息-
this.topicPublishInfoTable.get(topic):先尝试从本地主题发布信息映射表获取信息,获取不到继续执行 -
this.mQClientFactory.update...FromNameServer(topic):然后从 Namesrv 更新该 Topic 的路由数据 -
this.mQClientFactory.update...FromNameServer(...):路由数据是空,获取默认 TBW102 的数据return topicPublishInfo:返回 TBW102 主题的发布信息
-
-
String[] brokersSent = new String[timesTotal]:下标索引代表第几次发送,值代表这次发送选择 Broker name -
for (; times < timesTotal; times++):循环发送,发送成功或者发送尝试次数达到上限,结束循环 -
String lastBrokerName = null == mq ? null : mq.getBrokerName():获取上次发送失败的 BrokerName -
mqSelected = this.selectOneMessageQueue(topicPublishInfo, lastBrokerName):从发布信息中选择一个队列,生产者的负载均衡策略,参考系统特性章节 -
brokersSent[times] = mq.getBrokerName():将本次选择的 BrokerName 存入数组 -
msg.setTopic(this.defaultMQProducer.withNamespace(msg.getTopic())):产生重投,重投消息需要加上标记 -
sendResult = this.sendKernelImpl:核心发送方法 -
switch (communicationMode):异步或者单向消息直接返回 null,异步通过回调函数处理,同步发送进入逻辑判断if (sendResult.getSendStatus() != SendStatus.SEND_OK):服务端 Broker 存储失败,需要重试其他 Broker -
throw new MQClientException():未找到当前主题的路由数据,无法发送消息,抛出异常
-
-
sendKernelImpl():核心发送方法
//参数1:消息;参数2:选择的队列;参数3:发送模式(同步异步单向);参数4:回调函数,异步发送时需要;参数5:主题发布信息;参数6:剩余超时时间限制 private SendResult sendKernelImpl(msg, mq, communicationMode, sendCallback, topicPublishInfo, timeout)-
brokerAddr = this.mQClientFactory(...):获取指定 BrokerName 对应的 mater 节点的地址,master 节点的 ID 为 0,集群模式下,发送消息要发到主节点 -
brokerAddr = MixAll.brokerVIPChannel():Broker 启动时会绑定两个服务器端口,一个是普通端口,一个是 VIP 端口,服务器端根据不同端口创建不同的的 NioSocketChannel -
byte[] prevBody = msg.getBody():获取消息体 -
if (!(msg instanceof MessageBatch)):非批量消息,需要重新设置消息 IDMessageClientIDSetter.setUniqID(msg):msg id 由两部分组成,一部分是 ip 地址、进程号、Classloader 的 hashcode,另一部分是时间差(当前时间减去当月一号的时间)和计数器的值 -
if (this.tryToCompressMessage(msg)):判断消息是否压缩,压缩需要设置压缩标记 -
hasCheckForbiddenHook、hasSendMessageHook:执行钩子方法 -
requestHeader = new SendMessageRequestHeader():设置发送消息的消息头 -
if (requestHeader.getTopic().startsWith(MixAll.RETRY_GROUP_TOPIC_PREFIX)):重投的发送消息 -
switch (communicationMode):异步发送一种处理方式,单向和同步同样的处理逻辑sendResult = this.mQClientFactory.getMQClientAPIImpl().sendMessage():发送消息request = RemotingCommand.createRequestCommand():创建一个 RequestCommand 对象request.setBody(msg.getBody()):将消息放入请求体switch (communicationMode):根据不同的模式 invoke 不同的方法
-
-
request():请求方法,消费者回执消息,这种消息是异步消息
-
requestResponseFuture = new RequestResponseFuture(correlationId, timeout, null):创建请求响应对象 -
getRequestFutureTable().put(correlationId, requestResponseFuture):放入RequestFutureTable 映射表中 -
this.sendDefaultImpl(msg, CommunicationMode.ASYNC, new SendCallback()):发送异步消息,有回调函数 -
return waitResponse(msg, timeout, requestResponseFuture, cost):用来挂起请求的方法public Message waitResponseMessage(final long timeout) throws InterruptedException { // 请求挂起 this.countDownLatch.await(timeout, TimeUnit.MILLISECONDS); return this.responseMsg; } -
当消息被消费后,客户端处理响应时通过消息的关联 ID,从映射表中获取消息的 RequestResponseFuture,执行下面的方法唤醒挂起线程
public void putResponseMessage(final Message responseMsg) { this.responseMsg = responseMsg; this.countDownLatch.countDown(); }
-
路由信息
TopicPublishInfo 类用来存储路由信息
成员变量:
-
顺序消息:
private boolean orderTopic = false; -
消息队列:
private List<MessageQueue> messageQueueList = new ArrayList<>(); // 主题全部的消息队列 private volatile ThreadLocalIndex sendWhichQueue = new ThreadLocalIndex(); // 消息队列索引// 【消息队列类】 public class MessageQueue implements Comparable<MessageQueue>, Serializable { private String topic; private String brokerName; private int queueId;// 队列 ID } -
路由数据:主题对应的路由数据
private TopicRouteData topicRouteData;public class TopicRouteData extends RemotingSerializable { private String orderTopicConf; private List<QueueData> queueDatas; // 队列数据 private List<BrokerData> brokerDatas; // Broker 数据 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; // Broker节点名称 private HashMap<Long/* brokerId */, String/* broker address */> brokerAddrs; }
核心方法:
-
selectOneMessageQueue():选择消息队列使用
// 参数是上次失败时的 brokerName,可以为 null public MessageQueue selectOneMessageQueue(final String lastBrokerName) { if (lastBrokerName == null) { return selectOneMessageQueue(); } else { // 遍历消息队列 for (int i = 0; i < this.messageQueueList.size(); i++) { // 【获取队列的索引,+1】 int index = this.sendWhichQueue.getAndIncrement(); // 获取队列的下标位置 int pos = Math.abs(index) % this.messageQueueList.size(); if (pos < 0) pos = 0; // 获取消息队列 MessageQueue mq = this.messageQueueList.get(pos); // 与上次选择的不同就可以返回 if (!mq.getBrokerName().equals(lastBrokerName)) { return mq; } } return selectOneMessageQueue(); } }
公共配置
公共的配置信息类
-
ClientConfig 类
public class ClientConfig { // Namesrv 地址配置 private String namesrvAddr = NameServerAddressUtils.getNameServerAddresses(); // 客户端的 IP 地址 private String clientIP = RemotingUtil.getLocalAddress(); // 客户端实例名称 private String instanceName = System.getProperty("rocketmq.client.name", "DEFAULT"); // 客户端回调线程池的数量,平台核心数,8核16线程的电脑返回16 private int clientCallbackExecutorThreads = Runtime.getRuntime().availableProcessors(); // 命名空间 protected String namespace; protected AccessChannel accessChannel = AccessChannel.LOCAL; // 获取路由信息的间隔时间 30s private int pollNameServerInterval = 1000 * 30; // 客户端与 broker 之间的心跳周期 30s private int heartbeatBrokerInterval = 1000 * 30; // 消费者持久化消费的周期 5s private int persistConsumerOffsetInterval = 1000 * 5; private long pullTimeDelayMillsWhenException = 1000; private boolean unitMode = false; private String unitName; // vip 通道,broker 启动时绑定两个端口,其中一个是 vip 通道 private boolean vipChannelEnabled = Boolean.parseBoolean(); // 语言,默认是 Java private LanguageCode language = LanguageCode.JAVA; } -
NettyClientConfig
public class NettyClientConfig { // 客户端工作线程数 private int clientWorkerThreads = 4; // 回调处理线程池 线程数:平台核心数 private int clientCallbackExecutorThreads = Runtime.getRuntime().availableProcessors(); // 单向请求并发数,默认 65535 private int clientOnewaySemaphoreValue = NettySystemConfig.CLIENT_ONEWAY_SEMAPHORE_VALUE; // 异步请求并发数,默认 65535 private int clientAsyncSemaphoreValue = NettySystemConfig.CLIENT_ASYNC_SEMAPHORE_VALUE; // 客户端连接服务器的超时时间限制 3秒 private int connectTimeoutMillis = 3000; // 客户端未激活周期,60s(指定时间内 ch 未激活,需要关闭) private long channelNotActiveInterval = 1000 * 60; // 客户端与服务器 ch 最大空闲时间 2分钟 private int clientChannelMaxIdleTimeSeconds = 120; // 底层 Socket 写和收 缓冲区的大小 65535 64k private int clientSocketSndBufSize = NettySystemConfig.socketSndbufSize; private int clientSocketRcvBufSize = NettySystemConfig.socketRcvbufSize; // 客户端 netty 是否启动内存池 private boolean clientPooledByteBufAllocatorEnable = false; // 客户端是否超时关闭 Socket 连接 private boolean clientCloseSocketIfTimeout = false; }
客户端类
成员属性
MQClientInstance 是 RocketMQ 客户端实例,在一个 JVM 进程中只有一个客户端实例,既服务于生产者,也服务于消费者
成员变量:
-
配置信息:
private final int instanceIndex; // 索引一般是 0,因为客户端实例一般都是一个进程只有一个 private final String clientId; // 客户端 ID ip@pid private final long bootTimestamp; // 客户端的启动时间 private ServiceState serviceState; // 客户端状态 -
生产者消费者的映射表:key 是组名
private final ConcurrentMap<String, MQProducerInner> producerTable private final ConcurrentMap<String, MQConsumerInner> consumerTable private final ConcurrentMap<String, MQAdminExtInner> adminExtTable -
网络层配置:
private final NettyClientConfig nettyClientConfig; -
核心功能的实现:负责将 MQ 业务层的数据转换为网络层的 RemotingCommand 对象,使用内部持有的 NettyRemotingClient 对象的 invoke 系列方法,完成网络 IO(同步、异步、单向)
private final MQClientAPIImpl mQClientAPIImpl; -
本地路由数据:key 是主题名称,value 路由信息
private final ConcurrentMap<String, TopicRouteData> topicRouteTable = new ConcurrentHashMap<>(); -
锁信息:两把锁,锁不同的数据
private final Lock lockNamesrv = new ReentrantLock(); private final Lock lockHeartbeat = new ReentrantLock(); -
调度线程池:单线程,执行定时任务
private final ScheduledExecutorService scheduledExecutorService; -
Broker 映射表:key 是 BrokerName
// 物理节点映射表,value:Long 是 brokerID,【ID=0 的是主节点,其他是从节点】,String 是地址 ip:port private final ConcurrentMap<String, HashMap<Long, String>> brokerAddrTable; // 物理节点版本映射表,String 是地址 ip:port,Integer 是版本 ConcurrentMap<String, HashMap<String, Integer>> brokerVersionTable; -
客户端的协议处理器:用于处理 IO 事件
private final ClientRemotingProcessor clientRemotingProcessor; -
消息服务:
private final PullMessageService pullMessageService; // 拉消息服务 private final RebalanceService rebalanceService; // 消费者负载均衡服务 private final ConsumerStatsManager consumerStatsManager; // 消费者状态管理 -
内部生产者实例:处理消费端消息回退,用该生产者发送回退消息
private final DefaultMQProducer defaultMQProducer; -
心跳次数统计:
private final AtomicLong sendHeartbeatTimesTotal = new AtomicLong(0)
构造方法:
-
MQClientInstance 有参构造:
public MQClientInstance(ClientConfig clientConfig, int instanceIndex, String clientId, RPCHook rpcHook) { this.clientConfig = clientConfig; this.instanceIndex = instanceIndex; // Netty 相关的配置信息 this.nettyClientConfig = new NettyClientConfig(); // 平台核心数 this.nettyClientConfig.setClientCallbackExecutorThreads(...); this.nettyClientConfig.setUseTLS(clientConfig.isUseTLS()); // 【创建客户端协议处理器】 this.clientRemotingProcessor = new ClientRemotingProcessor(this); // 创建 API 实现对象 // 参数一:客户端网络配置 // 参数二:客户端协议处理器,注册到客户端网络层 // 参数三:rpcHook,注册到客户端网络层 // 参数四:客户端配置 this.mQClientAPIImpl = new MQClientAPIImpl(this.nettyClientConfig, this.clientRemotingProcessor, rpcHook, clientConfig); //... // 内部生产者,指定内部生产者的组 this.defaultMQProducer = new DefaultMQProducer(MixAll.CLIENT_INNER_PRODUCER_GROUP); } -
MQClientAPIImpl 有参构造:
public MQClientAPIImpl(nettyClientConfig, clientRemotingProcessor, rpcHook, clientConfig) { this.clientConfig = clientConfig; topAddressing = new TopAddressing(MixAll.getWSAddr(), clientConfig.getUnitName()); // 创建网络层对象,参数二为 null 说明客户端并不关心 channel event this.remotingClient = new NettyRemotingClient(nettyClientConfig, null); // 业务处理器 this.clientRemotingProcessor = clientRemotingProcessor; // 注册 RpcHook this.remotingClient.registerRPCHook(rpcHook); // ... // 注册回退消息的请求码 this.remotingClient.registerProcessor(RequestCode.PUSH_REPLY_MESSAGE_TO_CLIENT, this.clientRemotingProcessor, null); }
成员方法
-
start():启动方法
synchronized (this):加锁保证线程安全,保证只有一个实例对象启动this.mQClientAPIImpl.start():启动客户端网络层,底层调用 RemotingClient 类this.startScheduledTask():启动定时任务this.pullMessageService.start():启动拉取消息服务this.rebalanceService.start():启动负载均衡服务this.defaultMQProducer...start(false):启动内部生产者,参数为 false 代表不启动实例
-
startScheduledTask():启动定时任务,调度线程池是单线程
-
if (null == this.clientConfig.getNamesrvAddr()):Namesrv 地址是空,需要两分钟拉取一次 Namesrv 地址 -
定时任务 1:从 Namesrv 更新客户端本地的路由数据,周期 30 秒一次
// 获取生产者和消费者订阅的主题集合,遍历集合,对比从 namesrv 拉取最新的主题路由数据和本地数据,是否需要更新 MQClientInstance.this.updateTopicRouteInfoFromNameServer(); -
定时任务 2:周期 30 秒一次,两个任务
- 清理下线的 Broker 节点,遍历客户端的 Broker 物理节点映射表,将所有主题数据都不包含的 Broker 物理节点清理掉,如果被清理的 Broker 下所有的物理节点都没有了,就将该 Broker 的映射数据删除掉
- 向在线的所有的 Broker 发送心跳数据,同步发送的方式,返回值是 Broker 物理节点的版本号,更新版本映射表
MQClientInstance.this.cleanOfflineBroker(); MQClientInstance.this.sendHeartbeatToAllBrokerWithLock();// 心跳数据 public class HeartbeatData extends RemotingSerializable { // 客户端 ID ip@pid private String clientID; // 存储客户端所有生产者数据 private Set<ProducerData> producerDataSet = new HashSet<ProducerData>(); // 存储客户端所有消费者数据 private Set<ConsumerData> consumerDataSet = new HashSet<ConsumerData>(); } -
定时任务 3:消费者持久化消费数据,周期 5 秒一次
MQClientInstance.this.persistAllConsumerOffset(); -
定时任务 4:动态调整消费者线程池,周期 1 分钟一次
MQClientInstance.this.adjustThreadPool();
-
-
updateTopicRouteInfoFromNameServer():更新路由数据,通过加锁保证当前实例只有一个线程去更新
-
if (isDefault && defaultMQProducer != null):需要默认数据topicRouteData = ...getDefaultTopicRouteInfoFromNameServer():从 Namesrv 获取默认的 TBW102 的路由数据 -
topicRouteData = ...getTopicRouteInfoFromNameServer(topic):需要从 Namesrv 获取路由数据(同步) -
old = this.topicRouteTable.get(topic):获取客户端实例本地的该主题的路由数据 -
boolean changed = topicRouteDataIsChange(old, topicRouteData):对比本地和最新下拉的数据是否一致 -
if (changed):不一致进入更新逻辑this.brokerAddrTable.put(...):更新客户端 broker 物理节点映射表Update Pub info:更新生产者信息publishInfo = topicRouteData2TopicPublishInfo(topic, topicRouteData):将主题路由数据转化为发布数据,会创建消息队列 MQ,放入发布数据对象的集合中impl.updateTopicPublishInfo(topic, publishInfo):生产者将主题的发布数据保存到它本地,方便发送消息使用
Update sub info:更新消费者信息,创建 MQ 队列,更新订阅信息,用于负载均衡this.topicRouteTable.put(topic, cloneTopicRouteData):将数据放入本地路由表
-
网络通信
成员属性
NettyRemotingClient 类负责客户端的网络通信
成员变量:
-
Netty 服务相关属性:
private final NettyClientConfig nettyClientConfig; // 客户端的网络层配置 private final Bootstrap bootstrap = new Bootstrap(); // 客户端网络层启动对象 private final EventLoopGroup eventLoopGroupWorker; // 客户端网络层 Netty IO 线程组 -
Channel 映射表:
private final ConcurrentMap<String, ChannelWrapper> channelTables;// key 是服务器的地址,value 是通道对象 private final Lock lockChannelTables = new ReentrantLock(); // 锁,控制并发安全 -
定时器:启动定时任务
private final Timer timer = new Timer("ClientHouseKeepingService", true) -
线程池:
private ExecutorService publicExecutor; // 公共线程池 private ExecutorService callbackExecutor; // 回调线程池,客户端发起异步请求,服务器的响应数据由回调线程池处理 -
事件监听器:客户端这里是 null
private final ChannelEventListener channelEventListener;
构造方法
-
无参构造:
public NettyRemotingClient(final NettyClientConfig nettyClientConfig) { this(nettyClientConfig, null); } -
有参构造:
public NettyRemotingClient(nettyClientConfig, channelEventListener) { // 父类创建了2个信号量,1、控制单向请求的并发度,2、控制异步请求的并发度 super(nettyClientConfig.getClientOnewaySemaphoreValue(), nettyClientConfig.getClientAsyncSemaphoreValue()); this.nettyClientConfig = nettyClientConfig; this.channelEventListener = channelEventListener; // 创建公共线程池 int publicThreadNums = nettyClientConfig.getClientCallbackExecutorThreads(); if (publicThreadNums <= 0) { publicThreadNums = 4; } this.publicExecutor = Executors.newFixedThreadPool(publicThreadNums,); // 创建 Netty IO 线程,1个线程 this.eventLoopGroupWorker = new NioEventLoopGroup(1, ); if (nettyClientConfig.isUseTLS()) { sslContext = TlsHelper.buildSslContext(true); } }
成员方法
-
start():启动方法
public void start() { // channel pipeline 内的 handler 使用的线程资源,默认 4 个 this.defaultEventExecutorGroup = new DefaultEventExecutorGroup(); // 配置 netty 客户端启动类对象 Bootstrap handler = this.bootstrap.group(this.eventLoopGroupWorker).channel(NioSocketChannel.class) //... .handler(new ChannelInitializer<SocketChannel>() { @Override public void initChannel(SocketChannel ch) throws Exception { ChannelPipeline pipeline = ch.pipeline(); // 加几个handler pipeline.addLast( // 服务端的数据,都会来到这个 new NettyClientHandler()); } }); // 注意 Bootstrap 只是配置好客户端的元数据了,【在这里并没有创建任何 channel 对象】 // 定时任务 扫描 responseTable 中超时的 ResponseFuture,避免客户端线程长时间阻塞 this.timer.scheduleAtFixedRate(() -> { NettyRemotingClient.this.scanResponseTable(); }, 1000 * 3, 1000); // 这里是 null,不启动 if (this.channelEventListener != null) { this.nettyEventExecutor.start(); } } -
单向通信:
public RemotingCommand invokeSync(String addr, final RemotingCommand request, long timeoutMillis) { // 开始时间 long beginStartTime = System.currentTimeMillis(); // 获取或者创建客户端与服务端(addr)的通道 channel final Channel channel = this.getAndCreateChannel(addr); // 条件成立说明客户端与服务端 channel 通道正常,可以通信 if (channel != null && channel.isActive()) { try { // 执行 rpcHook 拓展点 doBeforeRpcHooks(addr, request); // 计算耗时,如果当前耗时已经超过 timeoutMillis 限制,则直接抛出异常,不再进行系统通信 long costTime = System.currentTimeMillis() - beginStartTime; if (timeoutMillis < costTime) { throw new RemotingTimeoutException("invokeSync call timeout"); } // 参数1:客户端-服务端通道channel // 参数二:网络层传输对象,封装着请求数据 // 参数三:剩余的超时限制 RemotingCommand response = this.invokeSyncImpl(channel, request, ...); // 后置处理 doAfterRpcHooks(RemotingHelper.parseChannelRemoteAddr(channel), request, response); // 返回响应数据 return response; } catch (RemotingSendRequestException e) {} } else { this.closeChannel(addr, channel); throw new RemotingConnectException(addr); } }
延迟消息
消息处理
BrokerStartup 初始化 BrokerController 调用 registerProcessor() 方法将 SendMessageProcessor 注册到 NettyRemotingServer 中,对应的请求 ID 为 SEND_MESSAGE = 10,NettyServerHandler 在处理请求时通过 CMD 会获取处理器执行 processRequest
// 参数一:处理通道的事件; 参数二:客户端
public RemotingCommand processRequest(ChannelHandlerContext ctx, RemotingCommand request) {
RemotingCommand response = null;
response = asyncProcessRequest(ctx, request).get();
return response;
}
SendMessageProcessor#asyncConsumerSendMsgBack:异步发送消费者的回调消息
-
final RemotingCommand response:创建一个服务器响应对象 -
final ConsumerSendMsgBackRequestHeader requestHeader:解析出客户端请求头信息,几个核心字段:private Long offset:回退消息的 CommitLog offsetprivate Integer delayLevel:延迟级别,一般是 0private String originMsgId, originTopic:原始的消息 ID,主题private Integer maxReconsumeTimes:最大重试次数,默认是 16 次
-
if ():鉴权,是否找到订阅组配置、Broker 是否支持写请求、订阅组是否支持消息重试 -
String newTopic = MixAll.getRetryTopic(...):获取消费者组的重试主题,规则是%RETRY%GroupName -
int queueIdInt = Math.abs():重试主题下的队列 ID 是 0 -
TopicConfig topicConfig:获取重试主题的配置信息 -
MessageExt msgExt:根据消息的物理 offset 到存储模块查询,内部先查询出这条消息的 size,然后再根据 offset 和 size 查询出整条 msg -
final String retryTopic:获取消息的原始主题 -
if (null == retryTopic):条件成立说明当前消息是第一次被回退, 添加RETRY_TOPIC属性 -
msgExt.setWaitStoreMsgOK(false):异步刷盘 -
if (msgExt...() >= maxReconsumeTimes || delayLevel < 0):消息重试次数超过最大次数,不支持重试newTopic = MixAll.getDLQTopic():获取消费者的死信队列,规则是%DLQ%GroupNamequeueIdInt, topicConfig:死信队列 ID 为 0,创建死信队列的配置 -
if (0 == delayLevel):说明延迟级别由 Broker 控制delayLevel = 3 + msgExt.getReconsumeTimes():延迟级别默认从 3 级开始,每重试一次,延迟级别 +1 -
msgExt.setDelayTimeLevel(delayLevel):将延迟级别设置进消息属性,存储时会检查该属性,该属性值 > 0 会将消息的主题和队列修改为调度主题和调度队列 ID -
MessageExtBrokerInner msgInner:创建一条空消息,消息属性从 offset 查询出来的 msg 中拷贝 -
msgInner.setReconsumeTimes):重试次数设置为原 msg 的次数 +1 -
UtilAll.isBlank(originMsgId):判断消息是否是初次返回到服务器- true:说明 msgExt 消息是第一次被返回到服务器,此时使用该 msg 的 id 作为 originMessageId
- false:说明原始消息已经被重试不止 1 次,此时使用 offset 查询出来的 msg 中的 originMessageId
-
CompletableFuture putMessageResult = ..asyncPutMessage(msgInner):调用存储模块存储消息DefaultMessageStore#asyncPutMessage:PutMessageResult result = this.commitLog.asyncPutMessage(msg):将新消息存储到 CommitLog 中
调度服务
DefaultMessageStore 中有成员属性 ScheduleMessageService,在 start 方法中会启动该调度服务
成员变量:
-
延迟级别属性表:
// 存储延迟级别对应的 延迟时间长度 (单位:毫秒) private final ConcurrentMap<Integer /* level */, Long/* delay timeMillis */> delayLevelTable; // 存储延迟级别 queue 的消费进度 offset,该 table 每 10 秒钟,会持久化一次,持久化到本地磁盘 private final ConcurrentMap<Integer /* level */, Long/* offset */> offsetTable; -
最大延迟级别:
private int maxDelayLevel; -
模块启动状态:
private final AtomicBoolean started = new AtomicBoolean(false); -
定时器:内部有线程资源,可执行调度任务
private Timer timer;
成员方法:
-
load():加载调度消息,初始化 delayLevelTable 和 offsetTable
public boolean load() -
start():启动消息调度服务
public void start()-
if (started.compareAndSet(false, true)):将启动状态设为 true -
this.timer:创建定时器对象 -
for (... : this.delayLevelTable.entrySet()):为每个延迟级别创建一个延迟任务提交到 timer ,周期执行,这样就可以将延迟消息得到及时的消费 -
this.timer.scheduleAtFixedRate():提交周期型任务,延迟 10 秒执行,周期为 10 秒,持久化延迟队列消费进度任务ScheduleMessageService.this.persist():持久化消费进度
-
调度任务
DeliverDelayedMessageTimerTask 是一个任务类
成员变量:
-
延迟级别:延迟队列任务处理的延迟级别
private final int delayLevel; -
消费进度:延迟队列任务处理的延迟队列的消费进度
private final long offset;
成员方法:
-
run():执行任务
public void run() { if (isStarted()) { this.executeOnTimeup(); } -
executeOnTimeup():执行任务
public void executeOnTimeup()-
ConsumeQueue cq:获取出该延迟队列任务处理的延迟队列 ConsumeQueue -
SelectMappedBufferResult bufferCQ:根据消费进度查询出 SMBR 对象 -
for (; i < bufferCQ.getSize(); i += ConsumeQueue.CQ_STORE_UNIT_SIZE):每次读取 20 各字节的数据 -
offsetPy, sizePy:延迟消息的物理偏移量和消息大小 -
long tagsCode:延迟消息的交付时间,在 ReputMessageService 转发时根据消息的 DELAY 属性是否 >0 ,会在 tagsCode 字段存储交付时间 -
long deliver... = this.correctDeliverTimestamp(..):校准交付时间,延迟时间过长会调整为当前时间立刻执行 -
long countdown = deliverTimestamp - now:计算差值 -
if (countdown <= 0):消息已经到达交付时间了MessageExt msgExt:根据物理偏移量和消息大小获取这条消息MessageExtBrokerInner msgInner:构建一条新消息,将原消息的属性拷贝过来long tagsCodeValue:不再是交付时间了MessageAccessor.clearProperty(msgInner, DELAY..):清理新消息的 DELAY 属性,避免存储时重定向到延迟队列msgInner.setTopic():修改主题为原始的主题%RETRY%GroupNameString queueIdStr:修改队列 ID 为原始的 ID
PutMessageResult putMessageResult:将新消息存储到 CommitLog,消费者订阅的是目标主题,会再次消费该消息 -
else:消息还未到达交付时间ScheduleMessageService.this.timer.schedule():创建该延迟级别的任务,延迟 countDown 毫秒之后再执行ScheduleMessageService.this.updateOffset():更新延迟级别队列的消费进度 -
PutMessageResult putMessageResult -
bufferCQ == null:说明通过消费进度没有获取到数据if (offset < cqMinOffset):如果消费进度比最小位点都小,说明是过期数据,重置为最小位点 -
ScheduleMessageService.this.timer.schedule():重新提交该延迟级别对应的延迟队列任务,延迟 100 毫秒后执行
-
事务消息
生产者类
TransactionMQProducer 类发送事务消息时使用
成员变量:
-
事务回查线程池资源:
private ExecutorService executorService; -
事务监听器:
private TransactionListener transactionListener;
核心方法:
-
start():启动方法
public void start()this.defaultMQProducerImpl.initTransactionEnv():初始化生产者实例和回查线程池资源super.start():启动生产者实例
-
sendMessageInTransaction():发送事务消息
public TransactionSendResult sendMessageInTransaction(final Message msg, final Object arg) { msg.setTopic(NamespaceUtil.wrapNamespace(this.getNamespace(), msg.getTopic())); // 调用实现类的发送方法 return this.defaultMQProducerImpl.sendMessageInTransaction(msg, null, arg); }-
TransactionListener transactionListener = getCheckListener():获取监听器 -
if (null == localTransactionExecuter && null == transactionListener):两者都为 null 抛出异常 -
MessageAccessor.putProperty(msg, MessageConst.PROPERTY_TRANSACTION_PREPARED, "true"):设置事务标志 -
sendResult = this.send(msg):发送消息,同步发送 -
switch (sendResult.getSendStatus()):判断发送消息的结果状态 -
case SEND_OK:消息发送成功msg.setTransactionId(transactionId):设置事务 ID 为消息的 UNIQ_KEY 属性localTransactionState = ...executeLocalTransactionBranch(msg, arg):执行本地事务 -
case SLAVE_NOT_AVAILABLE:其他情况都需要回滚事务localTransactionState = LocalTransactionState.ROLLBACK_MESSAGE:事务状态设置为回滚 -
this.endTransaction(sendResult, ...):结束事务EndTransactionRequestHeader requestHeader:构建事务结束头对象this.mQClientFactory.getMQClientAPIImpl().endTransactionOneway():向 Broker 发起事务结束的单向请求
-
接受消息
SendMessageProcessor 是服务端处理客户端发送来的消息的处理器,processRequest() 方法处理请求
核心方法:
-
asyncProcessRequest():处理请求public CompletableFuture<RemotingCommand> asyncProcessRequest(ChannelHandlerContext ctx, RemotingCommand request) { final SendMessageContext mqtraceContext; switch (request.getCode()) { // 回调消息回退 case RequestCode.CONSUMER_SEND_MSG_BACK: return this.asyncConsumerSendMsgBack(ctx, request); default: // 解析出请求头对象 SendMessageRequestHeader requestHeader = parseRequestHeader(request); if (requestHeader == null) { return CompletableFuture.completedFuture(null); } // 创建上下文对象 mqtraceContext = buildMsgContext(ctx, requestHeader); // 前置处理器 this.executeSendMessageHookBefore(ctx, request, mqtraceContext); // 判断是否是批量消息 if (requestHeader.isBatch()) { return this.asyncSendBatchMessage(ctx, request, mqtraceContext, requestHeader); } else { return this.asyncSendMessage(ctx, request, mqtraceContext, requestHeader); } } } -
asyncSendMessage():异步处理发送消息
private CompletableFuture<RemotingCommand> asyncSendMessage(ChannelHandlerContext ctx, RemotingCommand request, SendMessageContext mqtraceContext, SendMessageRequestHeader requestHeader)-
RemotingCommand response:创建响应对象 -
MessageExtBrokerInner msgInner = new MessageExtBrokerInner():创建 msgInner 对象,并赋值相关的属性,主题和队列 ID 都是请求头中的 -
String transFlag:获取事务属性 -
if (transFlag != null && Boolean.parseBoolean(transFlag)):判断事务属性是否是 true,走事务消息的存储流程-
putMessageResult = ...asyncPrepareMessage(msgInner):事务消息处理流程public CompletableFuture<PutMessageResult> asyncPutHalfMessage(MessageExtBrokerInner messageInner) { // 调用存储模块,将修改后的 msg 存储进 Broker(CommitLog) return store.asyncPutMessage(parseHalfMessageInner(messageInner)); }TransactionalMessageBridge#parseHalfMessageInner:
MessageAccessor.putProperty(...):将消息的原主题和队列 ID 放入消息的属性中msgInner.setSysFlag(...):消息设置为非事务状态msgInner.setTopic(TransactionalMessageUtil.buildHalfTopic()):消息主题设置为半消息主题msgInner.setQueueId(0):队列 ID 设置为 0
-
-
else:普通消息存储
-
回查处理
ClientRemotingProcessor 是客户端用于处理请求,创建 MQClientAPIImpl 时将该处理器注册到 Netty 中,processRequest() 方法根据请求的命令码,进行不同的处理,事务回查的处理命令码为 CHECK_TRANSACTION_STATE
Broker 端有定时任务发送回查请求
成员方法:
-
checkTransactionState():检查事务状态
public RemotingCommand checkTransactionState(ChannelHandlerContext ctx, RemotingCommand request)final CheckTransactionStateRequestHeader requestHeader:解析出请求头对象final MessageExt messageExt:从请求 body 中解析出服务器回查的事务消息String transactionId:提取 UNIQ_KEY 字段属性值赋值给事务 IDfinal String group:提取生产者组名MQProducerInner producer = this...selectProducer(group):根据生产者组获取生产者对象String addr = RemotingHelper.parseChannelRemoteAddr():解析出要回查的 Broker 服务器的地址producer.checkTransactionState(addr, messageExt, requestHeader):生产者的事务回查Runnable request = new Runnable():创建回查事务状态任务对象- 获取生产者的 TransactionCheckListener 和 TransactionListener,选择一个不为 null 的监听器进行事务状态回查
this.processTransactionState():处理回查状态EndTransactionRequestHeader thisHeader:构建 EndTransactionRequestHeader 对象DefaultMQProducerImpl...endTransactionOneway():向 Broker 发起结束事务单向请求,二阶段提交
this.checkExecutor.submit(request):提交到线程池运行
参考图:https://www.processon.com/view/link/61c8257e0e3e7474fb9dcbc0
参考视频:https://space.bilibili.com/457326371
事务提交
EndTransactionProcessor 类是服务端用来处理客户端发来的提交或者回滚请求
-
processRequest():处理请求
public RemotingCommand processRequest(ChannelHandlerContext ctx, RemotingCommand request)-
EndTransactionRequestHeader requestHeader:从请求中解析出 EndTransactionRequestHeader -
if (MessageSysFlag.TRANSACTION_COMMIT_TYPE):事务提交result = this.brokerController...commitMessage(requestHeader):根据 commitLogOffset 提取出 halfMsg 消息MessageExtBrokerInner msgInner:根据 result 克隆出一条新消息-
msgInner.setTopic(msgExt.getUserProperty(...)):设置回原主题 -
msgInner.setQueueId(Integer.parseInt(msgExt.getUserProperty(..))):设置回原队列 ID -
MessageAccessor.clearProperty():清理上面的两个属性
MessageAccessor.clearProperty(msgInner, ...):清理事务属性RemotingCommand sendResult = sendFinalMessage(msgInner):调用存储模块存储至 Brokerthis.brokerController...deletePrepareMessage(result.getPrepareMessage()):向删除(OP)队列添加消息,消息体的数据是 halfMsg 的 queueOffset,表示半消息队列指定的 offset 的消息已被删除if (this...putOpMessage(msgExt, TransactionalMessageUtil.REMOVETAG)):添加一条 OP 数据MessageQueue messageQueue:新建一个消息队列,OP 队列return addRemoveTagInTransactionOp(messageExt, messageQueue):添加数据Message message:创建 OP 消息writeOp(message, messageQueue):写入 OP 消息
-
-
else if (MessageSysFlag.TRANSACTION_ROLLBACK_TYPE):事务回滚this.brokerController...deletePrepareMessage(result.getPrepareMessage()):也需要向 OP 队列添加消息
-