Rocketmq nameServer 核心源码分析

最新推荐文章于 2023-10-15 00:13:07 发布

abinge89

最新推荐文章于 2023-10-15 00:13:07 发布

阅读量252

点赞数

分类专栏： rocketmq 文章标签： java-rocketmq rocketmq java

本文链接：https://blog.csdn.net/chenbj123/article/details/125488718

版权

rocketmq 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

1. rocketmq源码信息

1.1 源码版本 release-4.6.1

1.2 源码目录结构

在这里插入图片描述

ack：权限控制（ACL）主要为RocketMQ提供Topic资源级别的用户访问控制
broker: broker 模块（broke 启动进程）
client ：消息客户端，包含消息生产者、消息消费者相关类
common ：公共包
dev ：开发者信息（非源代码）
distribution ：部署实例文件夹（非源代码）
docs：文档
example: RocketMQ 例代码
filter ：消息过滤相关基础类
logappender、logging：日志相关
namesrv：NameServer实现相关类（NameServer启动进程）
openmessageing：消息开放标准
remoting：远程通信模块，给予Netty
srcutil：服务工具类
store：消息存储实现相关类
style：checkstyle相关实现
test：测试相关类
tools：工具类，监控命令相关实现类

2. NameServer

NameServer是一个非常简单的Topic路由注册中心，其角色类似Dubbo中的zookeeper，支持Broker的动态注册与发现。主要包括如下两个功能：

Broker管理：NameServer接受Broker集群的注册信息并且保存下来作为路由信息的基本数据。然后提供心跳检测机制，检查Broker是否还存活。
路由信息管理：每个NameServer将保存关于Broker集群的整个路由信息和用于客户端查询的队列信息。然后Producer和Conumser通过NameServer就可以知道整个Broker集群的路由信息，从而进行消息的投递和消费。

NameServer是一个几乎无状态节点，通常也是集群的方式部署，各实例间相互不进行信息通讯。Broker是向每一台NameServer注册自己的路由信息，所以每一个NameServer实例上面都保存一份完整的路由信息。当某个NameServer因某种原因下线了，Broker仍然可以向其它NameServer同步其路由信息，Producer,Consumer仍然可以动态感知Broker的路由的信息。

2.1 核心功能类

2.1.1 启动类NamesrvStartup

2.1.2 核心配置类NamesrvConfig

2.1.3 底层通信配置类NettyServerConfig

2.1.4 底层通信服务 NettyRemotingServer

2.1.5 核心功能入口 NamesrvController

2.1.6 路由管理核心类 RouteInfoManager

2.2 NameServer 启动流程时序

启动类：org.apache.rocketmq.namesrv.NamesrvStartup
在这里插入图片描述

2.3 启动核心方法代码说明

2.3.1 org.apache.rocketmq.namesrv.NamesrvStartup#main0

public class NamesrvStartup {
    
    public static void main(String[] args) {
        main0(args);
    }

    public static NamesrvController main0(String[] args) {

        try {
            // 创建NamesrvController
            NamesrvController controller = createNamesrvController(args);
            // 启动controller
            start(controller);
            String tip = "The Name Server boot success. serializeType=" + RemotingCommand.getSerializeTypeConfigInThisServer();
            log.info(tip);
            System.out.printf("%s%n", tip);
            return controller;
        } catch (Throwable e) {
            e.printStackTrace();
            System.exit(-1);
        }

        return null;
    }

2.3.2 org.apache.rocketmq.namesrv.NamesrvStartup#createNamesrvController

    public static NamesrvController createNamesrvController(String[] args) throws IOException, JoranException {
		……
        // 创建NamesrvConfig
        final NamesrvConfig namesrvConfig = new NamesrvConfig();
        // 创建NettyServerConfig并设置监听端口为9876
        final NettyServerConfig nettyServerConfig = new NettyServerConfig();
        nettyServerConfig.setListenPort(9876);
        // 解析启动参数中的 -c参数，并填充到namesrvConfig,nettyServerConfig
        if (commandLine.hasOption('c')) {
            String file = commandLine.getOptionValue('c');
            if (file != null) {
                InputStream in = new BufferedInputStream(new FileInputStream(file));
                properties = new Properties();
                properties.load(in);
                MixAll.properties2Object(properties, namesrvConfig);
                MixAll.properties2Object(properties, nettyServerConfig);

                namesrvConfig.setConfigStorePath(file);

                System.out.printf("load config properties file OK, %s%n", file);
                in.close();
            }
        }
		// 解析启动参数中的 -p参数，并填充到namesrvConfig，nettyServerConfig
        if (commandLine.hasOption('p')) {
            InternalLogger console = InternalLoggerFactory.getLogger(LoggerName.NAMESRV_CONSOLE_NAME);
            MixAll.printObjectProperties(console, namesrvConfig);
            MixAll.printObjectProperties(console, nettyServerConfig);
            System.exit(0);
        }
		//将启动参数填充到namesrvConfig
        MixAll.properties2Object(ServerUtil.commandLine2Properties(commandLine), namesrvConfig);

        if (null == namesrvConfig.getRocketmqHome()) {
            System.out.printf("Please set the %s variable in your environment to match the location of the RocketMQ installation%n", MixAll.ROCKETMQ_HOME_ENV);
            System.exit(-2);
        }
		// 日志相关配置
        LoggerContext lc = (LoggerContext) LoggerFactory.getILoggerFactory();
        JoranConfigurator configurator = new JoranConfigurator();
        configurator.setContext(lc);
        lc.reset();
        configurator.doConfigure(namesrvConfig.getRocketmqHome() + "/conf/logback_namesrv.xml");

        log = InternalLoggerFactory.getLogger(LoggerName.NAMESRV_LOGGER_NAME);

        MixAll.printObjectProperties(log, namesrvConfig);
        MixAll.printObjectProperties(log, nettyServerConfig);
		// 根据namesrvConfig，nettyServerConfig创建NameServerController
        final NamesrvController controller = new NamesrvController(namesrvConfig, nettyServerConfig);

        // remember all configs to prevent discard
        // 填充controller的相关配置参数
        controller.getConfiguration().registerConfig(properties);

        return controller;
    }

2.3.3 org.apache.rocketmq.namesrv.NamesrvStartup#start

public static NamesrvController start(final NamesrvController controller) throws Exception {

        if (null == controller) {
            throw new IllegalArgumentException("NamesrvController is null");
        }
		// controller初始化
        boolean initResult = controller.initialize();
        if (!initResult) {
            controller.shutdown();
            System.exit(-3);
        }
		// 注册JVM钩子函数，当JVM退出时，释放controller资源
        Runtime.getRuntime().addShutdownHook(new ShutdownHookThread(log, new Callable<Void>() {
            @Override
            public Void call() throws Exception {
                // 释放controller相关资源
                controller.shutdown();
                return null;
            }
        }));
		// 启动controller
        controller.start();

        return controller;
    }

2.3.4 org.apache.rocketmq.namesrv.NamesrvController#initialize

public boolean initialize() {
		// KV配置加载
        this.kvConfigManager.load();
		// 创建远程通信服务，其中初始化了nettyServer相关配置
        this.remotingServer = new NettyRemotingServer(this.nettyServerConfig, this.brokerHousekeepingService);
		// 创建工作线程池
        this.remotingExecutor =
            Executors.newFixedThreadPool(nettyServerConfig.getServerWorkerThreads(), new ThreadFactoryImpl("RemotingExecutorThread_"));
		// 注册默认的请求处理器
        this.registerProcessor();
		// 创建定时线程，每隔10s扫描下不活跃的broker信息，从路由表中剔除不活跃的broker
        this.scheduledExecutorService.scheduleAtFixedRate(new Runnable() {

            @Override
            public void run() {
                NamesrvController.this.routeInfoManager.scanNotActiveBroker();
            }
        }, 5, 10, TimeUnit.SECONDS);
		// 创建定时线程，每隔10min打印一次KV配置
        this.scheduledExecutorService.scheduleAtFixedRate(new Runnable() {

            @Override
            public void run() {
                NamesrvController.this.kvConfigManager.printAllPeriodically();
            }
        }, 1, 10, TimeUnit.MINUTES);

        ……
        ……
        ……

        return true;
    }

    private void registerProcessor() {
        if (namesrvConfig.isClusterTest()) {

            this.remotingServer.registerDefaultProcessor(new ClusterTestRequestProcessor(this, namesrvConfig.getProductEnvName()),
                this.remotingExecutor);
        } else {
			// 这里注册了默认的请求处理器，用于集群中各种请求事件的路由处理：DefaultRequestProcessor
            this.remotingServer.registerDefaultProcessor(new DefaultRequestProcessor(this), this.remotingExecutor);
        }
    }

2.3.5 org.apache.rocketmq.namesrv.processor.DefaultRequestProcessor#processRequest

public RemotingCommand processRequest(ChannelHandlerContext ctx,
        RemotingCommand request) throws RemotingCommandException {

        if (ctx != null) {
            log.debug("receive request, {} {} {}",
                request.getCode(),
                RemotingHelper.parseChannelRemoteAddr(ctx.channel()),
                request);
        }

		// 根据请求事件的code路由不同的请求，典型的如：RequestCode.REGISTER_BROKER: broker注册
        switch (request.getCode()) {
            case RequestCode.PUT_KV_CONFIG:
                return this.putKVConfig(ctx, request);
            case RequestCode.GET_KV_CONFIG:
                return this.getKVConfig(ctx, request);
            case RequestCode.DELETE_KV_CONFIG:
                return this.deleteKVConfig(ctx, request);
            case RequestCode.QUERY_DATA_VERSION:
                return queryBrokerTopicConfig(ctx, request);
            case RequestCode.REGISTER_BROKER:
                Version brokerVersion = MQVersion.value2Version(request.getVersion());
                if (brokerVersion.ordinal() >= MQVersion.Version.V3_0_11.ordinal()) {
                    return this.registerBrokerWithFilterServer(ctx, request);
                } else {
                    return this.registerBroker(ctx, request);
                }
            case RequestCode.UNREGISTER_BROKER:
                return this.unregisterBroker(ctx, request);
            case RequestCode.GET_ROUTEINTO_BY_TOPIC:
                return this.getRouteInfoByTopic(ctx, request);
            case RequestCode.GET_BROKER_CLUSTER_INFO:
                return this.getBrokerClusterInfo(ctx, request);
            case RequestCode.WIPE_WRITE_PERM_OF_BROKER:
                return this.wipeWritePermOfBroker(ctx, request);
            case RequestCode.GET_ALL_TOPIC_LIST_FROM_NAMESERVER:
                return getAllTopicListFromNameserver(ctx, request);
            case RequestCode.DELETE_TOPIC_IN_NAMESRV:
                return deleteTopicInNamesrv(ctx, request);
            case RequestCode.GET_KVLIST_BY_NAMESPACE:
                return this.getKVListByNamespace(ctx, request);
            case RequestCode.GET_TOPICS_BY_CLUSTER:
                return this.getTopicsByCluster(ctx, request);
            case RequestCode.GET_SYSTEM_TOPIC_LIST_FROM_NS:
                return this.getSystemTopicListFromNs(ctx, request);
            case RequestCode.GET_UNIT_TOPIC_LIST:
                return this.getUnitTopicList(ctx, request);
            case RequestCode.GET_HAS_UNIT_SUB_TOPIC_LIST:
                return this.getHasUnitSubTopicList(ctx, request);
            case RequestCode.GET_HAS_UNIT_SUB_UNUNIT_TOPIC_LIST:
                return this.getHasUnitSubUnUnitTopicList(ctx, request);
            case RequestCode.UPDATE_NAMESRV_CONFIG:
                return this.updateConfig(ctx, request);
            case RequestCode.GET_NAMESRV_CONFIG:
                return this.getConfig(ctx, request);
            default:
                break;
        }
        return null;
    }

2.3.6 org.apache.rocketmq.namesrv.NamesrvController#start

public void start() throws Exception {
    	// 启动remotingServer
        this.remotingServer.start();
		……
    }

2.3.7 org.apache.rocketmq.remoting.netty.NettyRemotingServer#start

public void start() {
    	// 默认事件处理线程池
        this.defaultEventExecutorGroup = new DefaultEventExecutorGroup(
            nettyServerConfig.getServerWorkerThreads(),
            new ThreadFactory() {

                private AtomicInteger threadIndex = new AtomicInteger(0);

                @Override
                public Thread newThread(Runnable r) {
                    return new Thread(r, "NettyServerCodecThread_" + this.threadIndex.incrementAndGet());
                }
            });
		// 初始化handler
        prepareSharableHandlers();
		// 构造serverBootstrap相关服务配置
        ServerBootstrap childHandler =
            this.serverBootstrap.group(this.eventLoopGroupBoss, this.eventLoopGroupSelector)
                .channel(useEpoll() ? EpollServerSocketChannel.class : NioServerSocketChannel.class)
                .option(ChannelOption.SO_BACKLOG, 1024)
                .option(ChannelOption.SO_REUSEADDR, true)
                .option(ChannelOption.SO_KEEPALIVE, false)
                .childOption(ChannelOption.TCP_NODELAY, true)
                .childOption(ChannelOption.SO_SNDBUF, nettyServerConfig.getServerSocketSndBufSize())
                .childOption(ChannelOption.SO_RCVBUF, nettyServerConfig.getServerSocketRcvBufSize())
                .localAddress(new InetSocketAddress(this.nettyServerConfig.getListenPort()))
                .childHandler(new ChannelInitializer<SocketChannel>() {
                    @Override
                    public void initChannel(SocketChannel ch) throws Exception {
                        ch.pipeline()
                            .addLast(defaultEventExecutorGroup, HANDSHAKE_HANDLER_NAME, handshakeHandler)
                            .addLast(defaultEventExecutorGroup,
                                encoder,
                                new NettyDecoder(),
                                new IdleStateHandler(0, 0, nettyServerConfig.getServerChannelMaxIdleTimeSeconds()),
                                connectionManageHandler,
                                serverHandler
                            );
                    }
                });
		
        if (nettyServerConfig.isServerPooledByteBufAllocatorEnable()) {
            childHandler.childOption(ChannelOption.ALLOCATOR, PooledByteBufAllocator.DEFAULT);
        }

        try {
            // 启动nettyServer的服务监听
            ChannelFuture sync = this.serverBootstrap.bind().sync();
            InetSocketAddress addr = (InetSocketAddress) sync.channel().localAddress();
            this.port = addr.getPort();
        } catch (InterruptedException e1) {
            throw new RuntimeException("this.serverBootstrap.bind().sync() InterruptedException", e1);
        }

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

        this.timer.scheduleAtFixedRate(new TimerTask() {

            @Override
            public void run() {
                try {
                    NettyRemotingServer.this.scanResponseTable();
                } catch (Throwable e) {
                    log.error("scanResponseTable exception", e);
                }
            }
        }, 1000 * 3, 1000);
    }

2.4 路由管理RouteInfoManager

NameServer的主要作用是为消息的生产者和消息消费者提供关于主题Topic的路由信息，那么NameServer需要存储路由的基础信息，还要管理Broker节点，包括路由注册、路由删除等。

2.4.1 路由元数据

public class RouteInfoManager {

    private final static long BROKER_CHANNEL_EXPIRED_TIME = 1000 * 60 * 2;
    private final ReadWriteLock lock = new ReentrantReadWriteLock();
    // Topic消息队列路由信息，消息发送时根据路由表进行负载均衡
    private final HashMap<String/* topic */, List<QueueData>> topicQueueTable;
    // Broker基础信息，包括brokerName、所属集群名称、主备Broker地址
    private final HashMap<String/* brokerName */, BrokerData> brokerAddrTable;
    // Broker集群信息，存储各个集群中所有Broker名称
    private final HashMap<String/* clusterName */, Set<String/* brokerName */>> clusterAddrTable;
    // Broker存活状态信息，NameServer每次收到心跳包是会替换该信息
    private final HashMap<String/* brokerAddr */, BrokerLiveInfo> brokerLiveTable;
    // Broker上的FilterServer列表，用于类模式消息过滤。
    private final HashMap<String/* brokerAddr */, List<String>/* Filter Server */> filterServerTable;

    // 路由构造器，该方法在 2.3.2 中的new NamesrvController(namesrvConfig, nettyServerConfig)方法时执行
    public RouteInfoManager() {
        this.topicQueueTable = new HashMap<String, List<QueueData>>(1024);
        this.brokerAddrTable = new HashMap<String, BrokerData>(128);
        this.clusterAddrTable = new HashMap<String, Set<String>>(32);
        this.brokerLiveTable = new HashMap<String, BrokerLiveInfo>(256);
        this.filterServerTable = new HashMap<String, List<String>>(256);
    }
    
    ……
}


// 2.3.2 中执行new NamesrvController(namesrvConfig, nettyServerConfig)方法时
public NamesrvController(NamesrvConfig namesrvConfig, NettyServerConfig nettyServerConfig) {
        this.namesrvConfig = namesrvConfig;
        this.nettyServerConfig = nettyServerConfig;
        this.kvConfigManager = new KVConfigManager(this);
    	// 此处通过构建了本地路由元数据信息
        this.routeInfoManager = new RouteInfoManager();
        this.brokerHousekeepingService = new BrokerHousekeepingService(this);
        this.configuration = new Configuration(
            log,
            this.namesrvConfig, this.nettyServerConfig
        );
        this.configuration.setStorePathFromConfig(this.namesrvConfig, "configStorePath");
    }

2.4.1.1 clusterAddrTable 数据结构

{
    "clusterAddrTable": {
        "c1": [
            {
                "broker-a",
                "broker-b"
            }
        ]
    }
}

2.4.1.2 brokerAddrTable 数据结构

{
    "brokerAddrTable": {
        "broker-a": {
            "cluster": "cl",
            "brokerName": "broker-a",
            "brokerAddrs": {
                0: "192.168.17.1:10000", // key：brokerId，value：broker IP地址及端口
                1: "192.168.17.2:10000",
            }
        }
    },
    "broker-b": {
        "cluster": "cl",
        "brokerAddrs": {
            0: "192.168.17.3:10000", // key：brokerId，value：broker IP地址及端口
            1: "192.168.17.4:10000"
        }
    }
}

2.4.1.3 brokerLiveTable 数据结构

{
    "brokerLiveTable": {
        "192.168.17.1:10000": {
            "lastUpdateTimestamp": 1518270318980,
            "dataversion": "versionobl",
            "channel": "channelobj",
            "haServerAddr": "192.168.17.2:10000"
        },
        "192.168.17.2:10000": {
            "lastUpdateTimestamp": 1518270318980,
            "dataversion": "versionobl",
            "channel": "channelobj",
            "haserverAddr": ""
        },
        "192.168.17.3:10000": {
            "lastUpdateTimestamp": 1518270318980,
            "dataversion": "versionobl",
            "channel": "channelobj",
            "haServerAddr": "192.168.17.4:10000"
        },
        "192.168.17.4:10000": {
            "lastUpdateTimestamp": 1518270318980,
            "dataversion": "versionobl",
            "channel": "channelobj",
            "haserverAddr": ""
        }
    }
}

2.4.1.4 topicQueueTable 数据结构

{
    "topicQueueTable": {
        "topic1": [
            {
                "brokerName": "broker-a",
                "readQueueNums": 4,
                "writeQueueNums": 4,
                "perm": 6, // 读写权限，具体参见org.apache.rocketmq.common.constant.PermName
                "topicsynFlag": 0 // topic 同步标记，具体参见org.apache.rocketmq.common.sysflag.TopicSysFlag
            },
            {
                "brokerName": "broker-b",
                "readQueueNums": 4,
                "writeQueueNums": 4,
                "perm": 6, // 读写权限，具体参见org.apache.rocketmq.common.constant.PermName
                "topicsynFlag": 0 // topic 同步标记，具体参见org.apache.rocketmq.common.sysflag.TopicSysFlag
            }
        ]
    },
    "topic other": []
}