RocketMQ八、nameserver的请求处理

最新推荐文章于 2021-11-21 11:31:22 发布
最新推荐文章于 2021-11-21 11:31:22 发布
阅读量180 收藏
点赞数
分类专栏： RocketMQ SpringCloudAlibaba 文章标签： java spring cloud alibaba RocketMQ
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_19414183/article/details/116796827
版权

继续DefaultRequestProcessor的processRequest方法：

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

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


    // 根据code进行不同的操作
    // 主要的功能：
    // 1.kv配置管理
    // 2.broker注册和注销 --这里管理几个容器 （topic、cluster、filterServer等）
    // 3.各种查询
    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;
}

这里有各种请求的处理代码。

我们随便拿几个为例子来看：

  1. REGISTER_BROKER注册broker

    public RemotingCommand registerBroker(ChannelHandlerContext ctx,
    RemotingCommand request) throws RemotingCommandException {
    final RemotingCommand response = RemotingCommand.createResponseCommand(RegisterBrokerResponseHeader.class);
    final RegisterBrokerResponseHeader responseHeader = (RegisterBrokerResponseHeader) response.readCustomHeader();
    final RegisterBrokerRequestHeader requestHeader =
        (RegisterBrokerRequestHeader) request.decodeCommandCustomHeader(RegisterBrokerRequestHeader.class);

    if (!checksum(ctx, request, requestHeader)) {
        response.setCode(ResponseCode.SYSTEM_ERROR);
        response.setRemark("crc32 not match");
        return response;
    }

    TopicConfigSerializeWrapper topicConfigWrapper;
    if (request.getBody() != null) {
        topicConfigWrapper = TopicConfigSerializeWrapper.decode(request.getBody(), TopicConfigSerializeWrapper.class);
    } else {
        topicConfigWrapper = new TopicConfigSerializeWrapper();
        topicConfigWrapper.getDataVersion().setCounter(new AtomicLong(0));
        topicConfigWrapper.getDataVersion().setTimestamp(0);
    }

    RegisterBrokerResult result = this.namesrvController.getRouteInfoManager().registerBroker(
        requestHeader.getClusterName(),
        requestHeader.getBrokerAddr(),
        requestHeader.getBrokerName(),
        requestHeader.getBrokerId(),
        requestHeader.getHaServerAddr(),
        topicConfigWrapper,
        null,
        ctx.channel()
    );

    responseHeader.setHaServerAddr(result.getHaServerAddr());
    responseHeader.setMasterAddr(result.getMasterAddr());

    byte[] jsonValue = this.namesrvController.getKvConfigManager().getKVListByNamespace(NamesrvUtil.NAMESPACE_ORDER_TOPIC_CONFIG);
    response.setBody(jsonValue);
    response.setCode(ResponseCode.SUCCESS);
    response.setRemark(null);
    return response;
}

    RouteInfoManager的registerBroker方法：

    public RegisterBrokerResult registerBroker(
    final String clusterName,
    final String brokerAddr,
    final String brokerName,
    final long brokerId,
    final String haServerAddr,
    final TopicConfigSerializeWrapper topicConfigWrapper,
    final List<String> filterServerList,
    final Channel channel) {
    RegisterBrokerResult result = new RegisterBrokerResult();
    try {
        try {
            // 获取写锁
            this.lock.writeLock().lockInterruptibly();

            // 获取该Cluster下的所有Broker,并添加该Broker
            Set<String> brokerNames = this.clusterAddrTable.get(clusterName);
            if (null == brokerNames) {
                brokerNames = new HashSet<String>();
                this.clusterAddrTable.put(clusterName, brokerNames);
            }
            brokerNames.add(brokerName);

            // 是否第一次注册，标志位
            boolean registerFirst = false;

            // 获取该BrokerName的BrokerData信息
            BrokerData brokerData = this.brokerAddrTable.get(brokerName);
            if (null == brokerData) {
                // 为空，第一次注册，构建信息存入
                registerFirst = true;
                brokerData = new BrokerData(clusterName, brokerName, new HashMap<Long, String>());
                this.brokerAddrTable.put(brokerName, brokerData);
            }
            Map<Long, String> brokerAddrsMap = brokerData.getBrokerAddrs();
            //Switch slave to master: first remove <1, IP:PORT> in namesrv, then add <0, IP:PORT>
            //The same IP:PORT must only have one record in brokerAddrTable
            Iterator<Entry<Long, String>> it = brokerAddrsMap.entrySet().iterator();
            while (it.hasNext()) {
                Entry<Long, String> item = it.next();
                if (null != brokerAddr && brokerAddr.equals(item.getValue()) && brokerId != item.getKey()) {
                    it.remove();
                }
            }

            // 存入brokerAddrs信息，若oldAddr为null则为第一次put
            String oldAddr = brokerData.getBrokerAddrs().put(brokerId, brokerAddr);
            registerFirst = registerFirst || (null == oldAddr);

            // 若TopicConfigSerializeWrapper不为空，该类为TopicConfig信息的包装类，方便传输
            // 且该broker为主，即 brokerId==0
            if (null != topicConfigWrapper
                && MixAll.MASTER_ID == brokerId) {
                // 判断Broker的TopicConfig信息是否改变||第一注册Broker信息
                if (this.isBrokerTopicConfigChanged(brokerAddr, topicConfigWrapper.getDataVersion())
                    || registerFirst) {
                    ConcurrentMap<String, TopicConfig> tcTable =
                        topicConfigWrapper.getTopicConfigTable();
                    if (tcTable != null) {
                        for (Map.Entry<String, TopicConfig> entry : tcTable.entrySet()) {
                            // 填充topicQueueTable
                            this.createAndUpdateQueueData(brokerName, entry.getValue());
                        }
                    }
                }
            }

            // 填充brokerLiveTable
            BrokerLiveInfo prevBrokerLiveInfo = this.brokerLiveTable.put(brokerAddr,
                new BrokerLiveInfo(
                    System.currentTimeMillis(),
                    topicConfigWrapper.getDataVersion(),
                    channel,
                    haServerAddr));
            // 第一次注册
            if (null == prevBrokerLiveInfo) {
                log.info("new broker registered, {} HAServer: {}", brokerAddr, haServerAddr);
            }

            if (filterServerList != null) {
                if (filterServerList.isEmpty()) {
                    this.filterServerTable.remove(brokerAddr);
                } else {
                    this.filterServerTable.put(brokerAddr, filterServerList);
                }
            }

            // 备机处理，获取Master地址，构建返回结果
            if (MixAll.MASTER_ID != brokerId) {
                String masterAddr = brokerData.getBrokerAddrs().get(MixAll.MASTER_ID);
                if (masterAddr != null) {
                    BrokerLiveInfo brokerLiveInfo = this.brokerLiveTable.get(masterAddr);
                    if (brokerLiveInfo != null) {
                        result.setHaServerAddr(brokerLiveInfo.getHaServerAddr());
                        result.setMasterAddr(masterAddr);
                    }
                }
            }
        } finally {
            // 释放写锁
            this.lock.writeLock().unlock();
        }
    } catch (Exception e) {
        log.error("registerBroker Exception", e);
    }

    return result;
}

    实际上就是往RouteInfoManager的几个map中添加信息

    那么我们可以想到，注销broker的过程就是RouteInfoManager的几个map的清理了：

    public void unregisterBroker(
    final String clusterName,
    final String brokerAddr,
    final String brokerName,
    final long brokerId) {
    try {
        try {
            this.lock.writeLock().lockInterruptibly();
            BrokerLiveInfo brokerLiveInfo = this.brokerLiveTable.remove(brokerAddr);
            log.info("unregisterBroker, remove from brokerLiveTable {}, {}",
                brokerLiveInfo != null ? "OK" : "Failed",
                brokerAddr
            );

            this.filterServerTable.remove(brokerAddr);

            boolean removeBrokerName = false;
            BrokerData brokerData = this.brokerAddrTable.get(brokerName);
            if (null != brokerData) {
                String addr = brokerData.getBrokerAddrs().remove(brokerId);
                log.info("unregisterBroker, remove addr from brokerAddrTable {}, {}",
                    addr != null ? "OK" : "Failed",
                    brokerAddr
                );

                if (brokerData.getBrokerAddrs().isEmpty()) {
                    this.brokerAddrTable.remove(brokerName);
                    log.info("unregisterBroker, remove name from brokerAddrTable OK, {}",
                        brokerName
                    );

                    removeBrokerName = true;
                }
            }

            if (removeBrokerName) {
                Set<String> nameSet = this.clusterAddrTable.get(clusterName);
                if (nameSet != null) {
                    boolean removed = nameSet.remove(brokerName);
                    log.info("unregisterBroker, remove name from clusterAddrTable {}, {}",
                        removed ? "OK" : "Failed",
                        brokerName);

                    if (nameSet.isEmpty()) {
                        this.clusterAddrTable.remove(clusterName);
                        log.info("unregisterBroker, remove cluster from clusterAddrTable {}",
                            clusterName
                        );
                    }
                }
                this.removeTopicByBrokerName(brokerName);
            }
        } finally {
            this.lock.writeLock().unlock();
        }
    } catch (Exception e) {
        log.error("unregisterBroker Exception", e);
    }
}

  2. GET_ROUTEINTO_BY_TOPIC根据TOPIC获取路由信息

    public RemotingCommand getRouteInfoByTopic(ChannelHandlerContext ctx,
    RemotingCommand request) throws RemotingCommandException {
    final RemotingCommand response = RemotingCommand.createResponseCommand(null);
    final GetRouteInfoRequestHeader requestHeader =
        (GetRouteInfoRequestHeader) request.decodeCommandCustomHeader(GetRouteInfoRequestHeader.class);

    TopicRouteData topicRouteData = this.namesrvController.getRouteInfoManager().pickupTopicRouteData(requestHeader.getTopic());

    if (topicRouteData != null) {
        if (this.namesrvController.getNamesrvConfig().isOrderMessageEnable()) {
            String orderTopicConf =
                this.namesrvController.getKvConfigManager().getKVConfig(NamesrvUtil.NAMESPACE_ORDER_TOPIC_CONFIG,
                    requestHeader.getTopic());
            topicRouteData.setOrderTopicConf(orderTopicConf);
        }

        byte[] content = topicRouteData.encode();
        response.setBody(content);
        response.setCode(ResponseCode.SUCCESS);
        response.setRemark(null);
        return response;
    }

    response.setCode(ResponseCode.TOPIC_NOT_EXIST);
    response.setRemark("No topic route info in name server for the topic: " + requestHeader.getTopic()
        + FAQUrl.suggestTodo(FAQUrl.APPLY_TOPIC_URL));
    return response;
}

    public TopicRouteData pickupTopicRouteData(final String topic) {
    TopicRouteData topicRouteData = new TopicRouteData();
    boolean foundQueueData = false;
    boolean foundBrokerData = false;
    Set<String> brokerNameSet = new HashSet<String>();
    List<BrokerData> brokerDataList = new LinkedList<BrokerData>();
    topicRouteData.setBrokerDatas(brokerDataList);

    HashMap<String, List<String>> filterServerMap = new HashMap<String, List<String>>();
    topicRouteData.setFilterServerTable(filterServerMap);

    try {
        try {
            this.lock.readLock().lockInterruptibly();
            List<QueueData> queueDataList = this.topicQueueTable.get(topic);
            if (queueDataList != null) {
                topicRouteData.setQueueDatas(queueDataList);
                foundQueueData = true;

                Iterator<QueueData> it = queueDataList.iterator();
                while (it.hasNext()) {
                    QueueData qd = it.next();
                    brokerNameSet.add(qd.getBrokerName());
                }

                for (String brokerName : brokerNameSet) {
                    BrokerData brokerData = this.brokerAddrTable.get(brokerName);
                    if (null != brokerData) {
                        BrokerData brokerDataClone = new BrokerData(brokerData.getCluster(), brokerData.getBrokerName(), (HashMap<Long, String>) brokerData
                            .getBrokerAddrs().clone());
                        brokerDataList.add(brokerDataClone);
                        foundBrokerData = true;
                        for (final String brokerAddr : brokerDataClone.getBrokerAddrs().values()) {
                            List<String> filterServerList = this.filterServerTable.get(brokerAddr);
                            filterServerMap.put(brokerAddr, filterServerList);
                        }
                    }
                }
            }
        } finally {
            this.lock.readLock().unlock();
        }
    } catch (Exception e) {
        log.error("pickupTopicRouteData Exception", e);
    }

    log.debug("pickupTopicRouteData {} {}", topic, topicRouteData);

    if (foundBrokerData && foundQueueData) {
        return topicRouteData;
    }

    return null;
}

  3. GET_ALL_TOPIC_LIST_FROM_NAMESERVER获取topic列表

    private RemotingCommand getAllTopicListFromNameserver(ChannelHandlerContext ctx, RemotingCommand request) {
    final RemotingCommand response = RemotingCommand.createResponseCommand(null);

    byte[] body = this.namesrvController.getRouteInfoManager().getAllTopicList();

    response.setBody(body);
    response.setCode(ResponseCode.SUCCESS);
    response.setRemark(null);
    return response;
}
public byte[] getAllTopicList() {
    TopicList topicList = new TopicList();
    try {
        try {
            this.lock.readLock().lockInterruptibly();
            topicList.getTopicList().addAll(this.topicQueueTable.keySet());
        } finally {
            this.lock.readLock().unlock();
        }
    } catch (Exception e) {
        log.error("getAllTopicList Exception", e);
    }

    return topicList.encode();
}

  4. PUT_KV_CONFIG 添加kv配置

    public RemotingCommand putKVConfig(ChannelHandlerContext ctx,
    RemotingCommand request) throws RemotingCommandException {
    final RemotingCommand response = RemotingCommand.createResponseCommand(null);
    final PutKVConfigRequestHeader requestHeader =
        (PutKVConfigRequestHeader) request.decodeCommandCustomHeader(PutKVConfigRequestHeader.class);

    this.namesrvController.getKvConfigManager().putKVConfig(
        requestHeader.getNamespace(),
        requestHeader.getKey(),
        requestHeader.getValue()
    );

    response.setCode(ResponseCode.SUCCESS);
    response.setRemark(null);
    return response;
}

    public void putKVConfig(final String namespace, final String key, final String value) {
    try {
        this.lock.writeLock().lockInterruptibly();
        try {
            HashMap<String, String> kvTable = this.configTable.get(namespace);
            if (null == kvTable) {
                kvTable = new HashMap<String, String>();
                this.configTable.put(namespace, kvTable);
                log.info("putKVConfig create new Namespace {}", namespace);
            }

            final String prev = kvTable.put(key, value);
            if (null != prev) {
                log.info("putKVConfig update config item, Namespace: {} Key: {} Value: {}",
                    namespace, key, value);
            } else {
                log.info("putKVConfig create new config item, Namespace: {} Key: {} Value: {}",
                    namespace, key, value);
            }
        } finally {
            this.lock.writeLock().unlock();
        }
    } catch (InterruptedException e) {
        log.error("putKVConfig InterruptedException", e);
    }

    this.persist();
}

    这里注意下persist方法，回写文件了：

    public void persist() {
    try {
        this.lock.readLock().lockInterruptibly();
        try {
            KVConfigSerializeWrapper kvConfigSerializeWrapper = new KVConfigSerializeWrapper();
            kvConfigSerializeWrapper.setConfigTable(this.configTable);

            String content = kvConfigSerializeWrapper.toJson();

            if (null != content) {
                MixAll.string2File(content, this.namesrvController.getNamesrvConfig().getKvConfigPath());
            }
        } catch (IOException e) {
            log.error("persist kvconfig Exception, "
                + this.namesrvController.getNamesrvConfig().getKvConfigPath(), e);
        } finally {
            this.lock.readLock().unlock();
        }
    } catch (InterruptedException e) {
        log.error("persist InterruptedException", e);
    }

}

总结一下：

关键是前面提到的nameserver启动时装载的几个管理类：RouteInfoManager、KVConfigManager、Configuration等，他们维护的各种元数据缓存信息，nameserver的请求处理就是对这些缓存信息进行基本的CURD操作。

vinylon1022
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【rocketmq系列】【三】【NameServer-路由中心】
weixin_43958091的博客
03-29 218
文章目录路由注册&故障剔除路由元信息参数解释路由元数据类图运行时数据结构路由注册发送心跳包处理心跳包路由剔除路由发现 路由管理，服务注册，服务发现 存储的是什么数据？ 避免单点故障，提供高可用？ 接口scheduleAtFixedRate原型定义及参数说明 接口scheduleAtFixedRate原型定义及参数说明 public ScheduledFuture<?> scheduleAtFixedRate(Runnable command, long initialDela
RocketMQ源码解析之NameServer请求处理
0xZzzz的博客
02-13 784
阅读须知 文章中使用/* */注释的方法会做深入分析 正文
RocketMQ源码分析——NameServer启动流程与路由管理器
一颗小陨石的博客
11-21 2040
一、NameServer作用 NameServer作为 RocketMQ 的服务路由中心，其主要起到了如下的作用： 服务注册 Broker 在启动的时候会向 NameServer 注册自己的信息，Broker 宕机时 NameServer 也会剔除该 Broker 信息 路由发现 Produer 发送消息或 Consumer 拉取消息，都需要从 NameServer 获取路由信息 通信、维持心跳 Producer、Consumer和 Broker 都会与 NameServer 进行通信或定时发送
RocketMQ源码系列(一) NameServer 核心源码解析
热门推荐
Dream_it_possible！的博客
06-15 2万+
一、NameServer 介绍 二、NameServer 功能列表 三、NameServer 架构分析 四、NameServer 架构
Linux配置多nameserver导致DNS问题
CSDN_niuniu的博客
07-07 2412
问题现象 1、请求响应时间很长，无业务逻辑也很慢； 2、启动时间很长，很难重启； 3、通过arthas(阿里云开源代码分析工具)跟踪定位发现： org.apache.catalina.core.StandardHostValve.invoke(org.apache.catalina.connector.Request request, org.apache.catalina.connector.Response response) 该行代码运行时间超过10s。 解决问题 1、StandardHostVal
springboot整合RocketMQ，实现请求异步处理
最新发布
06-24
RocketMQ 的核心，接收 Producer 发过来的消息、处理 Consumer 的消费消息请求、消息的持 久化存储、服务端过滤功能等 。 (2)、NameServer 消息队列中的状态服务器，集群的各个组件通过它来了解全局的信息 。类似...
spingboot-rocketmq事务消息
09-16
2. **配置RocketMQ**：配置RocketMQ的相关参数，如NameServer地址、Producer Group等。 3. **创建Producer**：创建一个SpringBean，实现`LocalTransactionExecutor`接口，用于执行本地事务。 4. **发送事务消息**：...
rocketmq源码、
06-19
- **Broker**：Broker是实际存储消息的节点，负责接收Producer发送的消息并转发给Consumer，同时处理Consumer的拉取消息请求。 - **Producer**：Producer负责生产消息，向Broker发送消息，并可以通过NameServer...
RocketMQ学习笔记1
08-04
RocketMQ可以用来解决流量高峰的问题，将大量的数据请求缓存起来，分散到相对长的一段时间内处理，提高系统的稳定性和用户体验。 消息分发 RocketMQ可以实现消息分发，生产者可以将消息发送到队列中，消费者可以...
rocketmq-console.rar
12-10
2. **后端源码**：主要处理HTTP请求，与RocketMQ集群通信，获取和更新数据。这部分可能基于Spring Boot或Node.js等后端框架开发。 3. **配置文件**：包含应用的配置信息，如数据库连接、RocketMQ服务器地址、报警...
RocketMQ使用命令查看主题列表报错：SubCommandException: TopicListSubCommand command failed
健身变秃，coding变强
10-26 3636
详细报错 org.apache.rocketmq.tools.command.SubCommandException: TopicListSubCommand command failed at org.apache.rocketmq.tools.command.topic.TopicListSubCommand.execute(TopicListSubCommand.java:113) at org.apache.rocketmq.tools.command.MQAdminStartup.main0(
RocketMQ路由中心NameServer
sdaujsj1的博客
04-15 269
文章目录RocketMQ路由中心NameServer一 NameServer架构设计启动流程步骤一步骤二步骤三二 NameServer动态路由发现与剔除机制1. 路由元信息2 路由注册1）Broker发送心跳包2）NameServer处理心跳包3 路由删除4路由发现 RocketMQ路由中心NameServer 一 NameServer架构设计 消息中间件的设计思路一般是基于主题订阅发布的机制，消息生产者（Producer）发送某一个主题到消息服务器，消息服务器负责将消息持久化存储，消息消费者（Cons
Apache RocketMQ：使用api实现对Topic的基本操作
编程学习者的博客
10-23 1494
当前rocketmq版本4.9 1. 声明 当前内容主要为本人学习Rocketmq之用，当前内容部分参考官方文档 pom依赖和前面的一样：之前的pom依赖 2. 重要的概念 就是Name Server就是一个名称服务器群组，所有的broker都注册到名称服务器中，名称服务器控制灾难恢复(保存元数据信息) 就是领导者，主要控制集群控制，实际数据的读写等操作 name server 默认启动在9876 broker server 默认启动在10911 所以如果在Rocketmq中只要出现与外界交互的参数
RocketMQ 简介 -- NameServer And Message
学习空间
04-12 754
RocketMQ NameServer And Message RocketMQ NameServer And Message NameServer 请求处理 Message 消息属性 概念 Cluster Broker Topic NameServer 管理以Key-Value的形式保存各个NameSpace下的配置(userHome/namesrv/kvC...
RocketMQ原理学习-- Name Server
井底之蛙
12-01 1174
       Name Server作为RocketMQ的一个组件，其作用就是一个注册中心，用于管理Broker相关的一些信息，生产者和消费者可以从Name Server中获取Broker中相关的Topic信息等，Name Server可以单台部署也可以多台部署，相互之间不存在联系。 Name Server主要有以下两个功能： 维护一份Broker信息(集群名称、Broker名称及相关地址信息...
rocketmq-连接rocketmq遇到的异常
面朝大海，春暖花开
01-18 4231
连接rocketmq遇到的异常 sendDefaultImpl call timeout org.apache.rocketmq.remoting.exception.RemotingTooMuchRequestException: sendDefaultImpl call timeout at org.apache.rocketmq.client.impl.producer.DefaultM...
RocketMQ学习教程：09.深入理解NameServer【云图智联】
07-22 702
1 NameServer介绍 Name Server 是专为 RocketMQ 设计的轻量级名称服务，具有简单、可集群横吐扩展、无状态，节点之间互不通信等特点。整个Rocketmq集群的工作原理如下图所示： 可以看到，Broker集群、Producer集群、Consumer集群都需要与NameServer集群进行通信： Broker集群: Broker用于接收生产者发送消息，或者消费者消费消息的请求。一个Broker集群由多组Master/Slave组成，Master可写可读，S...
linux系统--nameserver惹得祸
weixin_30471065的博客
05-21 789
症状： 1、所有用户包括root用户登录Linux服务器，输入用户名后要等很长时间才能输入密码 2、在oracle服务端使用tnsping命令执行非常慢 3、使用oracle客户端或者plsql登录oracle服务器响应非常慢 4、应用比如mdsp，portalone等在启动连接数据库超时，导致应用启动失败。 病因： 配置了错误的DNS，导致域名解析失败，从而导致访问系统缓慢。...
RocketMQ源码阅读（5）-NameServer定时路由状态监测
tdt008的博客
09-10 362
1、NameServer中定时监测路由状态的定时任务 在创建NamesrvController、调用initialize方法时候往线程池放入了一个任务，每隔十秒扫描一次Broker，移除处于不 激活状态的Broker（Broker在正常关闭的情况下，会执行unregisterBroker指定，移除broker信息）。 // 定时线程任务每隔十秒扫描一次Broker，移除处于不 激活状态...
rocketmq nameserver 源码解析
05-29
RocketMQ NameServer 的核心类是 `NamesrvController`，它继承了 Netty 的 `NettyRemotingServer` 类，并实现了 `RequestProcessor` 接口，用于处理来自 Broker 和 Consumer 节点的请求。在 `NamesrvController` 中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值