springboot客户端服务注册nacos原理_2

最新推荐文章于 2024-08-21 17:48:45 发布
最新推荐文章于 2024-08-21 17:48:45 发布
阅读量1k 收藏 1
点赞数
分类专栏： nacos spring cloud 文章标签： spring boot java 微服务
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/guntun8987/article/details/125273662
版权
本文详细剖析了Nacos服务注册过程，包括NamingService接口的行为，Instance结构，以及NacosNamingService.registerInstance方法的调用链。此外，还深入探讨了gRPC客户端的启动逻辑，涉及连接建立、心跳保鲜、重连策略以及处理Nacos服务器推送的事件。整个过程展示了Nacos服务发现和客户端管理的内部机制。
摘要由CSDN通过智能技术生成

上文中讲到了
NacosNamingService.registerInstance(serviceId, group, instance)：

NamingService结构：

public interface NamingService {
    
    //服务注册
    void registerInstance

    //服务注销
    void deregisterInstance

    //获取服务列表
    List<Instance> getAllInstances

    //查询健康服务
    List<Instance> selectInstances

    //查询集群中健康的服务
    List<Instance> selectInstances

    //负载均衡策略选择一个健康的服务
    Instance selectOneHealthyInstance

    //订阅服务事件
    void subscribe

    //取消订阅服务事件
    void unsubscribe

    //获取所有（或指定）服务名称
    ListView<String> getServicesOfServer

    //获取所有订阅的服务
    List<ServiceInfo> getSubscribeServices
     
    //获取Nacos服务的状态
    String getServerStatus
     
    //关闭服务
    void shutDown

}

可以看到NamingService是一个统一行为的接口，里面定义了很多重要的方法，如服务注册、服务注销、查询服务列表等。

Instance结构


可以看到Instance就是服务实例，包括了ip地址、port端口号、weight权重、healthy健康、ephemeral是否临时节点、clusterName集群名字等。

接着分析服务注册逻辑

NacosNamingService.registerInstance(String serviceName, String groupName, Instance instance)

public void registerInstance(String serviceName, String groupName, Instance instance) throws NacosException {
    //检查心跳
    NamingUtils.checkInstanceIsLegal(instance);
    //通过代理执行服务注册操作，这里的clientProxy实际为NamingClientProxyDelegate
    clientProxy.registerService(serviceName, groupName, instance);
}

NamingClientProxyDelegate.registerService(serviceName, groupName, instance)

public void registerService(String serviceName, String groupName, Instance instance) throws NacosException {
    getExecuteClientProxy(instance).registerService(serviceName, groupName, instance);
}

NamingClientProxyDelegate.getExecuteClientProxy(instance)

private NamingClientProxy getExecuteClientProxy(Instance instance) {
    return instance.isEphemeral() ? grpcClientProxy : httpClientProxy;
}

这里的路基是判断实例是临时还是持久，默认是临时，所以这里返回的是grpcClientProxy类型为NamingGrpcClientProxy采用grpc协议，nacos2.x版本中默认都是此协议进行通信。

NamingGrpcClientProxy.registerService(serviceName, groupName, instance)

public void registerService(String serviceName, String groupName, Instance instance) throws NacosException {
    NAMING_LOGGER.info("[REGISTER-SERVICE] {} registering service {} with instance {}", namespaceId, serviceName,
            instance);
    //缓存数据
    redoService.cacheInstanceForRedo(serviceName, groupName, instance);
    //进行服务注册
    doRegisterService(serviceName, groupName, instance);
}

public void cacheInstanceForRedo(String serviceName, String groupName, Instance instance) {
    String key = NamingUtils.getGroupedName(serviceName, groupName);
    InstanceRedoData redoData = InstanceRedoData.build(serviceName, groupName, instance);
    synchronized (registeredInstances) {
        registeredInstances.put(key, redoData);
    }
}

NamingGrpcClientProxy.doRegisterService(String serviceName, String groupName, Instance instance)

public void doRegisterService(String serviceName, String groupName, Instance instance) throws NacosException {
    //构建请求request
    InstanceRequest request = new InstanceRequest(namespaceId, serviceName, groupName,
            NamingRemoteConstants.REGISTER_INSTANCE, instance);
    //进行请求注册
    requestToServer(request, Response.class);
    //注册成功的话将缓存对应的信息改为已注册状态
    redoService.instanceRegistered(serviceName, groupName);
}

NamingGrpcClientProxy.requestToServer(request, Response.class)

private <T extends Response> T requestToServer(AbstractNamingRequest request, Class<T> responseClass)
        throws NacosException {
    try {
        request.putAllHeader(getSecurityHeaders());
        request.putAllHeader(getSpasHeaders(
                NamingUtils.getGroupedNameOptional(request.getServiceName(), request.getGroupName())));
        //grpc真正的请求数据，这里的rpcClient实际为GrpcSdkClient   
        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 (Exception e) {
        throw new NacosException(NacosException.SERVER_ERROR, "Request nacos server failed: ", e);
    }
    throw new NacosException(NacosException.SERVER_ERROR, "Server return invalid response");
}

NamingGrpcRedoService.instanceRegistered(serviceName, groupName)

public void instanceRegistered(String serviceName, String groupName) {
    String key = NamingUtils.getGroupedName(serviceName, groupName);
    synchronized (registeredInstances) {
        InstanceRedoData redoData = registeredInstances.get(key);
        if (null != redoData) {
            redoData.setRegistered(true);
        }
    }
}

分析GrpcClient启动的逻辑

初始化

public NamingGrpcClientProxy(String namespaceId, SecurityProxy securityProxy, ServerListFactory serverListFactory,
        Properties properties, ServiceInfoHolder serviceInfoHolder) throws NacosException {
    super(securityProxy, properties);
    this.namespaceId = namespaceId;
    this.uuid = UUID.randomUUID().toString();
    //请求的超时时间，默认3s
    this.requestTimeout = Long.parseLong(properties.getProperty(CommonParams.NAMING_REQUEST_TIMEOUT, "-1"));
    Map<String, String> labels = new HashMap<String, String>();
    labels.put(RemoteConstants.LABEL_SOURCE, RemoteConstants.LABEL_SOURCE_SDK);
    labels.put(RemoteConstants.LABEL_MODULE, RemoteConstants.LABEL_MODULE_NAMING);
    //创建grpc
    this.rpcClient = RpcClientFactory.createClient(uuid, ConnectionType.GRPC, labels);
    
    this.redoService = new NamingGrpcRedoService(this);
    //将grpc客户端启动
    start(serverListFactory, serviceInfoHolder);
}

private void start(ServerListFactory serverListFactory, ServiceInfoHolder serviceInfoHolder) throws NacosException {
    rpcClient.serverListFactory(serverListFactory);
    //注册连接事件当连接建立和断开时处理事件
    rpcClient.registerConnectionListener(redoService);
    //注册registerServerRequestHandler用于处理从Nacos Push到Client的请求
    rpcClient.registerServerRequestHandler(new NamingPushRequestHandler(serviceInfoHolder));
    //grpc客户端启动
    rpcClient.start();
    NotifyCenter.registerSubscriber(this);
}

到这里可以知道:

  • gRPC 客户端代理的初始化主要逻辑为创建gRPC 客户端并启动。
  • 并注册ServerRequestHandler用于处理Nacos 服务端推送的NotifySubscriberRequest请求。
  • 注册ConnectionListener用于处理gRPC建立和断开连接事件。
  • 请求超时时间可以通过namingRequestTimeout设置，默认3秒。

grpc客户端启动

rpcClient.start()

public final void start() throws NacosException {
    //将Client状态由INITIALIZED变更为STARTING
    boolean success = rpcClientStatus.compareAndSet(RpcClientStatus.INITIALIZED, RpcClientStatus.STARTING);
    if (!success) {
        return;
    }



    /**
     * 守护线程不断从阻塞队列eventLinkedBlockingQueue获取grpc连接/断开事件，
     * 并调用上文中注册的namingGrpcConnectionEventListener回调其onConnected/onDisConnect方法。其中事件添加时机为：
     * 
     * grpc连接建立时，添加连接事件：
     * // 连接成功添加ConnectionEvent
     * eventLinkedBlockingQueue.offer(new ConnectionEvent(ConnectionEvent.CONNECTED));
     * 
     * grpc连接关闭时，添加关闭事件：
     * private void closeConnection(Connection connection) {
     *      if (connection != null) {
     *          connection.close();
     *          // 断开连接添加DISCONNECTED事件
     *          eventLinkedBlockingQueue.add(new ConnectionEvent(ConnectionEvent.DISCONNECTED));
     *      }
     * }
     *
     *  
     * */

    //守护线程的线程池
    clientEventExecutor = new ScheduledThreadPoolExecutor(2, new ThreadFactory() {
        @Override
        public Thread newThread(Runnable r) {
            Thread t = new Thread(r);
            t.setName("com.alibaba.nacos.client.remote.worker");
            t.setDaemon(true);
            return t;
        }
    });
    
    //不断的从eventLinkedBlockingQueue获取连接时间，根据事件的类型回调notifyConnected/notifyDisConnected事件
    clientEventExecutor.submit(new Runnable() {
        @Override
        public void run() {
            while (!clientEventExecutor.isTerminated() && !clientEventExecutor.isShutdown()) {
                ConnectionEvent take = null;
                try {
                    take = eventLinkedBlockingQueue.take();
                    if (take.isConnected()) {
                        notifyConnected();
                    } else if (take.isDisConnected()) {
                        notifyDisConnected();
                    }
                } catch (Throwable e) {
                    //Do nothing
                }
            }
        }
    });




    /**
     * 
     * 守护线程不断从阻塞队列reconnectionSignal获取重新连接事件（ReconnectContext）也就是更换nacos server的连接grpc通道：
     *
     * 阻塞队列没有重新连接事件：则做心跳保鲜检测，心跳频率为5秒。当超过5秒时会向Nacos Server发起健康检查，当返回不健康时，
     * 将grpc client标记为unhealthy；返回健康则刷新心跳时间lastActiveTimeStamp。
     *
     * 阻塞队列有重新连接事件：重连事件上下文reconnectContext的的server ip在我们设置的nacos server 列表则使用，
     * 否则改为随机选择nacos server ip地址，并与新server建立连接。
     * 
     * */
    clientEventExecutor.submit(new Runnable() {
        @Override
        public void run() {
            while (true) {
                try {
                    if (isShutdown()) {
                        break;
                    }
                    //获取重定向连接上下文，指重新连接到其他server节点
                    ReconnectContext reconnectContext = reconnectionSignal
                            .poll(keepAliveTime, TimeUnit.MILLISECONDS);
                    if (reconnectContext == null) {
                        //check alive time.
                        //client活动时间超过5秒，向Nacos Server发起健康检测
                        if (System.currentTimeMillis() - lastActiveTimeStamp >= keepAliveTime) {
                            //进行健康检查
                            boolean isHealthy = healthCheck();
                            //如果为非健康节点的话
                            if (!isHealthy) {
                                if (currentConnection == null) {
                                    continue;
                                }
                                LoggerUtils.printIfInfoEnabled(LOGGER,
                                        "[{}]Server healthy check fail,currentConnection={}", name,
                                        currentConnection.getConnectionId());
                                
                                RpcClientStatus rpcClientStatus = RpcClient.this.rpcClientStatus.get();
                                if (RpcClientStatus.SHUTDOWN.equals(rpcClientStatus)) {
                                    break;
                                }
                                //将客户端为unhealthy状态
                                boolean success = RpcClient.this.rpcClientStatus
                                        .compareAndSet(rpcClientStatus, RpcClientStatus.UNHEALTHY);
                                if (success) {
                                    //重置ReconnectContext移除serverInfo
                                    reconnectContext = new ReconnectContext(null, false);
                                } else {
                                    continue;
                                }
                                
                            } else {
                                //健康连接更新时间戳
                                lastActiveTimeStamp = System.currentTimeMillis();
                                continue;
                            }
                        } else {
                            //心跳保鲜未过期，跳过本次检测
                            continue;
                        }
                        
                    }
                    
                    if (reconnectContext.serverInfo != null) {
                        //clear recommend server if server is not in server list.
                        boolean serverExist = false;
                        //判断连接上下文的reconnectContext.serverInfo是否在我们推荐设置的列表中
                        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 {}", 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 once, async starting if fail.
    //异步连接失败的话尝试为同步连接
    Connection connectToServer = null;
    rpcClientStatus.set(RpcClientStatus.STARTING);
    
    int startUpRetryTimes = RETRY_TIMES;
    while (startUpRetryTimes > 0 && connectToServer == null) {
        try {
            startUpRetryTimes--;
            ServerInfo serverInfo = nextRpcServer();
            
            LoggerUtils.printIfInfoEnabled(LOGGER, "[{}] Try to connect to server on start up, server: {}", 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: {}",
                    name, e.getMessage(), startUpRetryTimes);
        }
        
    }
    

    /**
     * 
     * 如果连接建立成功添加连接事件到阻塞队列；连接建立失败发起异步建立连接请求。
     * 注册ConnectResetRequestHandler用于处理nacos server推送的重置连接请求。
     * jvm退出时通过hook关闭grpc client。
     * */

    if (connectToServer != null) {
        LoggerUtils.printIfInfoEnabled(LOGGER, "[{}] Success to connect to server [{}] on start up,connectionId={}",
                name, connectToServer.serverInfo.getAddress(), connectToServer.getConnectionId());
        this.currentConnection = connectToServer;
        rpcClientStatus.set(RpcClientStatus.RUNNING);
        //连接成功的话构建ConnectionEvent添加到eventLinkedBlockingQueue中
        eventLinkedBlockingQueue.offer(new ConnectionEvent(ConnectionEvent.CONNECTED));
    } else {
        //没有建立连接成功的话重新发起异步建立连接
        switchServerAsync();
    }
    //注册ConnectResetRequestHandler用于处理nacos服务端推送的重置连接请求
    registerServerRequestHandler(new ConnectResetRequestHandler());
    
    //register client detection request.
    registerServerRequestHandler(new ServerRequestHandler() {
        @Override
        public Response requestReply(Request request) {
            if (request instanceof ClientDetectionRequest) {
                return new ClientDetectionResponse();
            }
            
            return null;
        }
    });
    
}

protected void reconnect(final ServerInfo recommendServerInfo, boolean onRequestFail) {
    
    try {
        
        AtomicReference<ServerInfo> recommendServer = new AtomicReference<ServerInfo>(recommendServerInfo);
        // nRequestFail=true表示当健康检查失败grpcClient被设置为unhealthy，
        //重连时重新发起健康检查，如果检查通过则不再执行重连
        if (onRequestFail && healthCheck()) {
            LoggerUtils.printIfInfoEnabled(LOGGER, "[{}] Server check success,currentServer is{} ", name,
                    currentConnection.serverInfo.getAddress());
            rpcClientStatus.set(RpcClientStatus.RUNNING);
            return;
        }
        
        LoggerUtils.printIfInfoEnabled(LOGGER, "[{}] try to re connect to a new server ,server is {}", name,
                recommendServerInfo == null ? " not appointed,will choose a random server."
                        : (recommendServerInfo.getAddress() + ", will try it once."));
        
        // loop until start client success.
        boolean switchSuccess = false;
        
        int reConnectTimes = 0;
        int retryTurns = 0;
        Exception lastException = null;
        //切换nacos server没有成功则会一直重试
        while (!switchSuccess && !isShutdown()) {
            
            //1.get a new server
            ServerInfo serverInfo = null;
            try {
                //获取需要重新连接的server地址
                serverInfo = recommendServer.get() == null ? nextRpcServer() : recommendServer.get();
                //2.create a new channel to new server
                //与新的server建立grpc连接，如果连接失败返回null
                Connection connectionNew = connectToServer(serverInfo);
                //关闭缓存的当前连接并重定向到新的连接
                if (connectionNew != null) {
                    LoggerUtils.printIfInfoEnabled(LOGGER, "[{}] success to connect a server  [{}],connectionId={}",
                            name, serverInfo.getAddress(), connectionNew.getConnectionId());
                    //successfully create a new connect.
                    if (currentConnection != null) {
                        LoggerUtils.printIfInfoEnabled(LOGGER,
                                "[{}] Abandon prev connection ,server is  {}, connectionId is {}", name,
                                currentConnection.serverInfo.getAddress(), currentConnection.getConnectionId());
                        //set current connection to enable connection event.
                        currentConnection.setAbandon(true);
                        closeConnection(currentConnection);
                    }
                    currentConnection = connectionNew;
                    rpcClientStatus.set(RpcClientStatus.RUNNING);
                    switchSuccess = true;
                    //添加连接成功时间到阻塞队列
                    boolean s = eventLinkedBlockingQueue.add(new ConnectionEvent(ConnectionEvent.CONNECTED));
                    return;
                }
                
                //close connection if client is already shutdown.
                if (isShutdown()) {
                    closeConnection(currentConnection);
                }
                
                lastException = null;
                
            } catch (Exception e) {
                lastException = e;
            } finally {
                //清理本次重连请求
                recommendServer.set(null);
            }
            //执行到这里表示上面没有成功建立连接，打印重试次数日志
            if (reConnectTimes > 0
                    && reConnectTimes % RpcClient.this.serverListFactory.getServerList().size() == 0) {
                LoggerUtils.printIfInfoEnabled(LOGGER,
                        "[{}] fail to connect server,after trying {} times, last try server is {},error={}", name,
                        reConnectTimes, serverInfo, lastException == null ? "unknown" : lastException);
                if (Integer.MAX_VALUE == retryTurns) {
                    retryTurns = 50;
                } else {
                    retryTurns++;
                }
            }
            
            reConnectTimes++;
            //重试时等待特定的时间
            try {
                //sleep x milliseconds to switch next server.
                if (!isRunning()) {
                    // first round ,try servers at a delay 100ms;second round ,200ms; max delays 5s. to be reconsidered.
                    Thread.sleep(Math.min(retryTurns + 1, 50) * 100L);
                }
            } catch (InterruptedException e) {
                // Do  nothing.
            }
        }
        
        if (isShutdown()) {
            LoggerUtils.printIfInfoEnabled(LOGGER, "[{}] Client is shutdown ,stop reconnect to server", name);
        }
        
    } catch (Exception e) {
        LoggerUtils.printIfWarnEnabled(LOGGER, "[{}] Fail to  re connect to server ,error is {}", name, e);
    }
}

重新切换连接server逻辑：

  • 当检查失败grpc client会被标记为unhealthy这类型onRequestFail为true，重连时重新发起健康检查，如果检查成功，则退出本次重连。
  • 获取重连的server地址和端口，并建立grpc连接，关闭当前缓存的旧连接并重定向到新连接，同时添加连接成功时间到阻塞队列。
  • 一直重试直到连接建立成功，每次重试等待一些时间（100ms,200ms…最大为5秒）。

到这里可以知道：

  • gRPC Client启动逻辑主要在于建立与nacos server的grpc连接，其中两个守护线程一直在运行。
  • 守护线程1用于处理grpc连接的建立和关闭事件。
  • 守护线程2用于与nacos server的心跳保鲜，并负责异步建立grpc连接。
  • 守护线程2同时负责当nacos server的地址信息发生变更时重新与新server建立连接。
  • nacos server的地址变更通过grpc通道由server推送ConnectResetRequest到client。
  • grpc client只与nacos server集群中一台建立grpc连接。

GrpcClient.connectToServer(serverInfo)

此方法的作用是客户端与服务端建立连接，GrpcClient负责与远程服务器建立连接，并初始化Grpc一元请求远程调用的Stub以及双向流的StreamObserver，创建一个GrpcConnection的对象，并将初始化的Channel注入到GrpcConnection中。随后发起一个连接建立的请求，在服务端侧注册自己的连接。值得一提的是，双向流的BiRequestStreamStub是建立在RequestFutureStub的Channel之上的，利用了HTTP2多路复用的特性，所以Client与Server之间只会有一个连接建立。

public Connection connectToServer(ServerInfo serverInfo) {
    try {
        if (grpcExecutor == null) {
            int threadNumber = ThreadUtils.getSuitableThreadCount(8);
            grpcExecutor = new ThreadPoolExecutor(threadNumber, threadNumber, 10L, TimeUnit.SECONDS,
                    new LinkedBlockingQueue<>(10000),
                    new ThreadFactoryBuilder().setDaemon(true).setNameFormat("nacos-grpc-client-executor-%d")
                            .build());
            grpcExecutor.allowCoreThreadTimeOut(true);
            
        }
        int port = serverInfo.getServerPort() + rpcPortOffset();
        RequestGrpc.RequestFutureStub newChannelStubTemp = createNewChannelStub(serverInfo.getServerIp(), port);
        if (newChannelStubTemp != null) {
            
            Response response = serverCheck(serverInfo.getServerIp(), port, newChannelStubTemp);
            if (response == null || !(response instanceof ServerCheckResponse)) {
                shuntDownChannel((ManagedChannel) newChannelStubTemp.getChannel());
                return null;
            }
            
            BiRequestStreamGrpc.BiRequestStreamStub biRequestStreamStub = BiRequestStreamGrpc
                    .newStub(newChannelStubTemp.getChannel());
            GrpcConnection grpcConn = new GrpcConnection(serverInfo, grpcExecutor);
            grpcConn.setConnectionId(((ServerCheckResponse) response).getConnectionId());
            
            //create stream request and bind connection event to this connection.
            StreamObserver<Payload> payloadStreamObserver = bindRequestStream(biRequestStreamStub, grpcConn);
            
            // stream observer to send response to server
            grpcConn.setPayloadStreamObserver(payloadStreamObserver);
            grpcConn.setGrpcFutureServiceStub(newChannelStubTemp);
            grpcConn.setChannel((ManagedChannel) newChannelStubTemp.getChannel());
            //send a  setup request.
            ConnectionSetupRequest conSetupRequest = new ConnectionSetupRequest();
            conSetupRequest.setClientVersion(VersionUtils.getFullClientVersion());
            conSetupRequest.setLabels(super.getLabels());
            conSetupRequest.setAbilities(super.clientAbilities);
            conSetupRequest.setTenant(super.getTenant());
            grpcConn.sendRequest(conSetupRequest);
            //wait to register connection setup
            Thread.sleep(100L);
            return grpcConn;
        }
        return null;
    } catch (Exception e) {
        LOGGER.error("[{}]Fail to connect to server!,error={}", GrpcClient.this.getName(), e);
    }
    return null;
}
阿星不是程序员
关注
专栏目录
springboot集成nacos
追梦赤子的博客
07-16 4845
nacos主要就是配置管理与服务发现，如果你不是很明白这两个概念的情况下建议你可以先去了解一下配置管理与服务发现的基本原理。本文基于理解这些概念的情况下来书写的 在nacos官网下载nacos下载 nacos-server-$version.zip 包（当启动nacos的时候账户名和密码都是nacos） 启动服务器 Linux/Unix/Mac 启动命令(standalone代表着单机模式运行，非...
SpringBoot使用Nacos进行服务注册
mengmeng2222222的博客
05-07 3483
SpringBoot使用Nacos进行服务注册，步骤如下 1、Nacos下载安装启动步骤自行省略，启动成功后，如果是本地启动的访问http://127.0.0.1:8848/nacos，初始登录的账号密码都是nacos，如下图 2、SpringBoot应用使用Nacos作为注册中心需要引入依赖nacos-discovery-spring-boot-starter，笔者编写本文的时候（2020-01-01），该依赖的版本为0.2.4，引入如下依赖： <!-- 1. nacos-配置管理功能依赖 --&
Springboot整合nacos实现配置中心及服务发现
qq_42077317的博客
04-15 829
首先，nacos是一个更易于构建云原生应用的动态服务发现、配置管理和服务管理平台。而springboot能够创建一个独立运行spring应用框架，因此，springboot整合nacos，可以更方便实现服务的发现、配置管理等相关功能。}来引用nacos中的配置。在bootstrap.properties或bootstrap.yml文件中配置nacos的相关信息。接着启动应用后，就可以在nacos的服务列表中看到我们已经注册到nacos的服务。1.在pom文件中添加nacos依赖。2.配置nacos。
Springboot项目注册到nacos
最新发布
yyb1369584682的博客
08-21 388
Springboot项目注册到nacos
springboot客户端服务注册nacos原理_1
guntun8987的博客
06-14 385
springboot客户端服务注册nacos原理
SpringBoot 集成 Nacos
weixin_43796132的博客
11-16 114
注意: Nacos部署在服务器中时spring.clound.nacos.discovery.server-addr的地址只能填本地地址（localhost、127.0.0.1）
spring boot接入nacos 配置中心
htydowd的博客
06-17 1809
注意， nacos-config-spring-boot-starter 的版本内 引入了 nacos-client，需要注意引入的版本 是否与nacos服务端匹配。这里使用的 nacos 服务端 是 1.x版本，所有引入的包也是1.x的才可以。1. spring boot 版本 (spring boot 2.x )这种方式 只是简单的拉去配置中心的内容，需要自己解析 配置内容和监听更新。2. nacos 配置中心 服务端 版本 (1.1.4)1. 启动 nacos 服务端，这里不做解释。
使用Spring Boot集成Nacos
技术研究中心
07-14 1082
Nacos作为阿里巴巴开源的一个动态服务发现、配置管理和服务管理平台，非常适合用来管理Spring Boot微服务应用。本文将详细介绍如何在Spring Boot项目中集成Nacos，实现服务发现和配置管理功能。通过上述步骤，我们成功地在Spring Boot项目中集成了Nacos，实现了服务发现和配置管理功能。Nacos强大的功能和简单的配置，使得它成为管理微服务应用的理想选择。大家好，我是微赚淘客系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！注解，确保在配置发生变化时，能够动态刷新配置。
springboot整合nacos(配置中心与服务注册，微服务整合之间的版本关系)
qq_19891197的博客
03-28 1601
springboot整合nacos(配置中心与服务注册，微服务整合之间的版本关系)
Alibaba：Nacos服务心跳和健康检查源码介绍，springboot自定义注解原理详解
m0_63174529的博客
12-18 1161
//注册实例 serviceManager.registerInstance(namespaceId, serviceName, instance); } //获取服务的信息 Service service = serviceManager.getService(namespaceId, serviceName); if (service == null) { throw new NacosException(NacosException.SERVER_ERROR, "service not found:
02. Nacos客户端-服务发现原理
u010369122的博客
12-03 465
2、判断是否有新增实例、修改实例、删除实例，如果有就发布实例变更事件（该事件会触发 InstancesChangeNotifier 的 onEvent 方法，然后再将事件，转为NamingEvent事件，最终调用到 NacosWatch类 start 方法里的 EventListener 监听器的onEvent方法，判断如果本实例的Meta信息和server端的不一样，更新本地的meta信息）3、如果有修改实例，更新本地的心跳信息（本地会定时发送心跳请求给nacos-server）接口，获取一次服务列表。
SpringBoot+Dubbo+Nacos微服务实践教程
4. 熟悉Nacos：掌握Nacos的基本操作，包括服务注册、服务发现、配置管理等。 5. 应用Ribbon：学会如何在消费端应用Ribbon来实现负载均衡，并了解其背后的算法和机制。 6. 实践操作：通过实际搭建和运行本示例项目，...
Nacos服务注册中心底层实现原理
Elvis Hu的博客
01-03 1038
1.x版本是通过Http协议来进行服务注册的2.x由于客户端与服务端的通信改成了gRPC长连接，所以改成通过gRPC长连接来注册2.x比1.x多个Redo操作，当注册的服务实例是临时实例是，出现网络异常，连接重新建立之后，客户端需要将服务注册、服务订阅之类的操作进行重做这里你可能会有个疑问既然2.x有Redo机制保证客户端与服务端通信正常之后重新注册，那么1.x有类似的这种Redo机制么？当然也会有，接下往下看。心跳机制仅仅针对临时实例而言。
springboot整合nacos-config-源码分析1（基础使用）
weixin_41150739的博客
11-09 369
1：springboot的整合： pom文件配置：父模块配置 <properties> <java.version>1.8</java.version> <spring-boot.version>2.2.6.RELEASE</spring-boot.version> <spring-cloud.version>Hoxton.SR9</spring-cloud.version>
SpringBoot的自动配置原理过程解析
weixin_30858241的博客
10-09 156
SpringBoot的最大好处就是实现了大部分的自动配置，使得开发者可以更多的关注于业务开发，避免繁琐的业务开发，但是SpringBoot如此好用的 自动注解过程着实让人忍不住的去了解一番，因为本文的注解解析过程会持续更新本部分，所以首先从简单的自动配置原理过程进行描述，后边在 学习完注解驱动开发后，进行更深入的记录； 自动配置原理过程解析： 万事都从SpringBoot的入口出发，...
Nacos——整合springboot详解
零栀
10-15 532
官方文档：https://nacos.io/zh-cn/docs/what-is-nacos.html 源码地址：https://github.com/ZeroClian/z-blog/tree/master/nacos 安装 步骤：https://nacos.io/zh-cn/docs/quick-start.html 启动： 启动：sh startup.sh -m standalone standalone代表着单机模式运行，非集群模式 关闭：sh shutdown.sh ❗️其他.
九、Nacos源码系列：Nacos配置中心原理（一）- SpringCloud应用启动时拉取配置
weixiaohuai的博客
02-19 1574
至此，在项目启动的时候（上下文准备阶段）通过NacosPropertySourceLocator就拉取到了远程 Nacos 中的配置信息，并且封装成 NacosPropertySource对象，然后PropertySourceBootstrapConfiguration依靠ApplicationContextInitializer机制（容器刷新之前支持一些自定义初始化工作），将前面封装好的NacosPropertySource对象放到了 Spring 的环境变量Environment 中。
springcloud/springboot集成NACOS 做注册和配置中心以及nacos源码分析
cnzzs的博客
08-02 1205
一、SpringCloud 简介Spring Cloud 是一系列框架的有序集合如服务发现注册、配置中心、消息总线、负载均衡、熔断器、数据监控等。SpringCloud 将多个服务框架组合起来，通过Spring Boot进行再封装，屏蔽掉了复杂的配置和实现原理，最终给开发者提供了一套简单易懂、易部署和易维护的分布式系统开发...
Day1——Nacos自动服务注册原理（一）
Android_la的博客
12-20 1124
文章目录一. 问题背景二. 前言三. 资源准备四. 原理4.1 快速开始构建spring应用的nacos步骤4.2 问题分析4.3 Spring Cloud Alibaba Nacos的自动服务注册大概原理4.4 源码分析Spring Cloud Commons模块的服务注册原理4.4.1 引入依赖4.4.2 服务注册的核心方法4.4.3 服务注册的调用关系4.4.4 更底层的原理4.5 利用事件监听机制完成自动服务注册的原理（重要）五. 课外知识5.1 Spring应用重构成微服务的方案5.2 WebSe
springboot + tomcat + nacos 实现服务注册
05-11
要实现服务注册，你需要在 Spring Boot 项目中引入 Nacos 客户端依赖，然后在 application.properties 或 application.yml 中配置 Nacos 服务的地址和端口以及服务名等信息。 下面是一个示例的 application.yml 文件： ```yaml server: port: 8080 spring: application: name: demo-service cloud: nacos: discovery: server-addr: localhost:8848 ``` 这里我们使用了 Spring Cloud Alibaba Nacos 的客户端依赖 spring-cloud-starter-alibaba-nacos-discovery，并在配置文件中指定了 Nacos 服务的地址和端口，以及当前服务的名字为 demo-service。 接着，在启动类中加上 @EnableDiscoveryClient 注解，启用服务注册和发现功能。示例代码如下： ```java @SpringBootApplication @EnableDiscoveryClient public class DemoServiceApplication { public static void main(String[] args) { SpringApplication.run(DemoServiceApplication.class, args); } } ``` 最后，可以在控制台或者 Nacos 管理界面中查看服务是否注册成功。 以上就是基于 Spring Boot、Tomcat 和 Nacos 实现服务注册的简单流程。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值