SpringCloud负载均衡-Ribbon

简介

Ribbon是SpringCloud提供的用于客户端软件负载均衡算法和服务调用的组件

负载均衡分类

负载均衡分为服务端负载均衡和客户端负载均衡

• 服务端负载均衡：在服务消费方和服务提供方有单独的负载均衡设施，由该设施将请求通过某种策略转发到服务提供方（例如：Nginx）
• 客户端负载均衡：在调用接口的时候，会在注册中心获取服务列表，利用算法选择一个服务进行连接（比如Ribbon）

Ribbon的工作流程

1.选择注册中心，优先选择同一个区域内负载较小的注册中心
2.根据用户指定的策略，再从注册中心获取到的服务列表中选择一个地址

负载均衡效果展示

在SpringCloud服务治理-Eureka这篇文章中我们已经展示过轮询负载均衡的效果，此处不再重复。值得一提的是为什么在Eureka客户端中可以实现负载均衡？这是因为EurekaClient默认集成了Ribbon依赖，如图所示：

image.png

Ribbon自带的负载均衡算法

Ribbon自带7种负载均衡算法：

• RoundRobinRule：轮询
• RandomRule：随机
• RetryRule：先按照轮询的策略获取服务，如果获取服务失败会在指定的时间内进行重试
• WeightedResponseTimeRule：响应速度越快的实例选择权重越大，越容易被选择
• BestAvailableRule：过滤掉多次访问故障而处于断路器跳闸状态的服务，选择一个并发最小的服务
• AvalabilityFilteringRule：过滤掉故障实例，选择并发较小的实例
• ZoneAvoidanceRule：符合判断server所在区域的性能和server的可用性选择服务器

切换Ribbon负载均衡算法

切换Ribbon的负载均衡算法有两种方式：1.通过配置yaml实现 2.通过注解+代码方式实现

• 通过配置yaml实现
  在消费者服务中的yaml中按照如下格式配置

服务提供者的spring.application.name:
  ribbon:
    NFLoadBalancerRuleClassName: 负载均衡规则

实例：

sword-provider:
  ribbon:
    NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RoundRobinRule

• 通过注解+代码方式实现
  Ribbon官网明确给出提示：自定义的rule配置类不能放在@ComponentScan所扫描的包及其子包下
  然而现实是：
  
  

  image.png
  
  可见@SpringBootApplication注解的元注解还存在@ComponentScan,所以启动类所在的包及其子包都不能存放自定义的Rule配置类，所以只能在外部独立创建一个包
  
  

  image.png
  
  在ruleconfig包下创建一个MyRule配置类：

@Configuration
public class MyRule {
    @Bean
    public IRule mySelfRule(){
        return new RandomRule();
    }
}

然后需要在主启动类上添加@RibbonClient注解告知服务启动时采用哪一种负载均衡规则

@SpringBootApplication
@EnableEurekaClient
@RibbonClient(name = "sword-provider",configuration = {MyRule.class})
public class ConsumerApplication {
    public static void main(String[] args) {
        SpringApplication.run(ConsumerApplication.class,args);
    }

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

负载均衡算法

原理

轮询算法原理：接口的第几次请求数 % 服务集群的总数 = 实际调用服务器的下标
每次服务重启后，请求计数从1开始

轮询算法源代码理解

IRule.java

image.png

所以我们重点看RoundRobinRule类的choose方法

image.png

可以看到目标服务的获取是通过incrementAndGetModulo()方法计算出下标，然后从服务列表中通过下标值来获取到的，所以接下来我们看懂incrementAndGetModulo()这个方法就行了

image.png

根据以上源码分析，上面的轮询算法原理得到了论证

模仿源码，手写一个算法

/**
 * 定义一个类继承自AbstractLoadBalancerRule，重写其中的方法，并添加一个无参构造方法
 * 添加@Component注解
 * 编写chose方法
 */
@Component
public class SelfDefineRule extends AbstractLoadBalancerRule {
    public SelfDefineRule() {
    }

    public void initWithNiwsConfig(IClientConfig iClientConfig) {

    }

    public Server choose(ILoadBalancer lb, Object key) {
        if (lb==null){
            return null;
        }else {
            Server server=null;
            while(server==null){
                //获取可达server列表
                List upList=lb.getReachableServers();
                //获取所有服务列表
                List all= lb.getAllServers();
                int allCount=all.size();
                //计算一个随机数
                int randomId=new Random().nextInt(allCount);
                server = upList.get(randomId);
                if (server==null){
                    //如果server为null，就让出cpu
                    Thread.yield();
                }else {
                    // 如果server存活，就返回server
                    if (server.isAlive()){
                        return server;
                    }
                    //如果server已经不活动，那么将server重新置空（以满足循环条件），让出cpu
                    server=null;
                    Thread.yield();
                }
            }
            return server;
        }
    }

    public Server choose(Object key) {
        return this.choose(this.getLoadBalancer(),key);
    }
}

使用

@Configuration
public class MyRule {
    @Bean
    public IRule mySelfRule(){
        return new SelfDefineRule();
    }
}

通过接口访问，发现能够随机访问到后台集群中的机器