服务负载均衡-Spring Cloud Netflix-Ribbon

绝地灬酷狼 2022-12-27 11:24 165阅读 0赞

> **关键词：**负载均衡    Ribbon

--------------------

# **█ 项目准备** #

**公共依赖：**

<properties>
        <java.version>1.8</java.version>
        
        <spring-cloud.version>Hoxton.RELEASE</spring-cloud.version>
        <spring-boot.version>2.2.1.RELEASE</spring-boot.version>
    </properties>
    
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter</artifactId>
                <version>${spring-boot.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

**创建服务端：**

（1）引入依赖：

<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

（2）创建配置文件application.yml

server:
      port: 9090
      
    spring:
      application:
        name: myServer

（3）创建Controller

import org.springframework.beans.factory.annotation.Value;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    @RestController
    public class MyServerController {
    
        @Value("${server.port}")
        private Integer port;
    
        @GetMapping("/server/info")
        public String getInfo() {
            return "server:"+port;
        }
    
    }

（4）创建启动类，并启动项目

import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    
    @SpringBootApplication
    public class MyServerApplication {
    
        public static void main(String[] args) {
            SpringApplication.run(MyServerApplication.class, args);
        }
    
    }

（5）测试服务端接口，浏览器访问：http://localhost:9090/server/info

![20201210193720486.png][]

**创建客户端：**

（1）引入依赖：

<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

（2）创建配置文件application.yml

server:
      port: 8080

（3）创建启动类，暂时不启动

import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    
    @SpringBootApplication
    public class MyClientApplication {
    
        public static void main(String[] args) {
            SpringApplication.run(MyClientApplication.class, args);
        }
    
    }

--------------------

# **█ 直连服务端** #

客户端知道服务端的具体的地址，将服务端地址固定写死在配置或代码中。此时的客户端与服务端是一对一直连调用。

（1）创建RestTemplate

服务调用采用的是http协议，所以使用RestTemplate进行服务调用，也可以使用httpClient等工具。创建RestTemplate的bean，用于在代码中可以通过@Autowired自动注入。

import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.web.client.RestTemplate;
    
    @Configuration
    public class RestTemplateConfiguration {
    
        @Bean
        public RestTemplate restTemplate() {
            return new RestTemplate();
        }
    
    }

（2）创建Controller

import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RestController;
    import org.springframework.web.client.RestTemplate;
    
    @RestController
    public class MyClientController {
    
        // 自动注入RestTemplate
        @Autowired
        private RestTemplate restTemplate;
    
        @GetMapping("/client/info")
        public String getInfo() {
    
            String serverUrl = "http://localhost:9090/server/info";
            String value = restTemplate.getForObject(serverUrl, String.class);
            return "client:"+value;
    
        }
    
    }

（3）运行MyClientApplication启动项目，在浏览器访问：http://localhost:8080/client/info

![20201210194031418.png][]

**问题：**直连服务端使用起来比较简单，在只有一个服务端的时候，客户端永远只会调用一个固定的服务端，采用此种方式是没有问题的，在以前的传统方式也是这样做的。但是在如今的分布式微服务架构下，服务端往往是多个，此时客户端与服务端的调用存在一对多的关系了。对于这样的情况，客户端在调用的时候就不能将服务端地址写死在代码中了。于是乎，在一对多的情况下，出现了负载均衡。下面我们使用Ribbon进行客户端的负载均衡。

--------------------

# **█ Ribbon** #

使用Ribbon进行负载均衡。

（1）因为Ribbo是在客户端进行负载均衡，所以在客户端引入Ribbon

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

（2）修改RestTemplateConfiguration，在restTemplate方法上加上注解：**@LoadBalanced**（org.springframework.cloud.client.loadbalancer.LoadBalanced）

@Configuration
    public class RestTemplateConfiguration {
    
        @Bean
        @LoadBalanced
        public RestTemplate restTemplate() {
            return new RestTemplate();
        }
    
    }

（3）修改application.yml

# 服务列表
    client:
      ribbon:
        listOfServers: http://localhost:9090,http://localhost:9091

（4）修改MyClientController中serverUrl的内容

@RestController
    public class MyClientController {
    
        @Autowired
        private RestTemplate restTemplate;
    
        @GetMapping("/client/info")
        public String getInfo() {
    
            // String serverUrl = "http://localhost:9090/server/info";
            // 将localhost:9090的值替换成client，client是在配置中配置的key前缀
            String serverUrl = "http://client/server/info";
            String value = restTemplate.getForObject(serverUrl, String.class);
            return "client:"+value;
    
        }
    
    }

（5）修改MyClientApplication，在类上加上注解：**@RibbonClient**或**@RibbonClients**（此步骤不做也是可以的）

@SpringBootApplication
    @RibbonClient("myRibbonClient")
    /*@RibbonClients({
            @RibbonClient("myRibbonClient")
    })*/
    public class MyClientApplication {
    
        public static void main(String[] args) {
            SpringApplication.run(MyClientApplication.class, args);
        }
    
    }

（6）在【直连服务端】中，已经启动了一个9090端口的服务端。通过添加项目启动参数（--server.port=9091）修改端口号，再启动一个9091端口的项目

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MDUxODI3MQ_size_16_color_FFFFFF_t_70][]

此时服务端启动了两个服务，只有端口号不同，分别为9090，9091。服务名都是：myServer。

（7）运行MyClientApplication启动客户端服务，在浏览器访问：http://localhost:8080/server/info

![202012101944352.png][]

刷新页面：

![20201210194456534.png][]

**问题：**结合使用Ribbon，一个客户端可以调用多个服务端的情况了。但此时的服务端地址还是固定写死在配置中的。如果服务端的服务地址更换了，需要修改配置然后重启客户端项目。显然这样对于分布式微服务追求的高可用是无法满足的。接下来使用Eureka作为注册中心，让客户端动态感知服务端地址。

--------------------

# **█ Ribbon+Eureka** #

使用Eureka服务注册和发现，Ribbon客户端负载均衡。

1、创建Eureka服务端项目作为注册中心，端口号为：8899。启动服务。

（关于Eureka服务端的创建以及其他相关内容，请戳《[服务注册与发现-Spring Cloud Netflix-Eureka][-Spring Cloud Netflix-Eureka]》）

2、服务端的修改：

（1）服务端要将服务注册到客户端，引入eureka-server依赖：

<dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
    </dependency>

（2）修改服务端配置application.yml，添加Eureka相关配置：

eureka:
      client:
        # 向Eureka服务端注册服务
        register-with-eureka: true
        fetch-registry: false
        service-url:
          # Eureka服务端地址
          defaultZone: http://localhost:8899/eureka

（3）启动两个服务端，端口号分别为：9090、9091。

（4）访问Eureka服务端：http://localhost:8899，可以看见两个服务已经注册进了Eureka：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MDUxODI3MQ_size_16_color_FFFFFF_t_70 1][]

3、客户端的修改：

客户端要使用Eureka客户端相关功能，需要引入依赖和配置

（1）引入Eureka客户端依赖：

<dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
    </dependency>

（2）修改application.yml配置：

# 注释掉这里的配置
    #client:
    #  ribbon:
    #    listOfServers: http://localhost:9090,http://localhost:9091
    
    eureka:
      client:
        # 从Eureka注册中心获取服务列表
        fetch-registry: true
        register-with-eureka: false
        service-url:
          defaultZone: http://localhost:8899/eureka

（3）修改MyClientController 中serverUrl的内容，需要使用已注册服务的**spring.application.name**的值：

@RestController
    public class MyClientController {
    
        @Autowired
        private RestTemplate restTemplate;
    
        @GetMapping("/client/info")
        public String getInfo() {
    
            // String serverUrl = "http://localhost:9090/server/info";
            // String serverUrl = "http://client/server/info";
            // myServer是服务端注册使用的spring.application.name的值
            String serverUrl = "http://myServer/server/info";
            String value = restTemplate.getForObject(serverUrl, String.class);
            return "client:"+value;
    
        }
    
    }

（4）启动客户端，访问客户端接口。效果同单独使用Ribbon中的一样，实现了负载均衡访问两个服务端。

--------------------

# **█ 相关类** #

*  **ILoadBalancer**

负载均衡器，负责添加服务列表，获取服务列表，选择服务等功能。默认实现为：**ZoneAwareLoadBalancer**

public interface ILoadBalancer {
       // 初始化服务列表
       public void addServers(List<Server> newServers);
       
       // 负载均衡算法选择一个服务
       public Server chooseServer(Object key);
       
       // 将服务标记为下线，不可用
       public void markServerDown(Server server);
       
       // 获取服务列表，已标记废弃的方法
       @Deprecated
       public List<Server> getServerList(boolean availableOnly);
    
       // 获取可用的服务列表
        public List<Server> getReachableServers();
    
       // 获取所有的服务列表 
       public List<Server> getAllServers();

*  **IRule**

定义负载均衡算法，从服务列表中选择一个服务用于调用。默认实现为：**ZoneAvoidanceRule** ，其中持有**RoundRobinRule**，最终通过RoundRobinRule选择服务：

public interface IRule{
        // 算法选择服务
        public Server choose(Object key);
        
        public void setLoadBalancer(ILoadBalancer lb);
        
        public ILoadBalancer getLoadBalancer();    
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MDUxODI3MQ_size_16_color_FFFFFF_t_70 2][]

*  **IPing**

检测服务是否可用

public interface IPing {
        
        public boolean isAlive(Server server);
    }

在**BaseLoadBalancer**的initWithConfig方法中，通过setPing方法设置IPing实现，并开启定时任务线程调用IPing的isAlive方法：

public void setPing(IPing ping) {
        if (ping != null) {
            if (!ping.equals(this.ping)) {
                this.ping = ping;
                setupPingTask(); // since ping data changed
            }
        } else {
            this.ping = null;
            // cancel the timer task
            lbTimer.cancel();
        }
    }

void setupPingTask() {
        if (canSkipPing()) {
            return;
        }
        if (lbTimer != null) {
            lbTimer.cancel();
        }
        lbTimer = new ShutdownEnabledTimer("NFLoadBalancer-PingTimer-" + name,
                true);
        lbTimer.schedule(new PingTask(), 0, pingIntervalSeconds * 1000);
        forceQuickPing();
    }

--------------------

# **█ 原理** #

**LoadBalancerAutoConfiguration、RibbonAutoConfiguration、RibbonClientConfiguration**

从【直连服务端】、【Ribbon】、【Ribbon+Eureka】可以发现。当使用RestTemplate调用服务端接口的时候，Ribbon是将我们编写的url中的服务名修改成了对应的IP+端口了。比如http://client/server/info将client修改成配置的localhost:9090，http://myServer/server/info将myServer修改成Eureka已注册的服务的localhost:9090。

去掉restTemplate方法上面的@LoadBalanced注解，再启动客户端，然后访问接口：

@Bean
    // @LoadBalanced
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }

页面返回如下的错误，无法识别的主机：myServer。可见@LoadBalanced起了一定的作用。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MDUxODI3MQ_size_16_color_FFFFFF_t_70 3][]

*  **LoadBalancerAutoConfiguration**

（1）**@LoadBalanced**

@Target({ ElementType.FIELD, ElementType.PARAMETER, ElementType.METHOD })
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Inherited
    @Qualifier
    public @interface LoadBalanced {
    
    }

主要起作用的是@Qualifier注解，在创建bean的时候，添加@LoadBalanced注解，也就相当于加了@Qualifier注解。即@Qualifier与@Bean组合使用，这样当通过@Qualifier与@Autowired组合使用时，可以自动注入@Qualifier与@Bean组合使用创建的Bean。

（2）**LoadBalancerAutoConfiguration**

@Configuration(proxyBeanMethods = false)
    @ConditionalOnClass(RestTemplate.class)
    @ConditionalOnBean(LoadBalancerClient.class)
    @EnableConfigurationProperties(LoadBalancerRetryProperties.class)
    public class LoadBalancerAutoConfiguration {
    
       // 会将@LoadBalanced与@Bean组合使用创建的RestTemplate类型的bean自动注入
       @LoadBalanced
       @Autowired(required = false)
       private List<RestTemplate> restTemplates = Collections.emptyList();
    
       @Autowired(required = false)
       private List<LoadBalancerRequestTransformer> transformers = 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);
                }
             }
          });
       }
    
       // LoadBalancerRequestFactory用于创建LoadBalancerRequest
       @Bean
       @ConditionalOnMissingBean
       public LoadBalancerRequestFactory loadBalancerRequestFactory(
             LoadBalancerClient loadBalancerClient) {
          return new LoadBalancerRequestFactory(loadBalancerClient, this.transformers);
       }
    
       @Configuration(proxyBeanMethods = false)
       @ConditionalOnMissingClass("org.springframework.retry.support.RetryTemplate")
       static class LoadBalancerInterceptorConfig {
          
          // 创建LoadBalancerInterceptor
          // 就是通过LoadBalancerInterceptor完成值的替换的
          @Bean
          public LoadBalancerInterceptor ribbonInterceptor(
                LoadBalancerClient loadBalancerClient,
                LoadBalancerRequestFactory requestFactory) {
             return new LoadBalancerInterceptor(loadBalancerClient, requestFactory);
          }
         
          // 创建RestTemplateCustomizer 
          @Bean
          @ConditionalOnMissingBean
          public RestTemplateCustomizer restTemplateCustomizer(
                final LoadBalancerInterceptor loadBalancerInterceptor) {
             return restTemplate -> {
                List<ClientHttpRequestInterceptor> list = new ArrayList<>(
                      restTemplate.getInterceptors());
                list.add(loadBalancerInterceptor);
                restTemplate.setInterceptors(list);
             };
          }
    
       }
       }

主要看如下两个方法：

public RestTemplateCustomizer restTemplateCustomizer(
                final LoadBalancerInterceptor loadBalancerInterceptor) {
             return restTemplate -> {
                List<ClientHttpRequestInterceptor> list = new ArrayList<>(
                      restTemplate.getInterceptors());
                list.add(loadBalancerInterceptor);
                restTemplate.setInterceptors(list);
             };
    }

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);
                }
             }
          });
    }

方法restTemplateCustomizer改造一下，即：

@Bean      
    public class RestTemplateCustomizerImpl implements RestTemplateCustomizer {
        
        @Autowired
        private LoadBalancerInterceptor loadBalancerInterceptor;
        
        public void customize(RestTemplate restTemplate) {
            List<ClientHttpRequestInterceptor> list = new ArrayList<>(
                      restTemplate.getInterceptors());
                list.add(loadBalancerInterceptor);
                restTemplate.setInterceptors(list);
        }
    }

方法loadBalancedRestTemplateInitializerDeprecated改造一下，即：

@Bean
    public class SmartInitializingSingletonImpl implements SmartInitializingSingleton {
        @Autowire
        private ObjectProvider<List<RestTemplateCustomizer>> restTemplateCustomizers;
        
        public void afterSingletonsInstantiated() {
            restTemplateCustomizers.ifAvailable(customizers -> {
                // 获取到RestTemplate 
                for (RestTemplate restTemplate : LoadBalancerAutoConfiguration.this.restTemplates) {
                    for (RestTemplateCustomizer customizer : customizers) {
                        // 调用上面的RestTemplateCustomizerImpl的方法customize 
                        customizer.customize(restTemplate);
                   }
               }
            }
        }
    
    }

**SmartInitializingSingleton**是后置处理器，会在Bean的创建的某个时机进行方法调用。经过改造后，可以理解，在Spring创建Bean的某个时机，会调用SmartInitializingSingletonImpl 的afterSingletonsInstantiated方法。afterSingletonsInstantiated的功能就是获取到所有加了@LoadBalanced注解的RestTemplate，对其添加**LoadBalancerInterceptor**拦截器。

（3）**LoadBalancerClient**

**LoadBalancerAutoConfiguration**配置类上标注了@ConditionalOnBean(LoadBalancerClient.class)，只有Spring容器中含有**LoadBalancerClient**类型的bean时，LoadBalancerAutoConfiguration配置类才会生效。LoadBalancerClient类型的bean是在**RibbonAutoConfiguration**中完成注入的。在spring-cloud-netflix-ribbon的jar包META-INF文件夹下的spring.factories中，配置了如下内容，完成RibbonAutoConfiguration的自动配置：

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
    org.springframework.cloud.netflix.ribbon.RibbonAutoConfiguration

LoadBalancerClient是**RibbonLoadBalancerClient**：

@Configuration
    public class RibbonAutoConfiguration {
        
        @Autowired(required = false)
        private List<RibbonClientSpecification> configurations = new ArrayList<>();
        
        @Bean
        public SpringClientFactory springClientFactory() {
           SpringClientFactory factory = new SpringClientFactory();
           factory.setConfigurations(this.configurations);
           return factory;
        }
        
        @Bean
        @ConditionalOnMissingBean(LoadBalancerClient.class)
        public LoadBalancerClient loadBalancerClient() {
           return new RibbonLoadBalancerClient(springClientFactory());
        }
    }

（4）**LoadBalancerRequestFactory**

负责创建LoadBalancerRequest。

public class LoadBalancerRequestFactory {
       
       // 在LoadBalancerAutoConfiguration中自动注入
       // RibbonLoadBalancerClient
       private LoadBalancerClient loadBalancer;
       
       // 在LoadBalancerAutoConfiguration中自动注入
       // @Autowired(required = false)
       // private List<LoadBalancerRequestTransformer> transformers = Collections.emptyList();
       // 默认没有LoadBalancerRequestTransformer类型的bean，可自定义
       private List<LoadBalancerRequestTransformer> transformers;
    
       public LoadBalancerRequestFactory(LoadBalancerClient loadBalancer,
             List<LoadBalancerRequestTransformer> transformers) {
          this.loadBalancer = loadBalancer;
          this.transformers = transformers;
       }
    
       public LoadBalancerRequestFactory(LoadBalancerClient loadBalancer) {
          this.loadBalancer = loadBalancer;
       }
       
       // 创建LoadBalancerRequest
       public LoadBalancerRequest<ClientHttpResponse> createRequest(
             final HttpRequest request, final byte[] body,
             final ClientHttpRequestExecution execution) {
          // 创建LoadBalancerRequest并实现apply方法       
          return instance -> {
             HttpRequest serviceRequest = new ServiceRequestWrapper(request, instance,
                   this.loadBalancer);
             if (this.transformers != null) {
                // 默认 transformers的列表是空列表，即没有LoadBalancerRequestTransformer类型的bean被注入
                // 可自定义bean
                for (LoadBalancerRequestTransformer transformer : this.transformers) {
                   serviceRequest = transformer.transformRequest(serviceRequest,
                         instance);
                }
             }
             // 继续下面的调用
             return execution.execute(serviceRequest, body);
          };
       }
    
    }

改造通过createRequest方法创建的LoadBalancerRequest：

public class LoadBalancerRequestImpl implements LoadBalancerRequest{
        
        private HttpRequest request;
        ......
        
        public LoadBalancerRequestImpl(HttpRequest request, byte[] body,
             ClientHttpRequestExecution execution) {
            this.request = request;
            ......
        }
        
        public T apply(ServiceInstance instance) {
            HttpRequest serviceRequest = new ServiceRequestWrapper(request, instance,
                   this.loadBalancer);
             if (this.transformers != null) {
                // 默认 transformers的列表是空列表，即没有LoadBalancerRequestTransformer类型的bean被注入
                // 可自定义bean
                for (LoadBalancerRequestTransformer transformer : this.transformers) {
                   serviceRequest = transformer.transformRequest(serviceRequest,
                         instance);
                }
             }
             // 继续下面的调用
             return execution.execute(serviceRequest, body);
        }
        
    }

**（5）LoadBalancerInterceptor**

添加了拦截器之后，当调用RestTemplate的方法时，会先进行拦截器的调用，这样在拦截器中就能完成值的替换了。

public class LoadBalancerInterceptor implements ClientHttpRequestInterceptor {
       // 在LoadBalancerAutoConfiguration中自动注入
       // RibbonLoadBalancerClient
       private LoadBalancerClient loadBalancer;
    
       private LoadBalancerRequestFactory requestFactory;
    
       public LoadBalancerInterceptor(LoadBalancerClient loadBalancer,
             LoadBalancerRequestFactory requestFactory) {
          this.loadBalancer = loadBalancer;
          this.requestFactory = requestFactory;
       }
    
       public LoadBalancerInterceptor(LoadBalancerClient loadBalancer) {
          // for backwards compatibility
          this(loadBalancer, new LoadBalancerRequestFactory(loadBalancer));
       }
       
       // 实际调用服务接口之前，会先调用连接器的intercept方法。
       @Override
       public ClientHttpResponse intercept(final HttpRequest request, final byte[] body,
             final ClientHttpRequestExecution execution) throws IOException {
          final URI originalUri = request.getURI();
          // 获取服务名，即client或myServer
          String serviceName = originalUri.getHost();
          Assert.state(serviceName != null,
                "Request URI does not contain a valid hostname: " + originalUri);
          return this.loadBalancer.execute(serviceName,
                this.requestFactory.createRequest(request, body, execution));
       }
    
    }

（6）**RibbonLoadBalancerClient**

调用execute(String serviceId, LoadBalancerRequest<T> request)方法：

public <T> T execute(String serviceId, LoadBalancerRequest<T> request)
          throws IOException {
       return execute(serviceId, request, null);
    }

public <T> T execute(String serviceId, LoadBalancerRequest<T> request, Object hint)
          throws IOException {
       // 根据服务名获取负载均衡器       
       ILoadBalancer loadBalancer = getLoadBalancer(serviceId);
       // 负载均衡获取一个服务
       Server server = getServer(loadBalancer, hint);
       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);
    }

public <T> T execute(String serviceId, ServiceInstance serviceInstance,
          LoadBalancerRequest<T> request) throws IOException {
              ......
              T returnVal = request.apply(serviceInstance);
              ......
    }

request.apply，即调用（4）中的LoadBalancerRequestImpl 的apply方法：

public T apply(ServiceInstance instance) {
            HttpRequest serviceRequest = new ServiceRequestWrapper(request, instance,
                   this.loadBalancer);
             if (this.transformers != null) {
                // 默认 transformers的列表是空列表，即没有LoadBalancerRequestTransformer类型的bean被注入
                // 可自定义bean
                for (LoadBalancerRequestTransformer transformer : this.transformers) {
                   serviceRequest = transformer.transformRequest(serviceRequest,
                         instance);
                }
             }
             // 继续下面的调用
             // serviceRequest是ServiceRequestWrapper
             return execution.execute(serviceRequest, body);
    }

execution.execute，即**ClientHttpRequestExecution**的execute方法，**InterceptingClientHttpRequest**是ClientHttpRequestExecution的实现类：

private class InterceptingRequestExecution implements ClientHttpRequestExecution {
    
       private final Iterator<ClientHttpRequestInterceptor> iterator;
    
       public InterceptingRequestExecution() {
          this.iterator = interceptors.iterator();
       }
    
       @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
             ClientHttpRequest delegate = requestFactory.createRequest(request.getURI(), method);
             ......
             return delegate.execute();
          }
       }
    }

通过request.getURI()获取请求的url，request是**ServiceRequestWrapper**：

@Override
    public URI getURI() {
       // 根据配置完成替换 
       URI uri = this.loadBalancer.reconstructURI(this.instance, getRequest().getURI());
       return uri;
    }

*  **RibbonAutoConfiguration**

在spring-cloud-netflix-ribbon的jar包下的META-INF文件夹下的spring.factories文件中配置了RibbonAutoConfiguration自动配置：

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
    org.springframework.cloud.netflix.ribbon.RibbonAutoConfiguration

在RibbonAutoConfiguration中创建**SpringClientFactory**和**LoadBalancerClient**的Bean。

@Configuration
    @Conditional(RibbonAutoConfiguration.RibbonClassesConditions.class)
    @RibbonClients
    @AutoConfigureAfter(
          name = "org.springframework.cloud.netflix.eureka.EurekaClientAutoConfiguration")
    @AutoConfigureBefore({ LoadBalancerAutoConfiguration.class,
          AsyncLoadBalancerAutoConfiguration.class })
    @EnableConfigurationProperties({ RibbonEagerLoadProperties.class,
          ServerIntrospectorProperties.class })
    public class RibbonAutoConfiguration {
        
        @Bean
        public SpringClientFactory springClientFactory() {
           SpringClientFactory factory = new SpringClientFactory();
           factory.setConfigurations(this.configurations);
           return factory;
        }
    
        @Bean
        @ConditionalOnMissingBean(LoadBalancerClient.class)
        public LoadBalancerClient loadBalancerClient() {
           return new RibbonLoadBalancerClient(springClientFactory());
        }
        
    }

（1）**SpringClientFactory**

创建客户端、负载均衡器和客户端配置实例的工厂，为每一个客户端创建一个Spring ApplicationContext。可以理解成相当于BeanFactory。在其中持有关于Ribbon的相关配置等信息。

public class SpringClientFactory extends NamedContextFactory<RibbonClientSpecification> {
       // 获取客户端
       public <C extends IClient<?, ?>> C getClient(String name, Class<C> clientClass) {
           ......
       }
       // 获取负载均衡器
       public ILoadBalancer getLoadBalancer(String name) {
           ......
       }
       // 获取客户端配置
       public IClientConfig getClientConfig(String name) {
           ......
       }
       // 获取上下文
       public RibbonLoadBalancerContext getLoadBalancerContext(String serviceId) {
           ......
       }
       
    }

SpringClientFacotry的构造函数：

public SpringClientFactory() {
       super(RibbonClientConfiguration.class, NAMESPACE, "ribbon.client.name");
    }

super调用父类**NamedContextFactory**的构造器，将RibbonClientConfiguration.class赋值给defaultConfigType。NamedContextFactory会为Spring ApplicationContext创建一个子ApplicationContext。

public NamedContextFactory(Class<?> defaultConfigType, String propertySourceName,
          String propertyName) {
       this.defaultConfigType = defaultConfigType;
       this.propertySourceName = propertySourceName;
       this.propertyName = propertyName;
    }

在createContext中有注入defaultConfigType类型的bean，即注入**RibbonClientConfiguration**。

protected AnnotationConfigApplicationContext createContext(String name) {
        ......
        context.register(PropertyPlaceholderAutoConfiguration.class,
          this.defaultConfigType);
        ......  
    }

（2）**LoadBalancerClient**

负载均衡客户端。在**LoadBalancerInterceptor**中开始执行服务名替换和负载均衡的操作的入口。**RibbonLoadBalancerClient**是具体的实现类。用于Ribbon负载均衡。

*  **RibbonClientConfiguration**

Ribbon客户端配置，提供默认的负载均衡算法等配置。第一次调用接口的时候，才会触发该配置类。

@Configuration(proxyBeanMethods = false)
    @EnableConfigurationProperties
    @Import({ HttpClientConfiguration.class, OkHttpRibbonConfiguration.class,
          RestClientRibbonConfiguration.class, HttpClientRibbonConfiguration.class })
    public class RibbonClientConfiguration {
        // 默认的IRule，默认为ZoneAvoidanceRule
        // 使用了ConditionalOnMissingBean，当自定义实现bean的时候，默认的配置就不会被加载了。
        @Bean
        @ConditionalOnMissingBean
        public IRule ribbonRule(IClientConfig config) {
            // propertiesFactory是通过配置设置IRule实现的，
            // 比如在application.yml文件中设置。
            if (this.propertiesFactory.isSet(IRule.class, name)) {
              return this.propertiesFactory.get(IRule.class, config, name);
           }
           ZoneAvoidanceRule rule = new ZoneAvoidanceRule();
           rule.initWithNiwsConfig(config);
           return rule;
        }
         
        // 默认的IPing实现，默认为： DummyPing
        @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();
        }
        
        // 默认的ILoadBalancer实现，默认为：ZoneAwareLoadBalancer
        @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);
           }
           // 将IRule和IPing作为参数
           return new ZoneAwareLoadBalancer<>(config, rule, ping, serverList,
             serverListFilter, serverListUpdater);
        }
        
        // Ribbon负载均衡上下文
        @Bean
        @ConditionalOnMissingBean
        public RibbonLoadBalancerContext ribbonLoadBalancerContext(ILoadBalancer loadBalancer,
            IClientConfig config, RetryHandler retryHandler) {
            return new RibbonLoadBalancerContext(loadBalancer, config, retryHandler);
        }
    }

--------------------

# **█ 负载均衡** #

在**RibbonLoadBalancerClient**的execute中会根据url中的服务名来获取负载均衡器：

public <T> T execute(String serviceId, LoadBalancerRequest<T> request, Object hint)
          throws IOException {
              // serviceId就是url中配置的，比如：http://myServer/server/info中的myServer
              ILoadBalancer loadBalancer = getLoadBalancer(serviceId);
              Server server = getServer(loadBalancer, hint);
    }

（1）getLoadBalancer：

获取负载均衡器

protected ILoadBalancer getLoadBalancer(String serviceId) { 
       return this.clientFactory.getLoadBalancer(serviceId);
    }

clientFactory是**SpringClientFactory**，调用SpringClientFactory的getLoadBalancer，最终会调用**NamedContextFactory**的getInstance方法：

public ILoadBalancer getLoadBalancer(String name) {
       return getInstance(name, ILoadBalancer.class);
    }

@Override
    public <C> C getInstance(String name, Class<C> type) {
        // 调用NamedContextFactory的getInstance方法
       C instance = super.getInstance(name, type);
       if (instance != null) {
          return instance;
       }
       IClientConfig config = getInstance(name, IClientConfig.class);
       return instantiateWithConfig(getContext(name), type, config);
    }

去上下文中获取ILoadBalancer类型的bean：

public <T> T getInstance(String name, Class<T> type) {
       AnnotationConfigApplicationContext context = getContext(name);
       if (BeanFactoryUtils.beanNamesForTypeIncludingAncestors(context,
             type).length > 0) {
          // 去上下文中获取ILoadBalancer类型的bean       
          return context.getBean(type);
       }
       return null;
    }

getContext：

获取服务名的上下文。

protected AnnotationConfigApplicationContext getContext(String name) {
       if (!this.contexts.containsKey(name)) {
          synchronized (this.contexts) {
             if (!this.contexts.containsKey(name)) {
                this.contexts.put(name, createContext(name));
             }
          }
       }
       return this.contexts.get(name);
    }

createContext：

创建上下文：

protected AnnotationConfigApplicationContext createContext(String name) {
       AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
       // 如果指定了服务名的配置，即@RibbonClient指定
       if (this.configurations.containsKey(name)) {
          for (Class<?> configuration : this.configurations.get(name)
                .getConfiguration()) {
             context.register(configuration);
          }
       }
       // 通过@RibbonClients的defaultConfiguration指定了配置
       for (Map.Entry<String, C> entry : this.configurations.entrySet()) {
          if (entry.getKey().startsWith("default.")) {
             for (Class<?> configuration : entry.getValue().getConfiguration()) {
                context.register(configuration);
             }
          }
       }
       // 使用默认的配置，即RibbonClientConfiguration
       context.register(PropertyPlaceholderAutoConfiguration.class,
             this.defaultConfigType);
       context.getEnvironment().getPropertySources().addFirst(new MapPropertySource(
             this.propertySourceName,
             Collections.<String, Object>singletonMap(this.propertyName, name)));
       if (this.parent != null) {
          // 将Spring ApplicationContext设置成该服务名的上下文的父级
          context.setParent(this.parent);
          context.setClassLoader(this.parent.getClassLoader());
       }
       context.setDisplayName(generateDisplayName(name));
       context.refresh();
       return context;
    }

根据服务名创建一个ApplicationContext，在ApplicationContext中会注册通过**@RibbonClient**或**@RibbonClients**配置的配置类，以及默认的配置类RibbonClientConfiureation。在各个Configuration中通过@Bean的方式注册IRule或ILoadBalancer等组件的时候，要使用@ConditionalOnMissingBean，如果不使用此注册，会存在多个Bean，后注册的会覆盖先注册的。

通过以上方法，最终通过getLoadBalancer获取到的ILoadBalancer，要么是默认的配置，要么是自定义的配置。

（2）getServer

protected Server getServer(ILoadBalancer loadBalancer, Object hint) {
       if (loadBalancer == null) {
          return null;
       }
       // Use 'default' on a null hint, or just pass it on?
       return loadBalancer.chooseServer(hint != null ? hint : "default");
    }

调用loadBalancer.chooseServer，以默认的**ZoneAwareLoadBalancer**为例：

@Override
    public Server chooseServer(Object key) {
        // ENABLED是ZoneAwareNIWSDiscoveryLoadBalancer.enabled的配置，默认为true
        // 或者只有一个zone
        if (!ENABLED.get() || getLoadBalancerStats().getAvailableZones().size() <= 1) {
            logger.debug("Zone aware logic disabled or there is only one zone");
            // 父类是BaseLoadBalancer
            return super.chooseServer(key);
        }
        ......
        // 存在多个Zone
       Set<String> availableZones = ZoneAvoidanceRule.getAvailableZones(zoneSnapshot, triggeringLoad.get(), triggeringBlackoutPercentage.get());
       logger.debug("Available zones: {}", availableZones);
       if (availableZones != null &&  availableZones.size() < zoneSnapshot.keySet().size()) {
           // 随机选择一个Zone
           String zone = ZoneAvoidanceRule.randomChooseZone(zoneSnapshot, availableZones);
           logger.debug("Zone chosen: {}", zone);
           if (zone != null) {
               BaseLoadBalancer zoneLoadBalancer = getLoadBalancer(zone);
               server = zoneLoadBalancer.chooseServer(key);
           }
       } 
    }

无论是只有一个Zone，还是多个Zone，都会转发到BaseLoadBalancer的chooseServer方法：

public Server chooseServer(Object key) {
        if (counter == null) {
            counter = createCounter();
        }
        counter.increment();
        if (rule == null) {
            return null;
        } else {
            try {
                // 使用IRule做负载均衡选择一个服务，默认是：
                return rule.choose(key);
            } catch (Exception e) {
                logger.warn("LoadBalancer [{}]:  Error choosing server for key {}", name, key, e);
                return null;
            }
        }
    }

--------------------

# **█ 自定义配置** #

不使用默认实现的IRule，自定义实现IRule。（ILoadBalancer 或IPing使用方式一样）

实现代码是在客户端。

1、通过注解@RibbonClient或@RibbonClients指定配置类。

（1）创建IRule的实现类，一般通过继承AbstractLoadBalancerRule：

import com.netflix.client.config.IClientConfig;
    import com.netflix.loadbalancer.AbstractLoadBalancerRule;
    import com.netflix.loadbalancer.Server;
    
    import java.util.List;
    
    /**
     * 自定义负载均衡规则
     * 永远返回服务列表中的第一个服务
     */
    public class MyLoadBalancerRule extends AbstractLoadBalancerRule {
    
        @Override
        public void initWithNiwsConfig(IClientConfig clientConfig) {
    
        }
    
        @Override
        public Server choose(Object key) {
            System.out.println("=====================进入MyLoadBalancerRule=================");
    
            // 获取所有的服务
            List<Server> serverList = getLoadBalancer().getAllServers();
    
            if (serverList==null || serverList.size()==0) {
                return null;
            }
            // 返回服务列表中的第一个服务
            return serverList.get(0);
        }
    }

（2）创建configuration：

import com.netflix.loadbalancer.IRule;
    import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    /**
     * 自定义
     */
    @Configuration
    public class MyRibbonClientConfiguration {
    
        @Bean
        @ConditionalOnMissingBean
        public IRule myIRule() {
            return new MyLoadBalancerRule();
        }
    
    
    }

（3）在启动类上加上@RibbonClient注解

@SpringBootApplication
    @RibbonClient(name = "www.rui",configuration = MyRibbonClientConfiguration.class)
    public class MyClientApplication {
    
        public static void main(String[] args) {
            SpringApplication.run(MyClientApplication.class, args);
        }
    
    }

（4）启动客户端项目，并访问接口。

可以发现进入了自定义的MyLoadBalancerRule的choose来实现负载均衡。

2、通过配置实现自定义组件

使用**PropertiesFactory**提供的功能，通过配置完成自定义组件。

NFLoadBalancerClassName：自定义ILoadBalancer
    NFLoadBalancerPingClassName：自定义IPing
    NFLoadBalancerRuleClassName：自定义IRule
    NIWSServerListClassName：自定义ServerList
    NIWSServerListFilterClassName：自定义ServerListFilter

修改application.yml配置：

myServer:
      ribbon:
        NFLoadBalancerRuleClassName:
          client.config.MyLoadBalancerRule

两个方式都可以实现自定义组件，并且第二种通过配置的方式优先级比通过代码实现要高。

### **注意点：** ###

Spring Cloud官网有这样一段警告：

The CustomConfiguration class must be a @Configuration class, but take care that it is not in a @ComponentScan for 
    the main application context. Otherwise, it is shared by all the @RibbonClients. If you use @ComponentScan (or @SpringBootApplication), 
    you need to take steps to avoid it being included (for instance, you can put it in a separate, non-overlapping package or 
    specify the packages to scan explicitly in the @ComponentScan).

是存在这样的一种情形。假设同一个客户端需要调用多个服务端的接口，比如一个接口需要调用服务A的接口：http://serverA/server/info，一个接口需要调用服务B的接口：http://http://serverB/server/info。如果此时你想调用服务A的接口使用自定义的负载均衡逻辑，调用服务B的接口还是使用默认的负载均衡逻辑。如果对于自定义的配置类，你把它放在了@ComponentScan的扫描范围内，则这个自定义的配置类将全局生效，这样会造成服务A和服务B都会使用自定义的配置。为了避免这样的情况，需要将服务A的自定义配置放在@ComponentScan无法扫描的类，或通过@ComponentScan过滤掉。

比如在启动类上通过@ComponentScan(excludeFilters=“”）过滤掉配置类，并且@RibbonClient中的name属性值一定要和url中的服务名相同：

// myServer一定要是调用接口http://myServer/server/info中的服务名
    @RibbonClient(name = "myServer",configuration = MyRibbonClientConfiguration.class)
    @ComponentScan(excludeFilters = "配置类所在的包")

**原因：**

在第一次调用客户端接口的时候，通过SpringClientFactory的getInstance获取负载均衡器，最终会调用其父类NamedContextFactory的createContext，来初始化服务名对应的上下文。会首先查看是否有服务名对应的配置，即通过@RibbonClient(name="服务名", configuration="")来配置，如果有注册到当前上下文中，然后再查看是否有default开头的配置，即通过@RibbonClients(defaultConfiguration="")来配置，如果有注册到当前上下文中。最后注册默认的配置。最后将当前服务名的上下文设置成Spring 上下文的子级。

（1）当自定义的配置在@ComponentScan扫描范围内的时候，即会被注册到Spring 上下文中。这样当加载默认的配置类RibbonClientConfiguration，因为使用了@ConditionalOnMissingBean，此时父级的上下文中已经存在了，条件不满足，就不会注册这里的bean。

（2）当自定义的配置不在@ComponentScan扫描范围内的时候，就不会加进Spring 上下文，此时要想配置生效，就需要@RibbonClient配置的name值与服务名一致，这样配置会加入当前服务名所对应的上下文中。只会对当前服务名生效。

当自定义的配置只需要应用到某个服务名上时，只需要将自定义配置注册到服务名的上下文中。

当自定义的配置需要应用到所有的服务名上时，则可以将自定义配置注册到Spring 上下文中。

protected AnnotationConfigApplicationContext createContext(String name) {
       AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
       // 通过@RibbonClient配置configuration，name=服务名
       if (this.configurations.containsKey(name)) {
          for (Class<?> configuration : this.configurations.get(name)
                .getConfiguration()) {
             context.register(configuration);
          }
       }
       // 通过@RibbonClients配置的configuration
       for (Map.Entry<String, C> entry : this.configurations.entrySet()) {
          if (entry.getKey().startsWith("default.")) {
             for (Class<?> configuration : entry.getValue().getConfiguration()) {
                context.register(configuration);
             }
          }
       }
       // 默认配置
       context.register(PropertyPlaceholderAutoConfiguration.class,
             this.defaultConfigType);
       context.getEnvironment().getPropertySources().addFirst(new MapPropertySource(
             this.propertySourceName,
             Collections.<String, Object>singletonMap(this.propertyName, name)));
       if (this.parent != null) {
          // Uses Environment from parent as well as beans
          context.setParent(this.parent);
          // jdk11 issue
          // https://github.com/spring-cloud/spring-cloud-netflix/issues/3101
          context.setClassLoader(this.parent.getClassLoader());
       }
       context.setDisplayName(generateDisplayName(name));
       context.refresh();
       return context;
    }

[20201210193720486.png]: /images/20221120/378de0df117d4c28b3f69fc06f333739.png
[20201210194031418.png]: /images/20221120/9844fda0e9304796829613d15dff9a7d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MDUxODI3MQ_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20201210194335916.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MDUxODI3MQ==,size_16,color_FFFFFF,t_70
[202012101944352.png]: https://img-blog.csdnimg.cn/202012101944352.png
[20201210194456534.png]: https://img-blog.csdnimg.cn/20201210194456534.png
[-Spring Cloud Netflix-Eureka]: https://blog.csdn.net/weixin_50518271/article/details/110402024
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MDUxODI3MQ_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20201210194720539.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MDUxODI3MQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MDUxODI3MQ_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20201210195050566.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MDUxODI3MQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MDUxODI3MQ_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20201210195330749.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MDUxODI3MQ==,size_16,color_FFFFFF,t_70