Java教程

RIbbon是什么?怎么实现的负载均衡?底层默认是如何实现的负载算法?带你深入其中

本文主要是介绍RIbbon是什么?怎么实现的负载均衡?底层默认是如何实现的负载算法?带你深入其中,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

@

目录
  • 1.工程中引入谷歌提供的guava工具类和Ribbon组件的依赖,
  • 2.测试类:
  • 3.BoadBalancerBuilder.newBilder()源码逐行深入
    • 3.1 执行newBilder()方法,进行创建"LoadBalancerBuilder"对象
    • 3.2 点进去,在创建“LoadBalancerBuilder”对象时,会初始化其类属性,这里有个关键点,在第16行会执行一个配置默认参数值的属性,并且返回其配置类
    • 3.3 此时会执行一个"default"默认的注册配置信息
    • 3.4 进入this.loadDefaultValues()方法
    • 3.5 AvailabilityFilteringRule对象
    • 3.6 看到这里我们就知道了,RIbbon的默认算法是轮询的算法机制。
  • 4. buildFixedServerListLoadBalancer(servers)源码逐行深入
    • 4.1 点进去会看到 rule肯定是null,然后他会拿到刚刚解析的配置类进行从配置类信息中创建Rule的操作
    • 4.2 这里就看到我们在3.3中提到的”NFLoadBalancerRuleClassName“key拿到默认负载算法的Class对象。
  • 5.既然默认的算法机制搞清楚了 就可以进行choose server了
    • 5.1 执行多个重载的choose方法
    • 5.2 执行增量取模算法
    • 5.3 算法执行完后进行检查处理
      • 6.默认算法需要注意点
  • 7.使用RxJava构建Ribbon

负载方案简介:

目前主流的负载方案分为以下两种:
1.集中式负载均衡,在消费者和服务提供方中间使用独立的代理方式进行负载,有硬件的(比如 F5),也有软件的(比如 Nginx)。
2.客户端自己做负载均衡,根据自己的请求情况做负载,Ribbon 就属于客户端自己做负载。

而Spring Cloud Ribbon 虽然只是一个工具类框架,它不像服务注册中心、配置中心、API 网关那样需要独立部署,但是它几乎存在于每一个 Spring Cloud 构建的微服务和基础设施中。因为微服务间的调用,API 网关的请求转发等内容,实际上都是通过 Ribbon 来实现的

接下来就带大家通过几行源码的debug查看单机的Ribbon默认算法是实现的



1.工程中引入谷歌提供的guava工具类和Ribbon组件的依赖,

pom.xml:

  <!-- https://mvnrepository.com/artifact/com.google.guava/guava -->
        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>30.1.1-jre</version>
        </dependency>

        <dependency>
            <groupId>com.netflix.ribbon</groupId>
            <artifactId>ribbon</artifactId>
            <version>2.2.2</version>
        </dependency>
        <dependency>
            <groupId>com.netflix.ribbon</groupId>
            <artifactId>ribbon-core</artifactId>
            <version>2.2.2</version>
        </dependency>
        <dependency>
            <groupId>com.netflix.ribbon</groupId>
            <artifactId>ribbon-loadbalancer</artifactId>
            <version>2.2.2</version>
        </dependency>

2.测试类:

    public static void main(String[] args) {
        // 	注册两个server,顺序分别是8081,8082
        List<Server> serverList = Lists.newArrayList(
                new Server("localhost", 8081),
                new Server("localhost", 8082)
        );

        ILoadBalancer baseLoadBalancer = LoadBalancerBuilder.newBuilder().buildFixedServerListLoadBalancer(serverList);
        Server localhost = baseLoadBalancer.chooseServer("localhost");
        Server localhost2 = baseLoadBalancer.chooseServer("localhost");
        Server localhost3 = baseLoadBalancer.chooseServer("localhost");
        Server localhost4 = baseLoadBalancer.chooseServer("localhost");
        System.out.println(localhost);
        System.out.println(localhost2);
        System.out.println(localhost3);
        System.out.println(localhost4);
}

3.BoadBalancerBuilder.newBilder()源码逐行深入

// 这段代码是其核心,这里注册了默认的算法机制和choose的api
LoadBalancerBuilder.newBuilder().buildFixedServerListLoadBalancer(serverList);

接下来介绍我所认知的几个核心关键点

// 用来注册默认的负载均衡算法类,以配置类对象的形式初始化用到的属性
LoadBalancerBuilder.newBuilder()

具体流程:

3.1 执行newBilder()方法,进行创建"LoadBalancerBuilder"对象

在这里插入图片描述

3.2 点进去,在创建“LoadBalancerBuilder”对象时,会初始化其类属性,这里有个关键点,在第16行会执行一个配置默认参数值的属性,并且返回其配置类

在这里插入图片描述

3.3 此时会执行一个"default"默认的注册配置信息

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

3.4 进入this.loadDefaultValues()方法

在这里会看到一大坨默认的注册信息,核心参数:"NFLoadBalancerRuleClassName" 请记住这个字段


咱们这里只看有关默认算法的代码,其他的不做扩展

public void loadDefaultValues() {
  xxxxxxxxxx        
  this.putDefaultStringProperty(CommonClientConfigKey.NFLoadBalancerRuleClassName, this.getDefaultNfloadbalancerRuleClassname());
  xxxxxxxxxx
}

在这里插入图片描述

3.5 AvailabilityFilteringRule对象

他继承自ClientConfigEnabledRoundRobinRule对象 所以在后期创建的时候会执行其构造方法和类的属性。
在这里插入图片描述

3.6 看到这里我们就知道了,RIbbon的默认算法是轮询的算法机制。

在这里插入图片描述

4. buildFixedServerListLoadBalancer(servers)源码逐行深入

ILoadBalancer baseLoadBalancer =
                LoadBalancerBuilder
                        .newBuilder()
	                        .buildFixedServerListLoadBalancer(serverList);

4.1 点进去会看到 rule肯定是null,然后他会拿到刚刚解析的配置类进行从配置类信息中创建Rule的操作

在这里插入图片描述

4.2 这里就看到我们在3.3中提到的”NFLoadBalancerRuleClassName“key拿到默认负载算法的Class对象。

在下面又通过ClientFactory.instantiateInstanceWithClientConfig(ruleClassName, config);方法进行className的实例化,拿到AvailabilityFilteringRule对象的实例,并且内部Rule默认为RoundRobinRule对象做负载均衡算法。
在这里插入图片描述
除了RoundRobinRule以外还有其他的算法
在这里插入图片描述

5.既然默认的算法机制搞清楚了 就可以进行choose server了

5.1 执行多个重载的choose方法

Server server = baseLoadBalancer.chooseServer();

往下直接看606行的choose方法
在这里插入图片描述

继续看choose方法
在这里插入图片描述
在点进去
在这里插入图片描述

5.2 执行增量取模算法

这里核心的方法是44行的"this.incrementAndGetModulo(serverCount);"方法,它通过你传入的server列表个数拿到负载均衡后的索引值。
在这里插入图片描述

算法实现是每次都拿这个AtomicInteger类型值做当前server数组的下标,每次choose都get出当前下标,进行+1再取模 达到雨露均沾的负载均衡效果,并且使用cas方式操作值的变化。

private AtomicInteger nextServerCyclicCounter;

在这里插入图片描述

5.3 算法执行完后进行检查处理

取出server后会进行server的检查判断:
1.如果server是null或者isAlive为false,则continue这次循环,继续下一次轮询
2.如果轮询次数超过10次,则会输入wran警告,并且返回null
log.warn("No available alive servers after 10 tries from load balancer: " + lb);



6.默认算法需要注意点

在这里插入图片描述

这里有意思的是,它内部算法先进行+1,然后就是1+1再%长度的运算。所以第一次取出来的就是server服务列表中的第二个server了...
存的顺序是8081,8082 默认取出来顺序是8082 8081 8082 8081



写到这里就结束了,基本是对默认的负载算法有一个流程的认识。如果不太了解Ribbon单机试玩版如何操作的话 看完可以帮助大家~

7.使用RxJava构建Ribbon

在结尾给大家附上一个通过RxJava实现的代码:

pom.xml:

<dependency>
    <groupId>io.reactivex</groupId>
    <artifactId>rxjava</artifactId>
    <version>1.0.10</version>
</dependency>

Java:

// 服务列表
List<Server> serverList = Lists.newArrayList(new Server("localhost", 8081), new Server("localhost", 8083));
// 构建负载实例
ILoadBalancer loadBalancer = LoadBalancerBuilder.newBuilder().buildFixedServerListLoadBalancer(serverList);
// 调用 5 次来测试效果
for (int i = 0; i < 5; i++) {
    String result = LoadBalancerCommand.<String>builder().withLoadBalancer(loadBalancer).build()
            .submit(new ServerOperation<String>() {
                public Observable<String> call(Server server) {
                    try {
                        String addr = "http://" + server.getHost() + ":" + server.getPort() + "/user/hello";
                        System.out.println(" 调用地址:" + addr);
                        URL url = new URL(addr);
                        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
                        conn.setRequestMethod("GET");
                        conn.connect();
                        InputStream in = conn.getInputStream();
                        byte[] data = new byte[in.available()];
                        in.read(data);
                        return Observable.just(new String(data));
                    } catch (Exception e) {
                        return Observable.error(e);
                    }
                }
            }).toBlocking().first();
    System.out.println(" 调用结果:" + result);
}
这篇关于RIbbon是什么?怎么实现的负载均衡?底层默认是如何实现的负载算法?带你深入其中的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!