nacos服务端服务注册原理_4(订阅者客户端接收服务端推送的serviceInfo请求)

已于 2022-08-09 17:48:00 修改
阅读量4.7k 收藏 6
点赞数
分类专栏： nacos spring cloud 文章标签： java spring cloud
于 2022-07-02 12:23:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/guntun8987/article/details/125570748
版权

在nacos服务端服务注册原理_3文章分析到了当服务端接收到服务注册和注销后，通过一系列的事件发布后和处理后，最后会通过grpc再通知给对应的订阅服务的客户端，这篇文章就来分析客户端接收服务端相应的过程

客户端的监听

NacosWatch

public class NacosWatch
		implements ApplicationEventPublisherAware, SmartLifecycle, DisposableBean {...}

NacosWatch实现了SmartLifecycle接口，所以当容器启动后会执行start方法。下面来分析此方法

NacosWatch.start()

public void start() {
	//判断服务端通知的监听是否开启，没有的话设置为true然后开启监听
	if (this.running.compareAndSet(false, true)) {
		EventListener eventListener = listenerMap.computeIfAbsent(buildKey(),
				event -> new EventListener() {
					@Override
					//当接口服务端通知后处理even事件
					public void onEvent(Event event) {
						if (event instanceof NamingEvent) {
							List<Instance> instances = ((NamingEvent) event)
									.getInstances();
							Optional<Instance> instanceOptional = selectCurrentInstance(
									instances);
							instanceOptional.ifPresent(currentInstance -> {
								resetIfNeeded(currentInstance);
							});
						}
					}
				});
		//获得namingService ，此方法内会创建接收服务端的grpc连接
		NamingService namingService = nacosServiceManager
				.getNamingService(properties.getNacosProperties());
		try {
			namingService.subscribe(properties.getService(), properties.getGroup(),
					Arrays.asList(properties.getClusterName()), eventListener);
		}
		catch (Exception e) {
			log.error("namingService subscribe failed, properties:{}", properties, e);
		}

		this.watchFuture = this.taskScheduler.scheduleWithFixedDelay(
				this::nacosServicesWatch, this.properties.getWatchDelay());
	}
}
nacosServiceManager.getNamingService(properties.getNacosProperties())

此方法会创建接收服务端的grpc连接，链路较长为
NacosServiceManager.getNamingService
—>
NacosServiceManager.buildNamingService(properties)
—>
NacosServiceManager.createNewNamingService(properties)
—>
NacosServiceManager.createNamingService(properties)
—>
NamingFactory.createNamingService(properties)

Class<?> driverImplClass = Class.forName("com.alibaba.nacos.client.naming.NacosNamingService");
Constructor constructor = driverImplClass.getConstructor(Properties.class);
return (NamingService) constructor.newInstance(properties);

—>
(NamingService) constructor.newInstance(properties)
—>
public NacosNamingService(Properties properties)
—>
NacosNamingService.init(properties)
—>
new NamingClientProxyDelegate(...)
—>
new NamingGrpcClientProxy(...)
—>
NamingGrpcClientProxy.start(serverListFactory, serviceInfoHolder)

NamingGrpcClientProxy.start(serverListFactory, serviceInfoHolder)

此方法开始真正的建立接收服务端的grpc连接

private void start(ServerListFactory serverListFactory, ServiceInfoHolder serviceInfoHolder) throws NacosException {
    rpcClient.serverListFactory(serverListFactory);
    // 注册连接事件Listener，当连接建立和断开时处理事件
    rpcClient.registerConnectionListener(redoService);
    //在客户端建立gRPC时，注册registerServerRequestHandler
    //用于处理从服务端推送到客户端的请求，添加到了serverRequestHandlers集合
    rpcClient.registerServerRequestHandler(new NamingPushRequestHandler(serviceInfoHolder));
    //grpc客户端启动
    rpcClient.start();
    NotifyCenter.registerSubscriber(this);
}

RpcClient.start()

public final void start() throws NacosException {
    
    boolean success = rpcClientStatus.compareAndSet(RpcClientStatus.INITIALIZED, RpcClientStatus.STARTING);
    if (!success) {
        return;
    
    /**
     * 省略
     */
    //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);
        }
        
    }
    
    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);
        eventLinkedBlockingQueue.offer(new ConnectionEvent(ConnectionEvent.CONNECTED));
    } else {
        switchServerAsync();
    }
    
    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;
        }
    });
    
}
RpcClient.connectToServer(serverInfo)
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());
            
            //在连接server时绑定相关事件
            StreamObserver<Payload> payloadStreamObserver = bindRequestStream(biRequestStreamStub, grpcConn);
            
            
            grpcConn.setPayloadStreamObserver(payloadStreamObserver);
            grpcConn.setGrpcFutureServiceStub(newChannelStubTemp);
            grpcConn.setChannel((ManagedChannel) newChannelStubTemp.getChannel());
            
            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;
}
RpcClient.bindRequestStream
private StreamObserver<Payload> bindRequestStream(final BiRequestStreamGrpc.BiRequestStreamStub streamStub,
        final GrpcConnection grpcConn) {
    
    return streamStub.requestBiStream(new StreamObserver<Payload>() {
        
        @Override
        public void onNext(Payload payload) {
            
            LoggerUtils.printIfDebugEnabled(LOGGER, "[{}]Stream server request receive, original info: {}",
                    grpcConn.getConnectionId(), payload.toString());
            try {
                Object parseBody = GrpcUtils.parse(payload);
                final Request request = (Request) parseBody;
                if (request != null) {
                    
                    try {
                        //接受server push处理
                        Response response = handleServerRequest(request);
                        if (response != null) {
                            response.setRequestId(request.getRequestId());
                            sendResponse(response);
                        } else {
                            LOGGER.warn("[{}]Fail to process server request, ackId->{}", grpcConn.getConnectionId(),
                                    request.getRequestId());
                        }
                        
                    } catch (Exception e) {
                        LoggerUtils.printIfErrorEnabled(LOGGER, "[{}]Handle server request exception: {}",
                                grpcConn.getConnectionId(), payload.toString(), e.getMessage());
                        sendResponse(request.getRequestId(), false);
                    }
                    
                }
                
            } catch (Exception e) {
                LoggerUtils.printIfErrorEnabled(LOGGER, "[{}]Error to process server push response: {}",
                        grpcConn.getConnectionId(), payload.getBody().getValue().toStringUtf8());
            }
        }
        
       
    });
}
RpcClient.handleServerRequest
protected Response handleServerRequest(final Request request) {
    
    LoggerUtils.printIfInfoEnabled(LOGGER, "[{}]receive server push request,request={},requestId={}", name,
            request.getClass().getSimpleName(), request.getRequestId());
    lastActiveTimeStamp = System.currentTimeMillis();
    //此循环中有个元素是NamingPushRequestHandler
    for (ServerRequestHandler serverRequestHandler : serverRequestHandlers) {
        try {
            Response response = serverRequestHandler.requestReply(request);
            
            if (response != null) {
                LoggerUtils.printIfInfoEnabled(LOGGER, "[{}]ack server push request,request={},requestId={}", name,
                        request.getClass().getSimpleName(), request.getRequestId());
                return response;
            }
        } catch (Exception e) {
            LoggerUtils.printIfInfoEnabled(LOGGER, "[{}]handleServerRequest:{}, errorMessage={}", name,
                    serverRequestHandler.getClass().getName(), e.getMessage());
        }
        
    }
    return null;
}
NamingPushRequestHandler.requestReply(Request request)
public Response requestReply(Request request) {
    if (request instanceof NotifySubscriberRequest) {
        NotifySubscriberRequest notifyResponse = (NotifySubscriberRequest) request;
        serviceInfoHolder.processServiceInfo(notifyResponse.getServiceInfo());
        return new NotifySubscriberResponse();
    }
    return null;
}

到这里serviceInfoHolder.processServiceInfo(notifyResponse.getServiceInfo())更新缓存的逻辑nacos客户端获取服务原理(订阅机制)已经做了详细的分析，这里只分析事件发布机制
serviceInfoHolder.processServiceInfo(serviceObj)

public ServiceInfo processServiceInfo(ServiceInfo serviceInfo) {
    /**
     * 省略
     */
    
    NAMING_LOGGER.info("current ips:(" + serviceInfo.ipCount() + ") service: " + serviceInfo.getKey() + " -> "
            + JacksonUtils.toJson(serviceInfo.getHosts()));
    // 添加实例变更事件，会被订阅者执行
    NotifyCenter.publishEvent(new InstancesChangeEvent(serviceInfo.getName(), serviceInfo.getGroupName(),
            serviceInfo.getClusters(), serviceInfo.getHosts()));
    return serviceInfo;
}

事件发布机制 NotifyCenter.publishEvent(new InstancesChangeEvent(…))

事件发布机制的详细过程在nacos服务端服务注册原理_2和_3文章中，针对服务端的事件发布机制已做了详细的分析，客户端流程也是相同，所以这里只分析主要的过程。

NotifyCenter.publishEvent(new InstancesChangeEvent(…))

  1. 当发布了InstancesChangeEvent事件后，仍旧放入队列queue中.
  2. 放入队列失败，或者放入成功从队列取出后，都是执行DefaultPublisher.receiveEvent
  3. 然后执行InstancesChangeNotifier.onEvent(InstancesChangeEvent event)

InstancesChangeNotifier.onEvent(InstancesChangeEvent event)

在这里插入图片描述
可以看到for循环中的listener就是NacosWatch中的eventListener，然后就执行onEvent中的逻辑了。

EventListener.onEvent
EventListener eventListener = listenerMap.computeIfAbsent(buildKey(),
    event -> new EventListener() {
        @Override
        public void onEvent(Event event) {
            if (event instanceof NamingEvent) {
                List<Instance> instances = ((NamingEvent) event)
                        .getInstances();
                Optional<Instance> instanceOptional = selectCurrentInstance(
                        instances);
                instanceOptional.ifPresent(currentInstance -> {
                    resetIfNeeded(currentInstance);
                });
            }
        }
    });

到这里还有个问题，NacosWatch中的eventListener是什么时候放入到InstancesChangeNotifier里的listenerMap呢。

回到NacosWatch.start()

public void start() {
    if (this.running.compareAndSet(false, true)) {
        EventListener eventListener = listenerMap.computeIfAbsent(buildKey(),
                event -> new EventListener() {
                    @Override
                    public void onEvent(Event event) {
                        if (event instanceof NamingEvent) {
                            List<Instance> instances = ((NamingEvent) event)
                                    .getInstances();
                            Optional<Instance> instanceOptional = selectCurrentInstance(
                                    instances);
                            instanceOptional.ifPresent(currentInstance -> {
                                resetIfNeeded(currentInstance);
                            });
                        }
                    }
                });

        NamingService namingService = nacosServiceManager
                .getNamingService(properties.getNacosProperties());
        try {
            namingService.subscribe(properties.getService(), properties.getGroup(),
                    Arrays.asList(properties.getClusterName()), eventListener);
        }
        catch (Exception e) {
            log.error("namingService subscribe failed, properties:{}", properties, e);
        }

        this.watchFuture = this.taskScheduler.scheduleWithFixedDelay(
                this::nacosServicesWatch, this.properties.getWatchDelay());
    }
}

重点关注namingService.subscribe

namingService.subscribe(properties.getService(), properties.getGroup(),
		 Arrays.asList(properties.getClusterName()), eventListener)

public void subscribe(String serviceName, String groupName, List<String> clusters, EventListener listener)
        throws NacosException {
    if (null == listener) {
        return;
    }
    String clusterString = StringUtils.join(clusters, ",");
	//这时的changeNotifier实际就是InstancesChangeNotifier
    changeNotifier.registerListener(groupName, serviceName, clusterString, listener);
    clientProxy.subscribe(serviceName, groupName, clusterString);
}

InstancesChangeNotifier.registerListener

public void registerListener(String groupName, String serviceName, String clusters, EventListener listener) {
    String key = ServiceInfo.getKey(NamingUtils.getGroupedName(serviceName, groupName), clusters);
    ConcurrentHashSet<EventListener> eventListeners = listenerMap.get(key);
    if (eventListeners == null) {
        synchronized (lock) {
            eventListeners = listenerMap.get(key);
            if (eventListeners == null) {
                eventListeners = new ConcurrentHashSet<EventListener>();
                listenerMap.put(key, eventListeners);
            }
        }
    }
    eventListeners.add(listener);
}

到这里就可以看到NacosWatch中的eventListener是什么时候放入到InstancesChangeNotifier里的listenerMap的过程了。

总结

  1. 服务端接收到服务注册请求后，发布了ClientRegisterServiceEvent客户端注册事件
  2. ClientRegisterServiceEvent事件被ClientServiceIndexesManager订阅后发布ServiceChangedEvent服务变更事件
  3. ServiceChangedEvent被NamingSubscriberServiceV2Impl订阅并创建PushDelayTask并被PushExecuteTask执行，负责向订阅该服务的客户端发起推送serviceInfo请求
  4. 推送的请求被NamingPushRequestHandler处理并发布InstancesChangeEvent，最终回调AbstractEventListener
阿星不是程序员
关注
专栏目录
nacosserver2.0.4.zip
05-23
github下载太慢，传一份保留下。
seata 报JacksonUndoLogParser - [encode,127] - json encode exception
zy_crazy_code的博客
02-23 2255
seata序列化错误
nacos request: /nacos/v1/ns/instance/beat failed, servers:
jiejiegua的博客
09-27 275
当nacos运行久了 会输出连接异常。这个多半是 nacos 缓存引起的。清理data目录下的文件 重启。
某马2024SpringCloud微服务开发与实战 bug记录与微服务知识拆解（MybatisPlus、Docker、MQ、ES、Redis）第四章重制版
擅长将自己的感受、想法、知识通俗地表达出来，会点前后端开发、自动化测试、性能测试、爬虫。将来可能学硬件、AI。但一定会写实用的脚本。
07-23 1万+
微服务项目的差错、网关概念 重制版。精益求精，不看后悔 背景色是为愧花黄绿
nacos Error to process server push response
axe的专栏
08-29 2661
nacos2.0.3报错： Error to process server push response。如果有，把版本改成0.9.11，低于0.9.11会有问题。
nacos2.3.0配置中心问题处理
山炮之家
12-31 2052
问题：Error to process server push response: {"headers":{},"abilityTable":{"supportPersistentInstanceByGrpc":true},"module":"internal"}
基于Nacos的Java/Shell语言服务端与客户端地址寻址web服务器设计源码
最新发布
10-04
该项目为基于Nacos（http://nacos.io）构建的Java与Shell语言服务端与客户端地址寻址Web服务器设计源码，共包含23个文件，其中包括14个Java源文件、2个属性文件、2个XML文件、1个Git忽略文件、1个Dockerfile、1个...
nacos服务端下载安装和客户端源码
09-28
1、Springboot 实践（16）Nacos server 2.2.3 下载安装 2、Springboot 实践（17）spring boot整合Nacos配置中心 3、Springboot 实践（18）Nacos配置中心...5、Springboot-Nacos-Client Springboot整合Nacos客户端源代码
nacos服务端安装程序
12-29
Nacos是阿里巴巴开源的一款分布式服务治理平台，主要应用于微服务架构中的服务发现、配置管理和控制台管理等场景。本文将详细介绍如何安装Nacos服务端，以及在安装过程中可能遇到的关键知识点。 首先，让我们理解...
nacos-server 服务端、注册中心、配置中心
09-11
nacos-server 服务端、注册中心、配置中心
nacos-server-1.1.4.tar（Nacos控制台，Nacos服务端）
11-06
Nacos的服务台程序。Spring-Cloud-Alibaba中的服务治理采用了Nacos，只需要解压资源后，运行bin目录下的开始脚本即可，支持Linux，Windows，Mac系统。1.1.4是截止到目前2019年11月的最新版本。
搭建springcloud服务初次启动报错
whatisthespring的博客
02-27 387
启动SpringCloudEureka 报错： com.netflix.discovery.shared.transport.TransportException: Cannot execute request on any known server 原因是SpringCloudEureka这个应用本身就是eureka服务器，不需要不断的尝试连接注册自己。 可以添加以下配置： 如果配置文件a...
【Seata】AT模式常见报错及解决
柒杯红酒
11-14 6745
seata 、RmTransactionException:Runtime、ShouldNeverHappenException、RmTransactionException:Response
【Gateway】网关服务快速上手
qq_45875349的博客
09-12 1094
API网关(简称网关)也是一个服务,通常是后端服务的唯一入口.它的定义类似设计模式中的Facade模式(门面模式,也称外观模式).它就类似整个微服务架构的门面,所有的外部客户端访问,都需要经过它来进行调度和过滤.
Springboot启动出现Error to process server push response的解决方法
码农研究僧的博客
12-17 2444
注意，此篇博客只提供一种bug排查思路，毕竟每个项目引起的依赖包冲突都不一致
使用Nacos配置中心后, 正常启动但是一直报Error to process server push response
minjun的博客
12-19 1742
nacos升级报错
Error -27796: Failed to connect to server问题解决记录
热门推荐
russ44的博客
10-27 1万+
在使用LoadRunner11运行场景时，出现了一个让我很奇怪的问题，当运行user数量大于1时请求会大量报错： Error -27796: Failed to connect to server 使用了网上的各种方式，无论是修改LoadRunner注册表，还是增加请求超时时间，发现均未能解决问题 经过一番查阅资料发现我由于前段时间在运行场景的时候使用了ip欺骗，现在运行场景时仍默认使用，
springCloud 连接nacos报错Server check failport 9848 error={} 解决方案
lihbps的博客
01-19 1万+
1、我们项目中使用的Nacos客户端是2.x之上的版本，Nacos在这个版本中新增了gRPC通信，默认通信端口是Nacos中配置的server-addr的端口号加1000的偏移量，所以我们的报错是检查9848端口是否开放，如下为官方解释：https://nacos.io/zh-cn/docs/v2/upgrading/2.0.0-compatibility.html。2、检查nacos 服务端的版本，目前我们使用的是最新版本 Nacos2.3.0。
Nacos9# 服务端响应连接和注册源码分析（二）
gaoliang1719的专栏
07-19 945
引言在《Nacos4# 服务端响应连接和注册源码分析（一）》在服务注册后发布了三个事件ClientEvent.ClientChangedEvent、ClientOperationEvent...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值