目錄
一、什麼是負載均衡？
負載均衡是對系統的高可用、解決網絡壓力和提升處處理能力的一種方式；我們常說的負載均衡都是指的服務器端負載均衡，其中分爲硬負載均衡和如負載均衡。負載均衡模塊會維護一個下掛可用的服務端清單，通過心跳檢查來剔除故障的服務端節點以保證清單中的都是可以正常訪問的服務端節點；當客戶端發送請求到負載均衡設備時，其會根據某種算法（輪詢、隨機等）從清單中取出一臺服務端地址，然後進行轉發。
二、硬負載均衡和軟負載均衡
硬負載均衡：主要通過在服務器節點之間安裝專門用於負載均衡的設備，例如F5、A10等；
軟負載均衡：主要就是通過在服務器上安裝具有均衡負載功能或者模塊的軟件來完成請求分發的工作，例如Nginx等。
架構圖如下：
三、客戶端負載均衡和服務端負載均衡區別
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函數做了進一步封裝，我們可以直接返回對象類型或者其他類型。
（二）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，其不要指定返回類型。
（三）、PUT和DELETE請求不做分析
五、源碼分析
1、Ribbon如何通過RestTemplate實現客戶端負載均衡的？
我們通過@LoadBalanced的源碼可以找到LoadBalancerClient，它的唯一實現類RibbonLoadBalancerClient，它重寫了一些方法，如圖：
其中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：獲取當前正在服務的實例列表。
該接口的實現結構如圖：
通過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接口的各個實現：
通過圖有關係我們可以發現，其中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結合
參照文檔
（四）、重試機制
參照文檔