一、Ribbon 负载均衡

Ribbon Spring Cloud 体系中的客户端负载均衡器，Ribbon 针对负载均衡提供了多种策略。

相应的类图如下：
01.png
部分类描述如下表：

策略类 描述
IRule 所有策略的最上层接口。规范了负载均衡策略方法实现。
AbstractLoadBalancerRule 所有策略的最上层抽象。提供了 ILoadBalancer 注入。
RandomRule 随机策略。随机选择存活的 server 实例。
RoundRobinRule 轮询策略。按顺序循环轮询存活的 server 实例。
RetryRule 重试策略。装饰者模式委派 RoundRobinRule 获取服务实例，如果实例死亡，在指定时间内，不断通过 RoundRobinRule尝试获取新的存活的服务实例。
BestAvailableRule 最好可用策略。遍历所有服务实例，找到 server 断路器未打开的服务实例，从其中选出并发链接最低的 server，如果找不到使用 RoundRobinRule 进行娄底。
AvailabilityFilteringRule 可用过滤策略。通过 RoundRobinRule 结合 AbstractServerPredicate 过滤断言进行服务实例过滤，最多过滤10次，如果还是无法获取到服务实例，使用 RoundRobinRule 进行娄底。
WeightedResponseTimeRule 响应时间权重策略。提供有专门的线程去统计服务实例的响应时间，并计算权重，然后根据权重进行服务实例获取，如果无法获取到服务实例，使用RoundRobinRule 进行娄底。
ZoneAvoidanceRule 区域权衡策略。和 AvailabilityFilteringRule 类似，不过其通过 装饰者模式 和 组合模式，通过一系列的复杂断言来过滤服务实例。

二、RandomRule 随机策略

类结构

02.png

关键代码

  1. public class RandomRule extends AbstractLoadBalancerRule {
  2.     public Server choose(ILoadBalancer lb, Object key) {
  3.         while (server == null) {
  4.             // 获取所有状态为 up 且，可达的服务列表
  5.             List<Server> upList = lb.getReachableServers();
  6.             // 获取所有服务列表，无论是否可达
  7.             List<Server> allList = lb.getAllServers();
  9.             // 所有服务实例总数
  10.             int serverCount = allList.size();
  11.             // 根据服务总数获取随机数
  12.             int index = chooseRandomInt(serverCount);
  13.             // 从可达的 up 状态的服务实例列表中，根据随机 index 获取服务实例
  14.             server = upList.get(index);
  15.             // 如果服务存活，返回实例名
  16.             if (server.isAlive()) {
  17.                 return (server);
  18.             }
  19.         }
  20.     }
  22.     // 随机数获取
  23.     protected int chooseRandomInt(int serverCount) {
  24.         return ThreadLocalRandom.current().nextInt(serverCount);
  25.     }
  26. }

三、RetryRule 重试策略

类结构

03.png

关键代码

  1. public class RetryRule extends AbstractLoadBalancerRule {
  2.     // 娄底策略：轮询策略
  3.     IRule subRule = new RoundRobinRule();
  5.     // 在指定时间内不断尝试获取服务实例。默认：500 ms
  6.     long maxRetryMillis = 500;
  8.     public Server choose(ILoadBalancer lb, Object key) {
  9.         // 当前请求时间
  10.         long requestTime = System.currentTimeMillis();
  11.         // 如果第一次获取到，在时间未到达 deadline 时，不断进行重试操作
  12.         long deadline = requestTime + maxRetryMillis;
  14.         // 通过轮询获取一个服务实例
  15.         Server answer = null;
  16.         answer = subRule.choose(key);
  18.         // 两个条件满足，进入到重试逻辑
  19.         // 条件一： 轮询获取到的实例为 null 或者 实例死亡
  20.         // 条件二： 时间在允许重试的范围内
  21.         if (((answer == null) || (!answer.isAlive())) && (System.currentTimeMillis() < deadline)) {
  23.             // 起一个线程，在重试时间到了之后，打断重试的线程
  24.             InterruptTask task = new InterruptTask(deadline
  25.                     - System.currentTimeMillis());
  26.             //
  27.             while (!Thread.interrupted()) {
  28.                 answer = subRule.choose(key);
  29.                 ......
  30.                 if (((answer == null) || (!answer.isAlive())) && (System.currentTimeMillis() < deadline)) {
  31.                     // 将重试线程重新归入就绪状态，模拟：线程短暂暂停
  32.                     Thread.yield();
  33.                 }else{
  34.                     // 获取到实例，跳出循环
  35.                     break;
  36.                 }
  37.             }
  39.             // 正常获取到实例，手动调用结束定时任务
  40.             task.cancel();
  41.         }
  43.         // 无论是正常结束，还是超时结束，最终都要进行返回
  44.         if ((answer == null) || (!answer.isAlive())) {
  45.             return null;
  46.         } else {
  47.             return answer;
  48.         }
  49.     }
  50. }

逻辑图如下：
05.png

四、ZoneAvoidanceRule 区域权衡策略

类结构

04.png

类组装图

06.png

父类 PredicateBasedRule 关键代码

ZoneAvoidanceRule 父类 PredicateBasedRule 对 choose 方法进行了覆盖，将服务实例的选择，委派给了 AbstractServerPredicate 实现。

  1. public abstract class PredicateBasedRule extends ClientConfigEnabledRoundRobinRule {
  3.     // 该方法由其子类实现，如：ZoneAvoidanceRule
  4.     public abstract AbstractServerPredicate getPredicate();
  6.     @Override
  7.     public Server choose(Object key) {
  8.         ILoadBalancer lb = getLoadBalancer();
  9.         // 服务实例的获取，由 AbstractServerPredicate#chooseRoundRobinAfterFiltering 来完成
  10.         Optional<Server> server = getPredicate().chooseRoundRobinAfterFiltering(lb.getAllServers(), key);
  11.         if (server.isPresent()) {
  12.             return server.get();
  13.         } else {
  14.             return null;
  15.         }       
  16.     }
  17. }

CompositePredicate 关键代码

类图结构

07.png

CompositePredicate#chooseRoundRobinAfterFiltering 服务实例获取时序图

chooseRoundRobinAfterFiltering 方法是在经过断言过滤之后，如果有多个实例，则通过轮询的方式获取实例

08.png
首先来看看 ZoneAvoidanceRule 组装的 CompositePredicate 。其由如下两个过滤链组成

  • AbstractServerPredicate delegate

    该过滤链由： ZoneAvoidancePredicate + AvailabilityPredicate 组成

  • List<AbstractServerPredicate> fallbacks

    该过滤链由： AvailabilityPredicate + AbstractServerPredicate.alwaysTrue() 空实现组成

  1. public class ZoneAvoidanceRule extends PredicateBasedRule {
  3.     // 组合断言
  4.     private CompositePredicate compositePredicate;
  6.     public ZoneAvoidanceRule() {
  7.         super();
  8.         // 组合断言
  9.         ZoneAvoidancePredicate zonePredicate = new ZoneAvoidancePredicate(this);
  10.         AvailabilityPredicate availabilityPredicate = new AvailabilityPredicate(this);
  11.         compositePredicate = createCompositePredicate(zonePredicate, availabilityPredicate);
  12.     }
  14.     // 组装 CompositePredicate
  15.     private CompositePredicate createCompositePredicate(ZoneAvoidancePredicate p1, AvailabilityPredicate p2) {
  16.         return CompositePredicate.withPredicates(p1, p2)
  17.                              .addFallbackPredicate(p2)
  18.                              .addFallbackPredicate(AbstractServerPredicate.alwaysTrue())
  19.                              .build();
  21.     }
  22. }

过滤执行操作

09.png