Spring Cloud——负载均衡Ribbon

大数据38

📢📢📢📣📣📣

哈喽！大家好，我是【 一心同学】，一位上进心十足的【 Java领域博主】！😜😜😜
✨【 一心同学】的 写作风格：喜欢用【 通俗易懂】的文笔去讲解每一个知识点，而不喜欢用【 高大上】的官方陈述。

✨【 一心同学】博客的 领域是【 面向后端技术】的学习，未来会持续更新更多的【 后端技术】以及【 学习心得】。

✨如果有对【 后端技术】感兴趣的【 小可爱】， 欢迎关注【 一心同学】💞💞💞

❤️❤️❤️ 感谢各位大可爱小可爱！❤️❤️❤️

目录

一、什么是负载均衡？

二、负载均衡分类

2.1 集中式LB

2.2 进程式 LB

三、Spring Cloud Ribbon是什么？

四、Ribbon 的负载均衡算法

五、环境准备-搭建Eureka

六、集成Ribbon

6.1 搭建Ribbon

6.2 切换负载均衡的规则

6.3 自定义负载均衡的规则

小结

一、什么是负载均衡？

负载均衡（Load Balance），意思是将负载（工作任务，访问请求）进行平衡、分摊到多个操作单元（服务器，组件）上进行执行。是解决高性能，单点故障（高可用），扩展性（水平伸缩）的终极解决方案。

例子：

在早高峰乘地铁时候，紧挨小区的地铁口人特别多，一般会有限流，还会有个地铁工作人员Y用那个大喇叭在喊"着急的人员请走B口，B口人少车空"。。。

而这个地铁工作人员Y就是负责负载均衡的 。为了提升网站的各方面能力，我们一般会把多台机器组成一个集群对外提供服务。然而，我们的网站对外提供的访问入口都是一个的，比如www.taobao.com。那么当用户在浏览器输入www.taobao.com的时候如何将用户的请求分发到集群中不同的机器上呢，这就是负载均衡在做的事情。

Spring Cloud——负载均衡Ribbon

二、负载均衡分类

注：LB，即负载均衡 (LoadBalancer)

2.1 集中式LB

即在 服务的提供方和 消费方之间使用 独立的LB设施，如 Nginx(反向代理服务器)，由该设施 负责把访问请求通过某种策略转发至服务的提供方！

2.2 进程式 LB

将LB逻辑 集成到消费方， 消费方从服务注册中心获知有哪些地址可用，然后自己再从这些地址中选出一个合适的服务器。

Ribbon 就属于进程式LB，它只是一个类库，集成于消费方进程，消费方通过它来获取到服务提供方的地址！

三、Spring Cloud Ribbon是什么？

（1）Ribbon负责实现 客户端的负载均衡，负载均衡器提供很多对http和tcp的行为控制。

（2）Ribbon默认提供了很多 负载均衡算法，如：轮询、随机等，也可以实现 自定义的负载均衡算法。

（3）在Spring cloud中，当Ribbon与Eureka结合使用时， Ribbon可以自动的从Eureka Server获取服务列表，基于负载均衡算法，进行服务调用。

（4）在Spring Cloud构建的微服务系统中， Ribbon作为客户端负载均衡器，有两种使用方式， 第一种是和RestTemplate相结合，第二种是和Feign相结合。

四、Ribbon 的负载均衡算法

（1） RoundRobinRule：轮询策略，默认策略。

（2） RandomRule，随机，使用Random对象从服务列表中随机选择一个服务。

（3） RetryRule，轮询 + 重试。

（4） WeightedResponseTimeRule：优先选择响应时间快，此策略会根据平均响应时间计算所有服务的权重，响应时间越快，服务权重越重、被选中的概率越高。此类有个DynamicServerWeightTask的定时任务，默认情况下每隔30秒会计算一次各个服务实例的权重。刚启动时，如果统计信息不足，则使用RoundRobinRule策略，等统计信息足够，会切换回来。

（5） AvailabilityFilteringRul：，可用性过滤，会先过滤掉以下服务：由于多次访问故障而断路器处于打开的服务、并发的连接数量超过阈值，然后对剩余的服务列表按照RoundRobinRule策略进行访问。

（6） BestAvailableRule：优先选择并发请求最小的，刚启动时吗，如果统计信息不足，则使用RoundRobinRule策略，等统计信息足够，才会切换回来。

（7） ZoneAvoidanceRule：可以实现避免可能访问失效的区域(zone)

五、环境准备-搭建Eureka

1、建立Maven父工程

编写pom.xml


                org.springframework.cloud
                spring-cloud-alibaba-dependencies
                0.2.0.RELEASE
                pom
                import

                org.springframework.cloud
                spring-cloud-dependencies
                Hoxton.SR12
                pom
                import

                org.springframework.boot
                spring-boot-dependencies
                2.3.12.RELEASE
                pom
                import

2、建立以下子工程

注：同样也是Maven。

Spring Cloud——负载均衡Ribbon

3、配置springcloud-eureka-7001

（1）目录如下

Spring Cloud——负载均衡Ribbon

(2)导入依赖


            org.springframework.cloud
            spring-cloud-starter-eureka-server
            1.4.6.RELEASE

            org.springframework.boot
            spring-boot-devtools

（3）编写配置文件

application.yml:

server:
  port: 7001
Eureka配置
eureka:
  instance:
    # Eureka服务端的实例名字
    hostname: localhost
  client:
    # 表示是否向 Eureka 注册中心注册自己(这个模块本身是服务器,所以不需要)
    register-with-eureka: false
    # fetch-registry如果为false,则表示自己为注册中心,客户端的化为 ture
    fetch-registry: false
    # Eureka监控页面~
    service-url:
      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/

undefined

(4)编写启动器

注意：要在主启动器上方添加 @EnableEurekaServer表示 服务端的启动类，可以接受别人注册进来。

package com.yixin.springcloud;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;

@SpringBootApplication
@EnableEurekaServer
public class EurekaServer_7001 {
    public static void main(String[] args) {
        SpringApplication.run(EurekaServer_7001.class,args);
    }
}

4、配置springcloud-provider-blog-8001

（1）建立目录如下

Spring Cloud——负载均衡Ribbon

（2）导入依赖


            org.springframework.cloud
            spring-cloud-starter-eureka
            1.4.6.RELEASE

            org.springframework.boot
            spring-boot-test
            2.4.5

            org.springframework.boot
            spring-boot-starter-web
            2.4.5

            org.springframework.boot
            spring-boot-devtools

（3）编写配置文件

application.yml:

server:
  port: 8001

spring:
  application:
    name: springcloud-provider-blog

Eureka配置：配置服务注册中心地址
eureka:
  client:
    service-url:
      defaultZone: http://localhost:7001/eureka/
  instance:
    instance-id: springcloud-provider-dept-8001 #修改Eureka上的默认描述信息

（4）编写BlogController

注：开发中，我们是需要连接到数据库的，但为了给大家演示清楚Ribbon，这里我们用简单dbsource来表示我们这个微服务对应的数据库。

package com.yixin.springcloud.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 BlogController {
    //表示db01这个数据库
    @Value("db01")
    private String dbsource;
    //注册进来的微服务，获取一些消息
    @GetMapping("/blog/info")
    public String discovery(){
        return dbsource;
    }
}

（5）编写启动类BlogProvider_8001

package com.yixin.springcloud;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

@SpringBootApplication
@EnableEurekaClient
public class BlogProvider_8001 {
    public static void main(String[] args) {
        SpringApplication.run(BlogProvider_8001.class,args);
    }
}

5、编写springcloud-provider-blog-8002和springcloud-provider-blog-8003

（1）导入的依赖和springcloud-provider-blog-8001一样

（2） 配置springcloud-provider-blog-8002

a、application.yml(其实就是改了端口号而已）

server:
  port: 8002

spring:
  application:
    name: springcloud-provider-blog

Eureka配置：配置服务注册中心地址
eureka:
  client:
    service-url:
      defaultZone: http://localhost:7001/eureka/
  instance:
    instance-id: springcloud-provider-dept-8002 #修改Eureka上的默认描述信息

b、编写BlogController

更改数据库名：db02

package com.yixin.springcloud.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 BlogController {

    //表示db02这个数据库
    @Value("db02")
    private String dbsource;
    //注册进来的微服务，获取一些消息
    @GetMapping("/blog/info")
    public String discovery(){
        return dbsource;
    }
}

c、编写启动类，和springcloud-provider-blog-8001一样

(3) 配置springcloud-provider-blog-8003

a、application.yml(其实就是改了端口号而已）

server:
  port: 8003

spring:
  application:
    name: springcloud-provider-blog

Eureka配置：配置服务注册中心地址
eureka:
  client:
    service-url:
      defaultZone: http://localhost:7001/eureka/
  instance:
    instance-id: springcloud-provider-dept-8003 #修改Eureka上的默认描述信息

b、BlogController

更改数据库名：db03

package com.yixin.springcloud.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 BlogController {

    //表示db03这个数据库
    @Value("db03")
    private String dbsource;
    //注册进来的微服务，获取一些消息
    @GetMapping("/blog/info")
    public String discovery(){
        return dbsource;
    }
}

c、编写启动类，和springcloud-provider-blog-8001一样。

6、配置springcloud-consumer-blog-80

（1）目录如下

Spring Cloud——负载均衡Ribbon

（2）导入依赖


            org.springframework.cloud
            spring-cloud-starter-eureka
            1.4.6.RELEASE

            org.springframework.boot
            spring-boot-test
            2.4.5

            org.springframework.boot
            spring-boot-starter-web
            2.4.5

            org.springframework.boot
            spring-boot-devtools

（3）编写ConfigBean

package com.yixin.springcloud.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;

@Configuration
public class ConfigBean {

    @Bean
    public RestTemplate getRestTemplate(){
        return new RestTemplate();
    }
}

（4）编写BlogConsumerController

package com.yixin.springcloud.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 BlogConsumerController {
    @Autowired
    private RestTemplate restTemplate;
    private static final String REST_URL_PREFIX="http://localhost:8001";
    @GetMapping("/consumer/blog")
    public String get(){
        return "消费端："+restTemplate.getForObject(REST_URL_PREFIX +"/blog/info", String.class);
    }
}

（5）测试

依次启动：
springcloud-eureka-7001
springcloud-provider-blog-8002
springcloud-consumer-blog-80

访问：http://localhost:8000/consumer/blog

Spring Cloud——负载均衡Ribbon

至此，Eureka就搭建好了！

六、集成Ribbon

6.1 搭建Ribbon

由于Ribbon属于进程式 LB （Load Balance），即将LB逻辑集成到 消费方， 消费方从服务注册中心获知有哪些地址可用，所以我们只需要在消费方这边进行配置即可。

Eureka搭建好了，我们集成Ribbon非常简单，只需 三步：

配置springcloud-consumer-blog-80

（1）添加依赖：


        org.springframework.cloud
        spring-cloud-starter-ribbon
        1.4.6.RELEASE

（2）在配置类增加注解@LoadBalanced

package com.yixin.springcloud.config;

import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;

@Configuration
public class ConfigBean {

    @LoadBalanced //配置负载均衡实现RestTemplate
    @Bean
    public RestTemplate getRestTemplate(){
        return new RestTemplate();
    }
}

（3）修改BlogConsumerController获取路径

package com.yixin.springcloud.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 BlogConsumerController {

    @Autowired
    private RestTemplate restTemplate;

    //private static final String REST_URL_PREFIX="http://localhost:8001";

    private static final String REST_URL_PREFIX="http://SPRINGCLOUD-PROVIDER-BLOG";

    @GetMapping("/consumer/blog")
    public String get(){
        return "消费端："+restTemplate.getForObject(REST_URL_PREFIX +"/blog/info", String.class);
    }
}

注意：这里的SPRINGCLOUD-PROVIDER-BLOG指的就是我们服务注册中的服务名。
所以为了搭建服务产生方集群，我们刚刚在搭建springcloud-provider-blog-8001、springcloud-provider-blog-8002、springcloud-provider-blog-8003的时候，我们就已经将其服务名全部设置为一样的了。

Spring Cloud——负载均衡Ribbon

Spring Cloud——负载均衡Ribbon

至此，Ribbon就搭建好了，Ribbon的 默认负载均衡算法是 轮询算法，也就是说，请求结束后都会向下一个服务端发送请求，例如 我们的有服务生产方A8001，服务端生产方B8002，服务端生产方C8003，那么消费端请求三次，依次的顺序是A,B,C。

我们来进行测试下：

依次启动
springcloud-eureka-7001
springcloud-provider-blog-8001
springcloud-provider-blog-8002
springcloud-provider-blog-8003
springcloud-consumer-blog-80

访问：http://localhost:7001/

可以发现，我们三个服务生产方已经成功绑定了。

Spring Cloud——负载均衡Ribbon

接着重头戏来了！

进行测试：

访问：http://localhost:8000/consumer/blog

访问第一次：

Spring Cloud——负载均衡Ribbon

访问第二次：

Spring Cloud——负载均衡Ribbon​

访问第三次：

Spring Cloud——负载均衡Ribbon

成功啦！！！

6.2 切换负载均衡的规则

修改springcloud-consumer-blog-80下的ConfigBean

package com.yixin.springcloud.config;

import com.netflix.loadbalancer.IRule;
import com.netflix.loadbalancer.RandomRule;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;

@Configuration
public class ConfigBean {

    @LoadBalanced //配置负载均衡实现RestTemplate
    @Bean
    public RestTemplate getRestTemplate() {
        return new RestTemplate();
    }

    /**
     * IRule:
     * RoundRobinRule 轮询策略
     * RandomRule 随机策略
     * AvailabilityFilteringRule ： 会先过滤掉，跳闸，访问故障的服务~，对剩下的进行轮询~
     * RetryRule ： 会先按照轮询获取服务~，如果服务获取失败，则会在指定的时间内进行，重试
     */
    @Bean
    public IRule myRule() {
        return new RandomRule();//使用随机策略
        //return new RoundRobinRule();//使用轮询策略
        //return new AvailabilityFilteringRule();//会先过滤掉，跳闸，访问故障的服务~，对剩下的进行轮询~
        //return new RetryRule();//会先按照轮询获取服务~，如果服务获取失败，则会在指定的时间内进行，重试
    }
}

测试：

重启springcloud-consumer-blog-80

访问：http://localhost:8000/consumer/blog

访问第一次：

Spring Cloud——负载均衡Ribbon​

访问第二次：

Spring Cloud——负载均衡Ribbon​

访问第三次：

Spring Cloud——负载均衡Ribbon​

可以发现它是 随机的！

6.3 自定义负载均衡的规则

在myRule包下自定义一个配置类MyRule.java。
注意：myRule包不要和主启动类所在的包同级。

Spring Cloud——负载均衡Ribbon

（1）编写自定义规则MyRule

规则：每个服务访问5次，换下一个服务。

package com.yixin.myRule;

import com.netflix.client.config.IClientConfig;
import com.netflix.loadbalancer.AbstractLoadBalancerRule;
import com.netflix.loadbalancer.ILoadBalancer;
import com.netflix.loadbalancer.Server;
import org.springframework.context.annotation.Configuration;

import java.util.List;
import java.util.concurrent.ThreadLocalRandom;

@Configuration
public class MyRule extends AbstractLoadBalancerRule {
    // 每个服务访问 5 次，换下一个服务
    // total=0 => 默认 0，如果等于 5 ，指向下一个服务节点
    // index=0 => 默认 0，如果 total 等于 5 ，index+1
    private int total = 0; //被调用的次数
    private int currentIndex = 0; //当前谁在提供服务

    public Server choose(ILoadBalancer lb, Object key) {
        if (lb == null) {
            return null;
        }
        Server server = null;
        while (server == null) {
            if (Thread.interrupted()) {
                return null;
            }
            List upList = lb.getReachableServers(); //获得存活的服务
            List allList = lb.getAllServers();//获得全部服务
            int serverCount = allList.size();
            if (serverCount == 0) {
                /*
                 * No servers. End regardless of pass, because subsequent passes
                 * only get more restrictive.

                 */
                return null;
            }
// int index = chooseRandomInt(serverCount);//在区间内随机获得一个地址

// server = upList.get(index);//从存活的列表中获得
            //=================================
            total++;
            if (total > 5) {
                total = 0;
                currentIndex++;
            }
            if (currentIndex >= upList.size()) currentIndex = 0;
            server = upList.get(currentIndex);
            //=================================
            if (server == null) {
                /*
                 * The only time this should happen is if the server list were
                 * somehow trimmed. This is a transient condition. Retry after
                 * yielding.

                 */
                Thread.yield();
                continue;
            }
            if (server.isAlive()) {
                return (server);
            }
            // Shouldn't actually happen.. but must be transient or a bug.

            server = null;
            Thread.yield();
        }
        return server;
    }

    protected int chooseRandomInt(int serverCount) {
        return ThreadLocalRandom.current().nextInt(serverCount);
    }

    @Override
    public Server choose(Object key) {
        return choose(getLoadBalancer(), key);
    }

    @Override
    public void initWithNiwsConfig(IClientConfig clientConfig) {
        // TODO Auto-generated method stub
    }
}

（2）编写配置类MyRuleConf

作用：将我们写的这个规则注入到Spring中。

package com.yixin.myRule;

import com.netflix.loadbalancer.IRule;
import com.netflix.loadbalancer.RandomRule;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class MyRuleConf {

    @Bean
    public IRule myRule(){
        return new MyRule();//自定义规则
    }
}

（3）启动类增加注解@RibbonClient

package com.yixin.springcloud;

import com.yixin.myRule.MyRuleConf;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.cloud.netflix.ribbon.RibbonClient;

@SpringBootApplication
@EnableEurekaClient
//在微服务启动的时候就能加载自定义的Ribbon类(自定义的规则会覆盖原有默认的规则)
@RibbonClient(name = "SPRINGCLOUD-PROVIDER-BLOG",configuration = MyRuleConf.class)//开启负载均衡,并指定自定义的规则
public class BlogConsumer_80 {

    public static void main(String[] args) {
        SpringApplication.run(BlogConsumer_80.class,args);
    }

}

（4）测试

重启 springcloud-consumer-blog-80

访问：http://localhost:8000/consumer/blog

访问1-5次：

Spring Cloud——负载均衡Ribbon​

访问第6-10次：

Spring Cloud——负载均衡Ribbon​

访问第11-15次：

Spring Cloud——负载均衡Ribbon​

自定义规则测试成功！！！

小结

以上就是【 一心同学】对基于 Spring Cloud的负载均衡Ribbon知识点和实操的讲解，实现负载均衡可以将我们的 压力分摊到多个操作单元，大家可以重新回头去看上面【 一心同学】对Ribbon的概念讲解，相信对Ribbon的理解马上就悟了！

如果这篇【 文章】有帮助到你，希望可以给【 一心同学】点个赞👍，创作不易，相比官方的陈述，我更喜欢用【 通俗易懂】的文笔去讲解每一个知识点，如果有对【 后端技术】感兴趣的小可爱，也欢迎关注❤️❤️❤️ 【 一心同学】❤️❤️❤️，我将会给你带来巨大的【 收获与惊喜】💕💕！

Original: https://blog.csdn.net/Huang_ZX_259/article/details/122331708
Author: 一心同学
Title: Spring Cloud——负载均衡Ribbon