Ribbon's loadbalancerclient, zoneawareloadbalancer and zoneavoidancerule are three musketeers by default

1.RibbonLoadBalancerClient From above

stay ribbon in LoadBalanceClient There is only one subclass , This subclass is RibbonLoadBalancerClient. It is from LoadBalancerInterceptor Accept the request , Enter the real load balancing process .

2.RibbonLoadBalancerClient What did you do ？

1. Get load balancer ILoadBalancer
2. Select services according to load balancer and rules （chooseServer）
3. Record each serviceId The state of RibbonStatsRecorder
4. perform request Request and return the result T returnVal = request.apply(serviceInstance);

3. Get load balancer getLoadBalancer(serviceId)

Here we see through serviceId Obtain the load balancer , That means every service （ Contains multiple service instances ） You should have your own load balancer , There should be some mechanisms to maintain the list of services , There are corresponding load balancing strategies , And the data maintenance required by the load balancing strategy .

adopt debug, I found it through AnnotationConfigApplicationContext For maintenance. , Then from the inside according to service Type to get the corresponding instance information .

See here that the default load balancer is ZoneAwareLoadBalancer

Where is the load balancer initialized ？ I will write a separate article on this later , I'll skip here first .

4.ZoneAwareLoadBalancer How to choose services

public Server chooseServer(Object key) {
    
				//  We know that every service has a load balancer , Here is the load balancing statistic for each service 
				//  See how many requests load balancing has been done 
        if (counter == null) {
    
            counter = createCounter();
        }
        counter.increment();
        if (rule == null) {
    
            return null;
        } else {
    
            try {
    
								//  EH , Here comes the rule selection 
                return rule.choose(key);
            } catch (Exception e) {
    
                logger.warn("LoadBalancer [{}]: Error choosing server for key {}", name, key, e);
                return null;
            }
        }
    }

Here we can see that the default load balancing policy is ZoneAvoidanceRule

5.ZoneAvoidanceRule How to choose services ？

public Server choose(Object key) {
    
        ILoadBalancer lb = getLoadBalancer();
				//  This completes the selection of services 
				//  And we can see , there lb.getAllServers  explain ILoadBalancer Directly or indirectly stores the service list 
        Optional<Server> server = getPredicate().chooseRoundRobinAfterFiltering(lb.getAllServers(), key);
        if (server.isPresent()) {
    
            return server.get();
        } else {
    
            return null;
        }       
    }

You can see from above chooseRoundRobinAfterFiltering This method means after filtering , Select the load balancing method of polling .

and lb.getAllServers Is to get all service instances of this service .

thus it can be seen chooseRoundRobinAfterFiltering Is the key point of choice .

public Optional<Server> chooseRoundRobinAfterFiltering(List<Server> servers, Object loadBalancerKey) {
    
        //  Filter out service instances without composite conditions 
				List<Server> eligible = getEligibleServers(servers, loadBalancerKey);
        if (eligible.size() == 0) {
    
            return Optional.absent();
        }
				// incrementAndGetModulo  This is the key calculation of polling 
        return Optional.of(eligible.get(incrementAndGetModulo(eligible.size())));
    }

The calculation process is relatively simple

//  This is the next time the current rule is stored 
private final AtomicInteger nextIndex = new AtomicInteger();

private int incrementAndGetModulo(int modulo) {
    
        for (;;) {
    
            int current = nextIndex.get();
						//  modulus 
            int next = (current + 1) % modulo;
						//  Reset next The pointer 
            if (nextIndex.compareAndSet(current, next) && current < modulo)
                return current;
        }
    }

In fact, the load balancing of polling mode is in n Servers are accessed in order , By taking a mold nextIndex Never greater than modulo The situation of .

Here, choose which service instance to use Server after , How to link ServiceProvider Replace the service name with Server Medium ip And ports ？

6. Service name to ip+ Port procedure

1. Encapsulate the obtained service instance into RibbonServer（ServiceInstance Subclasses of ）

2.LoadBalancerRequest.apply Encapsulate the service instance into HttpRequest Subclasses of ServiceRequestWrapper in

3. Hold ServiceRequestWrapper go back to InterceptionClientHttpRequest Continue to execute , stay getURI Method completes the service name to ip And port replacement process .

7. Replacement details

@Override
	public URI reconstructURI(ServiceInstance instance, URI original) {
    
		//  Get an example ID
		Assert.notNull(instance, "instance can not be null");
		String serviceId = instance.getServiceId();
		//  Get the context of the load balancer 
		RibbonLoadBalancerContext context = this.clientFactory
				.getLoadBalancerContext(serviceId);

		URI uri;
		Server server;
		if (instance instanceof RibbonServer) {
    
			RibbonServer ribbonServer = (RibbonServer) instance;
			server = ribbonServer.getServer();
			//  Determine whether to use the secure connection 
			uri = updateToSecureConnectionIfNeeded(original, ribbonServer);
		} else {
    
			server = new Server(instance.getScheme(), instance.getHost(), instance.getPort());
			IClientConfig clientConfig = clientFactory.getClientConfig(serviceId);
			ServerIntrospector serverIntrospector = serverIntrospector(serviceId);
			uri = updateToSecureConnectionIfNeeded(original, clientConfig,
					serverIntrospector, server);
		}
		//  Take the service instance information and the one with the service name uri Go to replace and return 
		return context.reconstructURIWithServer(server, uri);
	}

Start replacing

public URI reconstructURIWithServer(Server server, URI original) {
    
        String host = server.getHost();
        int port = server.getPort();
        String scheme = server.getScheme();
        //  check url Is it consistent with the information in the service instance 
        if (host.equals(original.getHost()) 
                && port == original.getPort()
                && scheme == original.getScheme()) {
    
            return original;
        }
				//  Get the request protocol prefix 
        if (scheme == null) {
    
            scheme = original.getScheme();
        }
        if (scheme == null) {
    
            scheme = deriveSchemeAndPortFromPartialUri(original).first();
        }

        try {
    
            StringBuilder sb = new StringBuilder();
						//  Protocol splicing 
            sb.append(scheme).append("://");
            if (!Strings.isNullOrEmpty(original.getRawUserInfo())) {
    
                sb.append(original.getRawUserInfo()).append("@");
            }
						//  Domain name or ip Splicing 
            sb.append(host);
            // Port integration 
						if (port >= 0) {
    
                sb.append(":").append(port);
            }
						//  Spell parameters 
            sb.append(original.getRawPath());
            if (!Strings.isNullOrEmpty(original.getRawQuery())) {
    
                sb.append("?").append(original.getRawQuery());
            }
            if (!Strings.isNullOrEmpty(original.getRawFragment())) {
    
                sb.append("#").append(original.getRawFragment());
            }
            URI newURI = new URI(sb.toString());
            return newURI;            
        } catch (URISyntaxException e) {
    
            throw new RuntimeException(e);
        }
    }

In this way, a new link is spliced to send http Request the .

8. Summary

In fact, here will be the whole ribbon Intercept restTemplate I combed the process in detail . We may study it later , How to get the service list , How to update and maintain . There are also different load balancing strategies and how different load balancers play .