RocketMQ源码解析五（Consumer启动流程）

骑猪看日落 2022-09-12 07:46 19阅读 0赞

> **RocketMQ版本4.6.0，记录自己看源码的过程**

Consumer示例：

public class Consumer { 
    
        public static void main(String[] args) throws InterruptedException, MQClientException { 
    
            DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("consumerGroup3");
            consumer.setNamesrvAddr("localhost:9876");
            consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_LAST_OFFSET);
            consumer.subscribe("TestTopic", "*");
            consumer.registerMessageListener(new MessageListenerConcurrently() { 
    
                @Override
                public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs,
                    ConsumeConcurrentlyContext context) { 
                    System.out.printf("%s Receive New Messages: %s %n", Thread.currentThread().getName(), msgs);
                    if (msgs.get(0).getReconsumeTimes() >= 5) { 
                        return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
                    }
                    return ConsumeConcurrentlyStatus.RECONSUME_LATER;
                }
            });
            consumer.start();
    
            System.out.printf("Consumer Started.%n");
        }
    }

先创建消费者DefaultMQPushConsumer

public DefaultMQPushConsumer(final String consumerGroup) { 
        // 这里可以看出负载均衡策略使用平均算法
        this(null, consumerGroup, null, new AllocateMessageQueueAveragely());
    }
    
    public DefaultMQPushConsumer(final String namespace, final String consumerGroup, RPCHook rpcHook,
        AllocateMessageQueueStrategy allocateMessageQueueStrategy) { 
        this.consumerGroup = consumerGroup;
        this.namespace = namespace;
        this.allocateMessageQueueStrategy = allocateMessageQueueStrategy;
        defaultMQPushConsumerImpl = new DefaultMQPushConsumerImpl(this, rpcHook);
    }

创建过程没什么操作，指定了负载均衡策略以及也跟生产者一样实例化了一个内部消费者实例DefaultMQPushConsumerImpl，将消费者的功能委托给这个类。  
接着设置Namesrv地址，从哪开始消费，订阅主题（同时会将订阅信息复制到重平衡组件）以及注册一个消息监听器，用来消费消息。最后启动。  
**DefaultMQPushConsumer**

@Override
    public void start() throws MQClientException { 
        setConsumerGroup(NamespaceUtil.wrapNamespace(this.getNamespace(), this.consumerGroup));
        this.defaultMQPushConsumerImpl.start();
        if (null != traceDispatcher) { 
            try { 
                traceDispatcher.start(this.getNamesrvAddr(), this.getAccessChannel());
            } catch (MQClientException e) { 
                log.warn("trace dispatcher start failed ", e);
            }
        }
    }

可以看到也是通过DefaultMQPushConsumerImpl来启动

public synchronized void start() throws MQClientException { 
        switch (this.serviceState) { 
            case CREATE_JUST:
                log.info("the consumer [{}] start beginning. messageModel={}, isUnitMode={}", this.defaultMQPushConsumer.getConsumerGroup(),
                    this.defaultMQPushConsumer.getMessageModel(), this.defaultMQPushConsumer.isUnitMode());
                this.serviceState = ServiceState.START_FAILED;
    			// 主要是对消费者的配置进行检查
                this.checkConfig();
                // 将订阅数据复制到重平衡组件中，并且如果是集群模式，也会订阅retryTopic，
                // 然后等consumer向broker发送心跳时在broker中创建该重试主题
                this.copySubscription();
    
                if (this.defaultMQPushConsumer.getMessageModel() == MessageModel.CLUSTERING) { 
                    this.defaultMQPushConsumer.changeInstanceNameToPID();
                }
    			// 从缓存获取或创建一个新的MQClientInstance实例
                this.mQClientFactory = MQClientManager.getInstance().getOrCreateMQClientInstance(this.defaultMQPushConsumer, this.rpcHook);
                // 为重平衡组件设置必要的属性
                this.rebalanceImpl.setConsumerGroup(this.defaultMQPushConsumer.getConsumerGroup());
                this.rebalanceImpl.setMessageModel(this.defaultMQPushConsumer.getMessageModel());
                this.rebalanceImpl.setAllocateMessageQueueStrategy(this.defaultMQPushConsumer.getAllocateMessageQueueStrategy());
                this.rebalanceImpl.setmQClientFactory(this.mQClientFactory);
                // 从这里也可以看出push底层也是pull
                this.pullAPIWrapper = new PullAPIWrapper(
                    mQClientFactory,
                    this.defaultMQPushConsumer.getConsumerGroup(), isUnitMode());
                this.pullAPIWrapper.registerFilterMessageHook(filterMessageHookList);
    
                if (this.defaultMQPushConsumer.getOffsetStore() != null) { 
                    this.offsetStore = this.defaultMQPushConsumer.getOffsetStore();
                } else { 
                    switch (this.defaultMQPushConsumer.getMessageModel()) { 
                        // 广播模式，消费组里的每个消费者都会收到全部消息，offset消费端自己管理
                        case BROADCASTING:
                            this.offsetStore = new LocalFileOffsetStore(this.mQClientFactory, this.defaultMQPushConsumer.getConsumerGroup());
                            break;
                        // 集群模式，消息平均分配给消费组中的每个消费者，offset由broker管理
                        case CLUSTERING:
                            this.offsetStore = new RemoteBrokerOffsetStore(this.mQClientFactory, this.defaultMQPushConsumer.getConsumerGroup());
                            break;
                        default:
                            break;
                    }
                    this.defaultMQPushConsumer.setOffsetStore(this.offsetStore);
                }
                // 集群模式是个空实现，只有广播模式有用，实现从本地文件加载进度
                this.offsetStore.load();
                // 根据并发消费还是顺序消费创建不同的 消费消息服务
                if (this.getMessageListenerInner() instanceof MessageListenerOrderly) { 
                    this.consumeOrderly = true;
                    this.consumeMessageService =
                        new ConsumeMessageOrderlyService(this, (MessageListenerOrderly) this.getMessageListenerInner());
                } else if (this.getMessageListenerInner() instanceof MessageListenerConcurrently) { 
                    this.consumeOrderly = false;
                    this.consumeMessageService =
                        new ConsumeMessageConcurrentlyService(this, (MessageListenerConcurrently) this.getMessageListenerInner());
                }
                //
                this.consumeMessageService.start();
                // 注册消费者缓存
                boolean registerOK = mQClientFactory.registerConsumer(this.defaultMQPushConsumer.getConsumerGroup(), this);
                if (!registerOK) { 
                    this.serviceState = ServiceState.CREATE_JUST;
                    this.consumeMessageService.shutdown();
                    throw new MQClientException("The consumer group[" + this.defaultMQPushConsumer.getConsumerGroup()
                        + "] has been created before, specify another name please." + FAQUrl.suggestTodo(FAQUrl.GROUP_NAME_DUPLICATE_URL),
                        null);
                }
    
                // 启动一些功能组件和后台任务，比如netty客户端启动，拉取消息服务，重平衡服务
                mQClientFactory.start();
                log.info("the consumer [{}] start OK.", this.defaultMQPushConsumer.getConsumerGroup());
                this.serviceState = ServiceState.RUNNING;
                break;
            case RUNNING:
            case START_FAILED:
            case SHUTDOWN_ALREADY:
                throw new MQClientException("The PushConsumer service state not OK, maybe started once, "
                    + this.serviceState
                    + FAQUrl.suggestTodo(FAQUrl.CLIENT_SERVICE_NOT_OK),
                    null);
            default:
                break;
        }
    
        this.updateTopicSubscribeInfoWhenSubscriptionChanged();
        this.mQClientFactory.checkClientInBroker();
        // 发送心跳到每个broker
        this.mQClientFactory.sendHeartbeatToAllBrokerWithLock();
        // 启动消费者需立即发起一次重平衡，通过CountdownLatch -1将重平衡线程立刻唤醒，如果线程已经在执行状态，则这里不会再重平衡
        this.mQClientFactory.rebalanceImmediately();
    }

Step1：检查消费者配置。  
Step2：将订阅数据复制到重平衡组件中，并且如果是集群模式，也会订阅retryTopic，然后等consumer向broker发送心跳时在broker中创建该重试主题。  
Step3：从缓存获取或创建一个新的MQClientInstance实例，这里面创建了包括拉取消息服务和重平衡服务等。  
**MQClientManager**

/** * 从缓存获取或创建一个新的MQClientInstance实例 */
    public MQClientInstance getOrCreateMQClientInstance(final ClientConfig clientConfig, RPCHook rpcHook) { 
        String clientId = clientConfig.buildMQClientId();
        MQClientInstance instance = this.factoryTable.get(clientId);
        // 根据clientId从缓存中获取，没获取到则创建一个放到缓存中
        if (null == instance) { 
            instance =
                new MQClientInstance(clientConfig.cloneClientConfig(),
                    this.factoryIndexGenerator.getAndIncrement(), clientId, rpcHook);
            MQClientInstance prev = this.factoryTable.putIfAbsent(clientId, instance);
            if (prev != null) { 
                instance = prev;
                log.warn("Returned Previous MQClientInstance for clientId:[{}]", clientId);
            } else { 
                log.info("Created new MQClientInstance for clientId:[{}]", clientId);
            }
        }
    
        return instance;
    }

整个JVM实例中只存在一个MQClientInstance实例，并维护一个MQClientInstance缓存factoryTable，一个clientId只会创建一个MQClientInstance。clientId = 客户端IP + “@” + instanceName，同一个JVM内，生产者和消费者都是用一个MQClientInstance实例。  
Step4：为重平衡组件设置必要的属性。  
Step5：创建Consumer端的消费进度管理组件。  
Step6：从消费进度组件加载消费进度，只有广播模式有用，实现从本地文件加载进度。  
Step7：根据并发消费还是顺序消费创建不同的消费消息服务。  
Step8：向MQClientInstance注册消费者实例，如果相同消费组已经存在一个实例了，则会报错。  
Step9：启动MQClientInstance实例，启动一些功能组件和后台任务，比如netty客户端启动，拉取消息服务，重平衡服务。

/** * 一个实例只会启动一次 */
    public void start() throws MQClientException { 
    
        synchronized (this) { 
            switch (this.serviceState) { 
                case CREATE_JUST:
                    this.serviceState = ServiceState.START_FAILED;
                    // If not specified,looking address from name server
                    if (null == this.clientConfig.getNamesrvAddr()) { 
                        this.mQClientAPIImpl.fetchNameServerAddr();
                    }
                    // Start request-response channel 启动netty客户端
                    this.mQClientAPIImpl.start();
                    // 启动一些定时任务，比如定时从NameServer拉取路由信息，定时向broker发送心跳等
                    this.startScheduledTask();
                    // 启动拉取消息服务
                    this.pullMessageService.start();
                    // 启动重平衡服务
                    this.rebalanceService.start();
                    // 用来消费者往broker发送重试消息？？
                    this.defaultMQProducer.getDefaultMQProducerImpl().start(false);
                    log.info("the client factory [{}] start OK", this.clientId);
                    this.serviceState = ServiceState.RUNNING;
                    break;
                case START_FAILED:
                    throw new MQClientException("The Factory object[" + this.getClientId() + "] has been created before, and failed.", null);
                default:
                    break;
            }
        }
    }

到这消费者就算启动完成了，接着就交给几个定时任务了。  
![在这里插入图片描述][dbec88c7047d05de4fdc263a764c9443.png_pic_center]

**参考资料**  
《儒猿技术窝——从 0 开始带你成为消息中间件实战高手》

[dbec88c7047d05de4fdc263a764c9443.png_pic_center]: /images/20220828/9e2c4135c904479c85b9ed8bf0792b32.png