源码篇--Nacos服务--中章(5):Nacos客户端启动-实例注册-grpc连接建立

已于 2024-04-24 10:24:13 修改
阅读量1k 收藏 17
点赞数 22
分类专栏： # spring-boot java工具篇 源码解析篇 文章标签： java nacos
于 2024-04-24 10:20:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/l123lgx/article/details/137149920
版权

文章目录

前言

本文对Nacos 客户端启动时，同服务端建立长连接的过程进行介绍。环境：客户端版本2.2.1，服务端版本 3.0.13；

一、 前奏：

实际客户端同服务端进行grpc 通道的建立，是在客户端实例注册过程中进行的，因为注册肯定要向服务端发送请求，所以要先通过grpc 完成通道的建立 ；一下对客户端实例的注册流程进行简单介绍。
流程图：
在这里插入图片描述
流程步骤解释：

  • 客户端所在web 应用启动完成，发布 WebServiceInitializedEvent 事件；
  • AbstractAutoServiceRegistration ，onApplicationEvent 方法接收事件 并调用start 方法；
public void onApplicationEvent(WebServerInitializedEvent event) {
  ApplicationContext context = event.getApplicationContext();
   if (!(context instanceof ConfigurableWebServerApplicationContext) || !"management".equals(((ConfigurableWebServerApplicationContext)context).getServerNamespace())) {
   	  // 本机web 端口 
       this.port.compareAndSet(0, event.getWebServer().getPort());
       // 初始化方法调用
       this.start();
   }
}

start() 方法：

public void start() {
    if (!this.isEnabled()) {
        if (logger.isDebugEnabled()) {
            logger.debug("Discovery Lifecycle disabled. Not starting");
        }

    } else {
        if (!this.running.get()) {
        	// 发布 实例注册 前事件
            this.context.publishEvent(new InstancePreRegisteredEvent(this, this.getRegistration()));
            this.registrationLifecycles.forEach((registrationLifecycle) -> {
                registrationLifecycle.postProcessBeforeStartRegister(this.getRegistration());
            });
            // 实例注册方法调用
            this.register();
            this.registrationLifecycles.forEach((registrationLifecycle) -> {
                registrationLifecycle.postProcessAfterStartRegister(this.getRegistration());
            });
            if (this.shouldRegisterManagement()) {
                this.registrationManagementLifecycles.forEach((registrationManagementLifecycle) -> {
                    registrationManagementLifecycle.postProcessBeforeStartRegisterManagement(this.getManagementRegistration());
                });
                this.registerManagement();
                this.registrationManagementLifecycles.forEach((registrationManagementLifecycle) -> {
                    registrationManagementLifecycle.postProcessAfterStartRegisterManagement(this.getManagementRegistration());
                });
            }
			 // 实例注册完成事件
            this.context.publishEvent(new InstanceRegisteredEvent(this, this.getConfiguration()));
            this.running.compareAndSet(false, true);
        }

    }
}
  • AbstractAutoServiceRegistration ，register() 方法 调用到 NacosServiceRegistry 的 register 方法；
  • namingService.registerInstance 进行客户端的注册；
 public void register(Registration registration) {
    if (StringUtils.isEmpty(registration.getServiceId())) {
        log.warn("No service to register for nacos client...");
    } else {
    	// 客户端长连接的建立
        NamingService namingService = this.namingService();
        String serviceId = registration.getServiceId();
        String group = this.nacosDiscoveryProperties.getGroup();
        // 构建客户端实例对象
        Instance instance = this.getNacosInstanceFromRegistration(registration);

        try {
             // grpc 发送 客户端实例注册请求
            namingService.registerInstance(serviceId, group, instance);
            log.info("nacos registry, {} {} {}:{} register finished", new Object[]{group, serviceId, instance.getIp(), instance.getPort()});
        } catch (Exception var7) {
            if (this.nacosDiscoveryProperties.isFailFast()) {
                log.error("nacos registry, {} register failed...{},", new Object[]{serviceId, registration.toString(), var7});
                ReflectionUtils.rethrowRuntimeException(var7);
            } else {
                log.warn("Failfast is false. {} register failed...{},", new Object[]{serviceId, registration.toString(), var7});
            }
        }

    }
}

二、客户端连接的建立：

NamingService namingService = this.namingService(); 这行代码做了很多事情，其中需要重点关注的时 客户端与服务端连接的建立，以及客户端的故障转移机制，下文先对连接的建立进行介绍；

2.1 NacosNamingService 创建：

public static NamingService createNamingService(Properties properties) throws NacosException {
    try {
        Class<?> driverImplClass = Class.forName("com.alibaba.nacos.client.naming.NacosNamingService");
        // 调用 NacosNamingService 的构造方法，传入配置参数
        Constructor constructor = driverImplClass.getConstructor(Properties.class);
        return (NamingService) constructor.newInstance(properties);
    } catch (Throwable e) {
        throw new NacosException(NacosException.CLIENT_INVALID_PARAM, e);
    }
}

2.2 NacosNamingService 初始化：

public NacosNamingService(Properties properties) throws NacosException {
init(properties);
}

private void init(Properties properties) throws NacosException {
    PreInitUtils.asyncPreLoadCostComponent();
    // 自定义属性
    final NacosClientProperties nacosClientProperties = NacosClientProperties.PROTOTYPE.derive(properties);
    ValidatorUtils.checkInitParam(nacosClientProperties);
    // 命名空间
    this.namespace = InitUtils.initNamespaceForNaming(nacosClientProperties);
    InitUtils.initSerialization();
    InitUtils.initWebRootContext(nacosClientProperties);
    // 日志名称属性设置
    initLogName(nacosClientProperties);

    this.notifierEventScope = UUID.randomUUID().toString();
    //  InstancesChangeNotifier extends Subscriber<InstancesChangeEvent>
    // 订阅者，订阅InstancesChangeEvent 实例变更事件 ，出现变更调用InstancesChangeNotifier onchange 方法
    this.changeNotifier = new InstancesChangeNotifier(this.notifierEventScope);
    // 注册事件发布器
    NotifyCenter.registerToPublisher(InstancesChangeEvent.class, 16384);
    // 注册订阅者
    NotifyCenter.registerSubscriber(changeNotifier);
    // 服务信息获取(故障转移)
    this.serviceInfoHolder = new ServiceInfoHolder(namespace, this.notifierEventScope, nacosClientProperties);
    // 客户端代理
    this.clientProxy = new NamingClientProxyDelegate(this.namespace, serviceInfoHolder, nacosClientProperties,
            changeNotifier);
}

2.3 NamingClientProxyDelegate 长连接建立：

2.3.1 grpc 代理对象创建：

 public NamingClientProxyDelegate(String namespace, ServiceInfoHolder serviceInfoHolder,
            NacosClientProperties properties, InstancesChangeNotifier changeNotifier) throws NacosException {
 // 服务更新
    this.serviceInfoUpdateService = new ServiceInfoUpdateService(properties, serviceInfoHolder, this,
            changeNotifier);
    // 服务端地址管理器
    this.serverListManager = new ServerListManager(properties, namespace);
    this.serviceInfoHolder = serviceInfoHolder;
    this.securityProxy = new SecurityProxy(this.serverListManager.getServerList(),
            NamingHttpClientManager.getInstance().getNacosRestTemplate());
    initSecurityProxy(properties);
    // http 代理
    this.httpClientProxy = new NamingHttpClientProxy(namespace, securityProxy, serverListManager, properties);
    // grpc 代理
    this.grpcClientProxy = new NamingGrpcClientProxy(namespace, securityProxy, serverListManager, properties,
            serviceInfoHolder);
}

2.3.2 NamingGrpcClientProxy grpc:

public NamingGrpcClientProxy(String namespaceId, SecurityProxy securityProxy, ServerListFactory serverListFactory,
        NacosClientProperties properties, ServiceInfoHolder serviceInfoHolder) throws NacosException {
    super(securityProxy);
    this.namespaceId = namespaceId;
    this.uuid = UUID.randomUUID().toString();
    // 请求超时时间
    this.requestTimeout = Long.parseLong(properties.getProperty(CommonParams.NAMING_REQUEST_TIMEOUT, "-1"));
    Map<String, String> labels = new HashMap<>();
    // 资源是sdk
    labels.put(RemoteConstants.LABEL_SOURCE, RemoteConstants.LABEL_SOURCE_SDK);
    // 模式是注册
    labels.put(RemoteConstants.LABEL_MODULE, RemoteConstants.LABEL_MODULE_NAMING);
    labels.put(Constants.APPNAME, AppNameUtils.getAppName());
    // rpc  客户端的创建
    this.rpcClient = RpcClientFactory.createClient(uuid, ConnectionType.GRPC, labels,
            RpcClientTlsConfig.properties(properties.asProperties()));
    this.redoService = new NamingGrpcRedoService(this, properties);
    NAMING_LOGGER.info("Create naming rpc client for uuid->{}", uuid);
    start(serverListFactory, serviceInfoHolder);
}
2.3.2.1 createClient 客户端的创建：
public static RpcClient createClient(String clientName, ConnectionType connectionType, Integer threadPoolCoreSize,
            Integer threadPoolMaxSize, Map<String, String> labels, RpcClientTlsConfig tlsConfig) {
        // 不是grpc 抛出异常
   if (!ConnectionType.GRPC.equals(connectionType)) {
        throw new UnsupportedOperationException("unsupported connection type :" + connectionType.getType());
    }
    // 客户端创建 Map<String, RpcClient> CLIENT_MAP
    return CLIENT_MAP.computeIfAbsent(clientName, clientNameInner -> {
        LOGGER.info("[RpcClientFactory] create a new rpc client of " + clientName);

        return new GrpcSdkClient(clientNameInner, threadPoolCoreSize, threadPoolMaxSize, labels, tlsConfig);
    });
}
2.3.2.2 start 长连接建立：
 private void start(ServerListFactory serverListFactory, ServiceInfoHolder serviceInfoHolder) throws NacosException {
  // 服务地址的工厂
   rpcClient.serverListFactory(serverListFactory);
   // 监听器放入
   rpcClient.registerConnectionListener(redoService);
   // 请求处理器
   rpcClient.registerServerRequestHandler(new NamingPushRequestHandler(serviceInfoHolder));
   // 客户端启动
   rpcClient.start();
   NotifyCenter.registerSubscriber(this);
}

rpcClient.start()：注意做了3件事 （具体的实现细节在后续文章进行介绍）

  • 客户端与服务端的通道建立：
    1）和nacos 服务端建立通信的channel 管道；建立双向流的grpc 通信存根；
    2）发送服务检查请求，从nacos 服务端获取到连接的connectId ；
    3) 发送给服务端客户端和服务端完成连接建立的请求；

  • 客户端与服务端的心跳监测：
    1） 在while(true) 循环中，发送healthCheck() 请求，得到true 则保持心跳（继续下一次循环），false 则失去心跳；
    2）如果失去心跳，则将客户端从健康状态标记为不健康状态；
    3）通过reconnect 方法尝试与nacos 服务端重新建立通信连接；

  • 客户端与服务端的断线重连：

    1. 通过 connectToServer 尝试与nacos 服务端重新建立通信连接；
      2）建立成功，则将原有的连接置为不可用，并关闭原有连接，释放资源；发布新的连接建立事件到 eventLinkedBlockingQueue 队列中；
      3）如果建立不成功则进行增大通nacos 服务端建立连接请求的时间间隔；
/**
 * Start this client.
 */
public final void start() throws NacosException {
    // cas 状态转换： 乐观锁实现
    boolean success = rpcClientStatus.compareAndSet(RpcClientStatus.INITIALIZED, RpcClientStatus.STARTING);
    if (!success) {
        return;
    }
    // 创建 clientEventExecutor  线程池，池子中设置了2个线程
    clientEventExecutor = new ScheduledThreadPoolExecutor(2, r -> {
        Thread t = new Thread(r);
        t.setName("com.alibaba.nacos.client.remote.worker");
        t.setDaemon(true);
        return t;
    });
    
    // connection event consumer.
    // 线程池提交任务： 客户端和服务端 连接重置；当nacos 服务端重启，客户端在心跳监测
    clientEventExecutor.submit(() -> {
        while (!clientEventExecutor.isTerminated() && !clientEventExecutor.isShutdown()) {
            ConnectionEvent take;
            try {
                take = eventLinkedBlockingQueue.take();
                if (take.isConnected()) {
                    notifyConnected();
                } else if (take.isDisConnected()) {
                    notifyDisConnected();
                }
            } catch (Throwable e) {
                // Do nothing
            }
        }
    });
    
    clientEventExecutor.submit(() -> {
        while (true) {
            try {
                if (isShutdown()) {
                    break;
                }
                // reconnectionSignal 重连接队列
                ReconnectContext reconnectContext = reconnectionSignal
                        .poll(rpcClientConfig.connectionKeepAlive(), TimeUnit.MILLISECONDS);
                if (reconnectContext == null) {
                	// 重连接队列是null 则表示 客户端与服务端没有发生断线重连的情况
                    // check alive time. 超过心跳的间隔时间，则重新发送healthCheck 监控检查请求
                    if (System.currentTimeMillis() - lastActiveTimeStamp >= rpcClientConfig.connectionKeepAlive()) {
                        boolean isHealthy = healthCheck();
                        if (!isHealthy) {
                        	// 如果 健康检测失败
                            if (currentConnection == null) {
                                continue;
                            }
                            LoggerUtils.printIfInfoEnabled(LOGGER,
                                    "[{}] Server healthy check fail, currentConnection = {}",
                                    rpcClientConfig.name(), currentConnection.getConnectionId());
                            
                            RpcClientStatus rpcClientStatus = RpcClient.this.rpcClientStatus.get();
                            if (RpcClientStatus.SHUTDOWN.equals(rpcClientStatus)) {
                                break;
                            }
                            // 标记客户端为 UNHEALTHY
                            boolean statusFLowSuccess = RpcClient.this.rpcClientStatus
                                    .compareAndSet(rpcClientStatus, RpcClientStatus.UNHEALTHY);
                            if (statusFLowSuccess) {
                            	// 服务端有可能发生了故障，则将服务端信息 ServerInfo 置为null 
                                reconnectContext = new ReconnectContext(null, false);
                            } else {
                                continue;
                            }
                            
                        } else {
                            lastActiveTimeStamp = System.currentTimeMillis();
                            continue;
                        }
                    } else {
                        continue;
                    }
                    
                }
                
                if (reconnectContext.serverInfo != null) {
                	// 发送连接重置时，检查 nacos 服务端的ip 和端口
                    // clear recommend server if server is not in server list.
                    boolean serverExist = false;
                    for (String server : getServerListFactory().getServerList()) {
                        ServerInfo serverInfo = resolveServerInfo(server);
                        if (serverInfo.getServerIp().equals(reconnectContext.serverInfo.getServerIp())) {
                            serverExist = true;
                            reconnectContext.serverInfo.serverPort = serverInfo.serverPort;
                            break;
                        }
                    }
                    if (!serverExist) {
                        LoggerUtils.printIfInfoEnabled(LOGGER,
                                "[{}] Recommend server is not in server list, ignore recommend server {}",
                                rpcClientConfig.name(), reconnectContext.serverInfo.getAddress());
                        
                        reconnectContext.serverInfo = null;
                        
                    }
                }
                // 发送重新连接服务端的请求
                reconnect(reconnectContext.serverInfo, reconnectContext.onRequestFail);
            } catch (Throwable throwable) {
                // Do nothing
            }
        }
    });
    
    // connect to server, try to connect to server sync retryTimes times, async starting if failed.
    // 客户端启动时 第一次进行同nacos 服务端的连接建立
    Connection connectToServer = null;
    rpcClientStatus.set(RpcClientStatus.STARTING);
    
    int startUpRetryTimes = rpcClientConfig.retryTimes();
    // 重试次数判断
    while (startUpRetryTimes > 0 && connectToServer == null) {
        try {
            startUpRetryTimes--;
            // 随机获取一个nacos 服务端的地址
            ServerInfo serverInfo = nextRpcServer();
            
            LoggerUtils.printIfInfoEnabled(LOGGER, "[{}] Try to connect to server on start up, server: {}",
                    rpcClientConfig.name(), serverInfo);
            // 服务端的连接
            connectToServer = connectToServer(serverInfo);
        } catch (Throwable e) {
            LoggerUtils.printIfWarnEnabled(LOGGER,
                    "[{}] Fail to connect to server on start up, error message = {}, start up retry times left: {}",
                    rpcClientConfig.name(), e.getMessage(), startUpRetryTimes, e);
        }
        
    }
    
    if (connectToServer != null) {
        LoggerUtils
                .printIfInfoEnabled(LOGGER, "[{}] Success to connect to server [{}] on start up, connectionId = {}",
                        rpcClientConfig.name(), connectToServer.serverInfo.getAddress(),
                        connectToServer.getConnectionId());
         // 连接建立成功，则将连接成功时间放入到 eventLinkedBlockingQueue 队列中进行消费
        this.currentConnection = connectToServer;
        rpcClientStatus.set(RpcClientStatus.RUNNING);
        eventLinkedBlockingQueue.offer(new ConnectionEvent(ConnectionEvent.CONNECTED));
    } else {
    	// 连接失败则 将失败时间放入到reconnectionSignal 队列中，消费改队列时 进入重连的逻辑
        switchServerAsync();
    }
    // 注册连接重置 处理器
    registerServerRequestHandler(new ConnectResetRequestHandler());
    
    // register client detection request.
    registerServerRequestHandler(request -> {
        if (request instanceof ClientDetectionRequest) {
            return new ClientDetectionResponse();
        }
        
        return null;
    });
    
}

三、客户端实例的注册：

在完成与服务端的通信channel 建立之后，就可以通过 namingService.registerInstance(serviceId, group, instance) 进行nacos 客户端实例的注册；

3.1 NamingGrpcClientProxy# registerService：

@Override
public void registerService(String serviceName, String groupName, Instance instance) throws NacosException {
    NAMING_LOGGER.info("[REGISTER-SERVICE] {} registering service {} with instance {}", namespaceId, serviceName,
            instance);
     //  ConcurrentMap<String, InstanceRedoData> registeredInstance map 中放入实例信息 key：分组名@@服务名
    redoService.cacheInstanceForRedo(serviceName, groupName, instance);
    // 向nacos 服务端发送注册请求，然后修改 InstanceRedoData 的实例信息为注册成功状态
    doRegisterService(serviceName, groupName, instance);
}
public void cacheInstanceForRedo(String serviceName, String groupName, Instance instance) {
//  key：分组名@@服务名
 String key = NamingUtils.getGroupedName(serviceName, groupName);
 	// 客户端服务对象创建，然后放入到  registeredInstance map 缓存（注册状态是未注册）
    InstanceRedoData redoData = InstanceRedoData.build(serviceName, groupName, instance);
    synchronized (registeredInstances) {
        registeredInstances.put(key, redoData);
    }
}

3.2 客户端发送注册请求：

public void doRegisterService(String serviceName, String groupName, Instance instance) throws NacosException {
    InstanceRequest request = new InstanceRequest(namespaceId, serviceName, groupName,
            NamingRemoteConstants.REGISTER_INSTANCE, instance);
     // 发送注册请求到服务端
    requestToServer(request, Response.class);
    // 请求发送成功 ，将当前服务实例的注册状态改为已注册
    redoService.instanceRegistered(serviceName, groupName);
}

requestToServer(request, Response.class);

private <T extends Response> T requestToServer(AbstractNamingRequest request, Class<T> responseClass)
            throws NacosException {
try {
       request.putAllHeader(
               getSecurityHeaders(request.getNamespace(), request.getGroupName(), request.getServiceName()));
       // 通过 rpcClient 获取通道 发送 InstanceRequest 类型的 request 请求
       Response response =
               requestTimeout < 0 ? rpcClient.request(request) : rpcClient.request(request, requestTimeout);
       if (ResponseCode.SUCCESS.getCode() != response.getResultCode()) {
           throw new NacosException(response.getErrorCode(), response.getMessage());
       }
       if (responseClass.isAssignableFrom(response.getClass())) {
           return (T) response;
       }
       NAMING_LOGGER.error("Server return unexpected response '{}', expected response should be '{}'",
               response.getClass().getName(), responseClass.getName());
   } catch (NacosException e) {
       throw e;
   } catch (Exception e) {
       throw new NacosException(NacosException.SERVER_ERROR, "Request nacos server failed: ", e);
   }
   throw new NacosException(NacosException.SERVER_ERROR, "Server return invalid response");
}

总结

客户端在启动成功之后发布 WebServiceInitializedEvent 事件，nacos 客户端同服务端创建通信通道，发送nacos 服务端的服务检查请求，正常返回后得到通道的id，创建双向流 grpc 的通信存根，发送连接确定建立的请求后；发起客户端实例的注册请求到nacos 服务端进行注册。

拽着尾巴的鱼儿
关注
专栏目录
Nacos（1.4.2）注册中心原理及源码系列（二）- Nacos Client 和 Spring Cloud 集成
louis_zzz的专栏
10-31 1266
1、客户端服务注册 Nacos在1.x版本的通信方式采用的HTTP协议，2.0版本以后会添加gRPC协议，本文写作采用的版本为1.4.2，所以本文还是基于HTTP协议来分析，服务注册的接口地址为：/nacos/v1/ns/instance，此接口的源码全路径为：com.alibaba.nacos.naming.controllers.InstanceController#register。 @CanDistro @PostMapping @Secured(parser = NamingReso...
gRPC结合nacos学习，实现远程调用grpc服务
erufhfhch的博客
05-23 1666
gRPC结合nacos学习，实现远程调用grpc服务
nacos-grpc-springcloud
02-20
SpringCloud + GRPC练习项目 SpringCloud@Hoxton.SR8 功能简介 使用gateway作为网关 内部服务之间调用使用Grpc调用 注册中心使用阿里巴巴的nacos
微服务中间件之Nacos
一个老Java开发的自白
09-14 1282
Nacos作为一个开源的分布式系统服务框架，提供了服务注册与发现、配置管理以及服务健康监测等核心功能，有助于构建稳健、高可用的分布式系统。通过其灵活的架构设计、丰富的技术栈支持和简单的安装部署方式，Nacos已成为微服务架构和云原生应用中的重要组件。
Nacos源码启动
技术百宝箱
02-23 2011
一步步启动Nacos源码项目，中间确实出现各种问题。
源码篇--Nacos服务--中章(1):Nacos服务端的启动
拽着尾巴的鱼儿的博客
04-19 1404
在源码篇–Nacos服务–前章我们对nacos 的架构及其概念进行了介绍，本文从源码层面对nacos 服务端资源的加载进行介绍；@Override// 自定义的环境变量 设置本文从源码层面对nacos 服务端资源的加载进行介绍。
2、Nacos通信gRPC
LiveOrange的博客
09-03 732
gRPC由 Google 开源的高性能 RPC 框架支持异构系统通讯，默认使用ProtoBuf () 协议，云原生体系下和其它组件广泛结合。主要利用gRPC高性能通信能力，结合云原生容器化、微服务架构和弹性伸缩等特性，实现高效、灵活和可扩展的云原生应用开发。nacos_grpc_service.proto 文件定义消息结构和服务的RPC方法，描述应用程序的通信方式。// 版本限定// 导入文件// 生成Java源文件个数// 生成Java类的路径// 定义消息请求头。
工具篇--Nacos 源码启动 & jmenv.tbsite.net 错误分析
拽着尾巴的鱼儿的博客
03-25 3975
本文对nacos 源码启动 报 Unable to start embedded Tomcat ，报错原因及解决办法进行介绍；如果想直接看结果可以直接到。本文环境 nacos ：2.4.0;Nacos 是一个开源的服务发现、配置管理和服务管理平台，旨在帮助开发人员构建和维护微服务架构的应用。Nacos 的功能包括：服务发现和注册、配置管理、动态 DNS 服务以及服务健康监测。服务发现与注册：Nacos 提供了服务发现和注册功能，使得微服务应用能够灵活地注册和发现其他服务实例。
Nacos-2.2.3-源码和执行环境
12-19
1. **服务发现和服务注册**：Nacos 作为服务注册中心，允许微服务实例在启动时向 Nacos 注册自身信息，同时其他服务可以通过 Nacos 查询到这些服务的地址和状态，实现服务间的相互发现。 2. **配置管理**：Nacos ...
nacos-server-2.2.0.1.zip
03-02
Nacos的主要目标是简化服务发现和服务管理，提供包括服务注册与发现、配置管理、健康检查、流量控制等核心功能，为微服务架构提供一站式解决方案。 在Nacos 2.2.0.1版本中，我们可以期待一系列增强特性和性能优化。...
Nacos 服务注册注销源码浅析
格物致知，知行合一。
09-11 1612
对 Nacos 注册中心的注册和注销做了简单的源码分析，欢迎阅读斧正。
微服务学习-SpringCloud -Nacos (服务注册源码学习)
m0_37688047的博客
04-08 906
ephemeral前面我们了解过，是否是临时实例，默认传true,所以一般返回 buildEphemeralInstanceListKey(namespaceId, serviceName)这个结果，所以这里主要是区分nacos是AP还是CP架构的地方。将service数据写入serviceMap后，创建临时实例的方法就结束了，现在我们代码回到创建临时实例createEmptyService处继续向下走，然后再判断一次注册表中是否有service,此次没有的话就会抛出异常。后面会重点讲一下AP和CP架构。
nacos源码启动
qq_19802871的博客
11-17 1104
1. git拉取nacos源码 报找不到对应的类 import com.alibaba.nacos.consistency.entity.ReadRequest; import com.alibaba.nacos.consistency.entity.Response; import com.alibaba.nacos.consistency.entity.WriteRequest; 官方回答： 解决方式： 2. 启动nacos的main函数在 console模块下，且本地启动时JV.
源码篇--Nacos服务--中章(6):Nacos客户端启动-grpc通道建立&客户端服务信息获取(故障转移)细节
拽着尾巴的鱼儿的博客
04-24 1234
在源码篇–Nacos服务–中章(5) 对nacos 客户端的创建及grpc 连接的建立，心跳检查，实例注册进行了介绍；本文对grpc通道建立&客户端服务信息获取(故障转移)细节进行介绍。本文对客户端服务信息获取的故障转移细节，及客户端同服务端的grpc 连接建立进行介绍。
nacos 源码方式启动
qq_41813060的博客
03-14 463
1.下载指定版本源码：git clone --branch 1.4.3 https://github.com/alibaba/nacos.git 2.打开IDEA，安装插件protobuf 3.打开源码编译：打开Idea/Terminal窗口执行 mvn clean package -Dmaven.test.skip=true -Dcheckstyle.skip=true 4.添加数据库，本地新建数据库nacos，执行nacos-mysql.sql脚本 5.修改配置文件 co.
Nacos源码启动运行
最新发布
hhyycc22_的博客
09-25 417
如果上述步骤正确不出错的情况下，在distribution/target这个目录下会有一个nacos-server-${vetsion}.zip的压缩包。nacos2.4.2，默认启动模式是集群，单机启动会报错，修改bin目录下startup.cmd启动模式cluster修改为standalone。打开目录，我的版本是2.4.2，双击nacos-server-2.4.2.zip压缩包，解压里面的内容。使用idea打包，也可以使用maven，两者没什么区别，idea也是使用maven。
nacos源码编译启动
123走的博客
04-16 1299
文章目录一、环境准备1.maven版本2.源码下载二、启动步骤1.在idea中打开下载的源码2.编译3. 启动 一、环境准备 1.maven版本 不能使用maven最新版，最初我使用maven3.8.x,在编译的时候报错，换成3.5.x编译就没问题。 2.源码下载 下载地址：https://gitee.com/mirrors/Nacos/tree/1.4.3/，本次使用1.4.3的tag版本来编译运行 二、启动步骤 1.在idea中打开下载的源码 2.编译 执行刷新，clean install命令 3
Nacos客户端
Leon_Jinhai_Sun的博客
11-27 105
NacosNamingService这个类实现了服务的注册，同时也实现了服务心跳： @Override public void registerInstance(String serviceName, String groupName, Instance instance) throws NacosException { NamingUtils.checkInstanceIsLegal(instance); String groupedServiceName = NamingUtils.
Nacos源码启动全过程
zjn640322的博客
06-11 2448
nacos源码启动全过程，报错解决，疑难杂症
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值