@[toc]

前言

本节配套案例代码：Gitee仓库、Github仓库

所有博客文件目录索引：博客目录索引(持续更新)

学习视频：动力节点最新SpringCloud视频教程|最适合自学的springcloud+springcloudAlibaba

PS：本章节中部分图片是直接引用学习课程课件，如有侵权，请联系删除。

一、认识Ribbon

1.1、介绍Ribbon

Spring Cloud Ribbon 是一个基于 HTTP 和 TCP 的客户端负载均衡工具，它基于 Netflix Ribbon 实现。通过 Spring Cloud 的封装，可以

让我们轻松地将面向服务的 REST 模版请求 自动转换成客户端负载均衡的服务调用。 轮询 hash 权重 …

简单的说 Ribbon 就是 netfix 公司的一个开源项目，主要功能是提供客户端负载均衡算法和 服务调用。

Ribbon 客户端组件提供了一套完善的配置项，比如连接超时，重试等。 在 Spring Cloud 构建的微服务系统中， Ribbon 作为服务消费者的负载均衡器，有两种使 用方式，一种是和 RestTemplate 相结合，另一种是和 OpenFeign 相结合。

OpenFeign 已经 默认集成了 Ribbon,关于 OpenFeign 的内容将会在下一章进行详细讲解。Ribbon 有很多子 模块，但很多模块没有用于生产环境!

1.2、负载均衡协议

负载均衡，英文名称为 Load Balance（LB）http:// lb://（负载均衡协议） ，其含义就是指将负载（工作任务）进行平衡、分摊到多个操作单元上进行运行，例如 Web 服务器、 企业核心应用服务器和其它主要任务服务器等，从而协同完成工作任务。

负载均衡构建在原有网络结构之上，它提供了一种透明且廉价有效的方法扩展服务器和网络设备的带宽、加强网络数据处理能力、增加吞吐量、提高网络的可用性和灵活性。

服务器的负载均衡

---

二、实战—快速集成Ribbon组件

目标：借助使用Ribbon组件集成到SpringCloud实现负载均衡【针对于某个服务的集群模式】。

项目版本环境：

• SpringBoot：2.3.12.RELEASE
• SpringCloud：Hoxton.SR12

2.1、前提准备（provider生产者）

想要完成这一个ribbondemo，首先需要准备一个Eureka Server服务端，还有两个provider生产端。

Eureake-Server使用的时之前的案例demo，然后最新的两个生产方则时最新创建的。其实这两个provider本质就是两个Eureka-client，在启动时都会注册到Server服务端中。

创建两个provider的流程与之前的相同，这里给出两个配置文件以及各自暴露的接口：

① provider-a：

application.yml：

server:
    port: 8080
spring:
    application:
      name: provider
eureka:
  client:
      service-url:
        defaultZone: http://localhost:8761/eureka
  instance:
      hostname: locahost
      prefer-ip-address: true
      instance-id: ${eureka.instance.hostname}:${spring.application.name}:${server.port}

controller/ProviderController.java：

package com.changlu.ribbonprovidera.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @Description:
 * @Author: changlu
 * @Date: 4:58 PM
 */
@RestController
public class ProviderController {

    @GetMapping("/hello")
    public String hello(){
        return "我是服务提供者aaa";
    }

}

②provider-b：

application.yml：

server:
  port: 8081
spring:
  application:
    name: provider
eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka
  instance:
    hostname: localhost
    prefer-ip-address: true
    instance-id: ${eureka.instance.hostname}:${spring.application.name}:${server.port}

controller/ProviderController.java：

package com.changlu.ribbonproviderb.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @Description:
 * @Author: changlu
 * @Date: 4:58 PM
 */
@RestController
public class ProviderController {

    @GetMapping("/hello")
    public String hello(){
        return "我是服务提供者bbb";
    }

}

暴露的接口返回的不是同一个内容，主要目的是为了之后的测试。

我们将这三个服务启动起来：

访问：http://localhost:8761/

可以看到此时provider应用有两个服务，之后我们的目标就是这个provider应用对其进行负载均衡：

2.2、创建消费者consumer

创建一个Eureka-Client项目：

• SpringBoot：2.3.1.RELEASE
• SpringCloud：Hoxton.SR12

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>

配置如下：

server:
  port: 8082
spring:
  application:
    name: consumer
eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka
  instance:
    hostname: localhost
    prefer-ip-address: true
    instance-id: ${eureka.instance.hostname}:${spring.application.name}:${server.port}

开启EureakClient：

@EnableEurekaClient

2.3、消费者集成Ribbon组件（两种方案）

前提

若是我们想要实现一个负载均衡的功能，那么我们引入netflix的ribbon依赖：

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
</dependency>

实践

方式一：增强RestTemplate方法，使其具备负载均衡功能。

如何增强呢？我们来RestTemplate来在注入过程中进行增强。

package com.changlu.ribbonconsumer.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;

/**
 * @Description: 个人配置类
 * @Author: changlu
 * @Date: 5:03 PM
        */
@Configuration
public class MyConfig {

    @Bean
    @LoadBalanced   //使用负载均衡器
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }

}

controller/ConsumerController.java：

package com.changlu.ribbonconsumer.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.loadbalancer.LoadBalancerClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

/**
 * @Description:
 * @Author: changlu
 * @Date: 4:56 PM
 */
@RestController
public class ConsumerController {

    //方式一：增强版的RestTemplate（附带负载均衡）
    @Autowired
    private RestTemplate restTemplate;

    @GetMapping("/testRibbon")
    public String testRibbon(String serviceId) {
        String url = "http://" + serviceId + "/hello";
        String content = restTemplate.getForObject(url, String.class);
        return content;
    }
}

启动服务后我们来进行测试：http://localhost:8082/testRibbon?serviceId=provider

思路如下：

思考 ribbon是怎么将 http://provider/hello 路径请求成功的【本质：对服务名来进行服务发现并进行替换发送请求】
1.拦截这个请求
2.截取主机名称
3.借助eureka来做服务发现 list<> （127.0.0.1:8080、127.0.0.1:8081）
4.通过负载均衡算法 拿到一个服务ip port，举例如：http://127.0.0.1:8080/hello
5.reConstructURL

方法二：直接使用ribbon给我们提供的客户端

package com.changlu.ribbonconsumer.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.loadbalancer.LoadBalancerClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

/**
 * @Description:
 * @Author: changlu
 * @Date: 4:56 PM
 */
@RestController
public class ConsumerController {
    
	//方式二：使用ribbon提供的客户端来进行负载均衡获取服务
    @Autowired
    private LoadBalancerClient loadBalancerClient;

    @GetMapping("/testRibbon2")
    public String testRibbon2(String serviceId) {
        //根据服务来进行选择一个实例
        ServiceInstance choose = loadBalancerClient.choose(serviceId);
        return choose.toString();
    }

}

访问路径：http://localhost:8082/testRibbon2?serviceId=provider

三、负载均衡算法

3.1、轮询算法思路

轮训的算法 怎么去实现
两台机器   A B
A
B
A
B
代码实现轮训的算法  List<机器>
请求次数
 int index =   1 % size    list.get(index);
% 取模 取余好处是一个周期函数 让得到的结果 总是小于 除数的
 1 / 2    1 % 2
1%2=1
2%2=0
3%2=1
4%2=0
全局顶一个int i = 0
i++  线程不安全的
i % size
怎么能做一个线程安全的轮训算法   加锁 效率极低  CAS 自旋锁 没有线程的等待和唤醒的开销
CAS 优点 性能好 java层面无锁的状态  但是在jvm层面 有锁的cmpxchg
CAS 缺点 会导致短暂时间内 CPU 飙升  还有ABA 问题

3.2、实战—项目中选择负载均衡算法

方式一：指定某个服务使用轮询算法（配置文件）

application.yaml：指定某个服务来使用对应的

# 访问不用的服务可以使用不用的算法规则
provider:  # 先写服务提供者的应用名称
    ribbon:
        NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule    #几种算法的全限定类名

检验：在BaseLoadBalancer类中的chooseServer()中的下列行打上断点即可

方式二：全局配置负载均衡算法（注入bean方式）

在配置类中手动注入某个负载均衡算法：

//手动注入一个负载均衡器
@Bean
public IRule loadBalanced() {
    return new RandomRule();
}

方式三：自己实现一个负载均衡算法

package com.changlu.ribbonconsumer.config;


import com.netflix.loadbalancer.ILoadBalancer;
import com.netflix.loadbalancer.IRule;
import com.netflix.loadbalancer.Server;

/**
 * @Description: 我的自定义负载均衡器
 * @Author: changlu
 * @Date: 10:21 PM
 */
public class MyRule implements IRule {
    @Override
    public Server choose(Object key) {
        return null;
    }

    @Override
    public void setLoadBalancer(ILoadBalancer lb) {

    }

    @Override
    public ILoadBalancer getLoadBalancer() {
        return null;
    }
}

实现好了自定义的负载均衡算法后，我们使用之前的方式一、方式二即可。

四、负载均衡源码分析

入口从下面的choose()开始：

//方式二：使用ribbon提供的客户端来进行负载均衡获取服务
@Autowired
private LoadBalancerClient loadBalancerClient;

@GetMapping("/testRibbon2")
public String testRibbon2(String serviceId) {
    //根据服务来进行选择一个实例
    ServiceInstance choose = loadBalancerClient.choose(serviceId);
    return choose.toString();
}

RibbonLoadBalancerClient.java：

public ServiceInstance choose(String serviceId) {
    //1、走this.choose
    return this.choose(serviceId, (Object)null);
}

public ServiceInstance choose(String serviceId, Object hint) {
    //2、走getServer
    Server server = this.getServer(this.getLoadBalancer(serviceId), hint);
    return server == null ? null : new RibbonLoadBalancerClient.RibbonServer(serviceId, server, this.isSecure(server, serviceId), this.serverIntrospector(serviceId).getMetadata(server));
}

protected Server getServer(ILoadBalancer loadBalancer, Object hint) {
    //3、走loadBalancer.chooseServer【=> ZoneAwareLoadBalancer】
    return loadBalancer == null ? null : loadBalancer.chooseServer(hint != null ? hint : "default");
}

ZoneAwareLoadBalancer.java：

public Server chooseServer(Object key) {
    if (ENABLED.get() && this.getLoadBalancerStats().getAvailableZones().size() > 1) {
        ...
    } else {
        logger.debug("Zone aware logic disabled or there is only one zone");
        //走这里的选择服务器（key=default）
        return super.chooseServer(key);
    }
}

BaseLoadBalancer.java：这里实际上会进行使用当前实例的rule规则来进行负载均衡

public Server chooseServer(Object key) {
    if (this.counter == null) {
        this.counter = this.createCounter();
    }
    this.counter.increment();
    if (this.rule == null) {
        return null;
    } else {
        try {
            //根据对应的rule规则来进行选择key
            //当前this.rule => ZoneAvoidancePredicate
            return this.rule.choose(key);
        } catch (Exception var3) {
            logger.warn("LoadBalancer [{}]:  Error choosing server for key {}", new Object[]{this.name, key, var3});
            return null;
        }
    }
}

ZoneAvoidanceRule#（其父类为：PredicateBasedRule，choose在其父类方法中）

• 注意默认走的是这个ZoneAvoidanceRule规则。

PredicateBasedRule.java：

public Server choose(Object key) {
    ILoadBalancer lb = this.getLoadBalancer();
    //走这个chooseRoundRobinAfterFiltering
    Optional<Server> server = this.getPredicate().chooseRoundRobinAfterFiltering(lb.getAllServers(), key);
    return server.isPresent() ? (Server)server.get() : null;
}

AbstractServerPredicate.java：

public Optional<Server> chooseRoundRobinAfterFiltering(List<Server> servers, Object loadBalancerKey) {
    List<Server> eligible = this.getEligibleServers(servers, loadBalancerKey);
    //走其中的this.incrementAndGetModulo()
    return eligible.size() == 0 ? Optional.absent() : Optional.of(eligible.get(this.incrementAndGetModulo(eligible.size())));
}

//就是一个cas轮询操作
//modulo = 2（2.3中项目）
private int incrementAndGetModulo(int modulo) {
    for (;;) {
        int current = nextIndex.get();
        int next = (current + 1) % modulo;
        if (nextIndex.compareAndSet(current, next) && current < modulo)
            return current;
    }
}

五、ribbon负载均衡详细配置

ribbon:
    eager-load:
        enabled: false # ribbon它只有自己的话 能不能做服务发现 借助eureka  # ribbon需要去eureka中获取服务列表 如果false就懒加载
    eureka:
        enabled: true  # 开启eureka支持
    # 若是想要选择其他网络请求工具，可以来进行下面选择配置
    http:  # 我们使用ribbon 用的restTemplate发请求 java.net.HttpUrlConnection 发的请求  很方便 但是它不支持连接池
        client:  # 发请求的工具有很多 httpClient  它支持连接池 效率更好  如果你想改请求的工具 记得加这个依赖即可
            enabled: false
    okhttp: # 这个也是请求工具 移动端用的比较多 轻量级的请求
        enabled: false

六、Ribbon总结

可以使用Eureka+Ribbon来做分布式项目！

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hQ9okMP1-1657598291528)(C:\Users\93997\AppData\Roaming\Typora\typora-user-images\image-20220705223200391.png)]

Ribbon 是客户端实现负载均衡的远程调用组件，用法简单 
Ribbon 源码核心： ILoadBalancer 接口：起到承上启下的作用 
    1. 承上：从 eureka 拉取服务列表 
    2. 启下：使用 IRule 算法实现客户端调用的负载均衡

设计思想：

每一个服务提供者都有自己的 ILoadBalancer 
userService---》客户端有自己的 ILoadBalancer 
TeacherService---》客户端有自己的 ILoadBalancer 
在客户端里面就是 Map<String,ILoadBalancer> iLoadBalancers Map<String,ILoadBalancer> iLoadBalancers 消费者端 
服务提供者的名称 value （服务列表 算法规则 ）

如何实现负载均衡的呢？

iloadBalancer loadbalance = iloadBalancers.get(“user-service”) 
List<Server> servers = Loadbalance.getReachableServers();//缓存起来 
Server server = loadbalance .chooseServer(key) //key 是区 id，--》IRule 算法 chooseServer 下面有一个 IRule 算法