devbox
weixin_40725706
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Nacos2.0.3源码解析（三）RPC客户端、服务端原理_rpcclient start

作者：weixin_40725706 | 2024-06-30 21:08:11

赞

踩

rpcclient start

目录

1、RPC客户端

1.1、RPC客户端结构

1.2、RpcClient类

1.3、RpcClient启动流程

2、RPC服务端

2.1、rpc服务端结构

2.2、BaseRpcServer类

2.3、GRPC服务端启动流程

2.4、ConnectionManager注册

1、RPC客户端

1.1、RPC客户端结构

源码中相关包结构如下图所示：

 话不多说，直接上UML图

从上图可知，RPC客户端目前只有一种GRPC，而GRPC又有两种具体的实现，一种是GrpcSdkClient和GrpcClusterClient，下面我们一起来看一下他们的抽象类RpcClient。

1.2、RpcClient类

在这个类中有非常多的属性，下面我们来看看这些属性。

以下属性注释中已经给出了一些注释，有些不太清楚作用的会在之后的内容中讲到。

  1.  /**
  2.      * 服务器工厂
  3.      * 作用：在这主要是获取服务器列表的
  4.      */
  5.     private ServerListFactory serverListFactory;
  6.  
  7.     /**
  8.      * rpc连接事件阻塞队列
  9.      */
  10.     protected LinkedBlockingQueue<ConnectionEvent> eventLinkedBlockingQueue = new LinkedBlockingQueue<ConnectionEvent>();
  11.  
  12.     /**
  13.      * rpc客户端状态
  14.      */
  15.     protected volatile AtomicReference<RpcClientStatus> rpcClientStatus = new AtomicReference<RpcClientStatus>(
  16.             RpcClientStatus.WAIT_INIT);
  17.  
  18.     /**
  19.      * 周期性任务线程池
  20.      */
  21.     protected ScheduledExecutorService clientEventExecutor;
  22.  
  23.     /**
  24.      * 重试服务阻塞队列
  25.      */
  26.     private final BlockingQueue<ReconnectContext> reconnectionSignal = new ArrayBlockingQueue<ReconnectContext>(1);
  27.  
  28.     /**
  29.      * 当前rpc连接
  30.      */
  31.     protected volatile Connection currentConnection;
  32.  
  33.     /**
  34.      * 用于标注客户端请求的标签
  35.      */
  36.     protected Map<String, String> labels = new HashMap<String, String>();
  37.  
  38.  
  39.     /**
  40.      * rpc客户端连接服务器重试次数
  41.      */
  42.     private static final int RETRY_TIMES = 3;
  43.  
  44.     /**
  45.      * rpc客户端请求默认的超时时间
  46.      */
  47.     private static final long DEFAULT_TIMEOUT_MILLS = 3000L;
  48.  
  49.     /**
  50.      * 表示rpc客户端能力的对象
  51.      */
  52.     protected ClientAbilities clientAbilities;
  53.  
  54.     /**
  55.      * default keep alive time 5s.
  56.      * rpc客户端与服务端连接默认保持时间为5s
  57.      */
  58.     private long keepAliveTime = 5000L;
  59.  
  60.     /**
  61.      * rpc客户端与服务端连接最后存活时间
  62.      */
  63.     private long lastActiveTimeStamp = System.currentTimeMillis();
  64.  
  65.     /**
  66.      * listener called where connection's status changed.
  67.      * 在连接状态改变的地方调用监听器
  68.      */
  69.     protected List<ConnectionEventListener> connectionEventListeners = new ArrayList<ConnectionEventListener>();
  70.  
  71.     /**
  72.      * handlers to process server push request.
  73.      * 处理服务器推送请求的处理程序
  74.      */
  75.     protected List<ServerRequestHandler> serverRequestHandlers = new ArrayList<ServerRequestHandler>();

这里主要说一下currentConnection属性。由下图可以看出，如果使用GRPC的话，RpcClient中的Connection属性是GrpcClient中创建的GrpcConnection。connection属性是rpc通信时，与服务端建立的链接通道，用于发送一些请求用的。

1.3、RpcClient启动流程

nacos的rpcClient启动最主要的方法是start方法，下面我们来看看这个方法。

  1. public final void start() throws NacosException {
  2.         // 修改rpc客户端状态为STARTING
  3.         boolean success = rpcClientStatus.compareAndSet(RpcClientStatus.INITIALIZED, RpcClientStatus.STARTING);
  4.         if (!success) {
  5.             return;
  6.         }
  7.  
  8.         // 创建周期性任务线程池
  9.         clientEventExecutor = new ScheduledThreadPoolExecutor(2, new ThreadFactory() {
  10.             @Override
  11.             public Thread newThread(Runnable r) {
  12.                 Thread t = new Thread(r);
  13.                 t.setName("com.alibaba.nacos.client.remote.worker");
  14.                 t.setDaemon(true);
  15.                 return t;
  16.             }
  17.         });
  18.  
  19.         // connection event consumer.
  20.         // 连接事件消费者，给对应监听器发送事件
  21.         clientEventExecutor.submit(new Runnable() {
  22.             @Override
  23.             public void run() {
  24.                 // 判断线程池是否被关闭，被关闭则不再执行
  25.                 while (!clientEventExecutor.isTerminated() && !clientEventExecutor.isShutdown()) {
  26.                     ConnectionEvent take = null;
  27.                     try {
  28.                         // 从连接事件阻塞队列拿连接事件
  29.                         // 在连接成功时，会往队列中存放连接成功的事件；连接断开时会存放连接断开的事件
  30.                         take = eventLinkedBlockingQueue.take();
  31.                         // 判断rpc客户端是否已经连接
  32.                         if (take.isConnected()) {
  33.                             // 执行连接成功的监听器（通知重试机制已经连接，不需要再重试）
  34.                             notifyConnected();
  35.                         } else if (take.isDisConnected()) {
  36.                             // 执行连接断开的监听器（通知重试机制未连接，需要重试）
  37.                             notifyDisConnected();
  38.                         }
  39.                     } catch (Throwable e) {
  40.                         //Do nothing
  41.                     }
  42.                 }
  43.             }
  44.         });
  45.  
  46.         // 服务端健康检查及重连服务，有重连的情况则不会进行健康检查，健康检查的前提是所有连接都健康
  47.         clientEventExecutor.submit(new Runnable() {
  48.             @Override
  49.             public void run() {
  50.                 while (true) {
  51.                     try {
  52.                         // 如果rpc客户端关闭则终止循环
  53.                         if (isShutdown()) {
  54.                             break;
  55.                         }
  56.                         // 获取ReconnectContext（重连上下文对象）对象，默认5秒内取不到则返回null
  57.                         ReconnectContext reconnectContext = reconnectionSignal
  58.                                 .poll(keepAliveTime, TimeUnit.MILLISECONDS);
  59.                         // 1、如果没有拿到ReconnectContext对象，则表示没有重连的需要，则会检查server的健康状况，
  60.                         // 如果不健康，则会创建一个空的重连上下文对象，后面会选择一个server重连
  61.                         if (reconnectContext == null) {
  62.                             //check alive time.
  63.                             // 检查存活时间
  64.                             // 如果没有重连的需求，这里每隔默认5秒会去检查server健康情况
  65.                             if (System.currentTimeMillis() - lastActiveTimeStamp >= keepAliveTime) {
  66.                                 // 判断当前连接是否健康
  67.                                 boolean isHealthy = healthCheck();
  68.                                 if (!isHealthy) {
  69.                                     // 如果currentConnection为空，表明还在启动连接server的情况，并不是server那边不健康的问题
  70.                                     if (currentConnection == null) {
  71.                                         continue;
  72.                                     }
  73.                                     // 执行到这里表示，rpc客户端和服务端连接有异常
  74.                                     LoggerUtils.printIfInfoEnabled(LOGGER,
  75.                                             "[{}]Server healthy check fail,currentConnection={}", name,
  76.                                             currentConnection.getConnectionId());
  77.  
  78.                                     RpcClientStatus rpcClientStatus = RpcClient.this.rpcClientStatus.get();
  79.                                     // 在发起重连之前，这里再次判断rpc客户端是否被关闭（这里有可能客户端被关闭了，如果不判断的话SHUTDOWN又被改为UNHEALTHY是不合理的）
  80.                                     if (RpcClientStatus.SHUTDOWN.equals(rpcClientStatus)) {
  81.                                         // 如果已经关闭连接，则中断循环
  82.                                         break;
  83.                                     }
  84.                                     // 设置客户端不健康状态（这里必须使用cas来更新，因为此时状态可能被修改了，可能会存在SHUTDOWN->UNHEALTHY）
  85.                                     boolean success = RpcClient.this.rpcClientStatus
  86.                                             .compareAndSet(rpcClientStatus, RpcClientStatus.UNHEALTHY);
  87.                                     // TODO 这个地方状态可能会变成RUNNING
  88.                                     if (success) {
  89.                                         // 如果客户端不健康状态设置成功，则设置一个空的重新连接上下文对象（相当于重新选一个随机的server来重连）
  90.                                         reconnectContext = new ReconnectContext(null, false);
  91.                                     } else {
  92.                                         // 如果设置失败，表示状态在更新之前发生了改变，则选择重试
  93.                                         // 可能是状态期间被改为SHUTDOWN了，也可能是状态期间被改为RUNNING
  94.                                         // 因为在代码①处是先赋值新连接，后修改状态的。可能会出现这个问题，所以这里选择continue
  95.                                         continue;
  96.                                     }
  97.  
  98.                                 } else {
  99.                                     // 健康则更新最后的活跃时间
  100.                                     lastActiveTimeStamp = System.currentTimeMillis();
  101.                                     continue;
  102.                                 }
  103.                             } else {
  104.                                 continue;
  105.                             }
  106.  
  107.                         }
  108.  
  109.                         // 2、有重连的需求，如果ReconnectContext对象是有指定的server，则检查server是否存在，如果不存在则将ReconnectContext设置为空
  110.                         // 之后自己会选取一个server
  111.                         if (reconnectContext.serverInfo != null) {
  112.                             //clear recommend server if server is not in server list.
  113.                             boolean serverExist = false;
  114.                             // 从serverListFactory中获取服务器列表
  115.                             for (String server : getServerListFactory().getServerList()) {
  116.                                 ServerInfo serverInfo = resolveServerInfo(server);
  117.                                 // 判断服务器是否存在
  118.                                 if (serverInfo.getServerIp().equals(reconnectContext.serverInfo.getServerIp())) {
  119.                                     serverExist = true;
  120.                                     reconnectContext.serverInfo.serverPort = serverInfo.serverPort;
  121.                                     break;
  122.                                 }
  123.                             }
  124.                             // 如果给到的server信息不存在，则自己选取一个
  125.                             if (!serverExist) {
  126.                                 LoggerUtils.printIfInfoEnabled(LOGGER,
  127.                                         "[{}] Recommend server is not in server list ,ignore recommend server {}", name,
  128.                                         reconnectContext.serverInfo.getAddress());
  129.  
  130.                                 reconnectContext.serverInfo = null;
  131.  
  132.                             }
  133.                         }
  134.  
  135.                         // 3、重新连接server，关闭之前的连接
  136.                         reconnect(reconnectContext.serverInfo, reconnectContext.onRequestFail);
  137.                     } catch (Throwable throwable) {
  138.                         //Do nothing
  139.                     }
  140.                 }
  141.             }
  142.         });
  143.  
  144.         //connect to server ,try to connect to server sync once, async starting if fail.
  145.         // 连接到服务器，尝试连接到服务器同步一次，如果失败异步启动
  146.         Connection connectToServer = null;
  147.         // TODO 这段我认为没什么必要，在这期间状态是不会被改变的
  148.         rpcClientStatus.set(RpcClientStatus.STARTING);
  149.  
  150.         int startUpRetryTimes = RETRY_TIMES;
  151.         while (startUpRetryTimes > 0 && connectToServer == null) {
  152.             try {
  153.                 startUpRetryTimes--;
  154.                 // 获取服务器信息
  155.                 ServerInfo serverInfo = nextRpcServer();
  156.  
  157.                 LoggerUtils.printIfInfoEnabled(LOGGER, "[{}] Try to connect to server on start up, server: {}", name,
  158.                         serverInfo);
  159.  
  160.                 connectToServer = connectToServer(serverInfo);
  161.             } catch (Throwable e) {
  162.                 LoggerUtils.printIfWarnEnabled(LOGGER,
  163.                         "[{}]Fail to connect to server on start up, error message={}, start up retry times left: {}",
  164.                         name, e.getMessage(), startUpRetryTimes);
  165.             }
  166.  
  167.         }
  168.  
  169.         // 判断是否连接成功
  170.         if (connectToServer != null) {
  171.             LoggerUtils.printIfInfoEnabled(LOGGER, "[{}] Success to connect to server [{}] on start up,connectionId={}",
  172.                     name, connectToServer.serverInfo.getAddress(), connectToServer.getConnectionId());
  173.             this.currentConnection = connectToServer; // ①
  174.             rpcClientStatus.set(RpcClientStatus.RUNNING);
  175.             // 添加连接成功事件
  176.             eventLinkedBlockingQueue.offer(new ConnectionEvent(ConnectionEvent.CONNECTED));
  177.         } else {
  178.             // 要是没有一个服务端能连接，则尝试随机重连
  179.             switchServerAsync();
  180.         }
  181.         // 监听重新设置连接请求
  182.         registerServerRequestHandler(new ConnectResetRequestHandler());
  183.  
  184.         //register client detection request.
  185.         registerServerRequestHandler(new ServerRequestHandler() {
  186.             @Override
  187.             public Response requestReply(Request request) {
  188.                 if (request instanceof ClientDetectionRequest) {
  189.                     return new ClientDetectionResponse();
  190.                 }
  191.  
  192.                 return null;
  193.             }
  194.         });
  195.  
  196.     }

start主要做了几件事

  1. 开启定时任务1，用于消费连接事件。用于通知ConnectionEventListener监听器，在连接成功或断开的时候会触发
  2. 开启定时任务2，在没有重连信号的时候每隔一段时间会进行健康检查，如果有重连信号则重新选择一个rpc服务端进行连接
  3. 自己去尝试连接rpc服务端，尝试几次如果都失败了，则发送重连信号到队列中，定时任务2会检测到重连信号进行重连
  4. 注册服务请求处理器，一个是用来监听服务端发送过来的重连请求的，还有一个是用来监听服务端发送过来的存活检测请求的

上面简单的说了一下大概的功能，下面具体展开聊聊。

第一个定时任务

  1. clientEventExecutor.submit(new Runnable() {
  2.             @Override
  3.             public void run() {
  4.                 // 判断线程池是否被关闭，被关闭则不再执行
  5.                 while (!clientEventExecutor.isTerminated() && !clientEventExecutor.isShutdown()) {
  6.                     ConnectionEvent take = null;
  7.                     try {
  8.                         // 从连接事件阻塞队列拿连接事件
  9.                         // 在连接成功时，会往队列中存放连接成功的事件；连接断开时会存放连接断开的事件
  10.                         take = eventLinkedBlockingQueue.take();
  11.                         // 判断rpc客户端是否已经连接
  12.                         if (take.isConnected()) {
  13.                             // 执行连接成功的监听器（通知重试机制已经连接，不需要再重试）
  14.                             notifyConnected();
  15.                         } else if (take.isDisConnected()) {
  16.                             // 执行连接断开的监听器（通知重试机制未连接，需要重试）
  17.                             notifyDisConnected();
  18.                         }
  19.                     } catch (Throwable e) {
  20.                         //Do nothing
  21.                     }
  22.                 }
  23.             }
  24.         });

这个定时任务会消费连接事件，其实本身ConnectionEventListener监听器暂时只有NamingGrpcRedoService一个，这个类的作用主要是用来grpc重连服务的，具体的实现会在之后的client编详细来讲，这块都简单带过～

第二个定时任务

  1.  clientEventExecutor.submit(new Runnable() {
  2.             @Override
  3.             public void run() {
  4.                 while (true) {
  5.                     try {
  6.                         // 如果rpc客户端关闭则终止循环
  7.                         if (isShutdown()) {
  8.                             break;
  9.                         }
  10.                         // 获取ReconnectContext（重连上下文对象）对象，默认5秒内取不到则返回null
  11.                         ReconnectContext reconnectContext = reconnectionSignal
  12.                                 .poll(keepAliveTime, TimeUnit.MILLISECONDS);
  13.                         // 1、如果没有拿到ReconnectContext对象，则表示没有重连的需要，则会检查server的健康状况，
  14.                         // 如果不健康，则会创建一个空的重连上下文对象，后面会选择一个server重连
  15.                         if (reconnectContext == null) {
  16.                             //check alive time.
  17.                             // 检查存活时间
  18.                             // 如果没有重连的需求，这里每隔默认5秒会去检查server健康情况
  19.                             if (System.currentTimeMillis() - lastActiveTimeStamp >= keepAliveTime) {
  20.                                 // 判断当前连接是否健康
  21.                                 boolean isHealthy = healthCheck();
  22.                                 if (!isHealthy) {
  23.                                     // 如果currentConnection为空，表明还在启动连接server的情况，并不是server那边不健康的问题
  24.                                     if (currentConnection == null) {
  25.                                         continue;
  26.                                     }
  27.                                     // 执行到这里表示，rpc客户端和服务端连接有异常
  28.                                     LoggerUtils.printIfInfoEnabled(LOGGER,
  29.                                             "[{}]Server healthy check fail,currentConnection={}", name,
  30.                                             currentConnection.getConnectionId());
  31.  
  32.                                     RpcClientStatus rpcClientStatus = RpcClient.this.rpcClientStatus.get();
  33.                                     // 在发起重连之前，这里再次判断rpc客户端是否被关闭（这里有可能客户端被关闭了，如果不判断的话SHUTDOWN又被改为UNHEALTHY是不合理的）
  34.                                     if (RpcClientStatus.SHUTDOWN.equals(rpcClientStatus)) {
  35.                                         // 如果已经关闭连接，则中断循环
  36.                                         break;
  37.                                     }
  38.                                     // 设置客户端不健康状态（这里必须使用cas来更新，因为此时状态可能被修改了，可能会存在SHUTDOWN->UNHEALTHY）
  39.                                     boolean success = RpcClient.this.rpcClientStatus
  40.                                             .compareAndSet(rpcClientStatus, RpcClientStatus.UNHEALTHY);
  41.                                     // TODO 这个地方状态可能会变成RUNNING
  42.                                     if (success) {
  43.                                         // 如果客户端不健康状态设置成功，则设置一个空的重新连接上下文对象（相当于重新选一个随机的server来重连）
  44.                                         reconnectContext = new ReconnectContext(null, false);
  45.                                     } else {
  46.                                         // 如果设置失败，表示状态在更新之前发生了改变，则选择重试
  47.                                         // 可能是状态期间被改为SHUTDOWN了，也可能是状态期间被改为RUNNING
  48.                                         // 因为在代码①处是先赋值新连接，后修改状态的。可能会出现这个问题，所以这里选择continue
  49.                                         continue;
  50.                                     }
  51.  
  52.                                 } else {
  53.                                     // 健康则更新最后的活跃时间
  54.                                     lastActiveTimeStamp = System.currentTimeMillis();
  55.                                     continue;
  56.                                 }
  57.                             } else {
  58.                                 continue;
  59.                             }
  60.  
  61.                         }
  62.  
  63.                         // 2、有重连的需求，如果ReconnectContext对象是有指定的server，则检查server是否存在，如果不存在则将ReconnectContext设置为空
  64.                         // 之后自己会选取一个server
  65.                         if (reconnectContext.serverInfo != null) {
  66.                             //clear recommend server if server is not in server list.
  67.                             boolean serverExist = false;
  68.                             // 从serverListFactory中获取服务器列表
  69.                             for (String server : getServerListFactory().getServerList()) {
  70.                                 ServerInfo serverInfo = resolveServerInfo(server);
  71.                                 // 判断服务器是否存在
  72.                                 if (serverInfo.getServerIp().equals(reconnectContext.serverInfo.getServerIp())) {
  73.                                     serverExist = true;
  74.                                     reconnectContext.serverInfo.serverPort = serverInfo.serverPort;
  75.                                     break;
  76.                                 }
  77.                             }
  78.                             // 如果给到的server信息不存在，则自己选取一个
  79.                             if (!serverExist) {
  80.                                 LoggerUtils.printIfInfoEnabled(LOGGER,
  81.                                         "[{}] Recommend server is not in server list ,ignore recommend server {}", name,
  82.                                         reconnectContext.serverInfo.getAddress());
  83.  
  84.                                 reconnectContext.serverInfo = null;
  85.  
  86.                             }
  87.                         }
  88.  
  89.                         // 3、重新连接server，关闭之前的连接
  90.                         reconnect(reconnectContext.serverInfo, reconnectContext.onRequestFail);
  91.                     } catch (Throwable throwable) {
  92.                         //Do nothing
  93.                     }
  94.                 }
  95.             }
  96.         });

这个定时任务会定时的从reconnectionSignal阻塞队列中取重连上下文对象，默认5s没有取到对象的话则会进行健康检查，如果不健康，则会经过一系列的判断给rpcClient状态改为不健康的，并往reconnectionSignal队列中设置重连上下文对象；如果取到重连上下文对象则判断是否有指定的服务端，如果没有则选择一个rpc服务端进行连接。

在上面方法中，关键的方法是这个reconnect方法，在reconnect方法之前的逻辑也都只是判断选取服务端而已，真正的重连逻辑在reconnect方法中。

  1. protected void reconnect(final ServerInfo recommendServerInfo, boolean onRequestFail) {
  2.  
  3.         try {
  4.  
  5.             AtomicReference<ServerInfo> recommendServer = new AtomicReference<ServerInfo>(recommendServerInfo);
  6.             // 判断服务端是否健康，当前请求是否失败
  7.             // onRequestFail为true，则表示rpc请求失败了，如果请求失败了，之后再次检查server是否健康
  8.             // 如果是false，则可能是服务端的重连请求，则不再检查服务端的健康状态
  9.             // 如果健康，则重新设置回RUNNING状态，不继续进行重连行为
  10.             if (onRequestFail && healthCheck()) {
  11.                 LoggerUtils.printIfInfoEnabled(LOGGER, "[{}] Server check success,currentServer is{} ", name,
  12.                         currentConnection.serverInfo.getAddress());
  13.                 // 有可能会出现这样的情况，在shutdown方法中设置状态为SHUTDOWN之后，这里还会继续执行改为RUNNING。但是实际上也只是状态的改变，关闭线程池之后不会影响
  14.                 // 之前修改状态代码如下：
  15.                 // RpcClientStatus rpcClientStatus = RpcClient.this.rpcClientStatus.get();
  16.                 // if (RpcClientStatus.SHUTDOWN.equals(rpcClientStatus)) {
  17.                 //     break;
  18.                 // }
  19.                 // boolean success = RpcClient.this.rpcClientStatus.compareAndSet(rpcClientStatus, RpcClientStatus.UNHEALTHY);
  20.                 // 使用cas来保证状态是因为是怕在关闭线程池之后还创建了重连对象，之后因为状态是UNHEALTHY，还会继续往下执行重连的操作，
  21.                 // 因为rpc连接被关闭后再次调用该连接去访问服务器会导致后续一些资源浪费（比如说关闭之前又创建了rpc连接，浪费性能）。
  22.                 // 而这里但存的将状态改为RUNNING是不会产生这些的，虽然会导致最后状态有问题，但是最后还是关闭了，不会影响。
  23.                 rpcClientStatus.set(RpcClientStatus.RUNNING);
  24.                 return;
  25.             }
  26.             LoggerUtils.printIfInfoEnabled(LOGGER, "[{}] try to re connect to a new server ,server is {}", name,
  27.                     recommendServerInfo == null ? " not appointed,will choose a random server."
  28.                             : (recommendServerInfo.getAddress() + ", will try it once."));
  29.  
  30.             // loop until start client success.
  31.             // 循环直到客户端启动成功
  32.             boolean switchSuccess = false;
  33.             // 重试次数
  34.             int reConnectTimes = 0;
  35.             // 重试了几轮
  36.             int retryTurns = 0;
  37.             Exception lastException = null;
  38.             // 如果没有切换成功并且client没有关闭，则继续连接
  39.             while (!switchSuccess && !isShutdown()) {
  40.  
  41.                 //1.get a new server
  42.                 // 获取到新的服务端
  43.                 ServerInfo serverInfo = null;
  44.                 try {
  45.                     // 如果没有指定server信息，则会重新轮询选取一个
  46.                     serverInfo = recommendServer.get() == null ? nextRpcServer() : recommendServer.get();
  47.                     //2.create a new channel to new server
  48.                     // 根据server信息，创建新服务端的新通道
  49.                     Connection connectionNew = connectToServer(serverInfo);
  50.                     // 成功创建新连接，则如果有老连接对象则替换，并发布连接成功事件
  51.                     if (connectionNew != null) {
  52.                         LoggerUtils.printIfInfoEnabled(LOGGER, "[{}] success to connect a server  [{}],connectionId={}",
  53.                                 name, serverInfo.getAddress(), connectionNew.getConnectionId());
  54.                         //successfully create a new connect.
  55.                         // 成功创建一个新连接
  56.                         if (currentConnection != null) {
  57.                             LoggerUtils.printIfInfoEnabled(LOGGER,
  58.                                     "[{}] Abandon prev connection ,server is  {}, connectionId is {}", name,
  59.                                     currentConnection.serverInfo.getAddress(), currentConnection.getConnectionId());
  60.                             //set current connection to enable connection event.
  61.                             // 标注废弃该连接
  62.                             currentConnection.setAbandon(true);
  63.                             // 关闭当前连接
  64.                             closeConnection(currentConnection);
  65.                         }
  66.                         // 新连接替换旧连接
  67.                         currentConnection = connectionNew;
  68.                         rpcClientStatus.set(RpcClientStatus.RUNNING);
  69.                         switchSuccess = true;
  70.                         // 发布已连接事件
  71.                         boolean s = eventLinkedBlockingQueue.add(new ConnectionEvent(ConnectionEvent.CONNECTED));
  72.                         return;
  73.                     }
  74.  
  75.                     //close connection if client is already shutdown.
  76.                     // 如果客户端已经关闭，则关闭连接
  77.                     if (isShutdown()) {
  78.                         closeConnection(currentConnection);
  79.                     }
  80.  
  81.                     lastException = null;
  82.  
  83.                 } catch (Exception e) {
  84.                     lastException = e;
  85.                 } finally {
  86.                     recommendServer.set(null);
  87.                 }
  88.  
  89.                 if (reConnectTimes > 0
  90.                         && reConnectTimes % RpcClient.this.serverListFactory.getServerList().size() == 0) {
  91.                     LoggerUtils.printIfInfoEnabled(LOGGER,
  92.                             "[{}] fail to connect server,after trying {} times, last try server is {},error={}", name,
  93.                             reConnectTimes, serverInfo, lastException == null ? "unknown" : lastException);
  94.                     if (Integer.MAX_VALUE == retryTurns) {
  95.                         retryTurns = 50;
  96.                     } else {
  97.                         // 服务器循环了一轮则加一
  98.                         retryTurns++;
  99.                     }
  100.                 }
  101.  
  102.                 reConnectTimes++;
  103.  
  104.                 try {
  105.                     //sleep x milliseconds to switch next server.
  106.                     if (!isRunning()) {
  107.                         // first round ,try servers at a delay 100ms;second round ,200ms; max delays 5s. to be reconsidered.
  108.                         // 第一轮，服务器延迟100ms;第二轮200ms，最后每轮最高一直是5000毫秒重连一次
  109.                         Thread.sleep(Math.min(retryTurns + 1, 50) * 100L);
  110.                     }
  111.                 } catch (InterruptedException e) {
  112.                     // Do  nothing.
  113.                 }
  114.             }
  115.  
  116.             if (isShutdown()) {
  117.                 LoggerUtils.printIfInfoEnabled(LOGGER, "[{}] Client is shutdown ,stop reconnect to server", name);
  118.             }
  119.  
  120.         } catch (Exception e) {
  121.             LoggerUtils.printIfWarnEnabled(LOGGER, "[{}] Fail to  re connect to server ,error is {}", name, e);
  122.         }
  123.     }

reconnect方法中可以看出，这里面主要还是做了一些重连的逻辑处理，连接成功则发布连接成功的事件，如果存在旧连接则替换旧连接。如果一直重连不上，则会延迟一段时间进行重连。

由上分析可得，reconnect中实际上创建连接对象的方法是connectToServer方法，这个方法由子类来实现，nacos目前支持的rpc只有grpc，下面我们来看看grpc创建连接对象的逻辑。

  1. public Connection connectToServer(ServerInfo serverInfo) {
  2.         try {
  3.             // 初始化线程池
  4.             if (grpcExecutor == null) {
  5.                 int threadNumber = ThreadUtils.getSuitableThreadCount(8);
  6.                 grpcExecutor = new ThreadPoolExecutor(threadNumber, threadNumber, 10L, TimeUnit.SECONDS,
  7.                         new LinkedBlockingQueue<>(10000),
  8.                         new ThreadFactoryBuilder().setDaemon(true).setNameFormat("nacos-grpc-client-executor-%d")
  9.                                 .build());
  10.                 grpcExecutor.allowCoreThreadTimeOut(true);
  11.  
  12.             }
  13.             int port = serverInfo.getServerPort() + rpcPortOffset();
  14.             // 创建stub
  15.             RequestGrpc.RequestFutureStub newChannelStubTemp = createNewChannelStub(serverInfo.getServerIp(), port);
  16.             if (newChannelStubTemp != null) {
  17.                 // 校验服务器是否可以访问
  18.                 Response response = serverCheck(serverInfo.getServerIp(), port, newChannelStubTemp);
  19.                 if (response == null || !(response instanceof ServerCheckResponse)) {
  20.                     // 如果服务器不能访问成功，则关闭channel
  21.                     shuntDownChannel((ManagedChannel) newChannelStubTemp.getChannel());
  22.                     return null;
  23.                 }
  24.  
  25.                 BiRequestStreamGrpc.BiRequestStreamStub biRequestStreamStub = BiRequestStreamGrpc
  26.                         .newStub(newChannelStubTemp.getChannel());
  27.                 GrpcConnection grpcConn = new GrpcConnection(serverInfo, grpcExecutor);
  28.                 grpcConn.setConnectionId(((ServerCheckResponse) response).getConnectionId());
  29.  
  30.                 //create stream request and bind connection event to this connection.
  31.                 // 创建stream观察者，将响应发送到服务器，到时候返回时会执行自定义的响应方法
  32.                 StreamObserver<Payload> payloadStreamObserver = bindRequestStream(biRequestStreamStub, grpcConn);
  33.  
  34.                 // stream observer to send response to server
  35.                 grpcConn.setPayloadStreamObserver(payloadStreamObserver);
  36.                 grpcConn.setGrpcFutureServiceStub(newChannelStubTemp);
  37.                 grpcConn.setChannel((ManagedChannel) newChannelStubTemp.getChannel());
  38.                 //send a  setup request.
  39.                 // 构建请求数据（用于注册到服务端的connectionManager中）
  40.                 ConnectionSetupRequest conSetupRequest = new ConnectionSetupRequest();
  41.                 conSetupRequest.setClientVersion(VersionUtils.getFullClientVersion());
  42.                 conSetupRequest.setLabels(super.getLabels());
  43.                 conSetupRequest.setAbilities(super.clientAbilities);
  44.                 conSetupRequest.setTenant(super.getTenant());
  45.                 grpcConn.sendRequest(conSetupRequest);
  46.                 //wait to register connection setup
  47.                 Thread.sleep(100L);
  48.                 return grpcConn;
  49.             }
  50.             return null;
  51.         } catch (Exception e) {
  52.             LOGGER.error("[{}]Fail to connect to server!,error={}", GrpcClient.this.getName(), e);
  53.         }
  54.         return null;
  55.     }

在上面的方法中，都是grpc的一些基本方法，封装了一下。客户端和服务端建立连接的方法其实就是这么一句RequestGrpc.RequestFutureStub newChannelStubTemp = createNewChannelStub(serverInfo.getServerIp(), port);如果创建通道失败，则返回一个null来表示连接创建失败；如果创建成功，则会构建请求对象注册到rpc服务端的connectionManager中（如果不符合服务端的一些规则注册失败，则服务端会给客户端发送重连的请求，并且拒绝该客户端的请求，之后的讲到服务端再具体分析），之后会返回连接对象。

2、RPC服务端

2.1、rpc服务端结构

 具体看一下UML图

这张图我列举了几个主要属性，由上图可见，RPC服务端和客户端结构类似，目前只有一种GRPC，而GRPC服务端又有两种具体的实现，一种是GrpcSdkServer和GrpcClusterServer，下面看一下他们的抽象类BaseRpcServer。

2.2、BaseRpcServer类

  1. @PostConstruct
  2.     public void start() throws Exception {
  3.         String serverName = getClass().getSimpleName();
  4.         Loggers.REMOTE.info("Nacos {} Rpc server starting at port {}", serverName, getServicePort());
  5.         // 具体启动rpc服务逻辑
  6.         startServer();
  7.         
  8.         Loggers.REMOTE.info("Nacos {} Rpc server started at port {}", serverName, getServicePort());
  9.         // 关闭时执行的钩子方法
  10.         Runtime.getRuntime().addShutdownHook(new Thread() {
  11.             @Override
  12.             public void run() {
  13.                 Loggers.REMOTE.info("Nacos {} Rpc server stopping", serverName);
  14.                 try {
  15.                     BaseRpcServer.this.stopServer();
  16.                     Loggers.REMOTE.info("Nacos {} Rpc server stopped successfully...", serverName);
  17.                 } catch (Exception e) {
  18.                     Loggers.REMOTE.error("Nacos {} Rpc server stopped fail...", serverName, e);
  19.                 }
  20.             }
  21.         });
  22.  
  23.     }

由上代码可见，BaseRpcServer实际上没有做什么，只是借助了@PostConstruct来启动rpc服务。下面我们来看看它的实现BaseGrpcServer。

2.3、GRPC服务端启动流程

BaseGrpcServer这个类中有几个属性，下面一一介绍一下。

  1.     // grpc 请求接收器
  2.     @Autowired
  3.     private GrpcRequestAcceptor grpcCommonRequestAcceptor;
  4.     // grpc bi流请求接收器
  5.     @Autowired
  6.     private GrpcBiStreamRequestAcceptor grpcBiStreamRequestAcceptor;
  7.     // 客户端连接管理器
  8.     @Autowired
  9.     private ConnectionManager connectionManager;
  10.     // grpc服务对象
  11.     private Server server;

grpc启动流程方法如下：

  1. @Override
  2.     public void startServer() throws Exception {
  3.         final MutableHandlerRegistry handlerRegistry = new MutableHandlerRegistry();
  4.         
  5.         // server interceptor to set connection id.
  6.         ServerInterceptor serverInterceptor = new ServerInterceptor() {
  7.             @Override
  8.             public <T, S> ServerCall.Listener<T> interceptCall(ServerCall<T, S> call, Metadata headers,
  9.                     ServerCallHandler<T, S> next) {
  10.                 Context ctx = Context.current()
  11.                         .withValue(CONTEXT_KEY_CONN_ID, call.getAttributes().get(TRANS_KEY_CONN_ID))
  12.                         .withValue(CONTEXT_KEY_CONN_REMOTE_IP, call.getAttributes().get(TRANS_KEY_REMOTE_IP))
  13.                         .withValue(CONTEXT_KEY_CONN_REMOTE_PORT, call.getAttributes().get(TRANS_KEY_REMOTE_PORT))
  14.                         .withValue(CONTEXT_KEY_CONN_LOCAL_PORT, call.getAttributes().get(TRANS_KEY_LOCAL_PORT));
  15.                 if (REQUEST_BI_STREAM_SERVICE_NAME.equals(call.getMethodDescriptor().getServiceName())) {
  16.                     Channel internalChannel = getInternalChannel(call);
  17.                     ctx = ctx.withValue(CONTEXT_KEY_CHANNEL, internalChannel);
  18.                 }
  19.                 return Contexts.interceptCall(ctx, call, headers, next);
  20.             }
  21.         };
  22.  
  23.         // 添加rpc服务
  24.         addServices(handlerRegistry, serverInterceptor);
  25.         
  26.         server = ServerBuilder.forPort(getServicePort()).executor(getRpcExecutor())
  27.                 // 设置服务端最大消息大小
  28.                 .maxInboundMessageSize(getInboundMessageSize()).fallbackHandlerRegistry(handlerRegistry)
  29.                 // 设置压缩的注册类
  30.                 .compressorRegistry(CompressorRegistry.getDefaultInstance())
  31.                 // 设置解压的注册类
  32.                 .decompressorRegistry(DecompressorRegistry.getDefaultInstance())
  33.                 // 添加过滤器
  34.                 .addTransportFilter(new ServerTransportFilter() {
  35.                     @Override
  36.                     public Attributes transportReady(Attributes transportAttrs) {
  37.                         InetSocketAddress remoteAddress = (InetSocketAddress) transportAttrs
  38.                                 .get(Grpc.TRANSPORT_ATTR_REMOTE_ADDR);
  39.                         InetSocketAddress localAddress = (InetSocketAddress) transportAttrs
  40.                                 .get(Grpc.TRANSPORT_ATTR_LOCAL_ADDR);
  41.                         int remotePort = remoteAddress.getPort();
  42.                         int localPort = localAddress.getPort();
  43.                         String remoteIp = remoteAddress.getAddress().getHostAddress();
  44.                         Attributes attrWrapper = transportAttrs.toBuilder()
  45.                                 .set(TRANS_KEY_CONN_ID, System.currentTimeMillis() + "_" + remoteIp + "_" + remotePort)
  46.                                 .set(TRANS_KEY_REMOTE_IP, remoteIp).set(TRANS_KEY_REMOTE_PORT, remotePort)
  47.                                 .set(TRANS_KEY_LOCAL_PORT, localPort).build();
  48.                         String connectionId = attrWrapper.get(TRANS_KEY_CONN_ID);
  49.                         Loggers.REMOTE_DIGEST.info("Connection transportReady,connectionId = {} ", connectionId);
  50.                         return attrWrapper;
  51.                         
  52.                     }
  53.                     
  54.                     @Override
  55.                     public void transportTerminated(Attributes transportAttrs) {
  56.                         String connectionId = null;
  57.                         try {
  58.                             connectionId = transportAttrs.get(TRANS_KEY_CONN_ID);
  59.                         } catch (Exception e) {
  60.                             // Ignore
  61.                         }
  62.                         if (StringUtils.isNotBlank(connectionId)) {
  63.                             Loggers.REMOTE_DIGEST
  64.                                     .info("Connection transportTerminated,connectionId = {} ", connectionId);
  65.                             // 注销连接
  66.                             connectionManager.unregister(connectionId);
  67.                         }
  68.                     }
  69.                 }).build();
  70.         // 启动grpc服务
  71.         server.start();
  72.     }
  73.  
  74.  
  75. private void addServices(MutableHandlerRegistry handlerRegistry, ServerInterceptor... serverInterceptor) {
  76.         
  77.         // unary common call register.
  78.         final MethodDescriptor<Payload, Payload> unaryPayloadMethod = MethodDescriptor.<Payload, Payload>newBuilder()
  79.                 .setType(MethodDescriptor.MethodType.UNARY)
  80.                 .setFullMethodName(MethodDescriptor.generateFullMethodName(REQUEST_SERVICE_NAME, REQUEST_METHOD_NAME))
  81.                 .setRequestMarshaller(ProtoUtils.marshaller(Payload.getDefaultInstance()))
  82.                 .setResponseMarshaller(ProtoUtils.marshaller(Payload.getDefaultInstance())).build();
  83.         // 定义服务处理方法回调
  84.         final ServerCallHandler<Payload, Payload> payloadHandler = ServerCalls
  85.                 .asyncUnaryCall((request, responseObserver) -> {
  86.                     grpcCommonRequestAcceptor.request(request, responseObserver);
  87.                 });
  88.         // 定义Service
  89.         final ServerServiceDefinition serviceDefOfUnaryPayload = ServerServiceDefinition.builder(REQUEST_SERVICE_NAME)
  90.                 .addMethod(unaryPayloadMethod, payloadHandler).build();
  91.         handlerRegistry.addService(ServerInterceptors.intercept(serviceDefOfUnaryPayload, serverInterceptor));
  92.         
  93.         // bi stream register.
  94.         // 定义bi注册器回调
  95.         final ServerCallHandler<Payload, Payload> biStreamHandler = ServerCalls.asyncBidiStreamingCall(
  96.                 (responseObserver) -> grpcBiStreamRequestAcceptor.requestBiStream(responseObserver));
  97.         
  98.         final MethodDescriptor<Payload, Payload> biStreamMethod = MethodDescriptor.<Payload, Payload>newBuilder()
  99.                 .setType(MethodDescriptor.MethodType.BIDI_STREAMING).setFullMethodName(MethodDescriptor
  100.                         .generateFullMethodName(REQUEST_BI_STREAM_SERVICE_NAME, REQUEST_BI_STREAM_METHOD_NAME))
  101.                 .setRequestMarshaller(ProtoUtils.marshaller(Payload.newBuilder().build()))
  102.                 .setResponseMarshaller(ProtoUtils.marshaller(Payload.getDefaultInstance())).build();
  103.         
  104.         final ServerServiceDefinition serviceDefOfBiStream = ServerServiceDefinition
  105.                 .builder(REQUEST_BI_STREAM_SERVICE_NAME).addMethod(biStreamMethod, biStreamHandler).build();
  106.         handlerRegistry.addService(ServerInterceptors.intercept(serviceDefOfBiStream, serverInterceptor));
  107.         
  108.     }

以上方法都是grpc的封装，具体这里就不说明了，不懂的可以先学习一下grpc相关知识。

2.4、ConnectionManager注册

ConnectionManager的主要作用是注册客户端连接实例，用来做一些客户端权限验证。下面我们来看看客户端是如何注册的。

之前在介绍grpc客户端的时候，在GrpcClient类中的connectToServer方法中，有向grpc服务端去注册的方法，我这里稍微删减了一些，如下代码

  1. StreamObserver<Payload> payloadStreamObserver = bindRequestStream(biRequestStreamStub, grpcConn);
  2.  
  3.                 // stream observer to send response to server
  4.                 grpcConn.setPayloadStreamObserver(payloadStreamObserver);
  5.                 grpcConn.setGrpcFutureServiceStub(newChannelStubTemp);
  6.                 grpcConn.setChannel((ManagedChannel) newChannelStubTemp.getChannel());
  7.                 //send a  setup request.
  8.                 // 构建请求数据（用于注册到服务端的connectionManager中）
  9.                 ConnectionSetupRequest conSetupRequest = new ConnectionSetupRequest();
  10.                 conSetupRequest.setClientVersion(VersionUtils.getFullClientVersion());
  11.                 conSetupRequest.setLabels(super.getLabels());
  12.                 conSetupRequest.setAbilities(super.clientAbilities);
  13.                 conSetupRequest.setTenant(super.getTenant());
  14.                 grpcConn.sendRequest(conSetupRequest);

在执行grpcConn.sendRequest(conSetupRequest);的时候，实际上是调用了payloadStreamObserver的onNext来发送数据到服务端到。源码如下图

 下面我们来看看服务端是怎么接收的。服务端接收代码如下：

  1. public void onNext(Payload payload) {
  2.                 
  3.                 clientIp = payload.getMetadata().getClientIp();
  4.                 traceDetailIfNecessary(payload);
  5.                 
  6.                 Object parseObj;
  7.                 try {
  8.                     parseObj = GrpcUtils.parse(payload);
  9.                 } catch (Throwable throwable) {
  10.                     Loggers.REMOTE_DIGEST
  11.                             .warn("[{}]Grpc request bi stream,payload parse error={}", connectionId, throwable);
  12.                     return;
  13.                 }
  14.                 
  15.                 if (parseObj == null) {
  16.                     Loggers.REMOTE_DIGEST
  17.                             .warn("[{}]Grpc request bi stream,payload parse null ,body={},meta={}", connectionId,
  18.                                     payload.getBody().getValue().toStringUtf8(), payload.getMetadata());
  19.                     return;
  20.                 }
  21.                 if (parseObj instanceof ConnectionSetupRequest) {
  22.                     ConnectionSetupRequest setUpRequest = (ConnectionSetupRequest) parseObj;
  23.                     Map<String, String> labels = setUpRequest.getLabels();
  24.                     String appName = "-";
  25.                     if (labels != null && labels.containsKey(Constants.APPNAME)) {
  26.                         appName = labels.get(Constants.APPNAME);
  27.                     }
  28.                     // 构建连接元数据对象
  29.                     // clientId默认是客户端的ip
  30.                     ConnectionMeta metaInfo = new ConnectionMeta(connectionId, payload.getMetadata().getClientIp(),
  31.                             remoteIp, remotePort, localPort, ConnectionType.GRPC.getType(),
  32.                             setUpRequest.getClientVersion(), appName, setUpRequest.getLabels());
  33.                     metaInfo.setTenant(setUpRequest.getTenant());
  34.                     // 创建连接对象
  35.                     Connection connection = new GrpcConnection(metaInfo, responseObserver, CONTEXT_KEY_CHANNEL.get());
  36.                     connection.setAbilities(setUpRequest.getAbilities());
  37.                     boolean rejectSdkOnStarting = metaInfo.isSdkSource() && !ApplicationUtils.isStarted();
  38.                     // 需要重连的情况有如下：
  39.                     // 1、客户端是sdk单机的，并且nacos服务没有启动完成
  40.                     // 2、客户端是sdk单机的，并且nacos服务启动完成了，但是注册失败
  41.                     // 3、客户端是集群的，不管有没有启动完成，但是注册失败
  42.                     if (rejectSdkOnStarting || !connectionManager.register(connectionId, connection)) {
  43.                         //Not register to the connection manager if current server is over limit or server is starting.
  44.                         try {
  45.                             Loggers.REMOTE_DIGEST.warn("[{}]Connection register fail,reason:{}", connectionId,
  46.                                     rejectSdkOnStarting ? " server is not started" : " server is over limited.");
  47.                             // 如果注册失败，则给服务端返回ConnectResetRequest进行重连
  48.                             connection.request(new ConnectResetRequest(), 3000L);
  49.                             connection.close();
  50.                         } catch (Exception e) {
  51.                             //Do nothing.
  52.                             if (connectionManager.traced(clientIp)) {
  53.                                 Loggers.REMOTE_DIGEST
  54.                                         .warn("[{}]Send connect reset request error,error={}", connectionId, e);
  55.                             }
  56.                         }
  57.                     }
  58.                     
  59.                 } else if (parseObj instanceof Response) {
  60.                     Response response = (Response) parseObj;
  61.                     if (connectionManager.traced(clientIp)) {
  62.                         Loggers.REMOTE_DIGEST
  63.                                 .warn("[{}]Receive response of server request  ,response={}", connectionId, response);
  64.                     }
  65.                     RpcAckCallbackSynchronizer.ackNotify(connectionId, response);
  66.                     connectionManager.refreshActiveTime(connectionId);
  67.                 } else {
  68.                     Loggers.REMOTE_DIGEST
  69.                             .warn("[{}]Grpc request bi stream,unknown payload receive ,parseObj={}", connectionId,
  70.                                     parseObj);
  71.                 }
  72.                 
  73.             }

由于客户端发送的请求类型是ConnectionSetupRequest，那么会进入if去构建connection，然后注册到connectionManager中去。如果无法注册，那么给客户端发送重连的请求。

下面我们看看客户端怎么处理服务端发送的ConnectResetRequest请求的。客户端接收代码如下：

  1. public void onNext(Payload payload) {
  2.                 // 接受服务端请求
  3.                 LoggerUtils.printIfDebugEnabled(LOGGER, "[{}]Stream server request receive, original info: {}",
  4.                         grpcConn.getConnectionId(), payload.toString());
  5.                 try {
  6.                     Object parseBody = GrpcUtils.parse(payload);
  7.                     final Request request = (Request) parseBody;
  8.                     if (request != null) {
  9.  
  10.                         try {
  11.                             // 处理服务器请求数据
  12.                             Response response = handleServerRequest(request);
  13.                             if (response != null) {
  14.                                 response.setRequestId(request.getRequestId());
  15.                                 sendResponse(response);
  16.                             } else {
  17.                                 LOGGER.warn("[{}]Fail to process server request, ackId->{}", grpcConn.getConnectionId(),
  18.                                         request.getRequestId());
  19.                             }
  20.  
  21.                         } catch (Exception e) {
  22.                             LoggerUtils.printIfErrorEnabled(LOGGER, "[{}]Handle server request exception: {}",
  23.                                     grpcConn.getConnectionId(), payload.toString(), e.getMessage());
  24.                             sendResponse(request.getRequestId(), false);
  25.                         }
  26.  
  27.                     }
  28.  
  29.                 } catch (Exception e) {
  30.  
  31.                     LoggerUtils.printIfErrorEnabled(LOGGER, "[{}]Error to process server push response: {}",
  32.                             grpcConn.getConnectionId(), payload.getBody().getValue().toStringUtf8());
  33.                 }
  34.  
  35.  
  36.  
  37. public Response requestReply(Request request) {
  38.  
  39.             if (request instanceof ConnectResetRequest) {
  40.  
  41.                 try {
  42.                     synchronized (RpcClient.this) {
  43.                         // 判断是否在运行中
  44.                         if (isRunning()) {
  45.                             ConnectResetRequest connectResetRequest = (ConnectResetRequest) request;
  46.                             if (StringUtils.isNotBlank(connectResetRequest.getServerIp())) {
  47.                                 ServerInfo serverInfo = resolveServerInfo(
  48.                                         connectResetRequest.getServerIp() + Constants.COLON + connectResetRequest
  49.                                                 .getServerPort());
  50.                                 switchServerAsync(serverInfo, false);
  51.                             } else {
  52.                                 // 往reconnectionSignal中设置空的重连上下文
  53.                                 switchServerAsync();
  54.                             }
  55.                         }
  56.                     }
  57.                 } catch (Exception e) {
  58.                     LoggerUtils.printIfErrorEnabled(LOGGER, "[{}]Switch server error ,{}", name, e);
  59.                 }
  60.                 return new ConnectResetResponse();
  61.             }
  62.             return null;
  63.         }

在接收到请求后，如果处理成功，则会给服务端返回一个response，服务端接收到response后会刷新连接到存活时间等操作（这段代码在这个逻辑下实际上是没什么用的，主要还是为了适配其他地方的调用逻辑），如下图所示

下面我们来看看 ConnectionManager类中的registry方法，代码如下：

  1. public synchronized boolean register(String connectionId, Connection connection) {
  2.         
  3.         if (connection.isConnected()) {
  4.             // 如果已经存在，则直接注册成功
  5.             if (connections.containsKey(connectionId)) {
  6.                 return true;
  7.             }
  8.             // 检查客户端限制规则
  9.             if (!checkLimit(connection)) {
  10.                 return false;
  11.             }
  12.             if (traced(connection.getMetaInfo().clientIp)) {
  13.                 connection.setTraced(true);
  14.             }
  15.             connections.put(connectionId, connection);
  16.             // 递增
  17.             connectionForClientIp.get(connection.getMetaInfo().clientIp).getAndIncrement();
  18.             // 发送连接成功事件
  19.             clientConnectionEventListenerRegistry.notifyClientConnected(connection);
  20.             Loggers.REMOTE_DIGEST
  21.                     .info("new connection registered successfully, connectionId = {},connection={} ", connectionId,
  22.                             connection);
  23.             return true;
  24.             
  25.         }
  26.         return false;
  27.         
  28.     }

以上代码主要是判断了下客户端是否可以注册，可以则存入到connections中去，其中有发送连接成功事件，这个在之后的distro协议篇再展开来讨论。

以上都是个人理解，如有错误恳请指正。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/weixin_40725706/article/detail/773995
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号