Spring Cloud学习之六 Ribbon 客户端负载均衡

谁践踏了优雅 2023-05-30 09:24 8阅读 0赞

**目录**

一、什么是负载均衡？

二、硬负载均衡和软负载均衡

三、客户端负载均衡和服务端负载均衡区别

四、RestTemplate

五、源码分析

六、负载均衡器

七、负载均衡策略

八、配置

--------------------

### **一、什么是负载均衡？** ###

负载均衡是对系统的高可用、解决网络压力和提升处处理能力的一种方式；我们常说的负载均衡都是指的服务器端负载均衡，其中分为硬负载均衡和如负载均衡。负载均衡模块会维护一个下挂可用的服务端清单，通过心跳检查来剔除故障的服务端节点以保证清单中的都是可以正常访问的服务端节点；当客户端发送请求到负载均衡设备时，其会根据某种算法（轮询、随机等）从清单中取出一台服务端地址，然后进行转发。

### **二、硬负载均衡和软负载均衡** ###

硬负载均衡：主要通过在服务器节点之间安装专门用于负载均衡的设备，例如F5、A10等；

软负载均衡：主要就是通过在服务器上安装具有均衡负载功能或者模块的软件来完成请求分发的工作，例如Nginx等。

架构图如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjIyODk1MA_size_16_color_FFFFFF_t_70][]

### **三、客户端负载均衡和服务端负载均衡区别** ###

1、服务清单维护的位置不同；在客户端负载均衡中，所有客户端都要维护自己要访问的服务清单，清单来自于服务注册中心。在服务端负载均衡中，清单是维护在负载均衡设备的模块中。

### **四、RestTemplate** ###

通过在启动类中配置使用**RestTemplate对象，并通过@loadBalanced注解，就能够开启客户端负载均衡。**

@EnableDiscoveryClient
    @SpringBootApplication
    public class RibbonConsumerApplication {
    
    	@Bean
    	@LoadBalanced
    	RestTemplate restTemplate(){
    		return new RestTemplate();
    	};
    	public static void main(String[] args) {
    		SpringApplication.run(RibbonConsumerApplication.class, args);
    	}
    
    }

在RestTemplate中，不同的请求方式有不同的调用实现方式 ：

（一）、GET请求

@RestController
      public class ConsumerController {
    
         @Autowired
         RestTemplate restTemplate;
    
       @RequestMapping(value = "/ribbon-consumer",method = RequestMethod.GET)
       public String helloConsumer(){
            return restTemplate.getForEntity("http://indexService/index",String.class).getBody();
         }
    
        @RequestMapping(value = "/ribbon-consumer1",method = RequestMethod.GET)
        public String helloConsumer1(){
            return restTemplate.getForObject("http://indexService/index",String.class);
        }
     }

GET请求有两个函数可以调用： getForEntity和getForObject。

getForEntity函数返回的是ResponseEntity,其是spring对HTTP请求响应的封装，存储了请求状态等信息，再通过getBody()方法返回需要的类型；例如对象类型等等。具体信息可以参考文档。

getForObject函数使用更为方便,有三种不同的重载实现，其相当于对getForEntity函数做了进一步封装，我们可以直接返回对象类型或者其他类型。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjIyODk1MA_size_16_color_FFFFFF_t_70 1][]

（二）POST请求

@RequestMapping(value = "/ribbon-consumer2",method = RequestMethod.POST)
        public String helloConsumer2(){
            User user = new User();
            return restTemplate.postForEntity("http://indexService/user",user,String.class).getBody();
        }
    
        @RequestMapping(value = "/ribbon-consumer3",method = RequestMethod.POST)
        public String helloConsumer3(){
            User user = new User();
            return restTemplate.postForObject("http://indexService/user",user,String.class);
        }
    
        @RequestMapping(value = "/ribbon-consumer4",method = RequestMethod.POST)
        public URI helloConsumer4(){
            User user = new User();
            URI uri = restTemplate.postForLocation("http://indexService/user", user);
            return uri;
        }

POST请求有三个函数可以调用：postForEntity、postForObject和postForLocation。

postForEntity和postForObject函数和get请求的类似，都有三种不同的重载方法； postForLocation函数则返回了新资源的URI，其不要指定返回类型。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjIyODk1MA_size_16_color_FFFFFF_t_70 2][]

（三）、PUT和DELETE请求不做分析

### **五、源码分析** ###

1、Ribbon如何通过RestTemplate实现客户端负载均衡的？

我们通过@LoadBalanced的源码可以找到LoadBalancerClient，它的唯一实现类RibbonLoadBalancerClient，它重写了一些方法，如图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjIyODk1MA_size_16_color_FFFFFF_t_70 3][]

其中ServiceInstance choose(String serviceId)方法，根据传入的服务名serviceId，从负载均衡器中挑选一个对应的服务实例。

其中<T> T execute(String serviceId, LoadBalancerRequest<T> request)方法，使用从负载均衡器中挑选的服务实力来执行请求内容。

其中URI reconstructURI(ServiceInstance instance, URI original)方法，为系统构建一个合适的URI。

我们还可以通过LoadBalancerAutoConfiguration类来查看负载均衡器的自动化配置，源码如下：

@Configuration
    @ConditionalOnClass(RestTemplate.class)
    @ConditionalOnBean(LoadBalancerClient.class)
    @EnableConfigurationProperties(LoadBalancerRetryProperties.class)
    public class LoadBalancerAutoConfiguration {
    
    	@LoadBalanced
    	@Autowired(required = false)
    	private List<RestTemplate> restTemplates = Collections.emptyList();
    
    	@Autowired(required = false)
    	private List<LoadBalancerRequestTransformer> transformers = Collections.emptyList();
    
    	@Bean
    	public SmartInitializingSingleton loadBalancedRestTemplateInitializerDeprecated(
    			final ObjectProvider<List<RestTemplateCustomizer>> restTemplateCustomizers) {
    		return () -> restTemplateCustomizers.ifAvailable(customizers -> {
    			for (RestTemplate restTemplate : LoadBalancerAutoConfiguration.this.restTemplates) {
    				for (RestTemplateCustomizer customizer : customizers) {
    					customizer.customize(restTemplate);
    				}
    			}
    		});
    	}
    
    	@Bean
    	@ConditionalOnMissingBean
    	public LoadBalancerRequestFactory loadBalancerRequestFactory(
    			LoadBalancerClient loadBalancerClient) {
    		return new LoadBalancerRequestFactory(loadBalancerClient, this.transformers);
    	}
    
    	@Configuration
    	@ConditionalOnMissingClass("org.springframework.retry.support.RetryTemplate")
    	static class LoadBalancerInterceptorConfig {
    
    		@Bean
    		public LoadBalancerInterceptor ribbonInterceptor(
    				LoadBalancerClient loadBalancerClient,
    				LoadBalancerRequestFactory requestFactory) {
    			return new LoadBalancerInterceptor(loadBalancerClient, requestFactory);
    		}
    
    		@Bean
    		@ConditionalOnMissingBean
    		public RestTemplateCustomizer restTemplateCustomizer(
    				final LoadBalancerInterceptor loadBalancerInterceptor) {
    			return restTemplate -> {
    				List<ClientHttpRequestInterceptor> list = new ArrayList<>(
    						restTemplate.getInterceptors());
    				list.add(loadBalancerInterceptor);
    				restTemplate.setInterceptors(list);
    			};
    		}
    
    	}
    
    	/**
    	 * Auto configuration for retry mechanism.
    	 */
    	@Configuration
    	@ConditionalOnClass(RetryTemplate.class)
    	public static class RetryAutoConfiguration {
    
    		@Bean
    		@ConditionalOnMissingBean
    		public LoadBalancedRetryFactory loadBalancedRetryFactory() {
    			return new LoadBalancedRetryFactory() {
    			};
    		}
    
    	}
    
    	/**
    	 * Auto configuration for retry intercepting mechanism.
    	 */
    	@Configuration
    	@ConditionalOnClass(RetryTemplate.class)
    	public static class RetryInterceptorAutoConfiguration {
    
    		@Bean
    		@ConditionalOnMissingBean
    		public RetryLoadBalancerInterceptor ribbonInterceptor(
    				LoadBalancerClient loadBalancerClient,
    				LoadBalancerRetryProperties properties,
    				LoadBalancerRequestFactory requestFactory,
    				LoadBalancedRetryFactory loadBalancedRetryFactory) {
    			return new RetryLoadBalancerInterceptor(loadBalancerClient, properties,
    					requestFactory, loadBalancedRetryFactory);
    		}
    
    		@Bean
    		@ConditionalOnMissingBean
    		public RestTemplateCustomizer restTemplateCustomizer(
    				final RetryLoadBalancerInterceptor loadBalancerInterceptor) {
    			return restTemplate -> {
    				List<ClientHttpRequestInterceptor> list = new ArrayList<>(
    						restTemplate.getInterceptors());
    				list.add(loadBalancerInterceptor);
    				restTemplate.setInterceptors(list);
    			};
    		}
    
    	}
    
    }

Ribbon实现自动化配置需要满足两个条件：@ConditionalOnClass(RestTemplate.class)  RestTemplate类必须存在于当前工程中；@ConditionalOnBean(LoadBalancerClient.class) 在Bean工程中必须有LoadBalancerClient的实现Bean.

该类主要做了三件事情：

1、创建了loadBalancerInterceptor的Bean，用于实现对客户端发起的请求进行拦截，以实现客户端负载均衡。

2、创建了RestTemplateCustomizer的bean，用于给RestTemplate增加loadBalancerInterceptor拦截器。

3、维护一个被@LoadBalanced注解修饰的RestTemplate对象列表，并初始化，通过调用restTemplateCustomizer的实例来给需要客户端负载均衡的resttemplate增加loadBalancerInterceptor拦截器。

接下来我们看一下LoadBalancerInterceptor如何将resttemplate变成客户端负载均衡的，源码如下：

public class LoadBalancerInterceptor implements ClientHttpRequestInterceptor {
    
    	private LoadBalancerClient loadBalancer;
    
    	private LoadBalancerRequestFactory requestFactory;
    
    	public LoadBalancerInterceptor(LoadBalancerClient loadBalancer,
    			LoadBalancerRequestFactory requestFactory) {
    		this.loadBalancer = loadBalancer;
    		this.requestFactory = requestFactory;
    	}
    
    	public LoadBalancerInterceptor(LoadBalancerClient loadBalancer) {
    		// for backwards compatibility
    		this(loadBalancer, new LoadBalancerRequestFactory(loadBalancer));
    	}
    
    	@Override
    	public ClientHttpResponse intercept(final HttpRequest request, final byte[] body,
    			final ClientHttpRequestExecution execution) throws IOException {
    		final URI originalUri = request.getURI();
    		String serviceName = originalUri.getHost();
    		Assert.state(serviceName != null,
    				"Request URI does not contain a valid hostname: " + originalUri);
    		return this.loadBalancer.execute(serviceName,
    				this.requestFactory.createRequest(request, body, execution));
    	}
    
    }

分析源码可以看到在拦截器中注入了LoadBalancerClient的实现，当一个被@LoadBalanced注解修饰的RestTemplate对象向外发起HTTP请求时，会被LoadBalancerInterceptor类中的intercept函数所拦截。String serviceName = originalUri.getHost();获取服务名，然后调用excute函数去根据服务器名来选择实例并发起请求。

RibbonLoadBalancerClient作为具体的实现类，我们可以查看源码中的execute函数，如下：

public <T> T execute(String serviceId, LoadBalancerRequest<T> request, Object hint)
    			throws IOException {
    		ILoadBalancer loadBalancer = getLoadBalancer(serviceId);
    		Server server = getServer(loadBalancer, hint);
    		if (server == null) {
    			throw new IllegalStateException("No instances available for " + serviceId);
    		}
    		RibbonServer ribbonServer = new RibbonServer(serviceId, server,
    				isSecure(server, serviceId),
    				serverIntrospector(serviceId).getMetadata(server));
    
    		return execute(serviceId, ribbonServer, request);
    	}
    
    	@Override
    	public <T> T execute(String serviceId, ServiceInstance serviceInstance,
    			LoadBalancerRequest<T> request) throws IOException {
    		Server server = null;
    		if (serviceInstance instanceof RibbonServer) {
    			server = ((RibbonServer) serviceInstance).getServer();
    		}
    		if (server == null) {
    			throw new IllegalStateException("No instances available for " + serviceId);
    		}
    
    		RibbonLoadBalancerContext context = this.clientFactory
    				.getLoadBalancerContext(serviceId);
    		RibbonStatsRecorder statsRecorder = new RibbonStatsRecorder(context, server);
    
    		try {
    			T returnVal = request.apply(serviceInstance);
    			statsRecorder.recordStats(returnVal);
    			return returnVal;
    		}
    		// catch IOException and rethrow so RestTemplate behaves correctly
    		catch (IOException ex) {
    			statsRecorder.recordStats(ex);
    			throw ex;
    		}
    		catch (Exception ex) {
    			statsRecorder.recordStats(ex);
    			ReflectionUtils.rethrowRuntimeException(ex);
    		}
    		return null;
    	}

它通过Server server = getServer(loadBalancer, hint)获取服务实例。getServer源码如下：

protected Server getServer(ILoadBalancer loadBalancer, Object hint) {
    		if (loadBalancer == null) {
    			return null;
    		}
    		// Use 'default' on a null hint, or just pass it on?
    		return loadBalancer.chooseServer(hint != null ? hint : "default");
    	}

通过分析我们可以看到获取具体服务实例的时候并没有使用RibbonLoadBalancerClient中choose函数，而是使用了ILoadBalancer接口中定义的chooseServer函数。ILoadBalancer接口源码如下：

public interface ILoadBalancer {
    
    	/**
    	 * Initial list of servers.
    	 * This API also serves to add additional ones at a later time
    	 * The same logical server (host:port) could essentially be added multiple times
    	 * (helpful in cases where you want to give more "weightage" perhaps ..)
    	 * 
    	 * @param newServers new servers to add
    	 */
    	public void addServers(List<Server> newServers);
    	
    	/**
    	 * Choose a server from load balancer.
    	 * 
    	 * @param key An object that the load balancer may use to determine which server to return. null if 
    	 *         the load balancer does not use this parameter.
    	 * @return server chosen
    	 */
    	public Server chooseServer(Object key);
    	
    	/**
    	 * To be called by the clients of the load balancer to notify that a Server is down
    	 * else, the LB will think its still Alive until the next Ping cycle - potentially
    	 * (assuming that the LB Impl does a ping)
    	 * 
    	 * @param server Server to mark as down
    	 */
    	public void markServerDown(Server server);
    	
    	/**
    	 * @deprecated 2016-01-20 This method is deprecated in favor of the
    	 * cleaner {@link #getReachableServers} (equivalent to availableOnly=true)
    	 * and {@link #getAllServers} API (equivalent to availableOnly=false).
    	 *
    	 * Get the current list of servers.
    	 *
    	 * @param availableOnly if true, only live and available servers should be returned
    	 */
    	@Deprecated
    	public List<Server> getServerList(boolean availableOnly);
    
    	/**
    	 * @return Only the servers that are up and reachable.
         */
        public List<Server> getReachableServers();
    
        /**
         * @return All known servers, both reachable and unreachable.
         */
    	public List<Server> getAllServers();
    }

其中定义了一系列的抽象操作：

addServers：向负载均衡器中维护的实例列表增加实例；

chooseServer：通过某种策略，从清单中挑选一个服务实例；

markServerDown：用来通知和标识负载均衡器中的某个实例已经停止服务；

getServerList：获取服务实例列表；

getAllServers：获取所有服务实例列表，包含正常和停止状态的服务。

getReachableServers：获取当前正在服务的实例列表。

该接口的实现结构如图：

![20191201154518988.jpg][]

通过RibbonClientConfiguration配置类可以看出来，整合Ribbon的时候SpringCloud默认采用了ZoneAwareLoadBalancer来实现负载均衡器。

@Bean
    	@ConditionalOnMissingBean
    	public ILoadBalancer ribbonLoadBalancer(IClientConfig config,
    			ServerList<Server> serverList, ServerListFilter<Server> serverListFilter,
    			IRule rule, IPing ping, ServerListUpdater serverListUpdater) {
    		if (this.propertiesFactory.isSet(ILoadBalancer.class, name)) {
    			return this.propertiesFactory.get(ILoadBalancer.class, config, name);
    		}
    		return new ZoneAwareLoadBalancer<>(config, rule, ping, serverList,
    				serverListFilter, serverListUpdater);
    	}

接下来继续看RibbonLoadBalancerClient中的execute函数，在获取到实例之后，将其内容包装成RibbonServer对象，在使用该对象回调请求拦截器中LoadBalancerRequest的apply函数，像一个服务实例发送请求。

部分未完善。

### **六、负载均衡器** ###

这里我们主要对ILoadBalancer接口的实现类进行简单的分析：

（一）、AbstractLoadBalancer 源码如下：

public abstract class AbstractLoadBalancer implements ILoadBalancer {
        
        public enum ServerGroup{
            ALL,
            STATUS_UP,
            STATUS_NOT_UP        
        }
            
        /**
         * delegate to {@link #chooseServer(Object)} with parameter null.
         */
        public Server chooseServer() {
        	return chooseServer(null);
        }
    
        
        /**
         * List of servers that this Loadbalancer knows about
         * 
         * @param serverGroup Servers grouped by status, e.g., {@link ServerGroup#STATUS_UP}
         */
        public abstract List<Server> getServerList(ServerGroup serverGroup);
        
        /**
         * Obtain LoadBalancer related Statistics
         */
        public abstract LoadBalancerStats getLoadBalancerStats();    
    }

枚举ServerGroup包含三种类型：ALL 所有服务实例、STATUS\_UP 正常服务的实例和STATUS\_NOT\_UP 停止服务的实例。

getServerList函数根据类型获取服务实例列表。

getLoadBalancerStats函数定义了获取LoadBalancerStats对象的方法。

（二）、BaseLoadBalancer 源码太多不做展示

BaseLoadBalancer 类是Ribbon负载均衡器的基础实现类，其中定义了负载均衡器相关内容。

（三）、DynamicServerListLoadBalancer源码太多不做展示

DynamicServerListLoadBalancer是对BaseLoadBalancer类的一种拓展，是负载均衡器的服务清单在运行时能够动态更新清单，以及具有对服务实例清单的过滤功能。

（四）、ZoneAwareLoadBalancer 源码如下：

/*
    *
    * Copyright 2013 Netflix, Inc.
    *
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    *
    * http://www.apache.org/licenses/LICENSE-2.0
    *
    * Unless required by applicable law or agreed to in writing, software
    * distributed under the License is distributed on an "AS IS" BASIS,
    * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    * See the License for the specific language governing permissions and
    * limitations under the License.
    *
    */
    package com.netflix.loadbalancer;
    
    import java.util.Collections;
    import java.util.List;
    import java.util.Map;
    import java.util.Set;
    import java.util.concurrent.ConcurrentHashMap;
    
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    
    import com.google.common.annotations.VisibleForTesting;
    import com.netflix.client.ClientFactory;
    import com.netflix.client.config.IClientConfig;
    import com.netflix.config.DynamicBooleanProperty;
    import com.netflix.config.DynamicDoubleProperty;
    import com.netflix.config.DynamicPropertyFactory;
    
    /**
     * Load balancer that can avoid a zone as a whole when choosing server. 
     *<p>
     * The key metric used to measure the zone condition is Average Active Requests,
    which is aggregated per rest client per zone. It is the
    total outstanding requests in a zone divided by number of available targeted instances (excluding circuit breaker tripped instances).
    This metric is very effective when timeout occurs slowly on a bad zone.
    <p>
    The  LoadBalancer will calculate and examine zone stats of all available zones. If the Average Active Requests for any zone has reached a configured threshold, this zone will be dropped from the active server list. In case more than one zone has reached the threshold, the zone with the most active requests per server will be dropped.
    Once the the worst zone is dropped, a zone will be chosen among the rest with the probability proportional to its number of instances.
    A server will be returned from the chosen zone with a given Rule (A Rule is a load balancing strategy, for example {@link AvailabilityFilteringRule})
    For each request, the steps above will be repeated. That is to say, each zone related load balancing decisions are made at real time with the up-to-date statistics aiding the choice.
    
     * @author awang
     *
     * @param <T>
     */
    public class ZoneAwareLoadBalancer<T extends Server> extends DynamicServerListLoadBalancer<T> {
    
        private ConcurrentHashMap<String, BaseLoadBalancer> balancers = new ConcurrentHashMap<String, BaseLoadBalancer>();
        
        private static final Logger logger = LoggerFactory.getLogger(ZoneAwareLoadBalancer.class);
                
        private volatile DynamicDoubleProperty triggeringLoad;
    
        private volatile DynamicDoubleProperty triggeringBlackoutPercentage; 
    
        private static final DynamicBooleanProperty ENABLED = DynamicPropertyFactory.getInstance().getBooleanProperty("ZoneAwareNIWSDiscoveryLoadBalancer.enabled", true);
                
        void setUpServerList(List<Server> upServerList) {
            this.upServerList = upServerList;
        }
        
        public ZoneAwareLoadBalancer() {
            super();
        }
    
        @Deprecated
        public ZoneAwareLoadBalancer(IClientConfig clientConfig, IRule rule,
                IPing ping, ServerList<T> serverList, ServerListFilter<T> filter) {
            super(clientConfig, rule, ping, serverList, filter);
        }
    
        public ZoneAwareLoadBalancer(IClientConfig clientConfig, IRule rule,
                                     IPing ping, ServerList<T> serverList, ServerListFilter<T> filter,
                                     ServerListUpdater serverListUpdater) {
            super(clientConfig, rule, ping, serverList, filter, serverListUpdater);
        }
    
        public ZoneAwareLoadBalancer(IClientConfig niwsClientConfig) {
            super(niwsClientConfig);
        }
    
        @Override
        protected void setServerListForZones(Map<String, List<Server>> zoneServersMap) {
            super.setServerListForZones(zoneServersMap);
            if (balancers == null) {
                balancers = new ConcurrentHashMap<String, BaseLoadBalancer>();
            }
            for (Map.Entry<String, List<Server>> entry: zoneServersMap.entrySet()) {
            	String zone = entry.getKey().toLowerCase();
                getLoadBalancer(zone).setServersList(entry.getValue());
            }
            // check if there is any zone that no longer has a server
            // and set the list to empty so that the zone related metrics does not
            // contain stale data
            for (Map.Entry<String, BaseLoadBalancer> existingLBEntry: balancers.entrySet()) {
                if (!zoneServersMap.keySet().contains(existingLBEntry.getKey())) {
                    existingLBEntry.getValue().setServersList(Collections.emptyList());
                }
            }
        }    
            
        @Override
        public Server chooseServer(Object key) {
            if (!ENABLED.get() || getLoadBalancerStats().getAvailableZones().size() <= 1) {
                logger.debug("Zone aware logic disabled or there is only one zone");
                return super.chooseServer(key);
            }
            Server server = null;
            try {
                LoadBalancerStats lbStats = getLoadBalancerStats();
                Map<String, ZoneSnapshot> zoneSnapshot = ZoneAvoidanceRule.createSnapshot(lbStats);
                logger.debug("Zone snapshots: {}", zoneSnapshot);
                if (triggeringLoad == null) {
                    triggeringLoad = DynamicPropertyFactory.getInstance().getDoubleProperty(
                            "ZoneAwareNIWSDiscoveryLoadBalancer." + this.getName() + ".triggeringLoadPerServerThreshold", 0.2d);
                }
    
                if (triggeringBlackoutPercentage == null) {
                    triggeringBlackoutPercentage = DynamicPropertyFactory.getInstance().getDoubleProperty(
                            "ZoneAwareNIWSDiscoveryLoadBalancer." + this.getName() + ".avoidZoneWithBlackoutPercetage", 0.99999d);
                }
                Set<String> availableZones = ZoneAvoidanceRule.getAvailableZones(zoneSnapshot, triggeringLoad.get(), triggeringBlackoutPercentage.get());
                logger.debug("Available zones: {}", availableZones);
                if (availableZones != null &&  availableZones.size() < zoneSnapshot.keySet().size()) {
                    String zone = ZoneAvoidanceRule.randomChooseZone(zoneSnapshot, availableZones);
                    logger.debug("Zone chosen: {}", zone);
                    if (zone != null) {
                        BaseLoadBalancer zoneLoadBalancer = getLoadBalancer(zone);
                        server = zoneLoadBalancer.chooseServer(key);
                    }
                }
            } catch (Exception e) {
                logger.error("Error choosing server using zone aware logic for load balancer={}", name, e);
            }
            if (server != null) {
                return server;
            } else {
                logger.debug("Zone avoidance logic is not invoked.");
                return super.chooseServer(key);
            }
        }
         
        @VisibleForTesting
        BaseLoadBalancer getLoadBalancer(String zone) {
            zone = zone.toLowerCase();
            BaseLoadBalancer loadBalancer = balancers.get(zone);
            if (loadBalancer == null) {
            	// We need to create rule object for load balancer for each zone
            	IRule rule = cloneRule(this.getRule());
                loadBalancer = new BaseLoadBalancer(this.getName() + "_" + zone, rule, this.getLoadBalancerStats());
                BaseLoadBalancer prev = balancers.putIfAbsent(zone, loadBalancer);
                if (prev != null) {
                	loadBalancer = prev;
                }
            } 
            return loadBalancer;        
        }
    
        private IRule cloneRule(IRule toClone) {
        	IRule rule;
        	if (toClone == null) {
        		rule = new AvailabilityFilteringRule();
        	} else {
        		String ruleClass = toClone.getClass().getName();        		
        		try {
    				rule = (IRule) ClientFactory.instantiateInstanceWithClientConfig(ruleClass, this.getClientConfig());
    			} catch (Exception e) {
    				throw new RuntimeException("Unexpected exception creating rule for ZoneAwareLoadBalancer", e);
    			}
        	}
        	return rule;
        }
        
           
        @Override
        public void setRule(IRule rule) {
            super.setRule(rule);
            if (balancers != null) {
                for (String zone: balancers.keySet()) {
                    balancers.get(zone).setRule(cloneRule(rule));
                }
            }
        }
    }

它实际上是对DynamicServerListLoadBalancer的拓展。

### **七、负载均衡策略** ###

Ribbon实现了很多种选择策略，下图所示是IRule接口的各个实现：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjIyODk1MA_size_16_color_FFFFFF_t_70 4][]

通过图有关系我们可以发现，其中AbstractLoadBalancerRule这个类是负载均衡的抽象类，里面定义了负载均衡器ILoadBalancer对象，它能够在具体的实现选择服务策略时，获取服务信息作为依据。

public abstract class AbstractLoadBalancerRule implements IRule, IClientConfigAware {
    
        private ILoadBalancer lb;
            
        @Override
        public void setLoadBalancer(ILoadBalancer lb){
            this.lb = lb;
        }
        
        @Override
        public ILoadBalancer getLoadBalancer(){
            return lb;
        }      
    }

**RandomRule**：随机策略，即从服务实例清单中随机选择一个服务。它的具体实现如下：重写的IRule接口中的choose（Object key）函数，并调用该类下面的choose(ILoadBalancer lb, Object key)，参数中增加了一个负载均衡器对象。先通过负载均衡器对象获取可用实例列表upList和所有实例列表allList，若两个集合大小都是零的话，那么就没有服务可用，ThreadLocalRandom.current().nextInt(serverCount)函数获取一个随机值，并将该随机值当成upList的索引来返回具体实例，如果该实例是可用并且准备就绪状态则返回该实例。

public class RandomRule extends AbstractLoadBalancerRule {
    
        /**
         * Randomly choose from all living servers
         */
        @edu.umd.cs.findbugs.annotations.SuppressWarnings(value = "RCN_REDUNDANT_NULLCHECK_OF_NULL_VALUE")
        public Server choose(ILoadBalancer lb, Object key) {
            if (lb == null) {
                return null;
            }
            Server server = null;
    
            while (server == null) {
                if (Thread.interrupted()) {
                    return null;
                }
                List<Server> upList = lb.getReachableServers();
                List<Server> allList = lb.getAllServers();
    
                int serverCount = allList.size();
                if (serverCount == 0) {
                    /*
                     * No servers. End regardless of pass, because subsequent passes
                     * only get more restrictive.
                     */
                    return null;
                }
    
                int index = chooseRandomInt(serverCount);
                server = upList.get(index);
    
                if (server == null) {
                    /*
                     * The only time this should happen is if the server list were
                     * somehow trimmed. This is a transient condition. Retry after
                     * yielding.
                     */
                    Thread.yield();
                    continue;
                }
    
                if (server.isAlive()) {
                    return (server);
                }
    
                // Shouldn't actually happen.. but must be transient or a bug.
                server = null;
                Thread.yield();
            }
    
            return server;
    
        }
    
        protected int chooseRandomInt(int serverCount) {
            return ThreadLocalRandom.current().nextInt(serverCount);
        }
    
    	@Override
    	public Server choose(Object key) {
    		return choose(getLoadBalancer(), key);
    	}
    
    	@Override
    	public void initWithNiwsConfig(IClientConfig clientConfig) {
    		// TODO Auto-generated method stub
    		
    	}
    }

**RoundRobinRule**：按照线性轮询的方法依次选择每个服务实例。它的内部结构和RandomRule相似，我们可看到它增加了一个计数变量，若超过10次选择不到服务，那么就结束尝试，打印No available alive servers after 10 tries from load balancer。它和RandomRule的区别是，线性轮询的实现是通过AtomicInteger nextServerCyclicCounter对象实现的，每次进行实例选择时通过调用int nextServerIndex = incrementAndGetModulo(serverCount);函数实现递增。

public class RoundRobinRule extends AbstractLoadBalancerRule {
    
        private AtomicInteger nextServerCyclicCounter;
        private static final boolean AVAILABLE_ONLY_SERVERS = true;
        private static final boolean ALL_SERVERS = false;
    
        private static Logger log = LoggerFactory.getLogger(RoundRobinRule.class);
    
        public RoundRobinRule() {
            nextServerCyclicCounter = new AtomicInteger(0);
        }
    
        public RoundRobinRule(ILoadBalancer lb) {
            this();
            setLoadBalancer(lb);
        }
    
        public Server choose(ILoadBalancer lb, Object key) {
            if (lb == null) {
                log.warn("no load balancer");
                return null;
            }
    
            Server server = null;
            int count = 0;
            while (server == null && count++ < 10) {
                List<Server> reachableServers = lb.getReachableServers();
                List<Server> allServers = lb.getAllServers();
                int upCount = reachableServers.size();
                int serverCount = allServers.size();
    
                if ((upCount == 0) || (serverCount == 0)) {
                    log.warn("No up servers available from load balancer: " + lb);
                    return null;
                }
    
                int nextServerIndex = incrementAndGetModulo(serverCount);
                server = allServers.get(nextServerIndex);
    
                if (server == null) {
                    /* Transient. */
                    Thread.yield();
                    continue;
                }
    
                if (server.isAlive() && (server.isReadyToServe())) {
                    return (server);
                }
    
                // Next.
                server = null;
            }
    
            if (count >= 10) {
                log.warn("No available alive servers after 10 tries from load balancer: "
                        + lb);
            }
            return server;
        }
    
        /**
         * Inspired by the implementation of {@link AtomicInteger#incrementAndGet()}.
         *
         * @param modulo The modulo to bound the value of the counter.
         * @return The next value.
         */
        private int incrementAndGetModulo(int modulo) {
            for (;;) {
                int current = nextServerCyclicCounter.get();
                int next = (current + 1) % modulo;
                if (nextServerCyclicCounter.compareAndSet(current, next))
                    return next;
            }
        }
    
        @Override
        public Server choose(Object key) {
            return choose(getLoadBalancer(), key);
        }
    
        @Override
        public void initWithNiwsConfig(IClientConfig clientConfig) {
        }
    }

**RetryRule**：具备重试机制的实例选择策略。通过源码我们可以看到，其中定义了一个IRule对象，并且使用的是RoundRobinRule实例。在choose(ILoadBalancer lb, Object key) 函数中实现了对内部定义的策略进行反复尝试的策略，若期间能够选择到具体实例，则返回，若一直选择不到，则到设定的阈值是就结束然后返回null。

public class RetryRule extends AbstractLoadBalancerRule {
    	IRule subRule = new RoundRobinRule();
    	long maxRetryMillis = 500;
    
    	public RetryRule() {
    	}
    
    	public RetryRule(IRule subRule) {
    		this.subRule = (subRule != null) ? subRule : new RoundRobinRule();
    	}
    
    	public RetryRule(IRule subRule, long maxRetryMillis) {
    		this.subRule = (subRule != null) ? subRule : new RoundRobinRule();
    		this.maxRetryMillis = (maxRetryMillis > 0) ? maxRetryMillis : 500;
    	}
    
    	public void setRule(IRule subRule) {
    		this.subRule = (subRule != null) ? subRule : new RoundRobinRule();
    	}
    
    	public IRule getRule() {
    		return subRule;
    	}
    
    	public void setMaxRetryMillis(long maxRetryMillis) {
    		if (maxRetryMillis > 0) {
    			this.maxRetryMillis = maxRetryMillis;
    		} else {
    			this.maxRetryMillis = 500;
    		}
    	}
    
    	public long getMaxRetryMillis() {
    		return maxRetryMillis;
    	}
    
    	
    	
    	@Override
    	public void setLoadBalancer(ILoadBalancer lb) {		
    		super.setLoadBalancer(lb);
    		subRule.setLoadBalancer(lb);
    	}
    
    	/*
    	 * Loop if necessary. Note that the time CAN be exceeded depending on the
    	 * subRule, because we're not spawning additional threads and returning
    	 * early.
    	 */
    	public Server choose(ILoadBalancer lb, Object key) {
    		long requestTime = System.currentTimeMillis();
    		long deadline = requestTime + maxRetryMillis;
    
    		Server answer = null;
    
    		answer = subRule.choose(key);
    
    		if (((answer == null) || (!answer.isAlive()))
    				&& (System.currentTimeMillis() < deadline)) {
    
    			InterruptTask task = new InterruptTask(deadline
    					- System.currentTimeMillis());
    
    			while (!Thread.interrupted()) {
    				answer = subRule.choose(key);
    
    				if (((answer == null) || (!answer.isAlive()))
    						&& (System.currentTimeMillis() < deadline)) {
    					/* pause and retry hoping it's transient */
    					Thread.yield();
    				} else {
    					break;
    				}
    			}
    
    			task.cancel();
    		}
    
    		if ((answer == null) || (!answer.isAlive())) {
    			return null;
    		} else {
    			return answer;
    		}
    	}
    
    	@Override
    	public Server choose(Object key) {
    		return choose(getLoadBalancer(), key);
    	}
    
    	@Override
    	public void initWithNiwsConfig(IClientConfig clientConfig) {
    	}
    }

**WeightedResponseTimeRule**：是对RoundRobinRule的拓展，增加了根据实例的运行情况来计算权重，并根据权重来选择实例，可以达到更好的分配效果，它主要有三个核心：定时任务、权重计算和实例选择。

定时任务：

WeightedResponseTimeRule在初始化的时候，会通过serverWeightTimer.schedule(new DynamicServerWeightTask(), 0, serverWeightTaskTimerInterval);启动一个定时任务，用来为每个服务计算权重，默认30秒执行一次。

class DynamicServerWeightTask extends TimerTask {
            public void run() {
                ServerWeight serverWeight = new ServerWeight();
                try {
                    serverWeight.maintainWeights();
                } catch (Exception e) {
                    logger.error("Error running DynamicServerWeightTask for {}", name, e);
                }
            }
        }

权重计算：

通过源码发现private volatile List<Double> accumulatedWeights = new ArrayList<Double>();是用于存储权重的对象，该list中每个权重值所处的位置对应了负载均衡器维护的服务实例清单中所有实例在清单中的位置。

public void maintainWeights() {
                ILoadBalancer lb = getLoadBalancer();
                if (lb == null) {
                    return;
                }
                
                if (!serverWeightAssignmentInProgress.compareAndSet(false,  true))  {
                    return; 
                }
                
                try {
                    logger.info("Weight adjusting job started");
                    AbstractLoadBalancer nlb = (AbstractLoadBalancer) lb;
                    LoadBalancerStats stats = nlb.getLoadBalancerStats();
                    if (stats == null) {
                        // no statistics, nothing to do
                        return;
                    }
                    //计算所有实例的平均响应时间的总和
                    double totalResponseTime = 0;
                    // find maximal 95% response time
                    for (Server server : nlb.getAllServers()) {
                        // 如果服务实例的状态不在缓存中那么这里会进行自动加载
                        ServerStats ss = stats.getSingleServerStat(server);
                        totalResponseTime += ss.getResponseTimeAvg();
                    }
                    // weight for each server is (sum of responseTime of all servers - responseTime)
                    // so that the longer the response time, the less the weight and the less likely to be chosen
                    Double weightSoFar = 0.0;
                    
                    // create new list and hot swap the reference
                    List<Double> finalWeights = new ArrayList<Double>();
                    for (Server server : nlb.getAllServers()) {
                        ServerStats ss = stats.getSingleServerStat(server);
                        double weight = totalResponseTime - ss.getResponseTimeAvg();
                        weightSoFar += weight;
                        finalWeights.add(weightSoFar);   
                    }
                    setWeights(finalWeights);
                } catch (Exception e) {
                    logger.error("Error calculating server weights", e);
                } finally {
                    serverWeightAssignmentInProgress.set(false);
                }
    
            }

实例选择：choose函数

@Override
        public Server choose(ILoadBalancer lb, Object key) {
            if (lb == null) {
                return null;
            }
            Server server = null;
    
            while (server == null) {
                // get hold of the current reference in case it is changed from the other thread
                List<Double> currentWeights = accumulatedWeights;
                if (Thread.interrupted()) {
                    return null;
                }
                List<Server> allList = lb.getAllServers();
    
                int serverCount = allList.size();
    
                if (serverCount == 0) {
                    return null;
                }
    
                int serverIndex = 0;
    
                // last one in the list is the sum of all weights
                double maxTotalWeight = currentWeights.size() == 0 ? 0 : currentWeights.get(currentWeights.size() - 1); 
                // No server has been hit yet and total weight is not initialized
                // fallback to use round robin
                if (maxTotalWeight < 0.001d || serverCount != currentWeights.size()) {
                    server =  super.choose(getLoadBalancer(), key);
                    if(server == null) {
                        return server;
                    }
                } else {
                    // generate a random weight between 0 (inclusive) to maxTotalWeight (exclusive)
                    double randomWeight = random.nextDouble() * maxTotalWeight;
                    // pick the server index based on the randomIndex
                    int n = 0;
                    for (Double d : currentWeights) {
                        if (d >= randomWeight) {
                            serverIndex = n;
                            break;
                        } else {
                            n++;
                        }
                    }
    
                    server = allList.get(serverIndex);
                }
    
                if (server == null) {
                    /* Transient. */
                    Thread.yield();
                    continue;
                }
    
                if (server.isAlive()) {
                    return (server);
                }
    
                // Next.
                server = null;
            }
            return server;
        }

**ClientConfigEnabledRoundRobinRule**：特殊的策略。我们一般都是继承该策略，不会直接使用。BestAvailableRule、PredicateBasedRule、AvailabilityFilteringRule和ZoneAvoidanceRule都是直接或者间接继承的该策略。很多高级策略都是基于ClientConfigEnabledRoundRobinRule来实现的。（相关策略暂时不研究）

### **八、配置** ###

（一）、自动化配置

参照文档

（二）、参数配置

Ribbon的参数配置有两种方式：全局配置或者指定客户端配置

全局配置：按照ribbon.<key> = <value>格式进行配置，key代表参数名，value代表参数值。

指定客户端配置：按照<client>.ribbon.<key> = <value>格式进行配置，client代表客户端名称

（三）、与Eureka结合

参照文档

（四）、重试机制

参照文档

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjIyODk1MA_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20191130114302123.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjIyODk1MA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjIyODk1MA_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20191130145357639.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjIyODk1MA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjIyODk1MA_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20191130150127869.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjIyODk1MA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjIyODk1MA_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20191201130916100.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjIyODk1MA==,size_16,color_FFFFFF,t_70
[20191201154518988.jpg]: https://img-blog.csdnimg.cn/20191201154518988.jpg
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjIyODk1MA_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20191208145640291.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjIyODk1MA==,size_16,color_FFFFFF,t_70