Spring Cloud Ribbon的原理-负载均衡器

RestTemplate内部调用负载均衡拦截器，拦截器内最终是调用了负载均衡器来选择服务实例。
接下来撸一撸负载均衡器的内部，看看是如何获取服务实例，获取以后做了哪些处理，处理后又是如何选取服务实例的。
分成三个部分来撸：

①：配置
②：获取服务
③：选择服务

配置
在上一篇《Spring Cloud Ribbon的原理》的配置部分可以看到默认的负载均衡器是ZoneAwareLoadBalancer。

看一看配置类。
位置：org.springframework.cloud.netflix.ribbon.RibbonClientConfiguration

 1 public class RibbonClientConfiguration {
 2 
 3     // ...略
 4     @Bean
 5     @ConditionalOnMissingBean
 6     public ILoadBalancer ribbonLoadBalancer(IClientConfig config,
 7             ServerList<Server> serverList, ServerListFilter<Server> serverListFilter,
 8             IRule rule, IPing ping, ServerListUpdater serverListUpdater) {
 9         if (this.propertiesFactory.isSet(ILoadBalancer.class, name)) {
10             return this.propertiesFactory.get(ILoadBalancer.class, config, name);
11         }
12         return new ZoneAwareLoadBalancer<>(config, rule, ping, serverList,
13                 serverListFilter, serverListUpdater);
14     }
15     
16     // ...略
17 }

在实例化ZoneAwareLoadBalancer的时候注入了，config、rule、ping、serverList、serverListFilter、serverListUpdater实例。
config：配置实例。
rule：负载均衡策略实例。
ping：ping实例。
serverList：获取和更新服务的实例。
serverListFilter：服务过滤实例。
serverListUpdater：服务列表信息更新实例。

  1 public class RibbonClientConfiguration {
  2 
  3     /**
  4      * Ribbon client default connect timeout.
  5      */
  6     public static final int DEFAULT_CONNECT_TIMEOUT = 1000;
  7 
  8     /**
  9      * Ribbon client default read timeout.
 10      */
 11     public static final int DEFAULT_READ_TIMEOUT = 1000;
 12 
 13     /**
 14      * Ribbon client default Gzip Payload flag.
 15      */
 16     public static final boolean DEFAULT_GZIP_PAYLOAD = true;
 17 
 18     @RibbonClientName
 19     private String name = "client";
 20 
 21     // TODO: maybe re-instate autowired load balancers: identified by name they could be
 22     // associated with ribbon clients
 23 
 24     @Autowired
 25     private PropertiesFactory propertiesFactory;
 26 
 27     @Bean
 28     @ConditionalOnMissingBean
 29     public IClientConfig ribbonClientConfig() {
 30         DefaultClientConfigImpl config = new DefaultClientConfigImpl();
 31         config.loadProperties(this.name);
 32         config.set(CommonClientConfigKey.ConnectTimeout, DEFAULT_CONNECT_TIMEOUT);
 33         config.set(CommonClientConfigKey.ReadTimeout, DEFAULT_READ_TIMEOUT);
 34         config.set(CommonClientConfigKey.GZipPayload, DEFAULT_GZIP_PAYLOAD);
 35         return config;
 36     }
 37 
 38     @Bean
 39     @ConditionalOnMissingBean
 40     public IRule ribbonRule(IClientConfig config) {
 41         if (this.propertiesFactory.isSet(IRule.class, name)) {
 42             return this.propertiesFactory.get(IRule.class, config, name);
 43         }
 44         ZoneAvoidanceRule rule = new ZoneAvoidanceRule();
 45         rule.initWithNiwsConfig(config);
 46         return rule;
 47     }
 48 
 49     @Bean
 50     @ConditionalOnMissingBean
 51     public IPing ribbonPing(IClientConfig config) {
 52         if (this.propertiesFactory.isSet(IPing.class, name)) {
 53             return this.propertiesFactory.get(IPing.class, config, name);
 54         }
 55         return new DummyPing();
 56     }
 57 
 58     @Bean
 59     @ConditionalOnMissingBean
 60     @SuppressWarnings("unchecked")
 61     public ServerList<Server> ribbonServerList(IClientConfig config) {
 62         if (this.propertiesFactory.isSet(ServerList.class, name)) {
 63             return this.propertiesFactory.get(ServerList.class, config, name);
 64         }
 65         ConfigurationBasedServerList serverList = new ConfigurationBasedServerList();
 66         serverList.initWithNiwsConfig(config);
 67         return serverList;
 68     }
 69 
 70     @Bean
 71     @ConditionalOnMissingBean
 72     public ServerListUpdater ribbonServerListUpdater(IClientConfig config) {
 73         return new PollingServerListUpdater(config);
 74     }
 75 
 76     @Bean
 77     @ConditionalOnMissingBean
 78     public ILoadBalancer ribbonLoadBalancer(IClientConfig config,
 79             ServerList<Server> serverList, ServerListFilter<Server> serverListFilter,
 80             IRule rule, IPing ping, ServerListUpdater serverListUpdater) {
 81         if (this.propertiesFactory.isSet(ILoadBalancer.class, name)) {
 82             return this.propertiesFactory.get(ILoadBalancer.class, config, name);
 83         }
 84         return new ZoneAwareLoadBalancer<>(config, rule, ping, serverList,
 85                 serverListFilter, serverListUpdater);
 86     }
 87 
 88     @Bean
 89     @ConditionalOnMissingBean
 90     @SuppressWarnings("unchecked")
 91     public ServerListFilter<Server> ribbonServerListFilter(IClientConfig config) {
 92         if (this.propertiesFactory.isSet(ServerListFilter.class, name)) {
 93             return this.propertiesFactory.get(ServerListFilter.class, config, name);
 94         }
 95         ZonePreferenceServerListFilter filter = new ZonePreferenceServerListFilter();
 96         filter.initWithNiwsConfig(config);
 97         return filter;
 98     }
 99 
100     @Bean
101     @ConditionalOnMissingBean
102     public RibbonLoadBalancerContext ribbonLoadBalancerContext(ILoadBalancer loadBalancer,
103             IClientConfig config, RetryHandler retryHandler) {
104         return new RibbonLoadBalancerContext(loadBalancer, config, retryHandler);
105     }
106 
107     @Bean
108     @ConditionalOnMissingBean
109     public RetryHandler retryHandler(IClientConfig config) {
110         return new DefaultLoadBalancerRetryHandler(config);
111     }
112 
113     @Bean
114     @ConditionalOnMissingBean
115     public ServerIntrospector serverIntrospector() {
116         return new DefaultServerIntrospector();
117     }
118 
119     @PostConstruct
120     public void preprocess() {
121         setRibbonProperty(name, DeploymentContextBasedVipAddresses.key(), name);
122     }
123 
124     static class OverrideRestClient extends RestClient {
125 
126         private IClientConfig config;
127 
128         private ServerIntrospector serverIntrospector;
129 
130         protected OverrideRestClient(IClientConfig config,
131                 ServerIntrospector serverIntrospector) {
132             super();
133             this.config = config;
134             this.serverIntrospector = serverIntrospector;
135             initWithNiwsConfig(this.config);
136         }
137 
138         @Override
139         public URI reconstructURIWithServer(Server server, URI original) {
140             URI uri = updateToSecureConnectionIfNeeded(original, this.config,
141                     this.serverIntrospector, server);
142             return super.reconstructURIWithServer(server, uri);
143         }
144 
145         @Override
146         protected Client apacheHttpClientSpecificInitialization() {
147             ApacheHttpClient4 apache = (ApacheHttpClient4) super.apacheHttpClientSpecificInitialization();
148             apache.getClientHandler().getHttpClient().getParams().setParameter(
149                     ClientPNames.COOKIE_POLICY, CookiePolicy.IGNORE_COOKIES);
150             return apache;
151         }
152 
153     }
154 
155 }

在这里配置相关的实例

config：DefaultClientConfigImpl。
rule：ZoneAvoidanceRule。
ping：DummyPing。
serverList：ConfigurationBasedServerList，基于配置的服务列表实例。
serverListFilter：ZonePreferenceServerListFilter。
serverListUpdater：PollingServerListUpdater。
要注意的是，在这里serverList的实例是ConfigurationBasedServerList，这是在未使用Nacos时获取服务信息的实例，是从配置文件中获取。
那么在和Nacos配合使用时，需要从Nacos Server获取服务信息，那该是哪个实例来做这件事情呢。
在启用Nacos服务发现时，会首先会采用NacosRibbonClientConfiguration配置类。
位置：com.alibaba.cloud.nacos.ribbon.NacosRibbonClientConfiguration

 1 @Configuration(proxyBeanMethods = false)
 2 @ConditionalOnRibbonNacos
 3 public class NacosRibbonClientConfiguration {
 4 
 5     @Autowired
 6     private PropertiesFactory propertiesFactory;
 7 
 8     @Bean
 9     @ConditionalOnMissingBean
10     public ServerList<?> ribbonServerList(IClientConfig config,
11             NacosDiscoveryProperties nacosDiscoveryProperties) {
12         if (this.propertiesFactory.isSet(ServerList.class, config.getClientName())) {
13             ServerList serverList = this.propertiesFactory.get(ServerList.class, config,
14                     config.getClientName());
15             return serverList;
16         }
17         NacosServerList serverList = new NacosServerList(nacosDiscoveryProperties);
18         serverList.initWithNiwsConfig(config);
19         return serverList;
20     }
21 
22     @Bean
23     @ConditionalOnMissingBean
24     public NacosServerIntrospector nacosServerIntrospector() {
25         return new NacosServerIntrospector();
26     }
27 
28 }

获取服务

在找到获取服务信息入口前，先把负载均衡器的类继承关系撸一下。

在ZoneAwareLoadBalancer的构造中调用了父类DynamicServerListLoadBalancer构造。

在DynamicServerListLoadBalancer的构造中，调用了restOfInit函数。
DynamicServerListLoadBalancer.class

 1     void restOfInit(IClientConfig clientConfig) {
 2         boolean primeConnection = this.isEnablePrimingConnections();
 3         // turn this off to avoid duplicated asynchronous priming done in BaseLoadBalancer.setServerList()
 4         this.setEnablePrimingConnections(false);
 5         enableAndInitLearnNewServersFeature();
 6 
 7         updateListOfServers();
 8         if (primeConnection && this.getPrimeConnections() != null) {
 9             this.getPrimeConnections()
10                     .primeConnections(getReachableServers());
11         }
12         this.setEnablePrimingConnections(primeConnection);
13         LOGGER.info("DynamicServerListLoadBalancer for client {} initialized: {}", clientConfig.getClientName(), this.toString());
14     }
15

先是通过调用enableAndInitLearnNewServersFeature方法启动定时更新服务列表，然后立即调用updateListOfServers函数马上获取并更新服务列表信息。
先看下enableAndInitLearnNewServersFeature方法，实际上是调用了服务列表信息更新实例的start方法启动定时更新功能。

1     /**
2      * Feature that lets us add new instances (from AMIs) to the list of
3      * existing servers that the LB will use Call this method if you want this
4      * feature enabled
5      */
6     public void enableAndInitLearnNewServersFeature() {
7         LOGGER.info("Using serverListUpdater {}", serverListUpdater.getClass().getSimpleName());
8         serverListUpdater.start(updateAction);
9     }

这里的服务列表信息更新实例就是配置阶段配置的PollingServerListUpdater实例，看一下这个类的构造和start方法。

  1 public class PollingServerListUpdater implements ServerListUpdater {
  2 
  3     private static final Logger logger = LoggerFactory.getLogger(PollingServerListUpdater.class);
  4 
  5     private static long LISTOFSERVERS_CACHE_UPDATE_DELAY = 1000; // msecs;
  6     private static int LISTOFSERVERS_CACHE_REPEAT_INTERVAL = 30 * 1000; // msecs;
  7 
  8     private static class LazyHolder {
  9         private final static String CORE_THREAD = "DynamicServerListLoadBalancer.ThreadPoolSize";
 10         private final static DynamicIntProperty poolSizeProp = new DynamicIntProperty(CORE_THREAD, 2);
 11         private static Thread _shutdownThread;
 12 
 13         static ScheduledThreadPoolExecutor _serverListRefreshExecutor = null;
 14 
 15         static {
 16             int coreSize = poolSizeProp.get();
 17             ThreadFactory factory = (new ThreadFactoryBuilder())
 18                     .setNameFormat("PollingServerListUpdater-%d")
 19                     .setDaemon(true)
 20                     .build();
 21             _serverListRefreshExecutor = new ScheduledThreadPoolExecutor(coreSize, factory);
 22             poolSizeProp.addCallback(new Runnable() {
 23                 @Override
 24                 public void run() {
 25                     _serverListRefreshExecutor.setCorePoolSize(poolSizeProp.get());
 26                 }
 27 
 28             });
 29             _shutdownThread = new Thread(new Runnable() {
 30                 public void run() {
 31                     logger.info("Shutting down the Executor Pool for PollingServerListUpdater");
 32                     shutdownExecutorPool();
 33                 }
 34             });
 35             Runtime.getRuntime().addShutdownHook(_shutdownThread);
 36         }
 37 
 38         private static void shutdownExecutorPool() {
 39             if (_serverListRefreshExecutor != null) {
 40                 _serverListRefreshExecutor.shutdown();
 41 
 42                 if (_shutdownThread != null) {
 43                     try {
 44                         Runtime.getRuntime().removeShutdownHook(_shutdownThread);
 45                     } catch (IllegalStateException ise) { // NOPMD
 46                         // this can happen if we're in the middle of a real
 47                         // shutdown,
 48                         // and that's 'ok'
 49                     }
 50                 }
 51 
 52             }
 53         }
 54     }
 55 
 56     private static ScheduledThreadPoolExecutor getRefreshExecutor() {
 57         return LazyHolder._serverListRefreshExecutor;
 58     }
 59 
 60 
 61     private final AtomicBoolean isActive = new AtomicBoolean(false);
 62     private volatile long lastUpdated = System.currentTimeMillis();
 63     private final long initialDelayMs;
 64     private final long refreshIntervalMs;
 65 
 66     private volatile ScheduledFuture<?> scheduledFuture;
 67 
 68     public PollingServerListUpdater() {
 69         this(LISTOFSERVERS_CACHE_UPDATE_DELAY, LISTOFSERVERS_CACHE_REPEAT_INTERVAL);
 70     }
 71 
 72     public PollingServerListUpdater(IClientConfig clientConfig) {
 73         this(LISTOFSERVERS_CACHE_UPDATE_DELAY, getRefreshIntervalMs(clientConfig));
 74     }
 75 
 76     public PollingServerListUpdater(final long initialDelayMs, final long refreshIntervalMs) {
 77         this.initialDelayMs = initialDelayMs;
 78         this.refreshIntervalMs = refreshIntervalMs;
 79     }
 80 
 81     @Override
 82     public synchronized void start(final UpdateAction updateAction) {
 83         if (isActive.compareAndSet(false, true)) {
 84             final Runnable wrapperRunnable = new Runnable() {
 85                 @Override
 86                 public void run() {
 87                     if (!isActive.get()) {
 88                         if (scheduledFuture != null) {
 89                             scheduledFuture.cancel(true);
 90                         }
 91                         return;
 92                     }
 93                     try {
 94                         updateAction.doUpdate();
 95                         lastUpdated = System.currentTimeMillis();
 96                     } catch (Exception e) {
 97                         logger.warn("Failed one update cycle", e);
 98                     }
 99                 }
100             };
101 
102             scheduledFuture = getRefreshExecutor().scheduleWithFixedDelay(
103                     wrapperRunnable,
104                     initialDelayMs,
105                     refreshIntervalMs,
106                     TimeUnit.MILLISECONDS
107             );
108         } else {
109             logger.info("Already active, no-op");
110         }
111     }
112 
113     @Override
114     public synchronized void stop() {
115         if (isActive.compareAndSet(true, false)) {
116             if (scheduledFuture != null) {
117                 scheduledFuture.cancel(true);
118             }
119         } else {
120             logger.info("Not active, no-op");
121         }
122     }
123 
124     @Override
125     public String getLastUpdate() {
126         return new Date(lastUpdated).toString();
127     }
128 
129     @Override
130     public long getDurationSinceLastUpdateMs() {
131         return System.currentTimeMillis() - lastUpdated;
132     }
133 
134     @Override
135     public int getNumberMissedCycles() {
136         if (!isActive.get()) {
137             return 0;
138         }
139         return (int) ((int) (System.currentTimeMillis() - lastUpdated) / refreshIntervalMs);
140     }
141 
142     @Override
143     public int getCoreThreads() {
144         if (isActive.get()) {
145             if (getRefreshExecutor() != null) {
146                 return getRefreshExecutor().getCorePoolSize();
147             }
148         }
149         return 0;
150     }
151 
152     private static long getRefreshIntervalMs(IClientConfig clientConfig) {
153         return clientConfig.get(CommonClientConfigKey.ServerListRefreshInterval, LISTOFSERVERS_CACHE_REPEAT_INTERVAL);
154     }
155 }

从构造和常量定义看出来，延迟一秒执行，默认每隔30秒执行更新，可以通过配置修改间隔更新的时间。
从start方法看，就是开了一个定时执行的schedule，定时执行 updateAction.doUpdate()。
回到start方法调用方DynamicServerListLoadBalancer类中看一下UpdateAction实例的定义。

1     protected final ServerListUpdater.UpdateAction updateAction = new ServerListUpdater.UpdateAction() {
2         @Override
3         public void doUpdate() {
4             updateListOfServers();
5         }
6     };

实际上就是调用了DynamicServerListLoadBalancer类的updateListOfServers方法，这跟启动完定时更新后立即更新服务信息列表的路径是一致的。
继续看updateListOfServers方法。

 1     public void updateListOfServers() {
 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     }

1.通过ServerList实例获取服务信息列表。
2.通过ServerListFilter 实例对获取到的服务信息列表进行过滤。
3.将过滤后的服务信息列表保存到LoadBalancerStats中作为状态保持。

接下分别看一下。
1.通过ServerList实例获取服务信息列表。

public class NacosServerList extends AbstractServerList<NacosServer> {

    private NacosDiscoveryProperties discoveryProperties;

    private String serviceId;

    public NacosServerList(NacosDiscoveryProperties discoveryProperties) {
        this.discoveryProperties = discoveryProperties;
    }

    @Override
    public List<NacosServer> getInitialListOfServers() {
        return getServers();
    }

    @Override
    public List<NacosServer> getUpdatedListOfServers() {
        return getServers();
    }

    private List<NacosServer> getServers() {
        try {
            String group = discoveryProperties.getGroup();
            List<Instance> instances = discoveryProperties.namingServiceInstance()
                    .selectInstances(serviceId, group, true);
            return instancesToServerList(instances);
        }
        catch (Exception e) {
            throw new IllegalStateException(
                    "Can not get service instances from nacos, serviceId=" + serviceId,
                    e);
        }
    }

    private List<NacosServer> instancesToServerList(List<Instance> instances) {
        List<NacosServer> result = new ArrayList<>();
        if (CollectionUtils.isEmpty(instances)) {
            return result;
        }
        for (Instance instance : instances) {
            result.add(new NacosServer(instance));
        }

        return result;
    }

    public String getServiceId() {
        return serviceId;
    }

    @Override
    public void initWithNiwsConfig(IClientConfig iClientConfig) {
        this.serviceId = iClientConfig.getClientName();
    }

}

2.通过ServerListFilter实例对获取到的服务信息列表进行过滤。

serverListFilte实例就是配置阶段生成的ZonePreferenceServerListFilter，通过调用该实例的getFilteredListOfServers方法进行过滤。

public class ZonePreferenceServerListFilter extends ZoneAffinityServerListFilter<Server> {

    private String zone;

    @Override
    public void initWithNiwsConfig(IClientConfig niwsClientConfig) {
        super.initWithNiwsConfig(niwsClientConfig);
        if (ConfigurationManager.getDeploymentContext() != null) {
            this.zone = ConfigurationManager.getDeploymentContext()
                    .getValue(ContextKey.zone);
        }
    }

    @Override
    public List<Server> getFilteredListOfServers(List<Server> servers) {
        List<Server> output = super.getFilteredListOfServers(servers);
        if (this.zone != null && output.size() == servers.size()) {
            List<Server> local = new ArrayList<>();
            for (Server server : output) {
                if (this.zone.equalsIgnoreCase(server.getZone())) {
                    local.add(server);
                }
            }
            if (!local.isEmpty()) {
                return local;
            }
        }
        return output;
    }

    public String getZone() {
        return zone;
    }

    public void setZone(String zone) {
        this.zone = zone;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }
        ZonePreferenceServerListFilter that = (ZonePreferenceServerListFilter) o;
        return Objects.equals(zone, that.zone);
    }

    @Override
    public int hashCode() {
        return Objects.hash(zone);
    }

    @Override
    public String toString() {
        return new StringBuilder("ZonePreferenceServerListFilter{").append("zone='")
                .append(zone).append("'").append("}").toString();
    }

}

在getFilteredListOfServers方法里面，一上来是调用父类的同名方法先过滤，其实父类也是把和消费端同区域的服务给过滤出来使用，不仅如此，增加了些智能的判定，保证在故障/负载较高时或者可用实例较少时不进行同区域的过滤。
但是在ZonePreferenceServerListFilter.getFilteredListOfServers这里，就算父类没做过过滤，这里依然要把同zone的服务给滤出来使用，谁叫这里的类是ZonePreference的呢。
这是比较怪异的地方，感觉父类的智能判定没什么作用。
还是看看ZoneAffinityServerListFilter.getFilteredListOfServers做的辛苦工作吧。

 1 public class ZoneAffinityServerListFilter<T extends Server> extends
 2         AbstractServerListFilter<T> implements IClientConfigAware {
 3 
 4     private volatile boolean zoneAffinity = DefaultClientConfigImpl.DEFAULT_ENABLE_ZONE_AFFINITY;
 5     private volatile boolean zoneExclusive = DefaultClientConfigImpl.DEFAULT_ENABLE_ZONE_EXCLUSIVITY;
 6     private DynamicDoubleProperty activeReqeustsPerServerThreshold;
 7     private DynamicDoubleProperty blackOutServerPercentageThreshold;
 8     private DynamicIntProperty availableServersThreshold;
 9     private Counter overrideCounter;
10     private ZoneAffinityPredicate zoneAffinityPredicate = new ZoneAffinityPredicate();
11     
12     private static Logger logger = LoggerFactory.getLogger(ZoneAffinityServerListFilter.class);
13     
14     String zone;
15         
16     public ZoneAffinityServerListFilter() {      
17     }
18     
19     public ZoneAffinityServerListFilter(IClientConfig niwsClientConfig) {
20         initWithNiwsConfig(niwsClientConfig);
21     }
22     
23     @Override
24     public void initWithNiwsConfig(IClientConfig niwsClientConfig) {
25         String sZoneAffinity = "" + niwsClientConfig.getProperty(CommonClientConfigKey.EnableZoneAffinity, false);
26         if (sZoneAffinity != null){
27             zoneAffinity = Boolean.parseBoolean(sZoneAffinity);
28             logger.debug("ZoneAffinity is set to {}", zoneAffinity);
29         }
30         String sZoneExclusive = "" + niwsClientConfig.getProperty(CommonClientConfigKey.EnableZoneExclusivity, false);
31         if (sZoneExclusive != null){
32             zoneExclusive = Boolean.parseBoolean(sZoneExclusive);
33         }
34         if (ConfigurationManager.getDeploymentContext() != null) {
35             zone = ConfigurationManager.getDeploymentContext().getValue(ContextKey.zone);
36         }
37         activeReqeustsPerServerThreshold = DynamicPropertyFactory.getInstance().getDoubleProperty(niwsClientConfig.getClientName() + "." + niwsClientConfig.getNameSpace() + ".zoneAffinity.maxLoadPerServer", 0.6d);
38         logger.debug("activeReqeustsPerServerThreshold: {}", activeReqeustsPerServerThreshold.get());
39         blackOutServerPercentageThreshold = DynamicPropertyFactory.getInstance().getDoubleProperty(niwsClientConfig.getClientName() + "." + niwsClientConfig.getNameSpace() + ".zoneAffinity.maxBlackOutServesrPercentage", 0.8d);
40         logger.debug("blackOutServerPercentageThreshold: {}", blackOutServerPercentageThreshold.get());
41         availableServersThreshold = DynamicPropertyFactory.getInstance().getIntProperty(niwsClientConfig.getClientName() + "." + niwsClientConfig.getNameSpace() + ".zoneAffinity.minAvailableServers", 2);
42         logger.debug("availableServersThreshold: {}", availableServersThreshold.get());
43         overrideCounter = Monitors.newCounter("ZoneAffinity_OverrideCounter");
44 
45         Monitors.registerObject("NIWSServerListFilter_" + niwsClientConfig.getClientName());
46     }
47     
48     private boolean shouldEnableZoneAffinity(List<T> filtered) {    
49         if (!zoneAffinity && !zoneExclusive) {
50             return false;
51         }
52         if (zoneExclusive) {
53             return true;
54         }
55         LoadBalancerStats stats = getLoadBalancerStats();
56         if (stats == null) {
57             return zoneAffinity;
58         } else {
59             logger.debug("Determining if zone affinity should be enabled with given server list: {}", filtered);
60             ZoneSnapshot snapshot = stats.getZoneSnapshot(filtered);
61             double loadPerServer = snapshot.getLoadPerServer();
62             int instanceCount = snapshot.getInstanceCount();            
63             int circuitBreakerTrippedCount = snapshot.getCircuitTrippedCount();
64             if (((double) circuitBreakerTrippedCount) / instanceCount >= blackOutServerPercentageThreshold.get() 
65                     || loadPerServer >= activeReqeustsPerServerThreshold.get()
66                     || (instanceCount - circuitBreakerTrippedCount) < availableServersThreshold.get()) {
67                 logger.debug("zoneAffinity is overriden. blackOutServerPercentage: {}, activeReqeustsPerServer: {}, availableServers: {}", 
68                         new Object[] {(double) circuitBreakerTrippedCount / instanceCount,  loadPerServer, instanceCount - circuitBreakerTrippedCount});
69                 return false;
70             } else {
71                 return true;
72             }
73             
74         }
75     }
76         
77     @Override
78     public List<T> getFilteredListOfServers(List<T> servers) {
79         if (zone != null && (zoneAffinity || zoneExclusive) && servers !=null && servers.size() > 0){
80             List<T> filteredServers = Lists.newArrayList(Iterables.filter(
81                     servers, this.zoneAffinityPredicate.getServerOnlyPredicate()));
82             if (shouldEnableZoneAffinity(filteredServers)) {
83                 return filteredServers;
84             } else if (zoneAffinity) {
85                 overrideCounter.increment();
86             }
87         }
88         return servers;
89     }
90 
91     @Override
92     public String toString(){
93         StringBuilder sb = new StringBuilder("ZoneAffinityServerListFilter:");
94         sb.append(", zone: ").append(zone).append(", zoneAffinity:").append(zoneAffinity);
95         sb.append(", zoneExclusivity:").append(zoneExclusive);
96         return sb.toString();       
97     }
98 }

首先会将与消费端相同的zone的服务过滤出来，然后通过shouldEnableZoneAffinity(filteredServers)来判定是否可以采纳同zone的服务，还是采用所有的服务。
在shouldEnableZoneAffinity方法内，对相同zone的服务做了一次snapshot，获取这些服务的实例数量，平均负载，断路的实例数进行计算判定。
可以看一下initWithNiwsConfig方法中关键指标的值。

判定条件：
断路实例百分比>=0.8（断路的实例数/服务的实例数量）
平均负载>=0.6
可用实例数<2（实例数量-断路的实例数）
如果达到判定条件，那么就使用全部的服务，保证可用性。
但，上面也说了，因为ZonePreferenceServerListFilter本身总是会选用和消费端zone一致的服务，所以ZoneAffinityServerListFilter.getFilteredListOfServers中做的智能操作并没什么用。
不过，当然可以通过自定义配置来采用ZoneAffinityServerListFilter实例。

3.将过滤后的服务信息列表保存到LoadBalancerStats中作为状态保持。

跟进updateAllServerList(servers);去，一步步深入，会发现，实际上是保存到LoadBalancerStats中，并且这时候的服务是按照zone分组以HashMap<String, List<Server>>结构保存的，key是zone。

选择服务
实现了ILoadBalancer接口的负载均衡器，是通过实现chooseServer方法来进行服务的选择，选择后的服务做为目标请求服务。
看一下ZoneAwareLoadBalancer.chooseServer方法。

 1     @Override
 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

注意这里有两种用法：

1.通过配置ZoneAwareNIWSDiscoveryLoadBalancer.enabled=false关闭区域感知负载均衡，或者zone的个数<=1个。

2.采用区域感知，或者zone的个数>1。

一个个来看一下

1.通过配置ZoneAwareNIWSDiscoveryLoadBalancer.enabled=false关闭区域感知负载均衡，或者zone的个数<=1个。

这种情况下，调用了父类BaseLoadBalancer.chooseServer方法。

 1     public Server chooseServer(Object key) {
 2         if (counter == null) {
 3             counter = createCounter();
 4         }
 5         counter.increment();
 6         if (rule == null) {
 7             return null;
 8         } else {
 9             try {
10                 return rule.choose(key);
11             } catch (Exception e) {
12                 logger.warn("LoadBalancer [{}]:  Error choosing server for key {}", name, key, e);
13                 return null;
14             }
15         }
16     }

这里使用的负载均衡策略rule实际上就是构造ZoneAwareLoadBalancer时传进来的，在配置阶段生成的ZoneAvoidanceRule策略实例。

    public void setRule(IRule rule) {
        if (rule != null) {
            this.rule = rule;
        } else {
            /* default rule */
            this.rule = new RoundRobinRule();
        }
        if (this.rule.getLoadBalancer() != this) {
            this.rule.setLoadBalancer(this);
        }
    }

默认使用RoundRobinRule规则

2.采用区域感知，或者zone的个数>1。

 1     @Override
 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

在这种情况下默认使用ZoneAvoidanceRule负载均衡策略。
获取zone的snapshot信息。
获取可用的zone，通过观察ZoneAvoidanceRule.getAvailableZones定义，不是可用zone的条件是：
所属实例数==0。
故障率>0.99999或者平均负载<0。
如果不是上面两种情况，就选择负载最高的一个去除不作为可用的zone。
可用zone都获取后，随机选一个。

并从该zone中，通过ZoneAwareLoadBalancer的父类BaseLoadBalancer.chooseServer选取服务，上面整理过，BaseLoadBalancer里如果没有传入rule，那么默认使用RoundRobinRule策略轮寻一个服务。
其实，还是上面获取服务中ZonePreferenceServerListFilter过滤器的问题，实际上过滤出来的只有一个和消费端相同的一个zone的服务，所以第2.部分的从可用zone中选取服务的功能是走不到，要走到就得把过滤器给换掉。

总结：
配置的负载均衡器会启动schedule获取服务信息，在使用了Eureka客户端时，会从Eureka服务获取所有服务实例信息，通过过滤器过滤出可以使用的服务，过滤器默认只过滤出与消费端相同zone的服务，如果要保证高可用可配置ZoneAffinityServerListFilter过滤器，过滤后的服务列表，通过实现了IRule接口的负载均衡策略选取对应的服务，如果是使用zone感知的策略，可以从负载情况良好的zone中选取合适的服务。

posted @ 2021-01-14 11:48 郭慕荣阅读(435) 评论(0) 编辑收藏举报

刷新页面返回顶部

郭慕荣博客园

Spring Cloud Ribbon的原理-负载均衡器

公告