RocketMQ源码解析-Broker部分之Broker启动过程

已于 2022-02-03 23:00:00 修改
阅读量3.8k 收藏 1
点赞数 2
分类专栏： RocketMq源码 文章标签： 消息队列 java 中间件 后端
于 2022-02-03 22:32:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014161463/article/details/122775468
版权

目录

broker启动流程

借用一下【秃头爱健身】博主的的图，我觉得画的很好。
在这里插入图片描述

broker启动可配置参数

 -n : 指定broker 的 namesrvAddr 地址；
 -h ：打印命令；
 -c ：指定配置文件的路径；
 -p ：启动时候日志打印配置信息；
 -m ：启动时候日志打印导入的配置信息。

启动入口BrokerStartup

broker启动的入口是在brokerStartup，方法是main

    public static void main(String[] args) {
        //创建BrokerController
        start(createBrokerController(args));
    }

1.创建brokerController

public static BrokerController createBrokerController(String[] args) {
        //设置RocketMq的版本号
        System.setProperty(RemotingCommand.REMOTING_VERSION_KEY, Integer.toString(MQVersion.CURRENT_VERSION));
        //设置broker的netty客户端的发送缓冲大小，默认是128 kb
        if (null == System.getProperty(NettySystemConfig.COM_ROCKETMQ_REMOTING_SOCKET_SNDBUF_SIZE)) {
            NettySystemConfig.socketSndbufSize = 131072;
        }
        //设置broker的netty客户端的接受缓冲大小，默认是128 kb
        if (null == System.getProperty(NettySystemConfig.COM_ROCKETMQ_REMOTING_SOCKET_RCVBUF_SIZE)) {
            NettySystemConfig.socketRcvbufSize = 131072;
        }

        try {
            //PackageConflictDetect.detectFastjson();
            //命令行选项解析
            Options options = ServerUtil.buildCommandlineOptions(new Options());
            //解析命令行为 ‘mqbroker’的参数
            commandLine = ServerUtil.parseCmdLine("mqbroker", args, buildCommandlineOptions(options),
                new PosixParser());
            //如果为空，直接退出
            if (null == commandLine) {
                System.exit(-1);
            }
            //创建broker，netty的相关配置对象
            final BrokerConfig brokerConfig = new BrokerConfig();
            final NettyServerConfig nettyServerConfig = new NettyServerConfig();
            final NettyClientConfig nettyClientConfig = new NettyClientConfig();
            //是否使用TLS （TLS是SSL的升级版本，TLS是SSL的标准化后的产物，有1.0 1.1 1.2三个版本）
            nettyClientConfig.setUseTLS(Boolean.parseBoolean(System.getProperty(TLS_ENABLE,
                String.valueOf(TlsSystemConfig.tlsMode == TlsMode.ENFORCING))));
            //设置netty的服务端监听的端口 10911，对外提供消息读写服务的端口
            nettyServerConfig.setListenPort(10911);
            //创建消息存储配置
            final MessageStoreConfig messageStoreConfig = new MessageStoreConfig();
            //如果broker是slave节点
            if (BrokerRole.SLAVE == messageStoreConfig.getBrokerRole()) {
                //比默认的40% 还要小 10
                int ratio = messageStoreConfig.getAccessMessageInMemoryMaxRatio() - 10;
                //设置消息存储配置所能使用的最大内存比例，超过该内存，消息将被置换出内存，
                messageStoreConfig.setAccessMessageInMemoryMaxRatio(ratio);
            }
            //解析命令行参数'-c'：指定broker的配置文件路径
            if (commandLine.hasOption('c')) {
                String file = commandLine.getOptionValue('c');
                if (file != null) {
                    configFile = file;
                    InputStream in = new BufferedInputStream(new FileInputStream(file));
                    properties = new Properties();
                    properties.load(in);

                    properties2SystemEnv(properties);
                    MixAll.properties2Object(properties, brokerConfig);
                    MixAll.properties2Object(properties, nettyServerConfig);
                    MixAll.properties2Object(properties, nettyClientConfig);
                    MixAll.properties2Object(properties, messageStoreConfig);

                    BrokerPathConfigHelper.setBrokerConfigPath(file);
                    in.close();
                }
            }

            MixAll.properties2Object(ServerUtil.commandLine2Properties(commandLine), brokerConfig);

            if (null == brokerConfig.getRocketmqHome()) {
                System.out.printf("Please set the %s variable in your environment to match the location of the RocketMQ installation", MixAll.ROCKETMQ_HOME_ENV);
                System.exit(-2);
            }
            //检查broker配置中的nameServer地址
            String namesrvAddr = brokerConfig.getNamesrvAddr();
            if (null != namesrvAddr) {
                try {
                    String[] addrArray = namesrvAddr.split(";");
                    for (String addr : addrArray) {
                        RemotingUtil.string2SocketAddress(addr);
                    }
                } catch (Exception e) {
                    System.out.printf(
                        "The Name Server Address[%s] illegal, please set it as follows, \"127.0.0.1:9876;192.168.0.1:9876\"%n",
                        namesrvAddr);
                    System.exit(-3);
                }
            }
			//检查broker的角色
            switch (messageStoreConfig.getBrokerRole()) {
                case ASYNC_MASTER:
                case SYNC_MASTER:
                    //如果是master节点，则设置该节点brokerId=0
                    brokerConfig.setBrokerId(MixAll.MASTER_ID);
                    break;
                case SLAVE:
                    if (brokerConfig.getBrokerId() <= 0) {
                        System.out.printf("Slave's brokerId must be > 0");
                        System.exit(-3);
                    }

                    break;
                default:
                    break;
            }
            //是否启用 DLedger，即是否启用 RocketMQ 主从切换，默认值为 false。如果需要开启主从切换，则该值需要设置为 true
            if (messageStoreConfig.isEnableDLegerCommitLog()) {
                brokerConfig.setBrokerId(-1);
            }
            //设置消息存储配置的高可用端口，10912
            messageStoreConfig.setHaListenPort(nettyServerConfig.getListenPort() + 1);
            LoggerContext lc = (LoggerContext) LoggerFactory.getILoggerFactory();
            JoranConfigurator configurator = new JoranConfigurator();
            configurator.setContext(lc);
            lc.reset();
            configurator.doConfigure(brokerConfig.getRocketmqHome() + "/conf/logback_broker.xml");
			//解析命令行参数'-p'：启动时候日志打印配置信息
            if (commandLine.hasOption('p')) {
                InternalLogger console = InternalLoggerFactory.getLogger(LoggerName.BROKER_CONSOLE_NAME);
                MixAll.printObjectProperties(console, brokerConfig);
                MixAll.printObjectProperties(console, nettyServerConfig);
                MixAll.printObjectProperties(console, nettyClientConfig);
                MixAll.printObjectProperties(console, messageStoreConfig);
                System.exit(0);
            } 
            //解析命令行参数'-m'：启动时候日志打印导入的配置信息
            else if (commandLine.hasOption('m')) {
                InternalLogger console = InternalLoggerFactory.getLogger(LoggerName.BROKER_CONSOLE_NAME);
                MixAll.printObjectProperties(console, brokerConfig, true);
                MixAll.printObjectProperties(console, nettyServerConfig, true);
                MixAll.printObjectProperties(console, nettyClientConfig, true);
                MixAll.printObjectProperties(console, messageStoreConfig, true);
                System.exit(0);
            }

            log = InternalLoggerFactory.getLogger(LoggerName.BROKER_LOGGER_NAME);
            MixAll.printObjectProperties(log, brokerConfig);
            MixAll.printObjectProperties(log, nettyServerConfig);
            MixAll.printObjectProperties(log, nettyClientConfig);
            MixAll.printObjectProperties(log, messageStoreConfig);
            //创建BrokerController
            final BrokerController controller = new BrokerController(
                brokerConfig,
                nettyServerConfig,
                nettyClientConfig,
                messageStoreConfig);
            // 记住所有的配置以防止丢弃
            controller.getConfiguration().registerConfig(properties);
            //初始化BrokerController
            boolean initResult = controller.initialize();
            if (!initResult) {
                controller.shutdown();
                System.exit(-3);
            }
            //注册关闭的钩子方法
            Runtime.getRuntime().addShutdownHook(new Thread(new Runnable() {
                private volatile boolean hasShutdown = false;
                private AtomicInteger shutdownTimes = new AtomicInteger(0);

                @Override
                public void run() {
                    synchronized (this) {
                        log.info("Shutdown hook was invoked, {}", this.shutdownTimes.incrementAndGet());
                        if (!this.hasShutdown) {
                            this.hasShutdown = true;
                            long beginTime = System.currentTimeMillis();
                            //BrokerController的销毁方法
                            controller.shutdown();
                            long consumingTimeTotal = System.currentTimeMillis() - beginTime;
                            log.info("Shutdown hook over, consuming total time(ms): {}", consumingTimeTotal);
                        }
                    }
                }
            }, "ShutdownHook"));

            return controller;
        } catch (Throwable e) {
            e.printStackTrace();
            System.exit(-1);
        }

        return null;
    }

broker启动会默认启动3个端口

端口说明
10911接收消息推送的端口
10912消息存储配置的高可用端口
10909推送消息的VIP端口

2.BrokerController构造函数

构造入参说明

参数类型说明
brokerConfigBrokerConfig封装Broker的基本配置信息
nettyServerConfigNettyServerConfig封装了broker作为对外提供消息读写操作的MQ服务器信息
nettyClientConfigNettyClientConfig封装了broker作为NameServer的客户端的信息
messageStoreConfigMessageStoreConfig封装消息存储Store的配置信息
public  BrokerController(
        final BrokerConfig brokerConfig,
        final NettyServerConfig nettyServerConfig,
        final NettyClientConfig nettyClientConfig,
        final MessageStoreConfig messageStoreConfig
    ) {
    	// BrokerStartup中准备的配置信息
        this.brokerConfig = brokerConfig;
        this.nettyServerConfig = nettyServerConfig;
        this.nettyClientConfig = nettyClientConfig;
        this.messageStoreConfig = messageStoreConfig;
        
        // Consumer消费进度记录管理类，会读取store/config/consumerOffset.json配置文件
        this.consumerOffsetManager = new ConsumerOffsetManager(this);
        
        //消息Topic维度的管理查询类， 管理Topic和Topic相关的配置关系，  会读取store/config/topics.json
        this.topicConfigManager = new TopicConfigManager(this);

		//Consumer端使用pull的方式向Broker拉取消息请求的处理类
        this.pullMessageProcessor = new PullMessageProcessor(this);

		//Consumer使用Push方式的长轮询机制拉取请求时，保存使用，当有消息到达时进行推送处理的类
        this.pullRequestHoldService = new PullRequestHoldService(this);

        //有消息到达Broker时的监听器，回调pullRequestHoldService中的notifyMessageArriving()方法
        this.messageArrivingListener = new NotifyMessageArrivingListener(this.pullRequestHoldService);
		
		//消费者id变化监听器
        this.consumerIdsChangeListener = new DefaultConsumerIdsChangeListener(this);
        
        //消费者管理类，并对消费者id变化进行监听
        this.consumerManager = new ConsumerManager(this.consumerIdsChangeListener);
        
        //消费者过滤类，按照Topic进行分类，  会读取store/config/consumerFilter.json
        this.consumerFilterManager = new ConsumerFilterManager(this);

		//生产者管理 按照group进行分类
        this.producerManager = new ProducerManager();
        
        //客户端心跳连接处理类
        this.clientHousekeepingService = new ClientHousekeepingService(this);

		//Console控制台获取Broker信息使用
        this.broker2Client = new Broker2Client(this);
	
		//订阅关系管理类
        this.subscriptionGroupManager = new SubscriptionGroupManager(this);

		//Broker对外访问的API
        this.brokerOuterAPI = new BrokerOuterAPI(nettyClientConfig);

		//FilterServer管理类
        this.filterServerManager = new FilterServerManager(this);

		//Broker主从同步进度管理类
        this.slaveSynchronize = new SlaveSynchronize(this);

		// 各种线程池的阻塞队列
		// 发送消息线程池队列
        this.sendThreadPoolQueue = new LinkedBlockingQueue<Runnable>(this.brokerConfig.getSendThreadPoolQueueCapacity());
        this.pullThreadPoolQueue = new LinkedBlockingQueue<Runnable>(this.brokerConfig.getPullThreadPoolQueueCapacity());
        this.replyThreadPoolQueue = new LinkedBlockingQueue<Runnable>(this.brokerConfig.getReplyThreadPoolQueueCapacity());
        this.queryThreadPoolQueue = new LinkedBlockingQueue<Runnable>(this.brokerConfig.getQueryThreadPoolQueueCapacity());
        this.clientManagerThreadPoolQueue = new LinkedBlockingQueue<Runnable>(this.brokerConfig.getClientManagerThreadPoolQueueCapacity());
        this.consumerManagerThreadPoolQueue = new LinkedBlockingQueue<Runnable>(this.brokerConfig.getConsumerManagerThreadPoolQueueCapacity());
        this.heartbeatThreadPoolQueue = new LinkedBlockingQueue<Runnable>(this.brokerConfig.getHeartbeatThreadPoolQueueCapacity());
        this.endTransactionThreadPoolQueue = new LinkedBlockingQueue<Runnable>(this.brokerConfig.getEndTransactionPoolQueueCapacity());

        this.brokerStatsManager = new BrokerStatsManager(this.brokerConfig.getBrokerClusterName());
        this.setStoreHost(new InetSocketAddress(this.getBrokerConfig().getBrokerIP1(), this.getNettyServerConfig().getListenPort()));

        this.brokerFastFailure = new BrokerFastFailure(this);
        this.configuration = new Configuration(
            log,
            BrokerPathConfigHelper.getBrokerConfigPath(),
            this.brokerConfig, this.nettyServerConfig, this.nettyClientConfig, this.messageStoreConfig
        );
    }

重点对一些核心类进行说明

参数说明
ConsumerOffsetManagerConsumer消费进度记录管理类，会读取store/config/consumerOffset.json配置文件
topicConfigManager消息Topic维度的管理查询类， 管理Topic和Topic相关的配置关系， 会读取store/config/topics.json
pullMessageProcessorConsumer端使用pull的方式向Broker拉取消息请求的处理类
pullRequestHoldServiceConsumer使用Push方式的长轮询机制拉取请求时，保存使用，当有消息到达时进行推送处理的类
messageArrivingListener有消息到达Broker时的监听器，回调pullRequestHoldService中的notifyMessageArriving()方法
consumerIdsChangeListener消费者id变化监听器
consumerManager消费者管理类，并对消费者id变化进行监听
consumerFilterManager消费者过滤类，按照Topic进行分类， 会读取store/config/consumerFilter.json
producerManager生产者管理 按照group进行分类
clientHousekeepingService客户端心跳连接处理类
broker2ClientConsole控制台获取Broker信息使用
subscriptionGroupManager订阅关系管理类
brokerOuterAPIBroker对外访问的API
filterServerManagerFilterServer管理类
slaveSynchronizeBroker主从同步进度管理类

3.BrokerController初始化initialize()

public boolean initialize() throws CloneNotSupportedException {
		//加载 topic 相关配置，文件地址为 {user.home}/store/config/topics.json
        boolean result = this.topicConfigManager.load();
 		//加载 不同的Consumer消费的进度情况  文件地址为 {user.home}/store/config/consumerOffset.json
        result = result && this.consumerOffsetManager.load();
        //加载 订阅关系  文件地址  {user.home}/store/config/subscriptionGroup.json
        result = result && this.subscriptionGroupManager.load();
        //加载 Consumer的过滤信息配置  文件地址  {user.home}/store/config/consumerFilter.json
        result = result && this.consumerFilterManager.load();
		
		//如果加载成功
        if (result) {
            try {
                //创建消息存储类messageStore
                this.messageStore =
                    new DefaultMessageStore(this.messageStoreConfig, this.brokerStatsManager, this.messageArrivingListener,
                        this.brokerConfig);
                //使用的是DLegerCommitLog，则创建DLedgerRoleChangeHandler
                if (messageStoreConfig.isEnableDLegerCommitLog()) {
                    DLedgerRoleChangeHandler roleChangeHandler = new DLedgerRoleChangeHandler(this, (DefaultMessageStore) messageStore);
                    ((DLedgerCommitLog)((DefaultMessageStore) messageStore).getCommitLog()).getdLedgerServer().getdLedgerLeaderElector().addRoleChangeHandler(roleChangeHandler);
                }
                //broker消息统计类
                this.brokerStats = new BrokerStats((DefaultMessageStore) this.messageStore);
                //load plugin
                MessageStorePluginContext context = new MessageStorePluginContext(messageStoreConfig, brokerStatsManager, messageArrivingListener, brokerConfig);
                this.messageStore = MessageStoreFactory.build(context, this.messageStore);
                this.messageStore.getDispatcherList().addFirst(new CommitLogDispatcherCalcBitMap(this.brokerConfig, this.consumerFilterManager));
            } catch (IOException e) {
                result = false;
                log.error("Failed to initialize", e);
            }
        }
		//加载消息的日志文件，包含CommitLog，ConsumeQueue等
        result = result && this.messageStore.load();
		//如果加载成功
        if (result) {
            //开启服务端
            this.remotingServer = new NettyRemotingServer(this.nettyServerConfig, this.clientHousekeepingService);
            NettyServerConfig fastConfig = (NettyServerConfig) this.nettyServerConfig.clone();
            //设置10909的服务端口
            fastConfig.setListenPort(nettyServerConfig.getListenPort() - 2);
            //开启10909的服务端口，这个端口只给生产者使用
            this.fastRemotingServer = new NettyRemotingServer(fastConfig, this.clientHousekeepingService);
            //处理消息生产者发送的生成消息请求相关的线程池
            this.sendMessageExecutor = new BrokerFixedThreadPoolExecutor(
                this.brokerConfig.getSendMessageThreadPoolNums(),
                this.brokerConfig.getSendMessageThreadPoolNums(),
                1000 * 60,
                TimeUnit.MILLISECONDS,
                this.sendThreadPoolQueue,
                new ThreadFactoryImpl("SendMessageThread_"));
			//处理消费者发出的消费消息请求相关的线程池
            this.pullMessageExecutor = new BrokerFixedThreadPoolExecutor(
                this.brokerConfig.getPullMessageThreadPoolNums(),
                this.brokerConfig.getPullMessageThreadPoolNums(),
                1000 * 60,
                TimeUnit.MILLISECONDS,
                this.pullThreadPoolQueue,
                new ThreadFactoryImpl("PullMessageThread_"));
		    //处理回复消息api的线程池
            this.replyMessageExecutor = new BrokerFixedThreadPoolExecutor(
                this.brokerConfig.getProcessReplyMessageThreadPoolNums(),
                this.brokerConfig.getProcessReplyMessageThreadPoolNums(),
                1000 * 60,
                TimeUnit.MILLISECONDS,
                this.replyThreadPoolQueue,
                new ThreadFactoryImpl("ProcessReplyMessageThread_"));
			//查询线程
            this.queryMessageExecutor = new BrokerFixedThreadPoolExecutor(
                this.brokerConfig.getQueryMessageThreadPoolNums(),
                this.brokerConfig.getQueryMessageThreadPoolNums(),
                1000 * 60,
                TimeUnit.MILLISECONDS,
                this.queryThreadPoolQueue,
                new ThreadFactoryImpl("QueryMessageThread_"));

            //省略一些线程池

			//为客户端注册需要处理API指令事件，以及消息发送和消费的回调方法
            this.registerProcessor();

            final long initialDelay = UtilAll.computeNextMorningTimeMillis() - System.currentTimeMillis();
            final long period = 1000 * 60 * 60 * 24;
            //每天执行一次，统计昨天put的message和get的message
            this.scheduledExecutorService.scheduleAtFixedRate(new Runnable() {
                @Override
                public void run() {
                    try {
                        BrokerController.this.getBrokerStats().record();
                    } catch (Throwable e) {
                        log.error("schedule record error.", e);
                    }
                }
            }, initialDelay, period, TimeUnit.MILLISECONDS);
			// 默认5s执行一次，会把消费这的偏移量存到文件中  ${user.home}/store/config/consumerOffset.json.json
            this.scheduledExecutorService.scheduleAtFixedRate(new Runnable() {
                @Override
                public void run() {
                    try {
                        BrokerController.this.consumerOffsetManager.persist();
                    } catch (Throwable e) {
                        log.error("schedule persist consumerOffset error.", e);
                    }
                }
            }, 1000 * 10, this.brokerConfig.getFlushConsumerOffsetInterval(), TimeUnit.MILLISECONDS);
			// 默认10s执行一次，会把消费者的消息过滤的信息持久化到文件 ${user.home}/store/config/consumerFilter.json
            this.scheduledExecutorService.scheduleAtFixedRate(new Runnable() {
                @Override
                public void run() {
                    try {
                        BrokerController.this.consumerFilterManager.persist();
                    } catch (Throwable e) {
                        log.error("schedule persist consumer filter error.", e);
                    }
                }
            }, 1000 * 10, 1000 * 10, TimeUnit.MILLISECONDS);
			// 每3分钟，当消费者消费太慢，会禁用到消费者组
            this.scheduledExecutorService.scheduleAtFixedRate(new Runnable() {
                @Override
                public void run() {
                    try {
                        BrokerController.this.protectBroker();
                    } catch (Throwable e) {
                        log.error("protectBroker error.", e);
                    }
                }
            }, 3, 3, TimeUnit.MINUTES);
			//打印当前的Send Queue Size，Pull Queue Size，Query Queue Size，Transaction Queue Size
            this.scheduledExecutorService.scheduleAtFixedRate(new Runnable() {
                @Override
                public void run() {
                    try {
                        BrokerController.this.printWaterMark();
                    } catch (Throwable e) {
                        log.error("printWaterMark error.", e);
                    }
                }
            }, 10, 1, TimeUnit.SECONDS);
			//每隔一分钟打印一次，dispath的消息偏移量和总的消息偏移量的差值
            this.scheduledExecutorService.scheduleAtFixedRate(new Runnable() {

                @Override
                public void run() {
                    try {
                        log.info("dispatch behind commit log {} bytes", BrokerController.this.getMessageStore().dispatchBehindBytes());
                    } catch (Throwable e) {
                        log.error("schedule dispatchBehindBytes error.", e);
                    }
                }
            }, 1000 * 10, 1000 * 60, TimeUnit.MILLISECONDS);
		
            if (this.brokerConfig.getNamesrvAddr() != null) {
                //更新nameServer地址
                this.brokerOuterAPI.updateNameServerAddressList(this.brokerConfig.getNamesrvAddr());
                log.info("Set user specified name server address: {}", this.brokerConfig.getNamesrvAddr());
            } else if (this.brokerConfig.isFetchNamesrvAddrByAddressServer()) {
                //没有明确指定name-server的地址，且配置了允许从地址服务器获取name-server地址
                this.scheduledExecutorService.scheduleAtFixedRate(new Runnable() {

                    @Override
                    public void run() {
                        try {
		                // 每隔2分钟从name-server地址服务器拉取最新的配置
		                // 这个是实现name-server动态增减的唯一方法   
		                BrokerController.this.brokerOuterAPI.fetchNameServerAddr();
                        } catch (Throwable e) {
                            log.error("ScheduledTask fetchNameServerAddr exception", e);
                        }
                    }
                }, 1000 * 10, 1000 * 60 * 2, TimeUnit.MILLISECONDS);
            }

            if (!messageStoreConfig.isEnableDLegerCommitLog()) {
                if (BrokerRole.SLAVE == this.messageStoreConfig.getBrokerRole()) {
                    if (this.messageStoreConfig.getHaMasterAddress() != null && this.messageStoreConfig.getHaMasterAddress().length() >= 6) {
                        this.messageStore.updateHaMasterAddress(this.messageStoreConfig.getHaMasterAddress());
                        this.updateMasterHAServerAddrPeriodically = false;
                    } else {
                        this.updateMasterHAServerAddrPeriodically = true;
                    }
                } else {
                    this.scheduledExecutorService.scheduleAtFixedRate(new Runnable() {
                        @Override
                        public void run() {
                            try {
                                //定时打印master与slave的差距
                                BrokerController.this.printMasterAndSlaveDiff();
                            } catch (Throwable e) {
                                log.error("schedule printMasterAndSlaveDiff error.", e);
                            }
                        }
                    }, 1000 * 10, 1000 * 60, TimeUnit.MILLISECONDS);
                }
            }

			//初始化事务消息相关的服务
            initialTransaction();
            //初始化权限管理器
            initialAcl();
            //初始化RPC调用的钩子
            initialRpcHooks();
        }
        return result;
    }
3.1注册消息处理器registerProcessor

rocketmq中有许多线程执行器，包括sendMessageExecutor(发送消息)，pullMessageExecutor（拉取消息），queryMessageExecutor（查询消息），adminBrokerExecutor（默认处理）。这些线程执行器会通过registerProcessor注册到NettyRemotingServer ，每一个RequestCode会有一个对应的执行器，最终会以RequestCode为键放到一个HashMap中，当请求到达nettyServer时会根据RequestCode把请求分发到不同的执行器去处理请求

 public void registerProcessor() {
        /**
         * SendMessageProcessor
         */
        SendMessageProcessor sendProcessor = new SendMessageProcessor(this);
        sendProcessor.registerSendMessageHook(sendMessageHookList);
        sendProcessor.registerConsumeMessageHook(consumeMessageHookList);

        this.remotingServer.registerProcessor(RequestCode.SEND_MESSAGE, sendProcessor, this.sendMessageExecutor);
        this.remotingServer.registerProcessor(RequestCode.SEND_MESSAGE_V2, sendProcessor, this.sendMessageExecutor);
       
        this.fastRemotingServer.registerProcessor(RequestCode.SEND_MESSAGE_V2, sendProcessor, this.sendMessageExecutor);
        this.fastRemotingServer.registerProcessor(RequestCode.SEND_BATCH_MESSAGE, sendProcessor, this.sendMessageExecutor);
 
        //省略其他的处理器

最终放到processorTable的map中

    @Override
    public void registerProcessor(int requestCode, NettyRequestProcessor processor, ExecutorService executor) {
        ExecutorService executorThis = executor;
        if (null == executor) {
            executorThis = this.publicExecutor;
        }

        Pair<NettyRequestProcessor, ExecutorService> pair = new Pair<NettyRequestProcessor, ExecutorService>(processor, executorThis);
        this.processorTable.put(requestCode, pair);
    }

相关的RequestCode说明一下：

事件名code说明
SEND_MESSAGE10生产者发送信息
SEND_MESSAGE_V2310生产者发送信息
SEND_BATCH_MESSAGE320批量发送消息
CONSUMER_SEND_MSG_BACK36消费端消费失败的时候返回的消息
PULL_MESSAGE11消费者拉取消息
SEND_REPLY_MESSAGE324消费者回包消息，可以用类似RPC调用
3.2初始化事务消息相关的服务initialTransaction（）

服务加载方式是Java的SPI方式。

 private void initialTransaction() {
        //加载TransactionalMessageService服务，实现类为TransactionalMessageServiceImpl
        this.transactionalMessageService = ServiceProvider.loadClass(ServiceProvider.TRANSACTION_SERVICE_ID, TransactionalMessageService.class);
        if (null == this.transactionalMessageService) {
            this.transactionalMessageService = new TransactionalMessageServiceImpl(new TransactionalMessageBridge(this, this.getMessageStore()));
            log.warn("Load default transaction message hook service: {}", TransactionalMessageServiceImpl.class.getSimpleName());
        }
        //AbstractTransactionalMessageCheckListener对应的服务类为LogTransactionalMessageCheckListener ，其中实现为空实现
        this.transactionalMessageCheckListener = ServiceProvider.loadClass(ServiceProvider.TRANSACTION_LISTENER_ID, AbstractTransactionalMessageCheckListener.class);
        if (null == this.transactionalMessageCheckListener) {
            this.transactionalMessageCheckListener = new DefaultTransactionalMessageCheckListener();
            log.warn("Load default discard message hook service: {}", DefaultTransactionalMessageCheckListener.class.getSimpleName());
        }
        //设置对应的brokerController到AbstractTransactionalMessageCheckListener中
        this.transactionalMessageCheckListener.setBrokerController(this);
        //创建TransactionalMessageCheckService，服务是周期检查事务的服务，
        this.transactionalMessageCheckService = new TransactionalMessageCheckService(this);
    }
  }
3.3initialize总结

initialize方法相应的逻辑相对来说比较多，稍微总结为已下几步：

1.服务器内的相关日志文件的加载，{user.home}/store/config/ 文件目录下的json配置文件（包含topics，consumerOffset，subscriptionGroup，consumerFilter）。
在这里插入图片描述

2.如果上述文件加载成功，会启动对应的Broker客户端，然后创建一些线程池，在后面注册 API 指令事件后会监听到API的时候会进行处理
3.注册事件到对应的Broker客户端上，然后会记录对应的API事件和对应线程池封装到一个对象中
4.启动一些 定时任务，这些任务比如记录Broker状态，消费进度持久化等任务
5.初始化一些服务，比如事务相关（周期检查事务），消息权限校验初始化和Rpc调用钩子相关服务。对应的服务加载方式是Java的SPI方式。

4.BrokerControler的start

 controller.start();
 
public void start() throws Exception {
    if (this.messageStore != null) {
        // 启动消息存储服务DefaultMessageStore，其会对/store/lock文件加锁，
        // 以确保在broker运行期间只有一个broker实例操作/store目录
        this.messageStore.start();
    }

    if (this.remotingServer != null) {
        // 启动Netty服务监听10911端口，对外提供服务（消息生产、消费）
        this.remotingServer.start();
    }

    if (this.fastRemotingServer != null) {
        // 监听10909端口
        this.fastRemotingServer.start();
    }

    if (this.fileWatchService != null) {
        // fileWatchService与TLS有关，todo tls解析
        this.fileWatchService.start();
    }

    if (this.brokerOuterAPI != null) {
        // 启动Netty客户端netty，broker使用其向外发送数据，比如：向NameServer上报心跳、topic信息。
        this.brokerOuterAPI.start();
    }

    if (this.pullRequestHoldService != null) {
        // 长轮询机制hold住拉取消息请求的服务
        this.pullRequestHoldService.start();
    }

    if (this.clientHousekeepingService != null) {
        // 每10s检查一遍非活动的连接服务
        this.clientHousekeepingService.start();
    }

    if (this.filterServerManager != null) {
        this.filterServerManager.start();
    }

    if (!messageStoreConfig.isEnableDLegerCommitLog()) {
        // 处理HA
        startProcessorByHa(messageStoreConfig.getBrokerRole());
        // 启动定时任务，定时与slave机器同步数据，同步的内容包括配置，消费位移等
        handleSlaveSynchronize(messageStoreConfig.getBrokerRole());
        // 向所有的nameserver发送本机所有的主题数据；
        // 包括主题名、读队列个数、写队列个数、队列权限、是否有序等
        this.registerBrokerAll(true, false, true);
    }

    this.scheduledExecutorService.scheduleAtFixedRate(new Runnable() {

        @Override
        public void run() {
            try {
                // 定时向NameServer注册Broker，最小每10s。
                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);

    if (this.brokerStatsManager != null) {
        // Broker信息统计，这个没有具体的实现；所以暂时不用管
        this.brokerStatsManager.start();
    }

    if (this.brokerFastFailure != null) {
        // Broker对请求队列中的请求进行快速失败，返回`Broker繁忙、请稍后重试`信息
        this.brokerFastFailure.start();
    }
}

对这几个服务进行说明一下:

服务名类型说明
messageStoreDefaultMessageStore处理消息的存储相关的日志，比如CommitLog，ConsumeQueue等
remotingServerRemotingServerBroker的服务端，处理消费者和生产者的请求
fastRemotingServerRemotingServer只给消息生产者的服务端
fileWatchServiceFileWatchService启动监控服务连接时用到的SSL连接文件的服务
brokerOuterAPIBrokerOuterAPIRocketMQ控制台跟Broker交互时候的客户端
pullRequestHoldServicePullRequestHoldService处理push模式消费，或者延迟消费的服务
clientHousekeepingServiceClientHousekeepingService心跳连接用的服务
filterServerManagerFilterServerManager消息过滤的服务
transactionalMessageCheckServiceTransactionalMessageCheckService定期检查和处理事务消息的服务
slaveSynchronizeSlaveSynchronize主从之间topic，消费偏移等信息同步用的
geekolaf
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
RocketMQ（17）——Broker可配置参数
Elim的博客
09-13 1994
之前使用Broker都是通过`mqbroker -n localhost:9876`启动Broker，同时指定对应的Name Server地址是`localhost:9876`。其实它还可以指定一些其它的信息。
退出 253 nohup sh mqbroker -c /usr/local/server/mq/rocketmq/conf/2m-2s-async/broker-a.pr，安装RocketMQ报错
十三月的博客
07-24 1084
退出 253 nohup sh mqbroker -c /usr/local/server/mq/rocketmq/conf/2m-2s-async/broker-a.pr
快速学习-RocketMQ运维管理
逍遥云恋
09-20 512
运维管理 1 集群搭建 1.1 单Master模式 这种方式风险较大，一旦Broker重启或者宕机时，会导致整个服务不可用。不建议线上环境使用,可以用于本地测试。 1）启动 NameServer ### 首先启动Name Server $ nohup sh mqnamesrv & ### 验证Name Server 是否启动成功 $ tail -f ~/logs/rocketmqlogs/namesrv.log The Name Server boot success... 2）启动 B
RocketMQ使用（1）：介绍与启动
最新发布
游王子的博客
05-22 709
消息队列中间件是分布式系统中重要的组件，主要解决应用耦合，异步消息，流量削锋等问题。实现高性能，高可用，可伸缩和最终一致性架构。使用较多的消息队列有ActiveMQ，RabbitMQ，ZeroMQ，Kafka，MetaMQ，RocketMQ等。RocketMQ是阿里研发的一个队列模型的消息中间件，后开源给apache基金会成为了apache的顶级开源项目，具有高性能、高可靠、高实时、分布式特点。
RocketMQ参数配置
kieven2008的专栏
02-22 4376
一、MQ启动 >nohup sh mqnamesrv & > nohup sh mqbroker -n 47.97.72.25:9876 -c broker.properties & jps查看启动情况 二、broker.properties参数配置详细 #第一台机器的公网ip brokerIP1=47.97.xx.2xx #第二台机器的公网ip brokerIP2=xx.xx.xx.xxx #broker集群名称，用于划分broker brokerClu
RocketMQ各种集群模式介绍
Leon_Jinhai_Sun的博客
06-13 1300
集群模式 1）单Master模式 这种方式风险较大，一旦Broker重启或者宕机时，会导致整个服务不可用。不建议线上环境使用,可以用于本地测试。 2）多Master模式 一个集群无Slave，全是Master，例如2个Master或者3个Master，这种模式的优缺点如下： 优点：配置简单，单个Master宕机或重启维护对应用无影响，在磁盘配置为RAID10时，即使机器宕机不可恢复情况下，由于RAID10磁盘非常可靠，消息也不会丢（异步刷盘丢失少量消息，同步刷盘一条不丢），性能最高；
RocketMQ源码分析----Broker处理发送请求
菜鸟一名
04-03 895
Producer发送消息后，会由SendMessageProcessor类的processRequest方法进行处理，其中会调用sendMesaage方法 主要步骤 1.创建响应对象Response，用来返回给Producer消息的处理结果 2.设置消息相关信息：请求id，消息体，请求队列，topic等 3.将信息封装到MessageExtBrokerInner对象中 4.消息t
rocketmq-externals-master.zip
12-04
"rocketmq-externals-master.zip"是一个包含RocketMQ源码的压缩包，对于深入理解RocketMQ的工作原理、性能优化以及进行二次开发非常有帮助。下面将详细阐述RocketMQ的核心概念、架构、工作流程以及源码解析的关键点...
Rocketmq核心源码剖析-图灵杨过老师1
08-03
在IDEA中，可以从GitHub下载RocketMQ源码，然后设置ROCKETMQ_HOME环境变量或者在启动类中直接指定RocketMQ项目的路径。启动NameServer和Broker服务时，需分别运行相应的启动类，并指定相应的配置文件。 在实际运行...
rocketmq 源码 rocketmq 源码 rocketmq 源码
10-25
RocketMQ 的源码解析有助于开发者更好地掌握其实现机制，提升在实际项目中的应用能力。 1. **整体架构** RocketMQ 采用主从复制模型，主要包含四个核心组件：Producer、Consumer、NameServer 和 Broker。Producer ...
rocketmq-4.9.2版本
05-06
以下是对RocketMQ核心知识点的详细解析： 1. **消息模型** - **点对点（P2P）**：消费者可以从队列中拉取消息，每个消息只会被一个消费者消费，适合一对多的发布/订阅场景。 - **发布/订阅（Pub/Sub）**：主题下...
RocketMQ入门实战及源码解析.7z
06-23
RocketMQ是中国阿里巴巴开源的一款分布式消息中间件，它在大规模分布式系统中扮演着重要的角色，用于处理高并发、低延迟的...提供的"RocketMQ源码解析.pdf"和"RocketMQ入门指南.pdf"将是深入理解RocketMQ的宝贵资源。
rocketMQ搭建
weixin_42654295的博客
06-06 360
下载地址 官网下载地址：http://rocketmq.apache.org/release_notes/release-notes-4.4.0/ 安装步骤 1.将压缩包放在新建文件夹rocetmq中通过unzip 命令解压 2.修改配置文件bin目录下的两个文件runbroker.sh和runserver.sh 因为默认启动内存为8g这边修改小一点 runbroker.sh JAVA_OPT="${JAVA_OPT} -server -Xms256m -Xmx256m -Xmn128m" runse
【RocketMQ】常见问题（2）
ibigboy
10-13 677
org.apache.rocketmq.client.exception.MQClientException: No route info of this topic, baseTopic异常解决 可能的原因： Broker 禁止自动创建Topic，且用户没有通过手动创建此Topic，或者broker 和 Nameserver网络不通； 若没有这个topic，且如果是测试环境自己测试，可以改成自动创建，如下启动 linux下：mqbroker -n localhost:9876 autoCreateTopi
RocketMQ（二）RocketMQ安装部署
fjd7474的博客
04-22 2393
注意：安装rocketmq需要提前安装好jdk和maven获取rocketmq wget https://archive.apache.org/dist/rocketmq/4.8.0/rocketmq-all-4.8.0-bin-release.zip
《专题四 服务化改造》之《第三章 【补充资料】常见消息中间件应用详解》之《第十一节 Rocketmq》
qq_23204557的博客
01-10 151
文章目录《3.11.1 rocketmq入门》《3.11.2 rocket集群架构》 《3.11.1 rocketmq入门》 RocketMQ的特性： NameServer: offset: partition: Tag: key: 《3.11.2 rocket集群架构》 rocketMQ架构方案： 配置与启动： vi bin/runserver.sh 如内存不够，请改动JAVA_OPT="${JAVA_OPT} -server -Xms4g -Xmx4g -Xmn2g vi bin/
RocketMQ
sumengnan的博客
08-05 538
一、rocketmq安装 （1）安装 官网地址：http://rocketmq.apache.org/docs/quick-start/ rocketmq下载：https://archive.apache.org/dist/rocketmq/4.7.1/rocketmq-all-4.7.1-bin-release.zip 源码下载：https://github.com/apache/rocketmq 注意：使用jdk1.8 解压完成后，启动 1、bin/mqnamesrv 启动nameSer.
RocketMQ源码9- broker 启动流程
xxxzzzqqq_的博客
03-23 411
本文主要分析了broker解析配置文件，这一步会解析各种配置，并将其赋值到对应的对象中创建及初始化：创建了对象，并进行初始化操作，所谓的初始化，就是加载配置文件中配置、创建线程池、注册请求处理器、启动定时任务等启动：这一步是启动broker的核心组件，如(消息存储)、netty服务，用来处理producer与consumer请求)、netty服务，用来向nameServer上报当前broker信息)等。在分析启动过程中，重点分析了两类消息的发送：在中，broker会向nameServer。
rocketmq-client-go
09-03
rocketmq-client-go提供了与RocketMQ Broker进行连接和交互的功能，可以方便地使用Go语言发送和接收消息。它支持顺序消息和广播消息模式，可以根据业务需求选择最适合的消息模式。 使用rocketmq-client-go，我们...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值