Nacos 服务注册

  • nacos-spring-boot-project 中有关服务注册的几个项目
    • nacos-discovery-spring-boot-actuator nacos-discovery-spring-boot-autoconfigure nacos-discovery-spring-boot-starter
  1. org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
  2.   com.alibaba.boot.nacos.discovery.autoconfigure.NacosDiscoveryAutoConfiguration

找到类 NacosDiscoveryAutoConfiguration

  1. @ConditionalOnProperty(name = NacosDiscoveryConstants.ENABLED, matchIfMissing = true)
  2. @ConditionalOnMissingBean(name = DISCOVERY_GLOBAL_NACOS_PROPERTIES_BEAN_NAME)
  3. @EnableNacosDiscovery
  4. @EnableConfigurationProperties(value = NacosDiscoveryProperties.class)
  5. @ConditionalOnClass(name = "org.springframework.boot.context.properties.bind.Binder")
  6.     public class NacosDiscoveryAutoConfiguration {
  8.  @Bean
  9.  public NacosDiscoveryAutoRegister discoveryAutoRegister() {
  10.   return new NacosDiscoveryAutoRegister();
  11.  }
  13. }
  • 注解:EnableNacosDiscovery
  1. @Target({ ElementType.TYPE, ElementType.ANNOTATION_TYPE })
  2. @Retention(RetentionPolicy.RUNTIME)
  3. @Documented
  4. @Import(NacosDiscoveryBeanDefinitionRegistrar.class)
  5. public @interface EnableNacosDiscovery {}
  • import 类 :NacosDiscoveryBeanDefinitionRegistrar
  1. public class NacosDiscoveryBeanDefinitionRegistrar
  2.       implements ImportBeanDefinitionRegistrar, EnvironmentAware {
  4.    private Environment environment;
  6.    @Override
  7.    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata,
  8.          BeanDefinitionRegistry registry) {
  9.       AnnotationAttributes attributes = AnnotationAttributes
  10.             .fromMap(importingClassMetadata
  11.                   .getAnnotationAttributes(EnableNacosDiscovery.class.getName()));
  12.       // Register Global Nacos Properties Bean
  13.       registerGlobalNacosProperties(attributes, registry, environment,
  14.             DISCOVERY_GLOBAL_NACOS_PROPERTIES_BEAN_NAME);
  15.       registerGlobalNacosProperties(attributes, registry, environment,
  16.             MAINTAIN_GLOBAL_NACOS_PROPERTIES_BEAN_NAME);
  17.       // Register Nacos Common Beans
  18.       registerNacosCommonBeans(registry);
  19.       // Register Nacos Discovery Beans
  20.       registerNacosDiscoveryBeans(registry);
  21.    }
  23.    @Override
  24.    public void setEnvironment(Environment environment) {
  25.       this.environment = environment;
  26.    }
  27. }

  • 两个流程

    1. 将注解EnableNacosDiscovery的属性读取,放入到 nacos 的全局属性配置中

    2. bean 注入

nacos 全局配置属性

  • com.alibaba.nacos.spring.context.annotation.discovery.NacosDiscoveryBeanDefinitionRegistrar#registerBeanDefinitions
    • com.alibaba.nacos.spring.util.NacosBeanUtils#registerGlobalNacosProperties(org.springframework.core.annotation.AnnotationAttributes, org.springframework.beans.factory.support.BeanDefinitionRegistry, org.springframework.core.env.PropertyResolver, java.lang.String)
  1. public static void registerGlobalNacosProperties(AnnotationAttributes attributes,
  2.       BeanDefinitionRegistry registry, PropertyResolver propertyResolver,
  3.       String beanName) {
  4.    if (attributes == null) {
  5.       return; // Compatible with null
  6.    }
  7.    AnnotationAttributes globalPropertiesAttributes = attributes
  8.          .getAnnotation("globalProperties");
  9.    registerGlobalNacosProperties((Map<?, ?>) globalPropertiesAttributes, registry,
  10.          propertyResolver, beanName);
  11. }
  • 贴出注解上的信息
  1.     NacosProperties globalProperties() default @NacosProperties(username = USERNAME_PLACEHOLDER, password = PASSWORD_PLACEHOLDER, endpoint = ENDPOINT_PLACEHOLDER, namespace = NAMESPACE_PLACEHOLDER, accessKey = ACCESS_KEY_PLACEHOLDER, secretKey = SECRET_KEY_PLACEHOLDER, serverAddr = SERVER_ADDR_PLACEHOLDER, contextPath = CONTEXT_PATH_PLACEHOLDER, clusterName = CLUSTER_NAME_PLACEHOLDER, encode = ENCODE_PLACEHOLDER);

  • 通过下面这段代码会将注解信息获取到对象AnnotationAttributes globalPropertiesAttributes中

    1. AnnotationAttributes globalPropertiesAttributes = attributes
    2.       .getAnnotation("globalProperties");

  • 下一段代码是将属性换算出来

    ```java registerGlobalNacosProperties((Map<?, ?>) globalPropertiesAttributes, registry,

    1.   propertyResolver, beanName)
  1.       public static void registerGlobalNacosProperties(Map<?, ?> globalPropertiesAttributes,
  2.           BeanDefinitionRegistry registry, PropertyResolver propertyResolver,
  3.           String beanName) {
  4.       // 占位符解析成具体的配置信息
  5.       Properties globalProperties = resolveProperties(globalPropertiesAttributes,
  6.               propertyResolver);
  7.       // 单例注册
  8.       registerSingleton(registry, beanName, globalProperties);
  9.   }
  2. ![image-20200821111938485](/uploads/projects/SpringBoot-source/images/nacos/image-20200821111938485.png)
  4. ## registerNacosCommonBeans

public static void registerNacosCommonBeans(BeanDefinitionRegistry registry) { // Register NacosApplicationContextHolder Bean registerNacosApplicationContextHolder(registry); // Register AnnotationNacosInjectedBeanPostProcessor Bean registerAnnotationNacosInjectedBeanPostProcessor(registry); }

  2. - 主要方法: registerInfrastructureBean
  3.   1. 定义出 bean
  4.   2. 设置构造参数
  5.   3. 注册对象
  7. ```java
  8. public static void registerInfrastructureBean(BeanDefinitionRegistry registry,
  9.       String beanName, Class<?> beanClass, Object... constructorArgs) {
  10.    // Build a BeanDefinition for NacosServiceFactory class
  11.    // 定义出 bean 根据类型
  12.    BeanDefinitionBuilder beanDefinitionBuilder = BeanDefinitionBuilder
  13.          .rootBeanDefinition(beanClass);
  14.    for (Object constructorArg : constructorArgs) {
  15.       beanDefinitionBuilder.addConstructorArgValue(constructorArg);
  16.    }
  17.    // ROLE_INFRASTRUCTURE
  18.    beanDefinitionBuilder.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
  19.    // Register
  20.    registry.registerBeanDefinition(beanName,
  21.          beanDefinitionBuilder.getBeanDefinition());
  22. }

@EnableConfigurationProperties(value = NacosDiscoveryProperties.class)

属性读取，从 application 配置文件中读取数据转换成 java 对象。

image-20200821132413628

NacosDiscoveryAutoRegister

  1. public class NacosDiscoveryAutoRegister
  2.         implements ApplicationListener<WebServerInitializedEvent> {}

  • 处理一个WebServerInitializedEvent 事件的方法

  • 重写方法如下，主要工作内容

    1. 把服务发现配置读取出来
    2. 设置一些数据值
    3. 调用服务注册接口
  1. @Override
  2. public void onApplicationEvent(WebServerInitializedEvent event) {
  4.     if (!discoveryProperties.isAutoRegister()) {
  5.         return;
  6.     }
  8.     Register register = discoveryProperties.getRegister();
  10.     if (StringUtils.isEmpty(register.getIp())) {
  11.         register.setIp(NetUtils.localIP());
  12.     }
  14.     if (register.getPort() == 0) {
  15.         register.setPort(event.getWebServer().getPort());
  16.     }
  18.     register.getMetadata().put("preserved.register.source", "SPRING_BOOT");
  20.     register.setInstanceId("");
  22.     String serviceName = register.getServiceName();
  24.     if (StringUtils.isEmpty(serviceName)){
  25.         if (StringUtils.isEmpty(applicationName)){
  26.             throw new AutoRegisterException("serviceName notNull");
  27.         }
  28.         serviceName = applicationName;
  29.     }
  31.     try {
  32.         namingService.registerInstance(serviceName, register.getGroupName(),
  33.                 register);
  34.         logger.info("Finished auto register service : {}, ip : {}, port : {}",
  35.                 serviceName, register.getIp(), register.getPort());
  36.     } catch (NacosException e) {
  37.         throw new AutoRegisterException(e);
  38.     }
  39. }

  • 注册的参数

    image-20200821133350982

服务注册

image-20200821133445090

  • 注册一个实例
    1. 将 instance 对象转换成 BeatInfo 对象
    2. 注册实例
  1.     @Override
  2.     public void registerInstance(String serviceName, String groupName, Instance instance) throws NacosException {
  4.         if (instance.isEphemeral()) {
  5.             // 实例信息转换
  6.             BeatInfo beatInfo = new BeatInfo();
  7.             beatInfo.setServiceName(NamingUtils.getGroupedName(serviceName, groupName));
  8.             beatInfo.setIp(instance.getIp());
  9.             beatInfo.setPort(instance.getPort());
  10.             beatInfo.setCluster(instance.getClusterName());
  11.             beatInfo.setWeight(instance.getWeight());
  12.             beatInfo.setMetadata(instance.getMetadata());
  13.             beatInfo.setScheduled(false);
  14.             beatInfo.setPeriod(instance.getInstanceHeartBeatInterval());
  15.             // 插入这条实例的信息
  16.             beatReactor.addBeatInfo(NamingUtils.getGroupedName(serviceName, groupName),
  17.                     beatInfo);
  18.         }
  20.         serverProxy.registerService(NamingUtils.getGroupedName(serviceName, groupName), groupName, instance);
  21.     }
  • addBeatInfo
    • 创建了一个定时任务 BeatTask
  1. public void addBeatInfo(String serviceName, BeatInfo beatInfo) {
  2.     NAMING_LOGGER.info("[BEAT] adding beat: {} to beat map.", beatInfo);
  3.     String key = buildKey(serviceName, beatInfo.getIp(), beatInfo.getPort());
  4.     BeatInfo existBeat = null;
  5.     //fix #1733
  6.     if ((existBeat = dom2Beat.remove(key)) != null) {
  7.         existBeat.setStopped(true);
  8.     }
  9.     dom2Beat.put(key, beatInfo);
  10.     executorService.schedule(new BeatTask(beatInfo), beatInfo.getPeriod(), TimeUnit.MILLISECONDS);
  11.     MetricsMonitor.getDom2BeatSizeMonitor().set(dom2Beat.size());
  12. }

BeatTask

  1. class BeatTask implements Runnable {
  3.     BeatInfo beatInfo;
  5.     public BeatTask(BeatInfo beatInfo) {
  6.         this.beatInfo = beatInfo;
  7.     }
  9.     @Override
  10.     public void run() {
  11.         if (beatInfo.isStopped()) {
  12.             return;
  13.         }
  14.         long nextTime = beatInfo.getPeriod();
  15.         try {
  16.             // 与nacos进行一次rest请求交互
  17.             JSONObject result = serverProxy.sendBeat(beatInfo, BeatReactor.this.lightBeatEnabled);
  18.             long interval = result.get(CLIENT_BEAT_INTERVAL_FIELD).asLong();
  19.             boolean lightBeatEnabled = false;
  20.             if (result.has(CommonParams.LIGHT_BEAT_ENABLED)) {
  21.                 lightBeatEnabled = result.get(CommonParams.LIGHT_BEAT_ENABLED).asBoolean();
  22.             }
  23.             BeatReactor.this.lightBeatEnabled = lightBeatEnabled;
  24.             if (interval > 0) {
  25.                 nextTime = interval;
  26.             }
  27.             int code = NamingResponseCode.OK;
  28.             if (result.has(CommonParams.CODE)) {
  29.                 code = result.get(CommonParams.CODE).asInt();
  30.             }
  31.             // 如果nacos找不到当前实例,
  32.             if (code == NamingResponseCode.RESOURCE_NOT_FOUND) {
  33.                 Instance instance = new Instance();
  34.                 instance.setPort(beatInfo.getPort());
  35.                 instance.setIp(beatInfo.getIp());
  36.                 instance.setWeight(beatInfo.getWeight());
  37.                 instance.setMetadata(beatInfo.getMetadata());
  38.                 instance.setClusterName(beatInfo.getCluster());
  39.                 instance.setServiceName(beatInfo.getServiceName());
  40.                 instance.setInstanceId(instance.getInstanceId());
  41.                 instance.setEphemeral(true);
  42.                 try {
  43.                     // 执行注册服务
  44.                     serverProxy.registerService(beatInfo.getServiceName(),
  45.                         NamingUtils.getGroupName(beatInfo.getServiceName()), instance);
  46.                 } catch (Exception ignore) {
  47.                 }
  48.             }
  49.         } catch (NacosException ne) {
  50.             NAMING_LOGGER.error("[CLIENT-BEAT] failed to send beat: {}, code: {}, msg: {}",
  51.                 JSON.toJSONString(beatInfo), ne.getErrCode(), ne.getErrMsg());
  53.         } catch (Exception unknownEx) {
  54.                 NAMING_LOGGER.error("[CLIENT-BEAT] failed to send beat: {}, unknown exception msg: {}",
  55.                         JacksonUtils.toJson(beatInfo), unknownEx.getMessage(), unknownEx);
  56.         } finally {
  57.                 executorService.schedule(new BeatTask(beatInfo), nextTime, TimeUnit.MILLISECONDS);
  58.         }
  59.     }
  60. }

  • 定时任务说明

    1. 和 nacos 进行一次交互，根据交互结果的 code 判断,如果不在 nacos 会执行注册.

  • 发送请求的方法

    1. public String reqAPI(String api, Map<String, String> params, String body, List<String> servers, String method) throws NacosException {
    3.     params.put(CommonParams.NAMESPACE_ID, getNamespaceId());
    5.     if (CollectionUtils.isEmpty(servers) && StringUtils.isEmpty(nacosDomain)) {
    6.         throw new NacosException(NacosException.INVALID_PARAM, "no server available");
    7.     }
    9.     NacosException exception = new NacosException();
    11.     if (serverListManager.isDomain()) {
    12.           String nacosDomain = serverListManager.getNacosDomain();
    13.           for (int i = 0; i < maxRetry; i++) {
    14.               try {
    15.                   return callServer(api, params, body, nacosDomain, method);
    16.               } catch (NacosException e) {
    17.                   exception = e;
    18.                   if (NAMING_LOGGER.isDebugEnabled()) {
    19.                       NAMING_LOGGER.debug("request {} failed.", nacosDomain, e);
    20.                   }
    21.               }
    22.           }
    23.       } else {
    24.           Random random = new Random(System.currentTimeMillis());
    25.           int index = random.nextInt(servers.size());
    27.           for (int i = 0; i < servers.size(); i++) {
    28.               String server = servers.get(index);
    29.               try {
    30.                   return callServer(api, params, body, server, method);
    31.               } catch (NacosException e) {
    32.                   exception = e;
    33.                   if (NAMING_LOGGER.isDebugEnabled()) {
    34.                       NAMING_LOGGER.debug("request {} failed.", server, e);
    35.                   }
    36.               }
    37.               index = (index + 1) % servers.size();
    38.           }
    39.       }
    41.       NAMING_LOGGER.error("request: {} failed, servers: {}, code: {}, msg: {}", api, servers, exception.getErrCode(),
    42.               exception.getErrMsg());
    44.       throw new NacosException(exception.getErrCode(),
    45.               "failed to req API:" + api + " after all servers(" + servers + ") tried: " + exception.getMessage());

学习点

  • 这里采用随机值作为第一个 server 的获取，主要目的是为了将请求随机分配给不同的 nacos 服务

    如果直接使用 for 循环的索引那第一台 nacos 服务会收到所有的请求，直到这台服务坏了才会请求第二台

    1.   Random random = new Random(System.currentTimeMillis());
    2.   int index = random.nextInt(servers.size());
    4.   for (int i = 0; i < servers.size(); i++) {
    5.       // 获取nacos所在的ip+port地址
    6.       String server = servers.get(index);
    7.       try {
    8.           // 进行请求
    9.           return callServer(api, params, body, server, method);
    10.       } catch (NacosException e) {
    11.           exception = e;
    12.           if (NAMING_LOGGER.isDebugEnabled()) {
    13.               NAMING_LOGGER.debug("request {} failed.", server, e);
    14.           }
    15.       }
    16.       index = (index + 1) % servers.size();
    17.   }

    }

registerService

  • 注册方法就是请求一次接口，将数据发送给 nacos 就完成了
  1. public void registerService(String serviceName, String groupName, Instance instance) throws NacosException {
  3.     NAMING_LOGGER.info("[REGISTER-SERVICE] {} registering service {} with instance: {}",
  4.         namespaceId, serviceName, instance);
  5.     String groupedServiceName = NamingUtils.getGroupedName(serviceName, groupName);
  6.     if (instance.isEphemeral()) {
  7.         BeatInfo beatInfo = beatReactor.buildBeatInfo(groupedServiceName, instance);
  8.         beatReactor.addBeatInfo(groupedServiceName, beatInfo);
  9.     }
  11.     final Map<String, String> params = new HashMap<String, String>(32);
  12.     params.put(CommonParams.NAMESPACE_ID, namespaceId);
  13.     params.put(CommonParams.SERVICE_NAME, groupedServiceName);
  14.     params.put(CommonParams.GROUP_NAME, groupName);
  15.     params.put(CommonParams.CLUSTER_NAME, instance.getClusterName());
  16.     params.put(IP_PARAM, instance.getIp());
  17.     params.put(PORT_PARAM, String.valueOf(instance.getPort()));
  18.     params.put(WEIGHT_PARAM, String.valueOf(instance.getWeight()));
  19.     params.put(REGISTER_ENABLE_PARAM, String.valueOf(instance.isEnabled()));
  20.     params.put(HEALTHY_PARAM, String.valueOf(instance.isHealthy()));
  21.     params.put(EPHEMERAL_PARAM, String.valueOf(instance.isEphemeral()));
  22.     params.put(META_PARAM, JacksonUtils.toJson(instance.getMetadata()));
  24.     reqAPI(UtilAndComs.NACOS_URL_INSTANCE, params, HttpMethod.POST);
  26. }

  • 服务注册的接口

    • /nacos/v1/ns/instance
    • /nacos/v1/ns/instance/beat

  • 接下来去寻找这两个接口的实现

    com.alibaba.nacos.naming.controllers.InstanceController

nacos 服务端

实例注册

  1. public void registerInstance(String namespaceId, String serviceName, Instance instance) throws NacosException {
  2.     // 创建空服务
  3.     createEmptyService(namespaceId, serviceName, instance.isEphemeral());
  5.     Service service = getService(namespaceId, serviceName);
  7.     if (service == null) {
  8.         throw new NacosException(NacosException.INVALID_PARAM,
  9.             "service not found, namespace: " + namespaceId + ", service: " + serviceName);
  10.     }
  12.     addInstance(namespaceId, serviceName, instance.isEphemeral(), instance);
  13. }

  • 创建空服务的流程

    • 获取服务对象

      nacos 的服务信息存储在

      com.alibaba.nacos.naming.core.ServiceManager#serviceMap

      1. private Map<String, Map<String, Service>> serviceMap = new ConcurrentHashMap<>();
  1. public void createServiceIfAbsent(String namespaceId, String serviceName, boolean local, Cluster cluster) throws NacosException {
  2.     // 获取服务信息
  3.     Service service = getService(namespaceId, serviceName);
  4.     if (service == null) {
  6.         Loggers.SRV_LOG.info("creating empty service {}:{}", namespaceId, serviceName);
  7.         service = new Service();
  8.         service.setName(serviceName);
  9.         service.setNamespaceId(namespaceId);
  10.         service.setGroupName(NamingUtils.getGroupName(serviceName));
  11.         // now validate the service. if failed, exception will be thrown
  12.         service.setLastModifiedMillis(System.currentTimeMillis());
  13.         service.recalculateChecksum();
  14.         if (cluster != null) {
  15.             cluster.setService(service);
  16.             service.getClusterMap().put(cluster.getName(), cluster);
  17.         }
  18.         service.validate();
  20.         putServiceAndInit(service);
  21.         if (!local) {
  22.             addOrReplaceService(service);
  23.         }
  24.     }
  25. }
  • 在了解 map 结构后不难理解下面这个获取 Service 的方法了
  1. public Service getService(String namespaceId, String serviceName) {
  2.     if (serviceMap.get(namespaceId) == null) {
  3.         return null;
  4.     }
  5.     return chooseServiceMap(namespaceId).get(serviceName);
  6. }
  1. private void putServiceAndInit(Service service) throws NacosException {
  2.     putService(service);
  3.     service.init();
  4.     consistencyService.listen(KeyBuilder.buildInstanceListKey(service.getNamespaceId(), service.getName(), true), service);
  5.     consistencyService.listen(KeyBuilder.buildInstanceListKey(service.getNamespaceId(), service.getName(), false), service);
  6.     Loggers.SRV_LOG.info("[NEW-SERVICE] {}", service.toJSON());
  7. }
  • 把服务加入 map 对象
  1. public void putService(Service service) {
  2.     if (!serviceMap.containsKey(service.getNamespaceId())) {
  3.         synchronized (putServiceLock) {
  4.             if (!serviceMap.containsKey(service.getNamespaceId())) {
  5.                 serviceMap.put(service.getNamespaceId(), new ConcurrentHashMap<>(16));
  6.             }
  7.         }
  8.     }
  9.     serviceMap.get(service.getNamespaceId()).put(service.getName(), service);
  10. }
  • init 方法设置了一个数据验证的任务 ， 并且在集群中设置 service 信息
  1. public void init() {
  3.     HealthCheckReactor.scheduleCheck(clientBeatCheckTask);
  5.     for (Map.Entry<String, Cluster> entry : clusterMap.entrySet()) {
  6.         entry.getValue().setService(this);
  7.         entry.getValue().init();
  8.     }
  9. }

  • 再往后添加两个 key 的监听

  • addInstance 方法

  1. public void addInstance(String namespaceId, String serviceName, boolean ephemeral, Instance... ips) throws NacosException {
  3.     String key = KeyBuilder.buildInstanceListKey(namespaceId, serviceName, ephemeral);
  5.     Service service = getService(namespaceId, serviceName);
  7.     synchronized (service) {
  8.         List<Instance> instanceList = addIpAddresses(service, ephemeral, ips);
  10.         Instances instances = new Instances();
  11.         instances.setInstanceList(instanceList);
  13.         consistencyService.put(key, instances);
  14.     }
  15. }
  • 简单理解 consistencyService 结构信息
    • key： 定义的一个名字
    • value : 实例的列表

实例健康检查

  • 获取实例独享, 从 service 中根据集群名称获取实例列表 ， 再根据 ip + 端口 返回实例对象
  1. Instance instance = serviceManager.getInstance(namespaceId, serviceName, clusterName, ip, port);
  1. public Instance getInstance(String namespaceId, String serviceName, String cluster, String ip, int port) {
  2.     Service service = getService(namespaceId, serviceName);
  3.     if (service == null) {
  4.         return null;
  5.     }
  7.     List<String> clusters = new ArrayList<>();
  8.     clusters.add(cluster);
  10.     List<Instance> ips = service.allIPs(clusters);
  11.     if (ips == null || ips.isEmpty()) {
  12.         return null;
  13.     }
  15.     for (Instance instance : ips) {
  16.         if (instance.getIp().equals(ip) && instance.getPort() == port) {
  17.             return instance;
  18.         }
  19.     }
  21.     return null;
  22. }
  • 实例健康检查接口做的事件
    1. 获取实例
      1. 实例不存在注册实例
    2. 获取服务
      1. 服务不存在抛出异常
      2. 服务存在执行一个心跳方法
    3. 组装结果返回
  1. @CanDistro
  2. @PutMapping("/beat")
  3. @Secured(action = ActionTypes.WRITE)
  4. public ObjectNode beat(@RequestParam(defaultValue = Constants.DEFAULT_NAMESPACE_ID) String namespaceId,
  5.           @RequestParam String serviceName,
  6.           @RequestParam(defaultValue = StringUtils.EMPTY) String ip,
  7.           @RequestParam(defaultValue = UtilsAndCommons.DEFAULT_CLUSTER_NAME) String clusterName,
  8.           @RequestParam(defaultValue = "0") Integer port,
  9.           @RequestParam(defaultValue = StringUtils.EMPTY) String beat)throws Exception {
  11.       ObjectNode result = JacksonUtils.createEmptyJsonNode();
  12.       result.put(SwitchEntry.CLIENT_BEAT_INTERVAL, switchDomain.getClientBeatInterval());
  13.       RsInfo clientBeat = null;
  14.       if (StringUtils.isNotBlank(beat)) {
  15.           clientBeat = JacksonUtils.toObj(beat, RsInfo.class);
  16.       }
  17.       if (clientBeat != null) {
  18.           if (StringUtils.isNotBlank(clientBeat.getCluster())) {
  19.               clusterName = clientBeat.getCluster();
  20.           } else {
  21.               // fix #2533
  22.               clientBeat.setCluster(clusterName);
  23.           }
  24.         ip = clientBeat.getIp();
  25.         port = clientBeat.getPort();
  26.         }
  28.         NamingUtils.checkServiceNameFormat(serviceName);
  29.         Loggers.SRV_LOG.debug("[CLIENT-BEAT] full arguments: beat: {}, serviceName: {}, namespaceId: {}", clientBeat,
  30.         serviceName, namespaceId);
  31.         BeatInfoInstanceBuilder builder = BeatInfoInstanceBuilder.newBuilder();
  32.         int resultCode = instanceServiceV2
  33.         .handleBeat(namespaceId, serviceName, ip, port, clusterName, clientBeat, builder);
  34.         result.put(CommonParams.CODE, resultCode);
  35.         result.put(SwitchEntry.CLIENT_BEAT_INTERVAL,
  36.         instanceServiceV2.getHeartBeatInterval(namespaceId, serviceName, ip, port, clusterName));
  37.         result.put(SwitchEntry.LIGHT_BEAT_ENABLED, switchDomain.isLightBeatEnabled());
  38.         return result;
  39. }