【Spring Cloud系列】- Ribbon详解与实战

梦里梦外; 2023-10-13 16:19 18阅读 0赞

## 【Spring Cloud系列】- Ribbon详解与实战 ##

#### 文章目录 ####

*  【Spring Cloud系列】- Ribbon详解与实战
 *   *  一、什么是Ribbon
     *  二、Spring Cloud中Ribbon应用
     *   *  Ribbon使用步骤如下
     *  三、Ribbon负载均衡策略设置
     *   *  3.1 全局策略设置
         *  3.2 基于注解的针对单个服务的 Ribbon 负载均衡策略
         *   *  3.2.1 注解方式
             *  3.2.2 IClientConfig针对客户端的配置管理器
         *  3.3 配置文件方式
     *  四、如何自定义Ribbon负载均衡策略
     *   *  4.1 自定义算法
         *  4.2 自定义配置类
         *  4.3 设置加载自定义Ribbon配置类
     *  五、LoadBalancer–负载均衡器的核心
     *   *  5.1 什么是LoadBalancerClient
         *  5.2 LoadBalancerClient原理
         *  5.3 LoadBabancerClient源码解析
         *   *  5.3.1 LoadBalancerClient 类图
             *  5.3.2 LoadBalancerClient 接口源码
             *  5.3.3 ServiceInstanceChooser 接口源码
             *  5.3.4 RibbonLoadBalanceClient 实现类源码
             *   *  choose()，用来选择具体的服务实例
                 *  getServer()，获取实例
                 *  5.3.5 BaseLoadBalancer 源码
                 *  5.3.6 IRule 接口源码
                 *  5.3.7 ILoadBalancer 源码
     *  六、Ribbon的配置参数
     *  七、总结

在前面的文章 Eureka详解与实战、Eureka Client应用、RestTemplate详解及其负载均衡几篇文章中，已经介绍了Spring Cloud基本应用，本文将从讲解在进程层面的负载均衡，在Spring Cloud中如何使用Ribbon做系统应用层面的负载均衡使用。

### 一、什么是Ribbon ###

**Ribbon**是netflix 公司开源的基于客户端的负载均衡组件，是Spring Cloud大家庭中非常重要的一个模块；Ribbon应该也是整个大家庭中相对而言比较复杂的模块，直接影响到服务调度的质量和性能。全面掌握Ribbon可以帮助我们了解在分布式微服务集群工作模式下，服务调度应该考虑到的每个环节。

Ribbon内部提供了一个接口叫做ILoadBalance的接口代表负载均衡器的操作，这个接口包含添加服务器操作、选择服务器操作、获取所有的服务器列表、获取可用服务器列表等功能。

**下图展示Ribbon的架构图**：

![在这里插入图片描述][8bac20009e9e49bfac5a814cbdb8b685.png_pic_center]

### 二、Spring Cloud中Ribbon应用 ###

#### Ribbon使用步骤如下 ####

1.  在Eureka Client中添加bom.xml 依赖
    
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
        </dependency>
2.  RestTemplate配置类添加@LoadBalanced注解
    
        @Configuration
        public class RestTemplateConfig {
              
            @Bean
            @LoadBalanced
            public RestTemplate getRestTemplate() {
              
                return new RestTemplate();
            }
        }
3.  启动类添加注解@EnableEurekaClient和@RibbonClient(name = “Eureka中spring.application.name”)
    
        @SpringBootApplication
        @EnableEurekaClient
        @RibbonClient(name="GoyeerRibbonDemo")
        public class GoyeerCloudRibbonAppliction {
              
            public static void main(String[] args){
              
                SpringApplication.run(GoyeerCloudRibbonAppliction.class);
            }
        }
4.  application.yml配置内容
    
        server:
          port: 8081
        eureka:
          client:
            service-url:
              defaultZone: http://server30000:30000/eureka/,http://server30001:30001/eureka/,http://server30002:30002/eureka/
            register-with-eureka: false
        spring:
          application:
            name: GoyeerRibbon
          profiles:
            active: ribbonClient
5.  编写控制器
    
        @Autowired
         private  RestTemplateConfig restTemplateConfig;
         @RequestMapping(value = "/")
         public String index(){
              
                String url="http://GOYEERBOM"; //注册Eureka中的服务名
                RestTemplate restTemplate=restTemplateConfig.getRestTemplate();
                String str=restTemplate.getForObject(url,String.class);
                return str;
         }
6.  服务端效果
    
     *  Eureka服务器端  
        ![在这里插入图片描述][f7c537fa99b840f781900478477b3162.png_pic_center]
     *  Ribbon调用后结构

### 三、Ribbon负载均衡策略设置 ###

#### 3.1 全局策略设置 ####

/**
     * @Author：Goyeer
     * @Description：Ribbon 全局的负载均衡策略配置类
     * @CreateDate:2023-07-11
     */
    @Configuration
    public class RibbonGlobalLoadBalancingConfiguration {
        
        /**
         * 随机规则
         */
        @Bean
        public IRule ribbonRule() {
        
            return new RandomRule();
        }
    
    }

#### 3.2 基于注解的针对单个服务的 Ribbon 负载均衡策略 ####

##### 3.2.1 注解方式 #####

/**
     * @Author：Goyeer
     * @Description：Ribbon 随机负载均衡策略配置类哪个服务引用就作用在那个服务上面在启动类上方使用 @RibbonClient 引用
     * @CreateDate：2023-07-11
     */
    @Configuration
    @AvoidScan
    public class RibbonRandomLoadBalancingConfiguration {
        
        @Resource
        IClientConfig clientConfig;
        @Bean
        public IRule ribbonRule(IClientConfig clientConfig) {
        
            return new RandomRule();
        }
    }

##### 3.2.2 IClientConfig针对客户端的配置管理器 #####

/** 配置针对单个服务的 Ribbon 负载均衡策略 **/
    @RibbonClient(
            name = "goyeer-balance-ribbon", configuration = RibbonRandomLoadBalancingConfiguration.class
    )
    /** 此处配置根据标识 @AvoidScan 过滤掉需要单独配置的 Ribbon 负载均衡策略，不然就会作用于全局，启动就会报错 */
    @ComponentScan(
            excludeFilters = @ComponentScan.Filter(type = FilterType.ANNOTATION, value = AvoidScan.class)
    )

#### 3.3 配置文件方式 ####

### 针对单个服务的 Ribbon 配置
    goyeer-balance-ribbon:
      ribbon:
        # 基于配置文件形式的 针对单个服务的 Ribbon 负载均衡策略
        NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule

### 四、如何自定义Ribbon负载均衡策略 ###

#### 4.1 自定义算法 ####

import com.netflix.client.config.IClientConfig;
    import com.netflix.loadbalancer.AbstractLoadBalancerRule;
    import com.netflix.loadbalancer.ILoadBalancer;
    import org.springframework.stereotype.Component;
    import com.netflix.loadbalancer.Server;
    import java.util.List;
    import java.util.concurrent.atomic.AtomicInteger;
    
    @Component
    public class RandomRule_ZY extends AbstractLoadBalancerRule {
        
        //定义一个原子类，以保证原子性
        private AtomicInteger atomicInteger =new AtomicInteger(0);
        public void initWithNiwsConfig(IClientConfig iClientConfig) {
        
        }
        public Server choose(ILoadBalancer lb, Object key) {
        
            if (lb == null){
        
                return null;
            }
            //用于统计获取次数，当达到一定数量就不再去尝试
            int count = 0;
            Server server = null;
            //当服务还没获取到，并且尝试没有超过8次
            while (server == null && count++ < 8){
        
                //获取服务
                List<Server> allServers = lb.getAllServers();
                List<Server> reachableServers = lb.getReachableServers();
                int allServersSize = allServers.size();
                int reachableServersSize = reachableServers.size();
                //如果获取的服务list都为0就返回null
                if(allServersSize == 0 || reachableServersSize == 0){
        
                    return  null;
                }
                //获取服务下标
                int next = getServerIndex(allServersSize);
                //获取服务
                server = reachableServers.get(next);
                //如果服务为空直接跳过下面的
                if (server == null){
        
                    continue;
                }
                //如果获取到的这个服务是活着的就返回
                if (server.isAlive()){
        
                    return server;
                }
                //如果获取到的服务不是空，但是不是存活状态，需要重新获取
                server=null;
            }
            //最后这里可能会返回null
            return  server;
        }
        //获取服务下标，为了保证原子性，使用了CAS
        public int getServerIndex(int allServersSize){
        
            //自旋锁
            for (;;) {
        
                //获取当前值
                int current = this.atomicInteger.get();
                //设置期望值
                int next = (current + 1) % allServersSize;
                //调用Native方法compareAndSet，执行CAS操作
                if (this.atomicInteger.compareAndSet(current, next))
                    //成功后才会返回期望值，否则无线循环
                    return next;
            }
        }
        public Server choose(Object key) {
        
            return choose(getLoadBalancer(),key);
        }
    }

#### 4.2 自定义配置类 ####

@Configuration
    //针对全局修改
    //@RibbonClients(defaultConfiguration = MyRuleConfig.class)
    //针对某个服务修改
    @RibbonClient(name = "nacos-app-a", configuration = MyRuleConfig.class)
    public class MyRuleConfig {
        
        @Bean
        public IRule rule() {
        
          //返回上面自定义的规则类
            return new RandomRule_ZY();
        }
    }

#### 4.3 设置加载自定义Ribbon配置类 ####

@SpringBootApplication
    @EnableEurekaClient
    @RibbonClient(name = "Client",configuration = MyRuleConfig.class)
    public class GoyeerCloudRibbonAppliction {
        
        public static void main(String[] args){
        
            SpringApplication.run(GoyeerCloudRibbonAppliction.class);
        }
    }

### 五、LoadBalancer–负载均衡器的核心 ###

Ribbon实现负载均衡是通过LoadBalancer注解来给RestTemplate标记，来实现负载均衡。LoadBalancer是如何实现负载均衡哪？查看源码我们可以看到有一个接口LoadBalancerClinet来实现的。

#### 5.1 什么是LoadBalancerClient ####

LoadBalancerClient 是 SpringCloud 提供的一种负载均衡客户端，Ribbon 负载均衡组件内部也是集成了 LoadBalancerClient 来实现负载均衡。

#### 5.2 LoadBalancerClient原理 ####

LoadBalancerClinet在初始化时会通过Euraka Clinet向Eureka服务端获取所有的服务实例的注册信息并缓存到本地，并且每10秒向EurakaClinet发送“Ping”请求，来判断服务的可用性。如果服务的可用性发生了改变或者服务数量和之前的不一致，则更新或重新拉取最新到本地。在得到最新服务注册信息后，ILoadBalancer根据IRule的策略进行负载均衡（默认策略为轮询）。

当使用LoadBalancerClient进行远程调用的负载均衡时，LoadBalancerClient先通过目标服务名在本地服务注册清单中获取服务提供方的某个实例，如多个服务器节点，LoadBalancerClient会通过choose()方法获取到多个节点中一个服务，拿到服务的信息之后取出服务IP信息，就可以得到完整的想要访问的IP地址和端口号，最后通过RestTempate访问具体的服务信息。

#### 5.3 LoadBabancerClient源码解析 ####

##### 5.3.1 LoadBalancerClient 类图 #####

LoadBalancerClient 是 Spring Cloud 提供的一个非常重要的接口，它继承ServiceInstanceChooser 接口，该接口的实现类是 RibbonLoadBalanceClient，它们之间的关系如下图所示：

##### 5.3.2 LoadBalancerClient 接口源码 #####

public interface LoadBalancerClient extends ServiceInstanceChooser 
    {
        
    	<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);
    }

可以发现 LoadBalancerClient 接口继承了 ServiceInstanceChooser 接口，包含两个方法:**execute**和**reconstructURI**

*  execute() 用来执行Request请求
 *  reconstructURI() 用来重构URL

##### 5.3.3 ServiceInstanceChooser 接口源码 #####

public interface ServiceInstanceChooser 
    {
        
    	ServiceInstance choose(String serviceId);
    }

ServiceInstanceChooser 接口中的主要方法为 choose()，该方法用于根据服务的名称 serviceId 来选择其中一个服务实例，即根据 serviceId 获取ServiceInstance。

##### 5.3.4 RibbonLoadBalanceClient 实现类源码 #####

LoadBalancerClient 的实现类 RibbonLoadBalanceClient，它用来执行最终的负载均衡请求。其中，RibbonLoadBalanceClient 的一个 choose() 方法用于选择具体的服务实例，其内部是通过 getServer() 方法交给 ILoadBalancer 完成的。

*  ###### choose()，用来选择具体的服务实例 ######
    
        @Override
        public ServiceInstance choose(String serviceId) {
              
        	return choose(serviceId, null);
        }
         
        /**
         * New: Select a server using a 'key'.
         * @param serviceId of the service to choose an instance for
         * @param hint to specify the service instance
         * @return the selected {@link ServiceInstance}
         */
        public ServiceInstance choose(String serviceId, Object hint) {
              
          Server server = getServer(getLoadBalancer(serviceId), hint);
          if (server == null) {
              
        	 return null;
          }
          return new RibbonServer(serviceId, server, isSecure(server, serviceId),serverIntrospector(serviceId).getMetadata(server));
        }
 *  ###### getServer()，获取实例 ######
    
        protected Server getServer(ILoadBalancer loadBalancer) {
              
           return getServer(loadBalancer, null);
        }
        protected Server getServer(ILoadBalancer loadBalancer, Object hint) {
              
           if (loadBalancer == null) {
              
        	   return null;
           }
           // 最终通过 loadBalancer 去做服务实例的选择。
           // Use 'default' on a null hint, or just pass it on?
           return loadBalancer.chooseServer(hint != null ? hint : "default");
        }

###### 5.3.5 BaseLoadBalancer 源码 ######

###### 5.3.6 IRule 接口源码 ######

public interface IRule{
         
        public Server choose(Object key);
        public void setLoadBalancer(ILoadBalancer lb);
        public ILoadBalancer getLoadBalancer();    
    }

IRule 接口定义了3个方法,分别是：**choose**、**setLoadBalancer**和**getLoadBalancer**

*  choose() 是用来选择实例的
 *  setLoadBalancer()用来设置负载均衡规则
 *  getLoadBalancer()获取负载均衡规则

实现IRule有个类，分别定义不同的负载均衡规则：

*  随机策略 RandomRule
 *  轮询策略 RoundRobinRule
 *  重试策略 RetryRule
 *  可用过滤策略 PredicateBaseRule
 *  响应时间权重策略 WeightedRespinseTimeRule
 *  并发量最小可用策略 BestAvailableRule
 *  区域权重策略 ZoneAvoidanceRule

###### 5.3.7 ILoadBalancer 源码 ######

ILoadBalancer 是一个接口，该接口定义了一系列实现负载均衡的方法，LoadBalancerClient 的实现类 RibbonLoadBalanceClient 也将负载均衡的具体实现交给了 ILoadBalancer 来处理，ILoadBalancer 通过配置 IRule、IPing 等，向 EurekaClient 获取注册列表信息，默认每10秒向 EurekaClient 发送一次 “ping”，进而检查是否需要更新服务的注册列表信息。最后，在得到服务注册列表信息后，ILoadBalancer 根据 IRule 的策略进行负载均衡。

查看 BaseLoadBalancer 和 DynamicServerListLoadBalancer 源码，默认情况下实现了以下配置：

1.  IClientConfig clientConfig：用于配置负载均衡客户端，默认实现类是 DefaultClientConfigImpl。
2.  IRule rule：用于配置负载均衡的策略，默认使用的是 RoundRobinRule 轮询策略。
3.  IPing ping：用于检查当前服务是否有响应，从而判断当前服务是否可用，默认实现类是 DummyPing，该实现类的 isAlive() 方法返回值是 true，默认所有服务实例都是可用的。
4.  ServerList serverList：用于获取所有 Server 注册列表信息。通过跟踪源码会发现，ServerList 的实现类是 DiscoveryEnabledNIWSServerList，该类定义的 obtainServersViaDiscovery() 方法是根据 eurekaClientProvider.get() 方法获取 EurekaClient，再根据 EurekaClient 获取服务注册列表信息。EurekaClient 的实现类是DiscoveryClient，DiscoveryClient 具有服务注册、获取服务注册列表等功能。
5.  ServerListFilter filter：定义了根据配置过滤或者动态获取符合条件的服务列表，默认实现类是 ZonePreferenceServerListFilter，该策略能够优先过滤出与请求调用方处于同区域的服务实例。

### 六、Ribbon的配置参数 ###

<table> 
 <thead> 
  <tr> 
   <th>控制参数</th> 
   <th>说明</th> 
   <th>默认值</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>&lt;service-name&gt;</code>.ribbon.NFLoadBalancerPingInterval</td> 
   <td>Ping定时任务周期</td> 
   <td>30s</td> 
  </tr> 
  <tr> 
   <td><code>service-name&gt;</code>.ribbon.NFLoadBalancerMaxTotalPingTime</td> 
   <td>Ping超时时间</td> 
   <td>2s</td> 
  </tr> 
  <tr> 
   <td><code>&lt;service-name&gt;</code>.ribbon.NFLoadBalancerRuleClassName</td> 
   <td>IRule实现类</td> 
   <td>RoundRobinRule,基于轮询调度算法规则选择服务实例</td> 
  </tr> 
  <tr> 
   <td><code>&lt;service-name&gt;</code>.ribbon.NFLoadBalancerPingClassName</td> 
   <td>IPing实现类</td> 
   <td>DummyPing,直接返回true</td> 
  </tr> 
  <tr> 
   <td><code>&lt;service-name&gt;</code>.ribbon.NFLoadBalancerClassName</td> 
   <td>负载均衡器实现类</td> 
   <td>2s</td> 
  </tr> 
  <tr> 
   <td><code>&lt;service-name&gt;</code>.ribbon.NIWSServerListClassName</td> 
   <td>ServerList实现类</td> 
   <td>ConfigurationBasedServerList，基于配置的服务列表</td> 
  </tr> 
  <tr> 
   <td><code>&lt;service-name&gt;</code>.ribbon.ServerListUpdaterClassName</td> 
   <td>服务列表更新类</td> 
   <td>PollingServerListUpdater</td> 
  </tr> 
  <tr> 
   <td>&lt;service-<code>name&gt;</code>.ribbon.NIWSServerListFilterClassName</td> 
   <td>服务实例过滤器</td> 
   <td>2s</td> 
  </tr> 
  <tr> 
   <td><code>&lt;service-name&gt;</code>.ribbon.NIWSServerListFilterClassName</td> 
   <td>服务实例过滤器</td> 
   <td>2s</td> 
  </tr> 
  <tr> 
   <td><code>&lt;service-name&gt;</code>.ribbon.ServerListRefreshInterval</td> 
   <td>服务列表刷新频率</td> 
   <td>2s</td> 
  </tr> 
  <tr> 
   <td><code>&lt;service-name&gt;</code>.ribbon.NFLoadBalancerClassName</td> 
   <td>自定义负载均衡器实现类</td> 
   <td>2s</td> 
  </tr> 
 </tbody> 
</table>

### 七、总结 ###

Ribbon是Spring cloud的核心，负载微服务内负载调用；Ribbon可以脱离Spring Cloud的单独使用。

Ribbon是微服务整个微服务组件最复杂的一环，控制流程上为保证服务的高可用性，有比较多的细节参数控制，在使用的过程中需要深入理清每个环节的处理机制，使之发挥稳定且高效的作用。

[8bac20009e9e49bfac5a814cbdb8b685.png_pic_center]: https://img-blog.csdnimg.cn/8bac20009e9e49bfac5a814cbdb8b685.png#pic_center
[f7c537fa99b840f781900478477b3162.png_pic_center]: https://img-blog.csdnimg.cn/f7c537fa99b840f781900478477b3162.png#pic_center