0
点赞
收藏
分享

微信扫一扫

彻底搞懂 Spring Cloud 前世今生 系列之 第⼀代 Spring Cloud 核⼼组件 — Ribbon负载均衡

Ribbon负载均衡

关于负载均衡

负载均衡⼀般分为服务器端负载均衡和客户端负载均衡
在这里插入图片描述

  • 服务器端负载均衡,⽐如Nginx、F5这些,请求到达服务器之后由这些负载均衡器根据⼀定的算法将请求路由到⽬标服务器处理。

  • 客户端负载均衡,⽐如我们要说的Ribbon,服务消费者客户端会有⼀个服务器地址列表,调⽤⽅在请求前通过⼀定的负载均衡算法选择⼀个服务器进⾏访问,负载均衡算法的执⾏是在请求客户端进⾏。

Ribbon是Netflix发布的负载均衡器。Eureka⼀般配合Ribbon进⾏使⽤,Ribbon利⽤从Eureka中读取到服务信息,在调⽤服务提供者提供的服务时,会根据⼀定的算法进⾏负载。

Ribbon⾼级应⽤

不需要引⼊额外的Jar坐标,因为在服务消费者中我们引⼊过eureka-client,它会引⼊Ribbon相关Jar包
在这里插入图片描述
代码中使⽤如下,在RestTemplate上添加对应注解即可

@Bean
// Ribbon负载均衡
@LoadBalanced
public RestTemplate getRestTemplate() {
	return new RestTemplate();
}

Ribbon负载均衡策略

负载均衡策略

Ribbon内置了多种负载均衡策略,内部负责复杂均衡的顶级接⼝为com.netflix.loadbalancer.IRule ,类树如下
在这里插入图片描述

负载均衡策略描述
RoundRobinRule:轮询策略默认超过10次获取到的server都不可⽤,会返回⼀个空的server
RandomRule:随机策略如果随机到的server为null或者不可⽤的话,会while不停的循环选取
RetryRule:重试策略⼀定时限内循环重试。默认继承RoundRobinRule,也⽀持⾃定义注⼊,RetryRule会在每次选取之后,对选举的server进⾏判断,是否为null,是否alive,并且在500ms内会不停的选取判断。⽽RoundRobinRule失效的策略是超过10次,RandomRule是没有失效时间的概念,只要serverList没都挂。
BestAvailableRule:最⼩连接数策略遍历serverList,选取出可⽤的且连接数最⼩的⼀个server。该算法⾥⾯有⼀个LoadBalancerStats的成员变量,会存储所有server的运⾏状况和连接数。如果选取到的server为null,那么会调⽤RoundRobinRule重新选取。
AvailabilityFilteringRule:可⽤过滤策略扩展了轮询策略,会先通过默认的轮询选取⼀个server,再去判断该server是否超时可⽤,当前连接数是否超限,都成功再返回。
ZoneAvoidanceRule:区域权衡策略(默认策略)扩展了轮询策略,继承了2个过滤器:ZoneAvoidancePredicate和AvailabilityPredicate,除了过滤超时和链接数过多的server,还会过滤掉不符合要求的zone区域⾥⾯的所有节点,AWS --ZONE 在⼀个区域/机房内的服务实例中轮询

修改负载均衡策略

#针对的被调⽤⽅微服务名称,不加就是全局⽣效
lagou-service-resume:
  ribbon:
    NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule #负载策略调整

Ribbon核⼼源码剖析

Ribbon⼯作原理

在这里插入图片描述
Ribbon给restTemplate添加了⼀个拦截器

Ribbon细节结构图

  1. 获取服务实例列表
  2. 从列表中选择⼀个server
    在这里插入图片描述
    图中核⼼是负载均衡管理器LoadBalancer(总的协调者,相当于⼤脑,为了做事情,协调四肢),围绕它周围的多有IRule、IPing等
    • IRule:是在选择实例的时候的负载均衡策略对象
    • IPing:是⽤来向服务发起⼼跳检测的,通过⼼跳检测来判断该服务是否可⽤
    • ServerListFilter:根据⼀些规则过滤传⼊的服务实例列表
    • ServerListUpdater:定义了⼀系列的对服务列表的更新操作

@LoadBalanced源码剖析

我们在RestTemplate实例上添加了⼀个@LoadBalanced注解,就可以实现负载均衡,很神奇,我们接下来分析这个注解背后的操作(负载均衡过程)

  • 查看@LoadBalanced注解,那这个注解是在哪⾥被识别到的呢?
    在这里插入图片描述

  • LoadBalancerClient类(实现类RibbonLoadBalancerClient,待⽤)
    在这里插入图片描述

  • ⽼规矩:SpringCloud充分利⽤了SpringBoot的⾃动装配特点,找spring.factories配置⽂件
    在这里插入图片描述
    在这里插入图片描述

  • 研究LoadBalancerAutoConfiguration
    在这里插入图片描述

  • LoadBalancerAutoConfiguration⾥⾯的内容剖析

    • 注⼊resttemplate对象到集合待⽤
      在这里插入图片描述
    • 注⼊resttemplate定制器
      在这里插入图片描述
    • 使⽤定制器给集合中的每⼀个resttemplate对象添加⼀个拦截器
      在这里插入图片描述
  • 到这⾥,我们明⽩,添加了注解的RestTemplate对象会被添加⼀个拦截器LoadBalancerInterceptor,该拦截器就是后续,拦截请求进⾏负载处理的。
    所以,下⼀步重点我们该分析拦截器LoadBalancerInterceptor --> intercept()⽅法
    –> 分析LoadBalancerInterceptor.intercept()⽅法

在这里插入图片描述

  • 那么?RibbonLoadBalancerClient对象是在哪⾥注⼊的===》》回到最初的⾃动配置类
    RibbonAutoConfiguration中
    在这里插入图片描述
  • OMG! 负载均衡的事情执⾏原来交给了我们最初看到的RibbonLoadBalancerClient对象
    ⾮常核⼼的⼀个⽅法:RibbonLoadBalancerClient.execute()
    在这里插入图片描述
    在这里插入图片描述
  • 回到主配置类RibbonAutoConfiguration
    在这里插入图片描述
    在这里插入图片描述
  • RibbonClientConfiguration中装配了⼤脑和肢⼲
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
  • ZoneAwareLoadBalancer#chooseServer
    在这里插入图片描述
  • ⽗类:com.netflix.loadbalancer.BaseLoadBalancer#chooseServer
    在这里插入图片描述
  • 来到区域隔离策略的⽗类choose⽅法中com.netflix.loadbalancer.PredicateBasedRule#choose
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
  • 前⽂我们提到的关注点3
    在这里插入图片描述
    在这里插入图片描述

在这里插入图片描述

  • AbstractClientHttpRequest#execute此处,就已经到了RestTemplate底层执⾏的代码了,由此也将验证最终请求的调⽤还是靠的RestTemplate
    在这里插入图片描述

  • 接下来,在进⾏负载chooseServer的时候,LoadBalancer负载均衡器中已经有了serverList,那么这个serverList是什么时候被注⼊到LoadBalancer中的,它的⼀个机制⼤概是怎样的?
    来到RibbonClientConfiguration
    在这里插入图片描述
    在这里插入图片描述

  • 把⽬光聚焦到使⽤这个空对象ServerList的地⽅
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

  • 进⼊enableAndInitLearnNewServersFeature()⽅法
    在这里插入图片描述
    在这里插入图片描述

RoundRobinRule轮询策略源码剖析

package com.netflix.loadbalancer;
import com.netflix.client.config.IClientConfig;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class RoundRobinRule extends AbstractLoadBalancerRule {
    private AtomicInteger nextServerCyclicCounter;
    private static final boolean AVAILABLE_ONLY_SERVERS = true;
    private static final boolean ALL_SERVERS = false;
    private static Logger log = LoggerFactory.getLogger(RoundRobinRule.class);

    public RoundRobinRule() {
        this.nextServerCyclicCounter = new AtomicInteger(0);
    }

    public RoundRobinRule(ILoadBalancer lb) {
        this();
        this.setLoadBalancer(lb);
    }

    // 负载均衡策略类核⼼⽅法
    public Server choose(ILoadBalancer lb, Object key) {
        if (lb == null) {
            log.warn("no load balancer");
            return null;
        } else {
            Server server = null;
            int count = 0;
            while (true) {
                if (server == null && count++ < 10) {
                    // 所有可⽤服务实例列表
                    List<Server> reachableServers = lb.getReachableServers();
                    // 所有服务实例列表
                    List<Server> allServers = lb.getAllServers();
                    int upCount = reachableServers.size();
                    int serverCount = allServers.size();
                    if (upCount != 0 && serverCount != 0) {
                        // 获得⼀个轮询索引
                        int nextServerIndex = this.incrementAndGetModulo(serverCount);
                        // 根据索引取出服务实例对象
                        server = (Server) allServers.get(nextServerIndex);
                        if (server == null) {
                            Thread.yield();
                        } else {
                            // 判断服务可⽤后返回
                            if (server.isAlive() && server.isReadyToServe()) {
                                return server;
                            }
                            server = null;
                        }
                        continue;
                    }
                    log.warn("No up servers available from load balancer: " +
                            lb);
                    return null;
                }
                if (count >= 10) {
                    log.warn("No available alive servers after 10 tries from load balancer:" + lb);
                }
                return server;
            }
        }
    }

    private int incrementAndGetModulo(int modulo) {
        int current;
        int next;
        do {
            // 取出上次的计数
            current = this.nextServerCyclicCounter.get();
            // 因为是轮询,计数+1之后对总数取模
            next = (current + 1) % modulo;
        } while (!this.nextServerCyclicCounter.compareAndSet(current, next));
        return next;
    }

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

    public void initWithNiwsConfig(IClientConfig clientConfig) {
    }
}

RandomRule随机策略源码剖析

在这里插入图片描述
在这里插入图片描述

CSDN社区 《创作达人》活动,只要参与其中并创作文章就有机会获得官方奖品:精品日历、新程序员杂志,快来参与吧!链接直达 https://bbs.csdn.net/topics/605272551

举报

相关推荐

【Spring Cloud】Ribbon负载均衡

0 条评论