定制设计Spring Cloud：负载均衡 - Spring Cloud Loadbalancer原理

Spring Cloud 2020版本以后，定制设计默认移除了对Netflix的依赖，定制设计其中就包括，定制设计官方默认推荐使用Spring Cloud Loadbalancer正式替换Ribbon，并成为了Spring Cloud定制设计负载均衡器的唯一实现。

定制设计今天我们深入分析一下Spring Cloud Loadbalancer定制设计的具体实现：

使用

1、公共依赖Spring Cloud，例如版本2020.0.2

  1. <dependency>
  2.         <groupId>org.springframework.cloud</groupId>
  3.         <artifactId>spring-cloud-dependencies</artifactId>
  4.         <version>2020.0.2</version>
  5.         <type>pom</type>
  6.         <scope>import</scope>
  7. </dependency>

注意：

如果是Hoxton定制设计之前的版本，默认器为Ribbon，需要移除Ribbon定制设计引用和增加配置spring.cloud.loadbalancer.ribbon.enabled: false

2、引入loadbalancer依赖

  1. <dependency>
  2.     <groupId>org.springframework.cloud</groupId>
  3.     <artifactId>spring-cloud-starter-loadbalancer</artifactId>
  4. </dependency>
  5.  
  6. <!-- 定制设计负载均衡需要搭配注册中心使用，这里引入Nacos定制设计做服务注册，也可采用Eureka等 -->
  7. <!-- SpringCloud Ailibaba Nacos -->
  8. <dependency>
  9.     <groupId>com.alibaba.cloud</groupId>
  10.     <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
  11. </dependency>

注意：

Nacos使用请参考官网：https://nacos.io/zh-cn/index.html

3、使用RestTemplate实现Demo

引入web依赖：

  1. <dependency>
  2.     <!-- 使用web，使用Spring MVC对外提供服务   -->
  3.     <groupId>org.springframework.boot</groupId>
  4.     <artifactId>spring-boot-starter-web</artifactId>
  5. </dependency>

编写DemoController：

  1. @RestController
  2. public class TestController {
  3.     @Autowired
  4.     private RestTemplate restTemplate;
  5.  
  6.     // 新增restTemplate对象注入方法，注意，此处LoadBalanced注解一定要加上，否则无法远程调用
  7.     @Bean
  8.     @LoadBalanced
  9.     public RestTemplate restTemplate() {
  10.         return new RestTemplate();
  11.     }
  12.  
  13.     @GetMapping("/load")
  14.     public String load() {
  15.         return restTemplate.getForObject("http://demo-server/hello/", String.class);
  16.     }
  17.  
  18.     @GetMapping(value = "/hello")
  19.     public String hello() {
  20.         return "Hello World";
  21.     }
  22. }

4、启动Nacos，调用接口http://localhost:8080/load

原理

上面是RestTemplate负载均衡的简单实现，除此之外，Spring Cloud LoadBalancer还支持Spring Web Flux响应式编程，这里我们不展开，两者的实现原理思想相同，都是通过客户端添加拦截器，在拦截器中实现负载均衡。

1、#RestTemplate，提供了一个方法setInterceptors，用于设置拦截器，拦截器需要实现ClientHttpRequestInterceptor接口即可，在实际远程去请求服务端接口之前会先调用拦截器的intercept方法逻辑。这里的拦截器相当于Servlet技术中的Filter功能。

  1. // 代码实现在抽象父类InterceptingHttpAccessor里
  2. // RestTemplate.InterceptingHttpAccessor#setInterceptors
  3. public void setInterceptors(List<ClientHttpRequestInterceptor> interceptors) {
  4.    // Take getInterceptors() List as-is when passed in here
  5.    if (this.interceptors != interceptors) {
  6.       this.interceptors.clear();
  7.       this.interceptors.addAll(interceptors);
  8.       AnnotationAwareOrderComparator.sort(this.interceptors);
  9.    }
  10. }

2、#LoadBalancerAutoConfiguration，由于@LoadBalanced注解由spring-cloud-commons实现，查看实现逻辑我们发现spring-cloud-commons存在自动配置类LoadBalancerAutoConfiguration，当满足条件时，将自动创建LoadBalancerInterceptor并注入到RestTemplate中。

  1.     @Configuration(
  2.         proxyBeanMethods = false
  3.     )
  4.     @Conditional({LoadBalancerAutoConfiguration.RetryMissingOrDisabledCondition.class})
  5.     static class LoadBalancerInterceptorConfig {
  6.         LoadBalancerInterceptorConfig() {
  7.         }
  8.  
  9.         @Bean
  10.         public LoadBalancerInterceptor loadBalancerInterceptor(LoadBalancerClient loadBalancerClient, LoadBalancerRequestFactory requestFactory) {
  11.             return new LoadBalancerInterceptor(loadBalancerClient, requestFactory);
  12.         }
  13.  
  14.         @Bean
  15.         @ConditionalOnMissingBean
  16.         public RestTemplateCustomizer restTemplateCustomizer(final LoadBalancerInterceptor loadBalancerInterceptor) {
  17.             return (restTemplate) -> {
  18.                 List<ClientHttpRequestInterceptor> list = new ArrayList(restTemplate.getInterceptors());
  19.                 list.add(loadBalancerInterceptor);
  20.                 restTemplate.setInterceptors(list);
  21.             };
  22.         }
  23.     }

3、#LoadRalancerLnterceptor，LoadBalancerInterceptor实现了ClientHttpRequestInterceptor接口，实现intercept方法，用于实现负载均衡的拦截处理。

  1. public class LoadBalancerInterceptor implements ClientHttpRequestInterceptor {
  2.     private LoadBalancerClient loadBalancer;
  3.     private LoadBalancerRequestFactory requestFactory;
  4.  
  5.     public LoadBalancerInterceptor(LoadBalancerClient loadBalancer, LoadBalancerRequestFactory requestFactory) {
  6.         this.loadBalancer = loadBalancer;
  7.         this.requestFactory = requestFactory;
  8.     }
  9.  
  10.     public LoadBalancerInterceptor(LoadBalancerClient loadBalancer) {
  11.         this(loadBalancer, new LoadBalancerRequestFactory(loadBalancer));
  12.     }
  13.  
  14.     public ClientHttpResponse intercept(final HttpRequest request, final byte[] body, final ClientHttpRequestExecution execution) throws IOException {
  15.         URI originalUri = request.getURI();
  16.         String serviceName = originalUri.getHost();
  17.         Assert.state(serviceName != null, "Request URI does not contain a valid hostname: " + originalUri);
  18.         return (ClientHttpResponse)this.loadBalancer.execute(serviceName, this.requestFactory.createRequest(request, body, execution));
  19.     }
  20. }

4、#LoadBalancerClient，负载均衡客户端，用于进行负载均衡逻辑，从服务列表中选择出一个服务地址进行调用。Spring Cloud LoadBalancer的默认实现为BlockingLoadBalancerClient，

  1.     public <T> T execute(String serviceId, LoadBalancerRequest<T> request) throws IOException {
  2.         String hint = this.getHint(serviceId);
  3.         LoadBalancerRequestAdapter<T, DefaultRequestContext> lbRequest = new LoadBalancerRequestAdapter(request, new DefaultRequestContext(request, hint));
  4.         Set<LoadBalancerLifecycle> supportedLifecycleProcessors = this.getSupportedLifecycleProcessors(serviceId);
  5.         supportedLifecycleProcessors.forEach((lifecycle) -> {
  6.             lifecycle.onStart(lbRequest);
  7.         });
  8.       //选择服务
  9.         ServiceInstance serviceInstance = this.choose(serviceId, lbRequest);
  10.         if (serviceInstance == null) {
  11.             supportedLifecycleProcessors.forEach((lifecycle) -> {
  12.                 lifecycle.onComplete(new CompletionContext(Status.DISCARD, lbRequest, new EmptyResponse()));
  13.             });
  14.             throw new IllegalStateException("No instances available for " + serviceId);
  15.         } else {
  16.             return this.execute(serviceId, serviceInstance, lbRequest);
  17.         }
  18.     }
  19.  
  20.     public <T> T execute(String serviceId, ServiceInstance serviceInstance, LoadBalancerRequest<T> request) throws IOException {
  21.         DefaultResponse defaultResponse = new DefaultResponse(serviceInstance);
  22.         Set<LoadBalancerLifecycle> supportedLifecycleProcessors = this.getSupportedLifecycleProcessors(serviceId);
  23.         Request lbRequest = request instanceof Request ? (Request)request : new DefaultRequest();
  24.         supportedLifecycleProcessors.forEach((lifecycle) -> {
  25.             lifecycle.onStartRequest(lbRequest, new DefaultResponse(serviceInstance));
  26.         });
  27.  
  28.         try {
  29.             T response = request.apply(serviceInstance);
  30.             Object clientResponse = this.getClientResponse(response);
  31.             supportedLifecycleProcessors.forEach((lifecycle) -> {
  32.                 lifecycle.onComplete(new CompletionContext(Status.SUCCESS, lbRequest, defaultResponse, clientResponse));
  33.             });
  34.             return response;
  35.         } catch (IOException var9) {
  36.             supportedLifecycleProcessors.forEach((lifecycle) -> {
  37.                 lifecycle.onComplete(new CompletionContext(Status.FAILED, var9, lbRequest, defaultResponse));
  38.             });
  39.             throw var9;
  40.         } catch (Exception var10) {
  41.             supportedLifecycleProcessors.forEach((lifecycle) -> {
  42.                 lifecycle.onComplete(new CompletionContext(Status.FAILED, var10, lbRequest, defaultResponse));
  43.             });
  44.             ReflectionUtils.rethrowRuntimeException(var10);
  45.             return null;
  46.         }
  47.     }
  48.  
  49. ....  
  50.  
  51.     public ServiceInstance choose(String serviceId) {
  52.         return this.choose(serviceId, ReactiveLoadBalancer.REQUEST);
  53.     }
  54.  
  55.  //通过不同的负载均衡客户端实现选择不同的服务
  56.     public <T> ServiceInstance choose(String serviceId, Request<T> request) {
  57.         ReactiveLoadBalancer<ServiceInstance> loadBalancer = this.loadBalancerClientFactory.getInstance(serviceId);
  58.         if (loadBalancer == null) {
  59.             return null;
  60.         } else {
  61.             Response<ServiceInstance> loadBalancerResponse = (Response)Mono.from(loadBalancer.choose(request)).block();
  62.             return loadBalancerResponse == null ? null : (ServiceInstance)loadBalancerResponse.getServer();
  63.         }
  64.     }

5、#LoadBalancerClientFactory，BlockingLoadBalancerClient中持有LoadBalancerClientFactory通过调用其getInstance方法获取具体的负载均衡客户端。客户端实现了不同的负载均衡算法，比如轮询、随机等。LoadBalancerClientFactory继承了NamedContextFactory，NamedContextFactory继承ApplicationContextAware，实现Spring ApplicationContext容器操作。

  1. public class LoadBalancerClientFactory extends NamedContextFactory<LoadBalancerClientSpecification> implements Factory<ServiceInstance> {
  2.     public static final String NAMESPACE = "loadbalancer";
  3.     public static final String PROPERTY_NAME = "loadbalancer.client.name";
  4.  
  5.     public LoadBalancerClientFactory() {
  6.         super(LoadBalancerClientConfiguration.class, "loadbalancer", "loadbalancer.client.name");
  7.     }
  8.  
  9.     public String getName(Environment environment) {
  10.         return environment.getProperty("loadbalancer.client.name");
  11.     }
  12.  
  13.     public ReactiveLoadBalancer<ServiceInstance> getInstance(String serviceId) {
  14.         return (ReactiveLoadBalancer)this.getInstance(serviceId, ReactorServiceInstanceLoadBalancer.class);
  15.     }
  16. }

在spring-cloud-loadbalabcer中的LoadBalancerAutoConfiguration实现了LoadBalancerClientFactory缺省值：

  1.     @ConditionalOnMissingBean
  2.     @Bean
  3.     public LoadBalancerClientFactory loadBalancerClientFactory() {
  4.         LoadBalancerClientFactory clientFactory = new LoadBalancerClientFactory();
  5.         clientFactory.setConfigurations((List)this.configurations.getIfAvailable(Collections::emptyList));
  6.         return clientFactory;
  7.     }

6、#ReactiveLoadBalancer，负载均衡器，实现服务选择。Spring Cloud Balancer中实现了轮询RoundRobinLoadBalancer和随机数RandomLoadBalancer两种负载均衡算法。

如果没有显式指定负载均衡算法，默认缺省值为RoundRobinLoadBalancer。

LoadBalancerClientConfiguration#LoadBalancerClientConfiguration

  1.     @Bean
  2.     @ConditionalOnMissingBean
  3.     public ReactorLoadBalancer<ServiceInstance> reactorServiceInstanceLoadBalancer(Environment environment, LoadBalancerClientFactory loadBalancerClientFactory) {
  4.         String name = environment.getProperty("loadbalancer.client.name");
  5.         return new RoundRobinLoadBalancer(loadBalancerClientFactory.getLazyProvider(name, ServiceInstanceListSupplier.class), name);
  6.     }

7、#LoadBalancerRequestFactory，LoadBalancerRequest工厂类，用于创建LoadBalancerRequest，调用createRequest方法。在内部持有LoadBalancerClient属性对象，即BlockingLoadBalancerClient。

  1. public class LoadBalancerRequestFactory {
  2.     private LoadBalancerClient 
  3. ;
  4.     private List<LoadBalancerRequestTransformer> transformers;
  5.  
  6.     public LoadBalancerRequestFactory(LoadBalancerClient loadBalancer, List<LoadBalancerRequestTransformer> transformers) {
  7.         this.loadBalancer = loadBalancer;
  8.         this.transformers = transformers;
  9.     }
  10.  
  11.     public LoadBalancerRequestFactory(LoadBalancerClient loadBalancer) {
  12.         this.loadBalancer = loadBalancer;
  13.     }
  14.  
  15.     public LoadBalancerRequest<ClientHttpResponse> createRequest(final HttpRequest request, final byte[] body, final ClientHttpRequestExecution execution) {
  16.         return (instance) -> {
  17.             HttpRequest serviceRequest = new ServiceRequestWrapper(request, instance, this.loadBalancer);
  18.             LoadBalancerRequestTransformer transformer;
  19.             if (this.transformers != null) {
  20.                 for(Iterator var6 = this.transformers.iterator(); var6.hasNext(); serviceRequest = transformer.transformRequest((HttpRequest)serviceRequest, instance)) {
  21.                     transformer = (LoadBalancerRequestTransformer)var6.next();
  22.                 }
  23.             }
  24.  
  25.             return execution.execute((HttpRequest)serviceRequest, body);
  26.         };
  27.     }
  28. }

 

整合Feign

在日常项目中，一般负载均衡都是结合Feign使用，下面我们讨论下结合Fegin的使用情况

1、引入依赖

  1.         <!-- SpringCloud Openfeign -->
  2.         <dependency>
  3.             <groupId>org.springframework.cloud</groupId>
  4.             <artifactId>spring-cloud-starter-openfeign</artifactId>
  5.         </dependency>
  6.  
  7.        <!-- 其他 loadbalancer依赖 -->

2、定义Feign接口

  1. @FeignClient(name = "my-service")
  2. public interface RemoteLogService {
  3.  
  4.     @PostMapping("/sys/log")
  5.     R<Boolean> saveLog(@RequestBody SysLog sysLog);
  6. }

3、调用Feign接口调试（正常负载均衡已经可以使用，无需做其他配置）

4、原理分析

下图是Feign的实现原理，详情可参考博文：

4.1、查看Feign的loadbalancer的自动配置：FeignLoadBalancerAutoConfiguration，存在

LoadBalancerClient和LoadBalancerClientFactory的bean时，配置生效，默认使用DefaultFeignLoadBalancerConfiguration。请注意，如果引用了OkHttp或HttpClient，将使用不同的configuration文件。

  1. @ConditionalOnClass({Feign.class})
  2. @ConditionalOnBean({LoadBalancerClient.class, LoadBalancerClientFactory.class})
  3. @AutoConfigureBefore({FeignAutoConfiguration.class})
  4. @AutoConfigureAfter({BlockingLoadBalancerClientAutoConfiguration.class, LoadBalancerAutoConfiguration.class})
  5. @EnableConfigurationProperties({FeignHttpClientProperties.class})
  6. @Configuration(
  7.     proxyBeanMethods = false
  8. )
  9. @Import({HttpClientFeignLoadBalancerConfiguration.class, OkHttpFeignLoadBalancerConfiguration.class, HttpClient5FeignLoadBalancerConfiguration.class, DefaultFeignLoadBalancerConfiguration.class})
  10. public class FeignLoadBalancerAutoConfiguration {
  11.     public FeignLoadBalancerAutoConfiguration() {
  12.     }
  13. }

4.2、#DefaultFeignLoadBalancerConfiguration，将缺省创建FeignBlockingLoadBalancerClient并注入LoadBalancerClient和LoadBalancerClientFactory，这两个bean的创建请参考上文。

  1. @Configuration(
  2.     proxyBeanMethods = false
  3. )
  4. @EnableConfigurationProperties({LoadBalancerProperties.class})
  5. class DefaultFeignLoadBalancerConfiguration {
  6.     DefaultFeignLoadBalancerConfiguration() {
  7.     }
  8.  
  9.     @Bean
  10.     @ConditionalOnMissingBean
  11.     @Conditional({OnRetryNotEnabledCondition.class})
  12.     public Client feignClient(LoadBalancerClient loadBalancerClient, LoadBalancerProperties properties, LoadBalancerClientFactory loadBalancerClientFactory) {
  13.         return new FeignBlockingLoadBalancerClient(new Default((SSLSocketFactory)null, (HostnameVerifier)null), loadBalancerClient, properties, loadBalancerClientFactory);
  14.     }
  15. 	
  16. 	...
  17. }

4.3、#FeignBlockingLoadBalancerClient，实现excute方法，实现Feign具体请求操作，通过loadBalancerClient.choose获取实例并执行请求，具体选择逻辑和RestTemplate一致。

  1. public class FeignBlockingLoadBalancerClient implements Client {
  2.  
  3.     private final Client delegate;
  4.     private final LoadBalancerClient loadBalancerClient;
  5.     private final LoadBalancerProperties properties;
  6.     private final LoadBalancerClientFactory loadBalancerClientFactory;
  7.  
  8.     public Response execute(Request request, Options options) throws IOException {
  9.         URI originalUri = URI.create(request.url());
  10.         String serviceId = originalUri.getHost();
  11.         Assert.state(serviceId != null, "Request URI does not contain a valid hostname: " + originalUri);
  12.         String hint = this.getHint(serviceId);
  13.         DefaultRequest<RequestDataContext> lbRequest = new DefaultRequest(new RequestDataContext(LoadBalancerUtils.buildRequestData(request), hint));
  14.         Set<LoadBalancerLifecycle> supportedLifecycleProcessors = LoadBalancerLifecycleValidator.getSupportedLifecycleProcessors(this.loadBalancerClientFactory.getInstances(serviceId, LoadBalancerLifecycle.class), RequestDataContext.class, ResponseData.class, ServiceInstance.class);
  15.         supportedLifecycleProcessors.forEach((lifecycle) -> {
  16.             lifecycle.onStart(lbRequest);
  17.         });
  18.         ServiceInstance instance = this.loadBalancerClient.choose(serviceId, lbRequest);
  19.         org.springframework.cloud.client.loadbalancer.Response<ServiceInstance> lbResponse = new DefaultResponse(instance);
  20.         String message;
  21.         if (instance == null) {
  22.             message = "Load balancer does not contain an instance for the service " + serviceId;
  23.             if (LOG.isWarnEnabled()) {
  24.                 LOG.warn(message);
  25.             }
  26.  
  27.             supportedLifecycleProcessors.forEach((lifecycle) -> {
  28.                 lifecycle.onComplete(new CompletionContext(Status.DISCARD, lbRequest, lbResponse));
  29.             });
  30.             return Response.builder().request(request).status(HttpStatus.SERVICE_UNAVAILABLE.value()).body(message, StandardCharsets.UTF_8).build();
  31.         } else {
  32.             message = this.loadBalancerClient.reconstructURI(instance, originalUri).toString();
  33.             Request newRequest = this.buildRequest(request, message);
  34.             return LoadBalancerUtils.executeWithLoadBalancerLifecycleProcessing(this.delegate, options, newRequest, lbRequest, lbResponse, supportedLifecycleProcessors);
  35.         }
  36.     }
  37.  
  38. }

 

 
网站建设定制开发 软件系统开发定制 定制软件开发 软件开发定制 定制app开发 app开发定制 app开发定制公司 电商商城定制开发 定制小程序开发 定制开发小程序 客户管理系统开发定制 定制网站 定制开发 crm开发定制 开发公司 小程序开发定制 定制软件 收款定制开发 企业网站定制开发 定制化开发 android系统定制开发 定制小程序开发费用 定制设计 专注app软件定制开发 软件开发定制定制 知名网站建设定制 软件定制开发供应商 应用系统定制开发 软件系统定制开发 企业管理系统定制开发 系统定制开发