文章目录
- 前言
- AbstractLoadBalancer
- BaseLoadBalancer
- DynamicServerListLoadBalancer
- ZoneAwareLoadBalancer
前言
通过前两节Spring Cloud Ribbon客户端负载均衡(一)，Spring Cloud Ribbon客户端负载均衡(二)的介绍，我们已经对SpringCloud如何使用Ribbon有了基本的了解。虽然SpringCloud中定义了LoadBalancerClient作为负载均衡器的通用接口，并且针对Ribbon实现了RibbonLoadBalancerClient，但是它在具体实现客户端负载均衡时，是通过Ribbon的ILoadBalancer接口实现的。
接下来就根据ILoadBalancer接口的实现类逐个看看它是怎样实现客户端负载均衡的。
AbstractLoadBalancer
在AbstractLoadBalancer类中定义了一个枚举类ServerGroup
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
2
3 public enum ServerGroup{
4 ALL,//所有服务实例
5 STATUS_UP,//正常服务的实例
6 STATUS_NOT_UP //停止服务的实例
7 }
8
9 public Server chooseServer() {
10 return chooseServer(null);
11 }
12//定义了根据分组类型来获取不同的服务实例的列表
13 public abstract List<Server> getServerList(ServerGroup serverGroup);
14
15 public abstract LoadBalancerStats getLoadBalancerStats();
16}
17
18
实现了一个chooseServer() 函数，该函数通过接口中的chooseServer(null)实现，表示在选择具体服务实例时忽略key的条件判断。
BaseLoadBalancer
BaseLoadBalancer类是Ribbon负载均衡器的基础实现类。
-
定义并维护了两个存储服务实例Server对象的列表，一个用于存储所有服务实例的请单，一个用于存储正常服务的实例清单。
2
3
4
5
6
7
8
2 protected volatile List<Server> allServerList = Collections
3 .synchronizedList(new ArrayList<Server>());
4 @Monitor(name = PREFIX + "UpServerList", type = DataSourceType.INFORMATIONAL)
5 protected volatile List<Server> upServerList = Collections
6 .synchronizedList(new ArrayList<Server>());
7
8
-
定义了用来存储负载均衡器各服务实例属性和统计信息的LoadBalancerStats对象
2
3
2
3
-
定义了检查服务实例是否正常服务的IPing对象，在BaseLoadBalancer中默认为null，需要在构造时注入它的具体实现。
2
3
2
3
-
定义了检查服务实例操作的执行策略对象IPingStrategy，在BaseLoadBalancer中默认使用了该类中定义的静态内部类SerialPingStrategy实现。
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
2
3 @Override
4 public boolean[] pingServers(IPing ping, Server[] servers) {
5 int numCandidates = servers.length;
6 boolean[] results = new boolean[numCandidates];
7
8 logger.debug("LoadBalancer: PingTask executing [{}] servers configured", numCandidates);
9
10 for (int i = 0; i < numCandidates; i++) {
11 results[i] = false; /* Default answer is DEAD. */
12 try {
13 if (ping != null) {
14 results[i] = ping.isAlive(servers[i]);
15 }
16 } catch (Exception e) {
17 logger.error("Exception while pinging Server: '{}'", servers[i], e);
18 }
19 }
20 return results;
21 }
22 }
23
24
- 定义了负载均衡的处理规则IRule对象
负载均衡器实际将服务实例选择任务委托给个IRule实例中的choose函数来实现。在这里默认初始化RoundRobinRule为IRule的实现对象。RoundRobinRule实现了最基本且常用的线性负载均衡规则。
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
2protected IRule rule = DEFAULT_RULE;
3
4public Server chooseServer(Object key) {
5 if (counter == null) {
6 counter = createCounter();
7 }
8 counter.increment();
9 if (rule == null) {
10 return null;
11 } else {
12 try {
13 return rule.choose(key);
14 } catch (Exception e) {
15 logger.warn("LoadBalancer [{}]: Error choosing server for key {}", name, key, e);
16 return null;
17 }
18 }
19 }
20
21
-
启动ping任务：在BaseLoadBalancer的默认构造函数中，会直接启动一个用于定时检查Server是否健康的任务，执行间隔为10s
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
2protected int pingIntervalSeconds = 10;
3public BaseLoadBalancer() {
4 this.name = DEFAULT_NAME;
5 this.ping = null;
6 setRule(DEFAULT_RULE);
7 setupPingTask();
8 lbStats = new LoadBalancerStats(DEFAULT_NAME);
9 }
10public void setRule(IRule rule) {
11 if (rule != null) {
12 this.rule = rule;
13 } else {
14 /* default rule */
15 this.rule = new RoundRobinRule();
16 }
17 if (this.rule.getLoadBalancer() != this) {
18 this.rule.setLoadBalancer(this);
19 }
20 }
21 void setupPingTask() {
22 if (canSkipPing()) {
23 return;
24 }
25 if (lbTimer != null) {
26 lbTimer.cancel();
27 }
28 lbTimer = new ShutdownEnabledTimer("NFLoadBalancer-PingTimer-" + name,
29 true);
30 lbTimer.schedule(new PingTask(), 0, pingIntervalSeconds * 1000);
31 forceQuickPing();
32 }
33
34
DynamicServerListLoadBalancer
DynamicServerListLoadBalancer 类继承于BaseLoadBalancer类，它是对基础负载均衡器的扩展。
- ServerList
在DynamicServerListLoadBalancer的成员变量中有一个关于服务列表的操作对象ServerList serverListImpl，其中泛型T从类名中对于T的限定DynamicServerListLoadBalancer可以获知它是一个Server的子类。
2
3
4
5
6
7
8
2 //用于获取初始化的服务实例清单
3 public List<T> getInitialListOfServers();
4 //用于获取更新的服务实例清单
5 public List<T> getUpdatedListOfServers();
6}
7
8
我们发现在DynamicServerListLoadBalancer类中updateListOfServers()方法中调用了getUpdatedListOfServers()函数，
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
2 List<T> servers = new ArrayList<T>();
3 if (serverListImpl != null) {
4 servers = serverListImpl.getUpdatedListOfServers();
5 LOGGER.debug("List of Servers for {} obtained from Discovery client: {}",
6 getIdentifier(), servers);
7
8 if (filter != null) {
9 servers = filter.getFilteredListOfServers(servers);
10 LOGGER.debug("Filtered List of Servers for {} obtained from Discovery client: {}",
11 getIdentifier(), servers);
12 }
13 }
14 updateAllServerList(servers);
15 }
16
17
然后我们再来看这个getUpdatedListOfServers都有哪些实现。
从上图中我们可以看到有多个ServerList的实现类，那么在DynamicServerListLoadBalancer中的ServerList默认配置到底使用了哪个具体实现呢?既然在该负载均衡器中需要实现服务实例的动态更新，那么势必需要Ribbon具备访问Eurake来获取服务实例的能力，所以我们从SpringCloud整合Ribbon与Eurake的包org.springframework.cloud.netflix.ribbon.eureka下可以找到配置类EurekaRibbonClientConfiguration，在该类中可以找到如下创建ServerList实例的内容
2
3
4
5
6
7
8
9
10
11
12
13
14
2 @ConditionalOnMissingBean
3 public ServerList<?> ribbonServerList(IClientConfig config, Provider<EurekaClient> eurekaClientProvider) {
4 if (this.propertiesFactory.isSet(ServerList.class, serviceId)) {
5 return this.propertiesFactory.get(ServerList.class, config, serviceId);
6 }
7 DiscoveryEnabledNIWSServerList discoveryServerList = new DiscoveryEnabledNIWSServerList(
8 config, eurekaClientProvider);
9 DomainExtractingServerList serverList = new DomainExtractingServerList(
10 discoveryServerList, config, this.approximateZoneFromHostname);
11 return serverList;
12 }
13
14
不难发现，这里创建了一个DomainExtractingServerList 实例，在DomainExtractingServerList类中我们可以看到它定义了一个ServerList list，同时DomainExtractingServerList类中对getInitialListOfServers()和getUpdatedListOfServers()的具体实现，其实是委托给了内部定义的ServerList对象，而该对象是通过创建DomainExtractingServerList 时由构造函数传入的DiscoveryEnabledNIWSServerList 实现的。
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
2
3 private ServerList<DiscoveryEnabledServer> list;
4 private final RibbonProperties ribbon;
5
6 private boolean approximateZoneFromHostname;
7
8 public DomainExtractingServerList(ServerList<DiscoveryEnabledServer> list,
9 IClientConfig clientConfig, boolean approximateZoneFromHostname) {
10 this.list = list;
11 this.ribbon = RibbonProperties.from(clientConfig);
12 this.approximateZoneFromHostname = approximateZoneFromHostname;
13 }
14
15 @Override
16 public List<DiscoveryEnabledServer> getInitialListOfServers() {
17 List<DiscoveryEnabledServer> servers = setZones(this.list
18 .getInitialListOfServers());
19 return servers;
20 }
21
22 @Override
23 public List<DiscoveryEnabledServer> getUpdatedListOfServers() {
24 List<DiscoveryEnabledServer> servers = setZones(this.list
25 .getUpdatedListOfServers());
26 return servers;
27 }
28 ...
29}
30
31
那就来看看DiscoveryEnabledNIWSServerList是如果实现这两个服务实例获取的
2
3
4
5
6
7
8
9
10
11
2 public List<DiscoveryEnabledServer> getInitialListOfServers(){
3 return obtainServersViaDiscovery();
4 }
5
6 @Override
7 public List<DiscoveryEnabledServer> getUpdatedListOfServers(){
8 return obtainServersViaDiscovery();
9 }
10
11
可以发现是obtainServersViaDiscovery()这个私有函数通过服务发现机制来实现服务实例的获取。
- ServerListFilter
我们来看一下DynamicServerListLoadBalancer类中ServerListFilter，在updateListOfServers函数中进行了条件不为空的判断。
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
2
3 protected final ServerListUpdater.UpdateAction updateAction = new ServerListUpdater.UpdateAction() {
4 @Override
5 public void doUpdate() {
6 updateListOfServers();
7 }
8 };
9
10@VisibleForTesting
11 public void updateListOfServers() {
12 List<T> servers = new ArrayList<T>();
13 if (serverListImpl != null) {
14 servers = serverListImpl.getUpdatedListOfServers();
15 LOGGER.debug("List of Servers for {} obtained from Discovery client: {}",
16 getIdentifier(), servers);
17
18 if (filter != null) {
19 servers = filter.getFilteredListOfServers(servers);
20 LOGGER.debug("Filtered List of Servers for {} obtained from Discovery client: {}",
21 getIdentifier(), servers);
22 }
23 }
24 updateAllServerList(servers);
25 }
26
27
ServerListFilter接口非常简单，主要用来实现对服务实例列表的过滤，来看看ServerListFilter接口的源码如下：
2
3
4
5
2 public List<T> getFilteredListOfServers(List<T> servers);
3}
4
5
再来看看这个接口有哪些具体的实现
1、AbstractServerListFilter：这是一个抽象过滤器，在这里定义了过滤是需要的一个重要依据对象LoadBalancerStats，
2
3
4
5
6
7
8
9
10
11
12
13
14
15
2
3 private volatile LoadBalancerStats stats;
4
5 public void setLoadBalancerStats(LoadBalancerStats stats) {
6 this.stats = stats;
7 }
8
9 public LoadBalancerStats getLoadBalancerStats() {
10 return stats;
11 }
12
13}
14
15
2、ZoneAffinityServerListFilter：该过滤器基于“区域感知（Zone Affinity）”的方式实现服务实例的过滤，也就是说，它会根据提供服务的实例所处的区域(Zone)与消费者自身的所处区域(Zone)进行比较，过滤掉那些不是同处一个区域的实例。
2
3
4
5
6
7
8
9
10
11
12
13
14
15
2 public List<T> getFilteredListOfServers(List<T> servers) {
3 if (zone != null && (zoneAffinity || zoneExclusive) && servers !=null && servers.size() > 0){
4 List<T> filteredServers = Lists.newArrayList(Iterables.filter(
5 servers, this.zoneAffinityPredicate.getServerOnlyPredicate()));
6 if (shouldEnableZoneAffinity(filteredServers)) {
7 return filteredServers;
8 } else if (zoneAffinity) {
9 overrideCounter.increment();
10 }
11 }
12 return servers;
13 }
14
15
-
ServerListUpdater
2
3
4
5
6
7
8
9
10
2 @Override
3 public void doUpdate() {
4 updateListOfServers();
5 }
6 };
7
8 protected volatile ServerListUpdater serverListUpdater;
9
10
这个对象实现的是对ServerList的更新，在ServerListUpdater内部还定义了一个UpdateAction接口。上面定义的updateAction对象就是以匿名内部类的方式创建了一个它的具体实现，其中doUpdate实现的内容就是对ServerList的具体更新操作。
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
2
3 //updateAction的接口，它实际执行服务实例列表更新
4 public interface UpdateAction {
5 void doUpdate();
6 }
7 //启动服务更新器，传入的UpdateAction对象为更新操作的具体实现
8 void start(UpdateAction updateAction);
9 //停止服务更新器
10 void stop();
11 //获取最近的更新时间戳
12 String getLastUpdate();
13 //返回自上次更新以来经过的毫秒数
14 long getDurationSinceLastUpdateMs();
15 //返回错过的更新周期数
16 int getNumberMissedCycles();
17 //返回核心线程数
18 int getCoreThreads();
19}
20
21
而ServerListUpdate的实现类不多
- PollingServerListUpdater：动态服务列表更新的默认策略，也就是说，DynamicServerListLoadBalancer负载均衡器中国的默认实现就是它，它通过定时任务的方式进行服务列表的更新
- EurekaNotificationServerListUpdater：该更新器也可服务于DynamicServerListLoadBalancer负载均衡器，但是它的触发机制与PollingServerListUpdater不同，它需要利用Eureka的事件监听器来驱动服务列表的更新操作。
来看一下用于启动“服务更新器”的start函数源码看起
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
2 public synchronized void start(final UpdateAction updateAction) {
3 if (isActive.compareAndSet(false, true)) {
4 final Runnable wrapperRunnable = new Runnable() {
5 @Override
6 public void run() {
7 if (!isActive.get()) {
8 if (scheduledFuture != null) {
9 scheduledFuture.cancel(true);
10 }
11 return;
12 }
13 try {
14 updateAction.doUpdate();
15 lastUpdated = System.currentTimeMillis();
16 } catch (Exception e) {
17 logger.warn("Failed one update cycle", e);
18 }
19 }
20 };
21
22 scheduledFuture = getRefreshExecutor().scheduleWithFixedDelay(
23 wrapperRunnable,
24 initialDelayMs,
25 refreshIntervalMs,
26 TimeUnit.MILLISECONDS
27 );
28 } else {
29 logger.info("Already active, no-op");
30 }
31 }
32
33
以定时任务的方式进行服务列表的更新，它先创建一个Runnable的线程实现，在该实现中调用了上面提到的具体更新服务实例列表的方法updateAction.doUpdate(),最后再为这个Runnable线程实现启动一个定时任务来实现。
我们在这个 start(final UpdateAction updateAction)函数中可以看到两个重要的参数initialDelayMs和refreshIntervalMs，默认定义分别为1000和10*1000，单位毫秒。也就是说，更新服务实例在初始化之后延迟1秒后开始执行，30s为周期。
2
3
4
5
6
7
8
9
10
11
12
13
2private static int LISTOFSERVERS_CACHE_REPEAT_INTERVAL = 30 * 1000; // msecs;
3
4public PollingServerListUpdater() {
5 this(LISTOFSERVERS_CACHE_UPDATE_DELAY, LISTOFSERVERS_CACHE_REPEAT_INTERVAL);
6 }
7
8 public PollingServerListUpdater(final long initialDelayMs, final long refreshIntervalMs) {
9 this.initialDelayMs = initialDelayMs;
10 this.refreshIntervalMs = refreshIntervalMs;
11 }
12
13
ZoneAwareLoadBalancer
ZoneAwareLoadBalancer负载均衡器是对DynamicServerListLoadBalancer的扩展。在DynamicServerListLoadBalancer没有重写选择具体服务实例的chooseServer函数，它依然是采用BaseLoadBalancer中实现的算法，使用RoundRobbinRule规则，以线性轮询的方式来选择调用的服务实例，该算法没有区域（Zone）的概念，它会把所有实现视为一个Zone下的节点来看待，这样就会周期性地产生跨区域访问的情况，由于跨区域会产生更高的延迟，这些实例主要以防止区域性故障实现高可用为目的而不能作为常规访问的实例，所以在多区域部署的情况下会有一定的性能问题，而该负载均衡则可以避免这样的问题。下面我们就来看看它是怎么实现的。
在ZoneAwareLoadBalancer中，它并没有重写setServersList，说明实现服务实例清单的更新主逻辑没有修改。但是它重写了setServerListForZones(Map<String, List> zoneServersMap)函数。
先来看一下在DynamicServerListLoadBalancer中setServerListForZones函数的实现
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
2 public void setServersList(List lsrv) {
3 super.setServersList(lsrv);
4 List<T> serverList = (List<T>) lsrv;
5 Map<String, List<Server>> serversInZones = new HashMap<String, List<Server>>();
6 for (Server server : serverList) {
7 // make sure ServerStats is created to avoid creating them on hot
8 // path
9 getLoadBalancerStats().getSingleServerStat(server);
10 String zone = server.getZone();
11 if (zone != null) {
12 zone = zone.toLowerCase();
13 List<Server> servers = serversInZones.get(zone);
14 if (servers == null) {
15 servers = new ArrayList<Server>();
16 serversInZones.put(zone, servers);
17 }
18 servers.add(server);
19 }
20 }
21 setServerListForZones(serversInZones);
22 }
23
24 protected void setServerListForZones(
25 Map<String, List<Server>> zoneServersMap) {
26 LOGGER.debug("Setting server list for zones: {}", zoneServersMap);
27 getLoadBalancerStats().updateZoneServerMapping(zoneServersMap);
28 }
29
30
setServerListForZones函数的调用位于更新服务实例清单函数setServersList(List lsrv)的最后，从其实现的内容来看，在DynamicServerListLoadBalancer中的作用是根据按区域Zone分组的实例列表，为负载均衡器中的LoadBalancerStats对象创建ZoneStats并放入Map zoneStatsMap集合中，每一个区域Zone对应一个ZoneStats，它对于存储每个Zone的一些状态和统计信息。
在ZoneAwareLoadBalancer中对setServerListForZones重写如下：
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
2 protected void setServerListForZones(Map<String, List<Server>> zoneServersMap) {
3 super.setServerListForZones(zoneServersMap);
4 if (balancers == null) {
5 balancers = new ConcurrentHashMap<String, BaseLoadBalancer>();
6 }
7 for (Map.Entry<String, List<Server>> entry: zoneServersMap.entrySet()) {
8 String zone = entry.getKey().toLowerCase();
9 getLoadBalancer(zone).setServersList(entry.getValue());
10 }
11 // check if there is any zone that no longer has a server
12 // and set the list to empty so that the zone related metrics does not
13 // contain stale data
14 for (Map.Entry<String, BaseLoadBalancer> existingLBEntry: balancers.entrySet()) {
15 if (!zoneServersMap.keySet().contains(existingLBEntry.getKey())) {
16 existingLBEntry.getValue().setServersList(Collections.emptyList());
17 }
18 }
19 }
20
21
在该实现中创建了一个ConcurrentHashMap类型的balancers对象，它将用来存储每个Zone区域对应的负载均衡器。而具体的负载均衡器的创建则是通过在下面的第一个循环中调用getLoadBalancer函数来完成，同时在创建负载均衡器的时候会创建它的规则（如果当前实现中没有IRule的实例，就创建一个AvailabilityFilteringRule规则，如果已经有具体实例就克隆一个）。在创建完负载均衡器后又调用setServersList函数为其设置对应Zone区域的实例清单。遍历balancers对Zone区域中实例清单检查，看看是否有Zone区域下已经没有实例了，是的话就将balancers中对应Zone区域的实例列表清空，该操作的作用是为了后续选择节点时，防止过时的Zone区域统计信息干扰具体实例的选择算法。
接下来再来看看它是如何选择服务实例来实现对区域的识别：
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
2 public Server chooseServer(Object key) {
3 if (!ENABLED.get() || getLoadBalancerStats().getAvailableZones().size() <= 1) {
4 logger.debug("Zone aware logic disabled or there is only one zone");
5 return super.chooseServer(key);
6 }
7 Server server = null;
8 try {
9 LoadBalancerStats lbStats = getLoadBalancerStats();
10 Map<String, ZoneSnapshot> zoneSnapshot = ZoneAvoidanceRule.createSnapshot(lbStats);
11 logger.debug("Zone snapshots: {}", zoneSnapshot);
12 if (triggeringLoad == null) {
13 triggeringLoad = DynamicPropertyFactory.getInstance().getDoubleProperty(
14 "ZoneAwareNIWSDiscoveryLoadBalancer." + this.getName() + ".triggeringLoadPerServerThreshold", 0.2d);
15 }
16
17 if (triggeringBlackoutPercentage == null) {
18 triggeringBlackoutPercentage = DynamicPropertyFactory.getInstance().getDoubleProperty(
19 "ZoneAwareNIWSDiscoveryLoadBalancer." + this.getName() + ".avoidZoneWithBlackoutPercetage", 0.99999d);
20 }
21 Set<String> availableZones = ZoneAvoidanceRule.getAvailableZones(zoneSnapshot, triggeringLoad.get(), triggeringBlackoutPercentage.get());
22 logger.debug("Available zones: {}", availableZones);
23 if (availableZones != null && availableZones.size() < zoneSnapshot.keySet().size()) {
24 String zone = ZoneAvoidanceRule.randomChooseZone(zoneSnapshot, availableZones);
25 logger.debug("Zone chosen: {}", zone);
26 if (zone != null) {
27 BaseLoadBalancer zoneLoadBalancer = getLoadBalancer(zone);
28 server = zoneLoadBalancer.chooseServer(key);
29 }
30 }
31 } catch (Exception e) {
32 logger.error("Error choosing server using zone aware logic for load balancer={}", name, e);
33 }
34 if (server != null) {
35 return server;
36 } else {
37 logger.debug("Zone avoidance logic is not invoked.");
38 return super.chooseServer(key);
39 }
40 }
41
42
从源码中我们可以看到，只有当负载均衡器中维护的实例所属的Zone区域的个数大于1的时候才会执行这里的选择策略，否则还是将使用父类的实现，当Zone区域的个数大于1的时候，它的实现步骤如下：
- 调用ZoneAvoidanceRule的静态方法createSnapshot(lbStats)，为当前负载均衡器中所有的Zone区域分别创建快照中的数据将用于后续的算法
- 调用ZoneAvoidanceRule的静态方法getAvailableZones(zoneSnapshot, triggeringLoad.get(), triggeringBlackoutPercentage.get())来获取可用的Zone区域集合，在该函数中会通过Zone区域快照中的统计数据来实现可用区的挑选。
- 当获得的可用Zone区域集合不为空，并且个数小于Zone区域总数，就随机选择一个Zone区域
- 在确定了整个Zone区域后，则获取了对应Zone区域的服务均衡器，并调用chooseServer来选择具体的服务实例，而在chooseServer中将使用IRule接口的choose函数来选择具体的服务实例。在这里，IRule接口的实现会使用ZoneAvoidanceRule来挑选出具体的服务实例。
这次就写到这里吧。。。
