刚学习Springcloud-Ribbon这个组件的时候，很多东西好困惑感觉好神奇，然后CSND找了很多大神写的Ribbon的文章，【戴明智】这位江湖高人写的这篇思路很清晰，很beautiful值得一看 。我在这里按照自己思路整理一下，就是为了加深下印象，萤火之光也不敢与日月争辉。
刚开始使用Ribbon我很好奇，RestTemplate 是一个HTTP接口请求工具的类，为啥在RestTemplate Bean打一个@LoadBalanced这么一个注解就能实现接口的负债均衡调用？
我们带这个这个问题往下看，在RestTemplate Bean 打一个@LoadBalanced这么一个注解 ，它到底做了些什么事情。
@Configuration
public class RestTemplateConfig {
@Bean
@LoadBalanced
public RestTemplate restTemplate() {
return new RestTemplate();
}
@Bean
public HttpHeaders getHeaders() {
HttpHeaders headers = new HttpHeaders();
String auth = "admin:admin";
//进行一个加密
byte[] encodeAuth = Base64.getEncoder()
.encode(auth.getBytes(Charset.forName("US-ASCII")));
String authHeader = "Basic " + new String(encodeAuth);
headers.set("Authorization", authHeader);
return headers;
}
}我们先来配置一个RestTemplate bean，然后在这个RestTemplate Bean上面加上@LoadBalanced注解
@SpringBootTest
@RunWith(SpringJUnit4ClassRunner.class)
public class ConsumerAppTest{
@Autowired
private RestTemplate restTemplate;
@Test
public void select(){
System.out.print(restTemplate);
}
}我们写一个测试案例，debug一下看看restTemplate对象
可以看到我们注入的RestTemplate 这个对象interceptors属性里面有一个LoadBalancerInterceptor ，这个LoadBalancerInterceptor 对象它是怎么添加进来的呢？我们带着这个疑问继续往下面看
我们来看 org.springframework.cloud.client.loadbalancer.LoadBalancerAutoConfiguration
这个是springboot启动的时候自动配置的一个类，我们进去看看这个类里面的一些东西
@Configuration
@ConditionalOnClass(RestTemplate.class)
@ConditionalOnBean(LoadBalancerClient.class)
@EnableConfigurationProperties(LoadBalancerRetryProperties.class)
public class LoadBalancerAutoConfiguration {
@LoadBalanced
@Autowired(required = false)
private List<RestTemplate> restTemplates = 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);
}
}
});
}
@Autowired(required = false)
private List<LoadBalancerRequestTransformer> transformers = Collections.emptyList();
@Bean
@ConditionalOnMissingBean
public LoadBalancerRequestFactory loadBalancerRequestFactory(
LoadBalancerClient loadBalancerClient) {
return new LoadBalancerRequestFactory(loadBalancerClient, transformers);
}
@Configuration
@ConditionalOnMissingClass("org.springframework.retry.support.RetryTemplate")
static class LoadBalancerInterceptorConfig {
@Bean
public LoadBalancerInterceptor ribbonInterceptor(
LoadBalancerClient loadBalancerClient,
LoadBalancerRequestFactory requestFactory) {
//这里创建了LoadBalancerInterceptor
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);
};
}
}
// 下面的直接省略了
}这个LoadBalancerAutoConfiguration类要被执行加载，要满足以下两个条件
-
@ConditionalOnClass(RestTemplate.class) 项目工程中必须要有RestTemplate类 -
@ConditionalOnBean(LoadBalancerClient.class) spring容器中必须要有LoadBalancerClient接口实现类
这个自动化配置类主要完成了以下两件事情
- 创建了一个LoadBalancerInterceptor 的Bean，并放入到spring容器中
@Bean
public LoadBalancerInterceptor ribbonInterceptor(
LoadBalancerClient loadBalancerClient,
LoadBalancerRequestFactory requestFactory) {
return new LoadBalancerInterceptor(loadBalancerClient, requestFactory);
}- 创建了一个RestTemplateCustomizer 的Bean，并设置了RestTemplate的Interceptors（拦截器）
@Bean
@ConditionalOnMissingBean
public RestTemplateCustomizer restTemplateCustomizer(
final LoadBalancerInterceptor loadBalancerInterceptor) {
return restTemplate -> {
List<ClientHttpRequestInterceptor> list = new ArrayList<>(
restTemplate.getInterceptors());
list.add(loadBalancerInterceptor);
restTemplate.setInterceptors(list);
};
}总结：说到这里，现在是不是搞明白了前面说的那个疑问吧？答案就是在配置RestTemplateCustomizer这个Bean的时候设置的
那接下来我们继续说RestTemplate这个东西，我们先抛开负债均衡这些概念来看RestTemplate 如何HTTP请求一个接口的
@Override
@Nullable
public <T> T getForObject(String url, Class<T> responseType, Object... uriVariables) throws RestClientException {
RequestCallback requestCallback = acceptHeaderRequestCallback(responseType);
HttpMessageConverterExtractor<T> responseExtractor =
new HttpMessageConverterExtractor<>(responseType, getMessageConverters(), logger);
return execute(url, HttpMethod.GET, requestCallback, responseExtractor, uriVariables);
}这个RestTemplate GET一个HTTP的接口，我们跟进去看下execute这个方法
@Override
@Nullable
public <T> T execute(String url, HttpMethod method, @Nullable RequestCallback requestCallback,
@Nullable ResponseExtractor<T> responseExtractor, Object... uriVariables) throws RestClientException {
URI expanded = getUriTemplateHandler().expand(url, uriVariables);
//在继续跟进去看下这个doExecute
return doExecute(expanded, method, requestCallback, responseExtractor);
}@Nullable
protected <T> T doExecute(URI url, @Nullable HttpMethod method, @Nullable RequestCallback requestCallback,
@Nullable ResponseExtractor<T> responseExtractor) throws RestClientException {
Assert.notNull(url, "URI is required");
Assert.notNull(method, "HttpMethod is required");
ClientHttpResponse response = null;
try {
//我们来看这里
ClientHttpRequest request = createRequest(url, method);
if (requestCallback != null) {
requestCallback.doWithRequest(request);
}
response = request.execute();
handleResponse(url, method, response);
return (responseExtractor != null ? responseExtractor.extractData(response) : null);
}
catch (IOException ex) {
String resource = url.toString();
String query = url.getRawQuery();
resource = (query != null ? resource.substring(0, resource.indexOf('?')) : resource);
throw new ResourceAccessException("I/O error on " + method.name() +
" request for \"" + resource + "\": " + ex.getMessage(), ex);
}
finally {
if (response != null) {
response.close();
}
}
}我们来看这一段ClientHttpRequest request = createRequest(url, method)，看下createRequest()这个方法
protected ClientHttpRequest createRequest(URI url, HttpMethod method) throws IOException {
ClientHttpRequest request = getRequestFactory().createRequest(url, method);
if (logger.isDebugEnabled()) {
logger.debug("HTTP " + method.name() + " " + url);
}
return request;
}这个 getRequestFactory() 这个方法在 InterceptingHttpAccessor 这个类里面重写了一下
@Override
public ClientHttpRequestFactory getRequestFactory() {
List<ClientHttpRequestInterceptor> interceptors = getInterceptors();
//如果存在拦截器并且个数大于1我们走if这段代码
if (!CollectionUtils.isEmpty(interceptors)) {
ClientHttpRequestFactory factory = this.interceptingRequestFactory;
if (factory == null) {
//这个factory 变换了类型了，注意啊这里变换了类型啊
factory = new InterceptingClientHttpRequestFactory(super.getRequestFactory(), interceptors);
this.interceptingRequestFactory = factory;
}
return factory;
}
else {
//不存在拦截器，直接调用父类的 - SimpleClientHttpRequestFactory
return super.getRequestFactory();
}
}我们发现如果RestTemplate这个对象中存在拦截器的情况，最后拿到的ClientHttpRequestFactory 接口实现对象 是InterceptingClientHttpRequestFactory ，不存在就是用 SimpleClientHttpRequestFactory 这个类
@Override
public ClientHttpResponse execute(HttpRequest request, byte[] body) throws IOException {
if (this.iterator.hasNext()) {
ClientHttpRequestInterceptor nextInterceptor = this.iterator.next();
return nextInterceptor.intercept(request, body, this);
}
else {
HttpMethod method = request.getMethod();
Assert.state(method != null, "No standard HTTP method");
ClientHttpRequest delegate = requestFactory.createRequest(request.getURI(), method);
request.getHeaders().forEach((key, value) -> delegate.getHeaders().addAll(key, value));
if (body.length > 0) {
if (delegate instanceof StreamingHttpOutputMessage) {
StreamingHttpOutputMessage streamingOutputMessage = (StreamingHttpOutputMessage) delegate;
streamingOutputMessage.setBody(outputStream -> StreamUtils.copy(body, outputStream));
}
else {
StreamUtils.copy(body, delegate.getBody());
}
}
return delegate.execute();
}
}我们直接看InterceptingClientHttpRequestFactory 这个类的execute()方法，看到熟悉的东西了（拦截器）了，我们看到RestTemplate在调用一个HTTP接口的时候，如果存在拦截器，则执行执行拦截器intercept()方法并返回
接下来我们看下LoadBalancerInterceptor这个类里面intercept()这个方法
@Override
public ClientHttpResponse intercept(final HttpRequest request, final byte[] body,
final ClientHttpRequestExecution execution) throws IOException {
final URI originalUri = request.getURI();
//这里面host其实就是eureka中的服务实例名称
String serviceName = originalUri.getHost();
Assert.state(serviceName != null, "Request URI does not contain a valid hostname: " + originalUri);
//然后调用loadBalancer这个execute
return this.loadBalancer.execute(serviceName, requestFactory.createRequest(request, body, execution));
}哇靠又冒出了一个 loadBalancer （LoadBalancerClient ）这个接口，我们还是看下 LoadBalancerClient 这个接口定义
public interface LoadBalancerClient extends ServiceInstanceChooser {
//根据serviceId找一个运行的服务实例出来，并调用 request.apply() 执行请求
<T> T execute(String serviceId, LoadBalancerRequest<T> request) throws IOException;
<T> T execute(String serviceId, ServiceInstance serviceInstance, LoadBalancerRequest<T> request) throws IOException;
URI reconstructURI(ServiceInstance instance, URI original);
}看到这些接口不难发现，这些肯定是定义负载均衡的一些规范接口，我们先看下这些接口大概的功能
- 父接口中的 ServiceInstance choose(String serviceId) 根据serviceId从负载均衡器中选一个被调用的目标服务实例
- T execute(…) 这个方法有两个重载形式，主要就是请求选好的目标服务实例
- URI reconstructURI(ServiceInstance instance, URI original) 在分布式系统中我们调用的URL 一般是这种格式 http://serviceId/user/getUserById ，这个方法作用就是把serviceId替换成指定 host:port 这种格式 ，比如：http://localhost:8090/user/getUserById
那LoadBalancerClient这个接口实现类 RibbonLoadBalancerClient ，它定义在RibbonAutoConfiguration 自动配置类中
@Bean
@ConditionalOnMissingBean({LoadBalancerClient.class})
public LoadBalancerClient loadBalancerClient() {
return new RibbonLoadBalancerClient(this.springClientFactory());
}@Override
public ServiceInstance choose(String serviceId) {
Server server = getServer(serviceId);
if (server == null) {
return null;
}
return new RibbonServer(serviceId, server, isSecure(server, serviceId),
serverIntrospector(serviceId).getMetadata(server));
}
@Override
public <T> T execute(String serviceId, LoadBalancerRequest<T> request) throws IOException {
//1、每次发送请求都回获取一个ILoadBalancer
ILoadBalancer loadBalancer = getLoadBalancer(serviceId);
//2、集群的时候多个server，这里要挑选一个server出来
Server server = getServer(loadBalancer);
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;
}- ILoadBalancer loadBalancer = getLoadBalancer(serviceId); 获取一个ILoadBalancer 接口实例 loadBalancer
- Server server = getServer(loadBalancer); 然后调用loadBalancer.chooseServer(serviceId)选择一服务器实例（eureka集群的话，要先选择出一台服务器，在选择这台服务器上面的目标服务实例）
上面提到ILoadBalancer这个接口，我们看下ILoadBalancer定义
public interface ILoadBalancer {
void addServers(List<Server> var1);
Server chooseServer(Object var1);
void markServerDown(Server var1);
/** @deprecated */
// 已过期，忽略
@Deprecated
List<Server> getServerList(boolean var1);
List<Server> getReachableServers();
List<Server> getAllServers();
}
可以看到这个ILoadBalacner定义了客户端负债均衡需要的抽象操作
- addServers 向负债均衡器维护的服务列表添加一个服务器实列
- chooseServer 根据serviceId 选择一台服务器实例
- markServerDown 用来通知和标识负载均衡器中某个具体实例已经停止服务
- getReachableServers 获取运行正常的服务器列表信息
- getAllServers 获取所有的服务器列表信息（包括正常和停止的服务器实例）
ILoadBalancer接口的实现类是哪个呢？在哪里初始化了 ？如果我们使用Ribbon做负载均衡的话，我们需要在启动类上面加@RibbonClient注解，我们就去看下@RibbonClient 这个注解
@SpringBootApplication
@EnableEurekaClient
//这个服务实例[ADMINCLOUD-PROVIDER-PRODUCT]负载均衡策略，采用RibbonConfig下面的配置策略
@RibbonClient(name = "ADMINCLOUD-PROVIDER-PRODUCT", configuration = RibbonConfig.class)
public class ConsumerApp {
public static void main(String[] args) {
SpringApplication.run(ConsumerApp.class, args);
}
}看看@RibbonClient这个注解
@Configuration
@Import(RibbonClientConfigurationRegistrar.class)
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface RibbonClient {
/**
* Synonym for name (the name of the client)
*
* @see #name()
*/
String value() default "";
/**
* The name of the ribbon client, uniquely identifying a set of client resources,
* including a load balancer.
*/
String name() default "";
/**
* A custom <code>@Configuration</code> for the ribbon client. Can contain override
# 自定义的Ribbon Client 的configuration，可以包含覆盖
* <code>@Bean</code> definition for the pieces that make up the client, for instance
* {@link ILoadBalancer}, {@link ServerListFilter}, {@link IRule}.
*
* @see RibbonClientConfiguration for the defaults
# 这个还回去自动配置这个 RibbonClientConfiguration 类
*/
Class<?>[] configuration() default {};
}注意看configuration这个属性的描述（我英文也很渣渣），如果我们指定了@RibbonClient 中的Configuration 的，可以包含覆盖 ，那就@RibbonClient默认还回去加载RibbonClientConfiguration 这个配置类
@Bean
@ConditionalOnMissingBean
public IClientConfig ribbonClientConfig() {
DefaultClientConfigImpl config = new DefaultClientConfigImpl();
config.loadProperties(this.name);
config.set(CommonClientConfigKey.ConnectTimeout, DEFAULT_CONNECT_TIMEOUT);
config.set(CommonClientConfigKey.ReadTimeout, DEFAULT_READ_TIMEOUT);
return config;
}
@Bean
@ConditionalOnMissingBean
public IRule ribbonRule(IClientConfig config) {
if (this.propertiesFactory.isSet(IRule.class, name)) {
return this.propertiesFactory.get(IRule.class, config, name);
}
ZoneAvoidanceRule rule = new ZoneAvoidanceRule();
rule.initWithNiwsConfig(config);
return rule;
}
@Bean
@ConditionalOnMissingBean
public IPing ribbonPing(IClientConfig config) {
if (this.propertiesFactory.isSet(IPing.class, name)) {
return this.propertiesFactory.get(IPing.class, config, name);
}
return new DummyPing();
}
@Bean
@ConditionalOnMissingBean
@SuppressWarnings("unchecked")
public ServerList<Server> ribbonServerList(IClientConfig config) {
if (this.propertiesFactory.isSet(ServerList.class, name)) {
return this.propertiesFactory.get(ServerList.class, config, name);
}
ConfigurationBasedServerList serverList = new ConfigurationBasedServerList();
serverList.initWithNiwsConfig(config);
return serverList;
}
@Bean
@ConditionalOnMissingBean
public ServerListUpdater ribbonServerListUpdater(IClientConfig config) {
return new PollingServerListUpdater(config);
}
@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);
}
@Bean
@ConditionalOnMissingBean
@SuppressWarnings("unchecked")
public ServerListFilter<Server> ribbonServerListFilter(IClientConfig config) {
if (this.propertiesFactory.isSet(ServerListFilter.class, name)) {
return this.propertiesFactory.get(ServerListFilter.class, config, name);
}
ZonePreferenceServerListFilter filter = new ZonePreferenceServerListFilter();
filter.initWithNiwsConfig(config);
return filter;
}这个RibbonClientConfiguration配置类里面定义了
- IClientConfig：client配置类
- IRule 负债均衡策略（艹这东西终于看到了）
- IPing 服务可用性检查
- ServerList 服务列表获取
- ServerFilter 服务列表过滤
ILoadBalacner Bean我们看到了，它默认实现类默认是 ZoneAwareLoadBalancer
我们还是来看下ILoadBalancer 里面的chooseServer()
public Server chooseServer(Object key) {
//1、如果就一个zone，直接返回，EurekaServer没做集群那就没啥选的了直接返回
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 {
//2、获取当前有关负载均衡的服务器状态集合
LoadBalancerStats lbStats = getLoadBalancerStats();
Map<String, ZoneSnapshot> zoneSnapshot = ZoneAvoidanceRule.createSnapshot(lbStats);
logger.debug("Zone snapshots: {}", zoneSnapshot);
//3、获取平均负载阈值
if (triggeringLoad == null) {
triggeringLoad = DynamicPropertyFactory.getInstance().getDoubleProperty(
"ZoneAwareNIWSDiscoveryLoadBalancer." + this.getName() + ".triggeringLoadPerServerThreshold", 0.2d);
}
//4、获取平均实例故障率阈值
if (triggeringBlackoutPercentage == null) {
triggeringBlackoutPercentage = DynamicPropertyFactory.getInstance().getDoubleProperty(
"ZoneAwareNIWSDiscoveryLoadBalancer." + this.getName() + ".avoidZoneWithBlackoutPercetage", 0.99999d);
}
//5、根据两个阈值来获取所有可用的服务列表
Set<String> availableZones = ZoneAvoidanceRule.getAvailableZones(zoneSnapshot, triggeringLoad.get(), triggeringBlackoutPercentage.get());
logger.debug("Available zones: {}", availableZones);
if (availableZones != null && availableZones.size() < zoneSnapshot.keySet().size()) {
//6、随机从可用服务区列表中选择一个服务器
String zone = ZoneAvoidanceRule.randomChooseZone(zoneSnapshot, availableZones);
logger.debug("Zone chosen: {}", zone);
if (zone != null) {
//7、得到zoone对应的BaseLoadBalancer
BaseLoadBalancer zoneLoadBalancer = getLoadBalancer(zone);
//8、这里面跟进去看看
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);
}
}- 1、如果就一个zone，直接返回，EurekaServer没做集群那就没啥选的了直接返回
- 2、获取当前有关负载均衡的服务器状态集合
- 3、获取平均负载阈值
- 4、获取平均实例故障率阈值
- 5、根据两个阈值来获取所有可用的服务列表
- 6、随机从可用服务区列表中选择一个服务器
- 7、得到zoone对应的BaseLoadBalancer
public Server chooseServer(Object key) {
if (counter == null) {
counter = createCounter();
}
counter.increment();
if (rule == null) {
return null;
} else {
try {
//根据rule负载策略选择一个server
return rule.choose(key);
} catch (Exception e) {
logger.warn("LoadBalancer [{}]: Error choosing server for key {}", name, key, e);
return null;
}
}
}然后根据我们设定IRule负载均衡策略去选择一个server实，这里多插一句如果我们没配置IRule策略的话，默认就会使用RoundRobinRule() 这个轮询规则
private static Logger logger = LoggerFactory
.getLogger(BaseLoadBalancer.class);
//如何我们没设置IRule的话，默认会采用这个负载策略
private final static IRule DEFAULT_RULE = new RoundRobinRule();
private final static SerialPingStrategy DEFAULT_PING_STRATEGY = new SerialPingStrategy();
private static final String DEFAULT_NAME = "default";
private static final String PREFIX = "LoadBalancer_";那我们继续看下IRule Bean一些实现内容
@Bean
@ConditionalOnMissingBean
public IRule ribbonRule(IClientConfig config) {
if (this.propertiesFactory.isSet(IRule.class, name)) {
return this.propertiesFactory.get(IRule.class, config, name);
}
ZoneAvoidanceRule rule = new ZoneAvoidanceRule();
rule.initWithNiwsConfig(config);
return rule;
} 
- BestAvailableRule :选择最小请求数的服务器
- RoundRobinRule：轮询
- ClientConfigEnabledRoundRobinRule: 使用RoundRobinRule选择服务器
- RetryRule： 根据选的轮询的方式重试
- WeightedResponseTimeRule：根据响应时间去计算一个权重weight ，weight越低，被选择的可能性就越低
- ZoneAvoidanceRule：根据server的zone区域和可用性来轮询选择。
public abstract class PredicateBasedRule extends ClientConfigEnabledRoundRobinRule {
public abstract AbstractServerPredicate getPredicate();
@Override
public Server choose(Object key) {
ILoadBalancer lb = getLoadBalancer();
Optional<Server> server = getPredicate().chooseRoundRobinAfterFiltering(lb.getAllServers(), key);
if (server.isPresent()) {
return server.get();
} else {
return null;
}
}
}ZoneAvoidanceRule是默认的IRule实例，他使用PredicateBasedRule来根据服务区的运行状况和服务器的可用性来选择服务器，它的父类是com.netflix.loadbalancer.PredicateBasedRule
- 先使用ILoadBalancer 获取服务器列表
- 使用AbstractServerPredicate进行服务器过滤
- 最后轮询从剩余的服务器列表中选择最终的服务器
com.netflix.loadbalancer.PredicateBasedRule#getPredicate 又是一个抽象的实现，具体实现 ZoneAvoidanceRule#getPredicate
public ZoneAvoidanceRule() {
super();
ZoneAvoidancePredicate zonePredicate = new ZoneAvoidancePredicate(this);
AvailabilityPredicate availabilityPredicate = new AvailabilityPredicate(this);
compositePredicate = createCompositePredicate(zonePredicate, availabilityPredicate);
}
private CompositePredicate createCompositePredicate(ZoneAvoidancePredicate p1, AvailabilityPredicate p2) {
return CompositePredicate.withPredicates(p1, p2)
.addFallbackPredicate(p2)
.addFallbackPredicate(AbstractServerPredicate.alwaysTrue())
.build();
}- ZoneAvoidancePredicate 判断一个服务器的运行状况是否可用，去除不可用服务器的所有服务器
- AvailabilityPredicate 用于过滤连接数过多的服务器
在来看下chooseRoundRobinAfterFiltering方法，前面已经说过了它是过滤的方法，然后PredicateBasedRule 里面并没有这方法，他直接继承了他的父类 AbstractServerPredicate
public Optional<Server> chooseRoundRobinAfterFiltering(List<Server> servers, Object loadBalancerKey) {
//过滤服务器列表
List<Server> eligible = getEligibleServers(servers, loadBalancerKey);
if (eligible.size() == 0) {
return Optional.absent();
}
//（i+1）%n 轮询选择一个服务实例
return Optional.of(eligible.get(incrementAndGetModulo(eligible.size())));
}/**
* Get servers filtered by this predicate from list of servers.
*/
public List<Server> getEligibleServers(List<Server> servers, Object loadBalancerKey) {
if (loadBalancerKey == null) {
return ImmutableList.copyOf(Iterables.filter(servers, this.getServerOnlyPredicate()));
} else {
List<Server> results = Lists.newArrayList();
for (Server server: servers) {
if (this.apply(new PredicateKey(loadBalancerKey, server))) {
results.add(server);
}
}
return results;
}
}方法getEligibleServers会使用serverOnlyPredicate来依次过滤，serverOnlyPredicate 则会调用apply方法，并将Server 对象分装PredicateKey当作参数传入
AbstractServerPredicate并没有实现apply方法，具体的实现又回到了子类CompositePredicate的apply方法，会依次调用ZoneAvoidancePredicate与AvailabilityPredicate的apply方法
public class ZoneAvoidancePredicate extends AbstractServerPredicate {
@Override
public boolean apply(@Nullable PredicateKey input) {
if (!ENABLED.get()) {
return true;
}
String serverZone = input.getServer().getZone();
if (serverZone == null) {
//1、如果服务器没有zone的相关信息，直接返回
return true;
}
LoadBalancerStats lbStats = getLBStats();
//LoadBalancerStats 存储每个服务器节点的执行特征和运行记录，这些信息可供动态负责均衡使用
if (lbStats == null) {
//2、如果没有服务器的记录，直接返回
return true;
}
if (lbStats.getAvailableZones().size() <= 1) {
//3、如果根本就一个服务器，直接返回
return true;
}
//4、PredicateKey 封装了Server的信息，判断下服务器区的记录是否用当前区的信息
Map<String, ZoneSnapshot> zoneSnapshot = ZoneAvoidanceRule.createSnapshot(lbStats);
//5、如果没有直接返回
if (!zoneSnapshot.keySet().contains(serverZone)) {
// The server zone is unknown to the load balancer, do not filter it out
return true;
}
logger.debug("Zone snapshots: {}", zoneSnapshot);
//6、获取可用的服务器列表
Set<String> availableZones = ZoneAvoidanceRule.getAvailableZones(zoneSnapshot, triggeringLoad.get(), triggeringBlackoutPercentage.get());
logger.debug("Available zones: {}", availableZones);
//7、判断当前服务器是否在可用的服务器列表中
if (availableZones != null) {
return availableZones.contains(input.getServer().getZone());
} else {
return false;
}
}
}最后落到ZoneAvoidanceRule.getAvailableZones 这个方法上面来了
public static Set<String> getAvailableZones(
Map<String, ZoneSnapshot> snapshot, double triggeringLoad,
double triggeringBlackoutPercentage) {
if (snapshot.isEmpty()) {
return null;
}
Set<String> availableZones = new HashSet<String>(snapshot.keySet());
if (availableZones.size() == 1) {
return availableZones;
}
Set<String> worstZones = new HashSet<String>();
double maxLoadPerServer = 0;
boolean limitedZoneAvailability = false;
//遍历所有的服务区
for (Map.Entry<String, ZoneSnapshot> zoneEntry : snapshot.entrySet()) {
String zone = zoneEntry.getKey();
ZoneSnapshot zoneSnapshot = zoneEntry.getValue();
//获取服务器中的服务实例数
int instanceCount = zoneSnapshot.getInstanceCount();
if (instanceCount == 0) {
//如果服务器中没有服务实例，那么移除该服务区
availableZones.remove(zone);
limitedZoneAvailability = true;
} else {
double loadPerServer = zoneSnapshot.getLoadPerServer();
//服务区的实例平均负载小于0，或者实例故障率（断路器端口次数/实例数）大于等于阈值（默认0.99999），则去掉该服务区
if (((double) zoneSnapshot.getCircuitTrippedCount())
/ instanceCount >= triggeringBlackoutPercentage
|| loadPerServer < 0) {
availableZones.remove(zone);
limitedZoneAvailability = true;
} else {
//如果该服务区的平均负载和最大负载的差小于一定的两，则将该服务器加入到最坏服务区集合
if (Math.abs(loadPerServer - maxLoadPerServer) < 0.000001d) {
// they are the same considering double calculation
// round error
worstZones.add(zone);
} else if (loadPerServer > maxLoadPerServer) {
//该zone的负载比平均负载还要大
maxLoadPerServer = loadPerServer;
worstZones.clear();
//把这个zone放到备胎里面去
worstZones.add(zone);
}
}
}
}
//如果当前最大的平均负载小于设定的阈值则直接返回
if (maxLoadPerServer < triggeringLoad && !limitedZoneAvailability) {
// zone override is not needed here
return availableZones;
}
//否则，从最好的服务器集合里面随机挑选一个，如果没有合适的就会去备胎里面选一个
String zoneToAvoid = randomChooseZone(snapshot, worstZones);
if (zoneToAvoid != null) {
availableZones.remove(zoneToAvoid);
}
return availableZones;
}
那接下来就是AvailabilityPredicate的apply方法了
@Override
public boolean apply(@Nullable PredicateKey input) {
LoadBalancerStats stats = getLBStats();
if (stats == null) {
return true;
}
//获得关于该服务器的记录
return !shouldSkipServer(stats.getSingleServerStat(input.getServer()));
}
private boolean shouldSkipServer(ServerStats stats) {
//如果该服务器的断路器已经打开，或者他的连接数大于设定的阈值，那么就需要将服务器过滤掉
if ((CIRCUIT_BREAKER_FILTERING.get() && stats.isCircuitBreakerTripped())
|| stats.getActiveRequestsCount() >= activeConnectionsLimit.get()) {
return true;
}
return false;
}
Server服务器筛选出来后，把serviceId、server服务器实例打包成一个RibbonServer对象，执行execute()方法
@Override
public <T> T execute(String serviceId, LoadBalancerRequest<T> request) throws IOException {
ILoadBalancer loadBalancer = getLoadBalancer(serviceId);
Server server = getServer(loadBalancer);
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;
}最后还是回到 T returnVal = request.apply(serviceInstance); ，这个request 对象就是 requestFactory.createRequest(request, body, execution) 这段代码
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, requestFactory.createRequest(request, body, execution));
}public LoadBalancerRequest<ClientHttpResponse> createRequest(final HttpRequest request,
final byte[] body, final ClientHttpRequestExecution execution) {
return instance -> {
//这里还会将request对象封装成ServiceRequestWrapper对象
HttpRequest serviceRequest = new ServiceRequestWrapper(request, instance, loadBalancer);
if (transformers != null) {
for (LoadBalancerRequestTransformer transformer : transformers) {
serviceRequest = transformer.transformRequest(serviceRequest, instance);
}
}
return execution.execute(serviceRequest, body);
};
}最后执行request.apply() 执行HTTP请求，将请求结果的内容直接return结束
刚开始接触这个Ribbon组件，@LoadBalancer、LoadBalancerClient、ILoadBalancer这几个东西长得都是差不多，但是功能不一样，还是要多看理一理才能搞明白 。。。
- 我们在RestTemplate Bean添加@LoadBalancer注解就是往RestTemplate对象添加LoadBalancerInterceptor拦截器
- HTTP目标接口的时候，如果RestTemplate对象里面有拦截器，拦截器方法里面会调用RibbonLoadBalancerClient 的execute方法
- 在execute方法里面会调用ILoadBalancer.chooseServer() 方法筛选server
- 得到server后封装成RibbonServer对象，最后在执行request 请求接口
