In 6. Above, create the dependency element of LoadBalancer, the instance instance table of ServerList target service, and the specific service discovery client implementation. Let's take a look at the implementation of Nacos

public class NacosServerList extends AbstractServerList<NacosServer> {
    @Override
    public List<NacosServer> getInitialListOfServers() {
        return getServers();
    }

    @Override
    public List<NacosServer> getUpdatedListOfServers() {
        return getServers();
    }

    private List<NacosServer> getServers() {
        String group = discoveryProperties.getGroup();
        //Call Nacos SDK to query the instance list
        List<Instance> instances = discoveryProperties.namingServiceInstance()
                .selectInstances(serviceId, group, true);
        // Type conversion
        return instancesToServerList(instances);

    }
}

• • updateAction implementation

  public void doUpdate() {
  	DynamicServerListLoadBalancer.this.updateListOfServers();
  }
  Copy code

  public class PollingServerListUpdater implements ServerListUpdater {
      public void updateListOfServers() {
          List<T> servers = new ArrayList();
          
          // Call NacosServiceList to get the list of all services
          servers = this.serverListImpl.getUpdatedListOfServers();
          
          // If the configuration instance filter is performing filtering
          if (this.filter != null) {
              servers = this.filter.getFilteredListOfServers((List)servers);
          }
          
          // Update LoadBalancer service list
          this.updateAllServerList((List)servers);
      }
  }

  Extensions: Server state maintenance

  

  • setupPingTask() is triggered when LoadBalancer is initially constructed

  public BaseLoadBalancer() {
    this.name = DEFAULT_NAME;
    this.ping = null;
    setRule(DEFAULT_RULE);
    // Enable ping check task
    setupPingTask();
    lbStats = new LoadBalancerStats(DEFAULT_NAME);
  }

  • setupPingTask

  void setupPingTask() {
    // Whether it is possible to ping. The default DummyPing directly skips not to execute
    if (canSkipPing()) {
      return;
    }
    // Execute PingTask
    lbTimer.schedule(new BaseLoadBalancer.PingTask(), 0, pingIntervalSeconds * 1000);
    // Open task
    new BaseLoadBalancer.Pinger(pingStrategy).runPinger();
  }

  • SerialPingStrategy serial execution logic

  // Serial scheduling execution of Iping logic
  private static class SerialPingStrategy implements IPingStrategy {
    @Override
    public boolean[] pingServers(IPing ping, Server[] servers) {
      int numCandidates = servers.length;
      boolean[] results = new boolean[numCandidates];
  
      for (int i = 0; i < numCandidates; i++) {
        results[i] = false; /* Default answer is DEAD. */
        if (ping != null) {
          results[i] = ping.isAlive(servers[i]);
        }
  
      }
      return results;
    }
  }

  • Call url to judge availability

  public class PingUrl implements IPing {
      public boolean isAlive(Server server) {
          urlStr = urlStr + server.getId();
          urlStr = urlStr + this.getPingAppendString();
          boolean isAlive = false;
          HttpClient httpClient = new DefaultHttpClient();
          HttpUriRequest getRequest = new HttpGet(urlStr);
          String content = null;
  
          HttpResponse response = httpClient.execute(getRequest);
          content = EntityUtils.toString(response.getEntity());
          isAlive = response.getStatusLine().getStatusCode() == 200;
          return isAlive;
      }
  }

  Extension: RibbonClient lazy load processing

  It can be seen from the above that by default, the Ribbon will not create a LoadBalancer until the first request. This lazy loading mechanism will cause the delay of the first call to the service after the service is started, and even lead to the timeout fuse of the integrated circuit breaker (hystrix).

  To solve this problem, we will configure the hungry loading of Ribbon

  ribbon:
    eager-load:
      clients:
        - provider

  • After the RibbonApplicationContextInitializer service is started, it automatically calls the factory to create the required ribbon clients in advance

  public class RibbonApplicationContextInitializer
          implements ApplicationListener<ApplicationReadyEvent> {
      private final List<String> clientNames;
  
      protected void initialize() {
          if (clientNames != null) {
              for (String clientName : clientNames) {
                  this.springClientFactory.getContext(clientName);
              }
          }
      }
      @Override
      public void onApplicationEvent(ApplicationReadyEvent event) {
          initialize();
      }
  
  }

  All of the above are my own thoughts. You are welcome to share them. By the way, please pay attention to them. Partners with ideas can comment or send me private letters~