1.认识 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 有很多子模块，但很多模块没有用于生产环境！

Ribbon 的工作架构：

主要就是为了在微服务之间提供负载均衡的远程 http 调用

因为这些微服务之间也存在着生产和消费的关系，有的模块需要消费另一个模块（集群），这就必须要负载均衡才可以让生产者达到最大利用率！

1.2、负载均衡协议

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

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

服务器的负载均衡

目标：借助使用 Ribbon 组件集成到 SpringCloud 实现负载均衡【实战—快速集成 Ribbon 组件】。

项目版本环境：

SpringBoot：2.3.12.RELEASE
SpringCloud：Hoxton.SR12

2.实战—快速集成 Ribbon 组件

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

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

Eureake-Server 使用的时之前的案例 demo，然后最新的两个生产方则时最新创建的。

其实这两个 provider 本质就是两个 Eureka-client，在启动时都会注册到 Server 服务端中。

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

① provider-a：

application.yml：

yml

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

controller/ProviderController.java：

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：

yml

server:
  port: 8081
spring:
  application:
    name: provider #这个就相当于发请求时的主机ip，因为会根据这个服务名进行服务发现，找到对应的ip和端口号
eureka:
  client:
    service-url:
      defaultZone: localhost:8761/eureka
  instance:
    hostname: localhost
    prefer-ip-address: true
    instance-id: ${
   eureka.instance.hostname}:${
   spring.application.name}:${
   server.port}

controller/ProviderController.java：

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";
    }

}

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

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

访问：localhost:8761/

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

2.2、创建一个消费者 consumer

创建一个 Eureka-Client 项目：

SpringBoot：2.3.1.RELEASE
SpringCloud：Hoxton.SR12

xml

<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>

配置如下：

yml

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

开启 EureakClient：

java

@EnableEurekaClient

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

前提

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

xml

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

实践

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

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

java

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   //ribbon注解：开启使用负载均衡器
    public RestTemplate restTemplate() {

        return new RestTemplate();
    }

}

controller/ConsumerController.java：

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 serviceName) {

        String url = "http://" + serviceName + "/hello";
        String content = restTemplate.getForObject(url, String.class);
        return content;

        // 只要你给restTemplate 加了ribbon的注解 项目中这个对象发起的请求 都会走ribbon的代理
        // 如果你想使用原生的restTemplate 就需要重新创建一个对象，就和ribbon无关了：
        // RestTemplate myRest = new RestTemplate();
        // String forObject = myRest.getForObject("localhost:8888/aaa", String.class);
        // 如果直接使用restTemplate.getForObject("localhost:8888/aaa", String.class);是行不通的！
    }
}

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

思路如下：

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

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

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 {


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

    @GetMapping("/testRibbon2")
    public String testRibbon2(String serviceId) {

        //根据服务来进行选择一个实例
        ServiceInstance choose = loadBalancerClient.choose(serviceId);
        return choose.toString();
    }

}

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

3.负载均衡算法

负载均衡算法：

3.1、轮询算法思路

什么是轮训？

有两台机器：A B

请求顺序：A B A B

代码需要的变量：

List<所有机器> ，请求次数

思路：

先 int index = i % size 得到机器的索引号，然后 list.get(index)得到机器的 ip port;

为什么使用% 取余？

%取余好处是这是一个周期函数让得到的结果总是小于除数，防止下标越界

例子：

1 / 1 = 1 ； 1 % 1 = 0

1%2=1

2%2=0

3%2=1

4%2=0

具体实现轮训算法：

全局定义一个 int i = 0

然后 i++，但是线程是不安全的

然后 i % size

然后 list.get(index)

怎么能做一个线程安全的轮训算法？
1.加锁但是效率低
2.加 CAS 自旋锁这样就没有线程的等待和唤醒的开销（很浪费时间），只会不停地请求，开销小

CAS 优点：性能好一些在 java 层面是无锁的状态，但是在 jvm 层面是有锁的 cmpxchg

CAS 缺点：会导致短暂时间内 CPU 飙升（会一直请求），还有 ABA 问题

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

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

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

yml

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

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

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

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

java

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

    return new RandomRule();
}

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

java

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;
    }
}

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

4.负载均衡源码分析

源码分析：

入口从下面的 choose()方法，即 LoadBalancerClient 类的源码开始：

java

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

@GetMapping("/testRibbon2")
public String testRibbon2(String serviceId) {

    //根据服务来进行选择一个实例
    ServiceInstance choose = loadBalancerClient.choose(serviceId);
    return choose.toString();
}

RibbonLoadBalancerClient.java：

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：

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 规则来进行负载均衡

java

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：

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：

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中项目），incrementAndGetModulo就是轮询算法
private int incrementAndGetModulo(int modulo) {

    for (;;) { //;;就是死循环

        int current = nextIndex.get();
        int next = (current + 1) % modulo;
        if (nextIndex.compareAndSet(current, next) && current < modulo)
            return current;
    }
}

5.ribbon 负载均衡详细配置

但是其实也可以不用配置，默认就是配置好的！

yml

ribbon:
  eager-load:
    enabled: false # ribbon它只有自己的话 能不能做服务发现？ 不能，要借助eureka
    # ribbon需要去eureka中获取服务列表，使用true进行开启，但是如果false就懒加载（需要的时候才加载）
  eureka:
    enabled: true # 开启ribbon的eureka支持

  # 若是想要选择其他网络请求工具，可以来进行下面选择配置
  #配置httpClient
  http: # 我们使用ribbon 用的restTemplate发请求 java.net.HttpUrlConnection 发的请求  很方便 但是它不支持连接池
    client: # 发请求的工具有很多 httpClient  它支持连接池 效率更好  如果你想改请求的工具 记得还要加这个pom依赖
      enabled: false
  #配置okhttpClient
  okhttp: # 这个也是请求工具 移动端用的比较多 轻量级的请求
    enabled: false

7.Ribbon 总结

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

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

设计思想：

每一个服务提供者都有自己的 ILoadBalancer

userService---》客户端有自己的 ILoadBalancer

TeacherService---》客户端有自己的 ILoadBalancer

在客户端里面就是 Map<String,ILoadBalancer> iLoadBalancers Map<String,ILoadBalancer>

iLoadBalancers 消费者端

服务提供者的名称作为 value （服务列表算法规则）

如何实现负载均衡的呢？

java

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

1.认识 Ribbon ​

1.1、介绍 Ribbon ​

1.2、负载均衡协议 ​

2.实战—快速集成 Ribbon 组件 ​

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

2.2、创建一个消费者 consumer ​

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

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

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

3.负载均衡算法 ​

3.1、轮询算法思路 ​

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

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

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

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

4.负载均衡源码分析 ​

5.ribbon 负载均衡详细配置 ​

7.Ribbon 总结 ​

1.认识 Ribbon

1.1、介绍 Ribbon

1.2、负载均衡协议

2.实战—快速集成 Ribbon 组件

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

2.2、创建一个消费者 consumer

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

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

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

3.负载均衡算法

3.1、轮询算法思路

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

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

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

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

4.负载均衡源码分析

5.ribbon 负载均衡详细配置

7.Ribbon 总结