簡介： Spring Cloud LoadBalancer詳解和源碼分析

Spring Cloud LoadBalancer目前Spring官方是放在spring-cloud-commons裡，

Spring Cloud最新版本為2021.0.2

Spring Cloud LoadBalancer 官網文檔位址 https://docs.spring.io/spring-cloud-commons/docs/3.1.2/reference/html/#spring-cloud-loadbalancer

Spring Cloud官網文檔位址 https://docs.spring.io/spring-cloud/docs/current/reference/html/

一方面Netflix Ribbon停止更新，Spring Cloud LoadBalancer是Spring Cloud官方自己提供的用戶端負載均衡器,抽象和實作，用來替代Ribbon。

常見負載均衡器分為服務端負載均衡器(如網關層均衡負載)和用戶端層均衡負載。

網關層如硬體層面的F5或軟體層面的LVS、或者nginx等。

用戶端層就如Spring Cloud LoadBalancer，作為一個用戶端去發現更新維護服務清單，自定義服務的均衡負載政策（随機、輪詢、小流量的金絲雀等等）。

Spring Cloud提供了自己的用戶端負載平衡器抽象和實作。對于負載均衡機制，

增加了ReactiveLoadBalancer接口，并提供了基于round-robin輪詢和Random随機的實作。

為了從響應式ServiceInstanceListSupplier中選擇執行個體，需要使用ServiceInstanceListSupplier。目前支援ServiceInstanceListSupplier的基于服務發現的實作，該實作使用類路徑中的發現用戶端從Service Discovery中檢索可用的執行個體。

可以通過如下配置來禁用Spring Cloud LoadBalance

spring:

cloud:

loadbalancer:

enabled: false

入門示例

前面simple-ecommerce項目建立已在父Pom引入三大父依賴，詳細可以看下前面的文章<<SpringCloudAlibaba注冊中心與配置中心之利器Nacos實戰與源碼分析>>，其中Spring Cloud的版本為2021.0.1，

前面文章也已說過，Spring Cloud Alibaba整合在spring-cloud-starter-alibaba-nacos-discovery本身就依賴spring-cloud-loadbalancer。

注意如果是Hoxton之前的版本，預設負載均衡器為Ribbon，需要移除Ribbon引用和增加配置spring.cloud.loadbalancer.ribbon.enabled: false。

如果是在Spring Boot項目中添加下面的啟動器依賴，該starter也包含了Spring Boot Caching and Evictor.

<dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-loadbalancer</artifactId>
</dependency>

我們使用Spring官方提供了負載均衡的用戶端之一RestTemplate，RestTemplate是Spring提供的用于通路Rest服務的用戶端，RestTemplate提供了多種便捷通路遠端Http服務的方法，能夠大大提高用戶端的編寫效率。預設情況下，RestTemplate預設依賴jdk的HTTP連接配接工具。建立RestTemplateConfig配置類，

标注 @LoadBalanced注解，預設使用的ReactiveLoadBalancer實作是RoundRobinLoadBalancer。

原理:

RestTemplate

Spring Cloud LoadBalancer源碼分析我們先從RestTemplate負載均衡的簡單實作來分析入手，除此之外其支援Spring Web Flux響應式程式設計的實作原理思想也是相同，都是通過用戶端添加攔截器，在攔截器中實作負載均衡。從RestTemplate的源碼中可以知道其繼承自InterceptingHttpAccessor抽象類

Spring Cloud LoadBalancer詳解和源碼分析，看了搞定面試官

而InterceptingHttpAccessor抽象類則提供了一個方法setInterceptors，用于設定攔截器，攔截器需要實作ClientHttpRequestInterceptor接口即可，在實際遠端請求服務端接口之前會先調用攔截器的intercept方法。這裡的攔截器相當于Servlet技術中的Filter功能

// 代碼實作在抽象父類InterceptingHttpAccessor裡
// RestTemplate.InterceptingHttpAccessor#setInterceptors
public void setInterceptors(List<ClientHttpRequestInterceptor> interceptors) {
 Assert.noNullElements(interceptors, "'interceptors' must not contain null elements");
 // Take getInterceptors() List as-is when passed in here
 if (this.interceptors != interceptors) {
  this.interceptors.clear();
  this.interceptors.addAll(interceptors);
  AnnotationAwareOrderComparator.sort(this.interceptors);
 }
}

LoadBalancerAutoConfiguration

從官網可以知道Spring Cloud LoadBalancer放在spring-cloud-commons，是以也作為其核心的@LoadBalanced注解也就是由spring-cloud-commons來實作，依據SpringBoot自動裝配的原理先檢視依賴包的實作邏輯，不難發現spring-cloud-commons引入了自動配置類LoadBalancerAutoConfiguration和ReactorLoadBalancerClientAutoConfiguration。

當滿足上述的條件時（@Conditional為條件注解），将自動建立LoadBalancerInterceptor并注入到RestTemplate中。

LoadBalancerLnterceptor

LoadBalancerInterceptor實作了ClientHttpRequestInterceptor接口，是以也實作intercept方法，用于實作負載均衡的攔截處理。

LoadBalancerClient

LoadBalancerClient用于進行負載均衡邏輯，繼承自ServiceInstanceChooser接口，從服務清單中選擇出一個服務位址進行調用。在LoadBalancerClient種存在兩個execute()方法，均是用來執行請求的，reconstructURI()是用來重構URL。

對于LoadBalancerClient接口Spring Cloud LoadBalancer的提供預設實作為BlockingLoadBalancerClient

@SuppressWarnings({ "unchecked", "rawtypes" })
public class BlockingLoadBalancerClient implements LoadBalancerClient {
private final ReactiveLoadBalancer.Factory<ServiceInstance> loadBalancerClientFactory;
/**
 * @deprecated in favour of
 * {@link BlockingLoadBalancerClient#BlockingLoadBalancerClient(ReactiveLoadBalancer.Factory)}
 */
@Deprecated
public BlockingLoadBalancerClient(LoadBalancerClientFactory loadBalancerClientFactory,
  LoadBalancerProperties properties) {
 this.loadBalancerClientFactory = loadBalancerClientFactory;
}
public BlockingLoadBalancerClient(ReactiveLoadBalancer.Factory<ServiceInstance> loadBalancerClientFactory) {
 this.loadBalancerClientFactory = loadBalancerClientFactory;
}
@Override
public <T> T execute(String serviceId, LoadBalancerRequest<T> request) throws IOException {
 String hint = getHint(serviceId);
 LoadBalancerRequestAdapter<T, DefaultRequestContext> lbRequest = new LoadBalancerRequestAdapter<>(request,
   new DefaultRequestContext(request, hint));
 Set<LoadBalancerLifecycle> supportedLifecycleProcessors = getSupportedLifecycleProcessors(serviceId);
 supportedLifecycleProcessors.forEach(lifecycle -> lifecycle.onStart(lbRequest));
 ServiceInstance serviceInstance = choose(serviceId, lbRequest);
    // 選擇服務
 if (serviceInstance == null) {
  supportedLifecycleProcessors.forEach(lifecycle -> lifecycle.onComplete(
    new CompletionContext<>(CompletionContext.Status.DISCARD, lbRequest, new EmptyResponse())));
  throw new IllegalStateException("No instances available for " + serviceId);
 }
 return execute(serviceId, serviceInstance, lbRequest);
}
@Override
public <T> T execute(String serviceId, ServiceInstance serviceInstance, LoadBalancerRequest<T> request)
  throws IOException {
 DefaultResponse defaultResponse = new DefaultResponse(serviceInstance);
 Set<LoadBalancerLifecycle> supportedLifecycleProcessors = getSupportedLifecycleProcessors(serviceId);
 Request lbRequest = request instanceof Request ? (Request) request : new DefaultRequest<>();
 supportedLifecycleProcessors
   .forEach(lifecycle -> lifecycle.onStartRequest(lbRequest, new DefaultResponse(serviceInstance)));
 try {
  T response = request.apply(serviceInstance);
  Object clientResponse = getClientResponse(response);
  supportedLifecycleProcessors
    .forEach(lifecycle -> lifecycle.onComplete(new CompletionContext<>(CompletionContext.Status.SUCCESS,
      lbRequest, defaultResponse, clientResponse)));
  return response;
 }
 catch (IOException iOException) {
  supportedLifecycleProcessors.forEach(lifecycle -> lifecycle.onComplete(
    new CompletionContext<>(CompletionContext.Status.FAILED, iOException, lbRequest, defaultResponse)));
  throw iOException;
 }
 catch (Exception exception) {
  supportedLifecycleProcessors.forEach(lifecycle -> lifecycle.onComplete(
    new CompletionContext<>(CompletionContext.Status.FAILED, exception, lbRequest, defaultResponse)));
  ReflectionUtils.rethrowRuntimeException(exception);
 }
 return null;
}
private <T> Object getClientResponse(T response) {
 ClientHttpResponse clientHttpResponse = null;
 if (response instanceof ClientHttpResponse) {
  clientHttpResponse = (ClientHttpResponse) response;
 }
 if (clientHttpResponse != null) {
  try {
   return new ResponseData(clientHttpResponse, null);
  }
  catch (IOException ignored) {
  }
 }
 return response;
}
private Set<LoadBalancerLifecycle> getSupportedLifecycleProcessors(String serviceId) {
 return LoadBalancerLifecycleValidator.getSupportedLifecycleProcessors(
   loadBalancerClientFactory.getInstances(serviceId, LoadBalancerLifecycle.class),
   DefaultRequestContext.class, Object.class, ServiceInstance.class);
}
@Override
public URI reconstructURI(ServiceInstance serviceInstance, URI original) {
 return LoadBalancerUriTools.reconstructURI(serviceInstance, original);
}
@Override
public ServiceInstance choose(String serviceId) {
 return choose(serviceId, REQUEST);
}
// 通過不同的負載均衡用戶端實作選擇不同的服務
@Override
public <T> ServiceInstance choose(String serviceId, Request<T> request) {
 ReactiveLoadBalancer<ServiceInstance> loadBalancer = loadBalancerClientFactory.getInstance(serviceId);
 if (loadBalancer == null) {
  return null;
 }
 Response<ServiceInstance> loadBalancerResponse = Mono.from(loadBalancer.choose(request)).block();
 if (loadBalancerResponse == null) {
  return null;
 }
 return loadBalancerResponse.getServer();
}
private String getHint(String serviceId) {
 LoadBalancerProperties properties = loadBalancerClientFactory.getProperties(serviceId);
 String defaultHint = properties.getHint().getOrDefault("default", "default");
 String hintPropertyValue = properties.getHint().get(serviceId);
 return hintPropertyValue != null ? hintPropertyValue : defaultHint;
}
}

LoadBalancerClientFactory

BlockingLoadBalancerClient中持有LoadBalancerClientFactory通過調用其getInstance方法擷取具體的負載均衡用戶端。通過工廠類LoadBalancerClientFactory擷取具體的負載均衡器執行個體，後面的loadBalancer.choose(request)調用其接口choose()方法實作根據負載均衡算法選擇下一個伺服器完成負載均衡，而ReactiveLoadBalancer getInstance(String serviceId) 有預設實作LoadBalancerClientFactory

LoadBalancerClientFactory用戶端實作了不同的負載均衡算法，比如輪詢、随機等。LoadBalancerClientFactory繼承自NamedContextFactory，NamedContextFactory繼承ApplicationContextAware，實作Spring ApplicationContext容器操作。

ReactiveLoadBalancer

ReactiveLoadBalancer負載均衡器實作服務選擇，Spring Cloud Balancer中實作了輪詢RoundRobinLoadBalancer、随機RandomLoadBalancer、NacosLoadBalancer算法。

LoadBalancerClientConfiguration

如果沒有顯式指定負載均衡算法，預設預設值為RoundRobinLoadBalancer

@Bean

@ConditionalOnMissingBean

public ReactorLoadBalancer<ServiceInstance> reactorServiceInstanceLoadBalancer(Environment environment,

LoadBalancerClientFactory loadBalancerClientFactory) {

String name = environment.getProperty(LoadBalancerClientFactory.PROPERTY_NAME);

return new RoundRobinLoadBalancer(

loadBalancerClientFactory.getLazyProvider(name, ServiceInstanceListSupplier.class), name);

}

LoadBalancerRequestFactory

LoadBalancerRequest工廠類調用createRequest方法用于建立LoadBalancerRequest。其内部持有LoadBalancerClient對象也即持有BlockingLoadBalancerClient。

在日常項目中，一般負載均衡都是結合Feign使用，後續我們有時間再來分析Feign整合LoadBalancer的自動配置類FeignLoadBalancerAutoConfiguration的實作

ReactorLoadBalancerClientAutoConfiguration

我們也抛一下基于WebClient的@Loadbalanced的流程的引入，首先聲明負載均衡過濾器ReactorLoadBalancerClientAutoConfiguration是一個自動裝配器類，在項目中引入了 WebClient 和 ReactiveLoadBalancer 類之後，自動裝配流程就開始運作，它會初始化一個實作了 ExchangeFilterFunction 的執行個體，在後面該執行個體将作為過濾器被注入到WebClient。後續流程有興趣再自行研究

自定義負載均衡器

從上面可以知道LoadBalancerClientFactory是建立客戶機、負載均衡器和客戶機配置執行個體的工廠。它根據用戶端名稱建立一個Spring ApplicationContext，并從中提取所需的bean。是以進入到LoadBalancerClientFactory類中，需要去實作它的子接口ReactorServiceInstanceLoadBalancer，因為去擷取負載均衡器執行個體的時候，是通過去容器中查找ReactorServiceInstanceLoadBalancer類型的bean來實作的，可以參照RandomLoadBalancer實作代碼

自定義負載均衡器

Spring Cloud LoadBalancer詳解和源碼分析，看了搞定面試官

可以通過如下配置來禁用Spring Cloud LoadBalance

RestTemplate

LoadBalancerAutoConfiguration

LoadBalancerLnterceptor

LoadBalancerClient

LoadBalancerClientFactory

ReactiveLoadBalancer

LoadBalancerRequestFactory

ReactorLoadBalancerClientAutoConfiguration

繼續閱讀

馴服爛代碼_馴服Tomcat：Tomcat 5的過濾技巧

基于Springboot+VUE+Mysql的大學生校園疫情防控管理系統

Using MessageConverter

馴服爛代碼_C＃中的馴服配置

Spring Cloud整合Sleuth，當請求完成後，Zipkin沒有鍊路資訊

JAVA自學之路——馬士兵

Rabbitmq指令行手動建立隊列

整合 Spring 開發架構及服務端技術

SSM整合02---Spring-SpringMVC層一、添加web架構支援二、web.xml三、spring-mvc.xml

SSM架構（二）------------表現層的SpringMVC

Intellij idea基于Maven 的SSM 架構整合

F-15“鷹”式座艙的演變圖一：F-15A/BEagle圖二：F-15C/DEagle圖三：F-15EStrikeEag

Spring資料和Redis

SpringMVC的啟動過程源碼分析1 SpringMVC 配置XML的方式啟動2 SpringMVC純注解模式啟動

Java Spring 架構

SpringCloud微服務（四）之ribbon筆記ribbon是什麼？入門案例自定義均衡負載算法