Ribbon 客户端负载均衡

1-Ribbon 概述
- 1.1-是什么
- 1.2-能干嘛
2-Ribbon 集成 Eureka
- 2.1-配置示例
- 2.2-配置总结
3-Ribbon 负载均衡
- 3.1-架构说明
- 3.2-配置示例
- 3.3-配置总结
4-Ribbon 核心组件 IRule
- 4.1-负载均衡算法
- 4.2-自定义算法示例
- 4.3-自定义算法定制

1-Ribbon 概述

官网：https://github.com/Netflix/ribbon/wiki/Getting-Started
在这里插入图片描述
Ribbon 目前也进入维护模式，未来替换方案 SpringCloud Loadbalance。

1.1-是什么

SpringCloud Ribbon 是基于 Netflix Ribbon 实现的一套客户端负载均衡的工具。

简单的说：Ribbon 是 Netflix 发布的开源项目，主要功能是提供客户端的软件负载均衡算法和服务调用。

Ribbon 客户端组件提供一系列完善的配置项如连接超时、重试等。简单的说：就是在配置文件中列出 Load Balancer（简称 LB）后面所有的机器，Ribbon 会自动的帮助你基于某种规则（如简单轮询，随机连接等）去连接这些机器。我们也很容易使用 Ribbon 实现自定义的负载均衡算法。

1.2-能干嘛

LB 负载均衡(Load Balance)是什么？

简单的说就是将用户的请求平摊的分配到多个服务上，从而达到系统的 HA（高可用）。常见的负载均衡有软件 Nginx、LVS，硬件 F5 等。

Ribbon 本地负载均衡客户端 VS Nginx 服务端负载均衡区别：

Nginx 是服务器负载均衡，客户端所有请求都会交给 Nginx，然后由 Nginx 实现转发请求。即负载均衡是由服务端实现的。
Ribbon 本地负载均衡，在调用微服务接口时候，会在注册中心上获取注册信息服务列表之后缓存到 JVM 本地内存，从而在本地实现 RPC 远程服务调用技术。

集中式 LB 与进程内 LB：

集中式 LB：

即在服务的消费方和提供方之间使用独立的 LB 设施（可以是硬件，如 F5；也可以是软件，如 Nginx），由该设施负责把访问请求通过某种策略转发至服务的提供方。
进程内 LB：

将 LB 逻辑集成到消费方，消费方从服务注册中心获知有哪些地址可用，然后自己再从这些地址中选择出一个合适的服务器。Ribbon 就属于进程内 LB，它只是一个类库，集成于消费方进程，消费方通过它来获取到服务提供方的地址。

一句话：负载均衡 + RestTemplate 调用

2-Ribbon 集成 Eureka

2.1-配置示例

a、右击父工程 mscloud，新建子模块 cloud-provider-payment8002
在这里插入图片描述
b、复制子模块 cloud-provider-payment8001 中 pom.xml 到子模块 cloud-provider-payment8002

c、修改子模块 cloud-provider-payment8002 中 pom.xml
在这里插入图片描述
d、修改子模块 cloud-provider-payment8002，目录 /src/main/java 中新建包 com.atguigu.springcloud

e、复制子模块 cloud-provider-payment8001 中包 com.atguigu.springcloud 内容到子模块 cloud-provider-payment8002 包 com.atguigu.springcloud

f、修改子模块 cloud-provider-payment8002，包 com.atguigu.springcloud 启动类重命名为 PaymentMain8002.java

g、复制子模块 cloud-provider-payment8001 中目录 /src/main/resources 内容到子模块 cloud-provider-payment8002 目录 /src/main/resources

h、修改子模块 cloud-provider-payment8002，目录 /src/main/resources 中 application.yml
在这里插入图片描述

server:
  port: 8002
eureka:
  client:
    register-with-eureka: true
    fetchRegistry: true
    service-url:
      # 单机版
      #defaultZone: http://localhost:7001/eureka
      # 集群版
      defaultZone: http://eureka7001.com:7001/eureka,http://eureka7002.com:7002/eureka
  instance:
    # 自定义服务名称
    instance-id: payment8002
    # 访问路径可以显示IP地址
    prefer-ip-address: true
    # Eureka 客户端向服务端发送心跳的时间间隔，单位为秒（默认是 30 秒）
    lease-renewal-interval-in-seconds: 1
    # Eureka 服务端在收到最后一次心跳后等待时间上限，单位为秒（默认是 90 秒），超时将剔除服务
    lease-expiration-duration-in-seconds: 2
info:
  app.name: atguigu-payment8001
  company.name: www.atguigu.com
  build.artifactId: "@project.artifactId@"
  build.version: "@project.version@"
spring:
  application:
    name: cloud-payment-service
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: org.gjt.mm.mysql.Driver
    url: jdbc:mysql://localhost:3306/db2019?useUnicode=true&characterEncoding=utf-8&useSSL=false
    username: root
    password: 123456
mybatis:
  mapperLocations: classpath:mapper/*.xml
  type-aliases-package: com.atguigu.springcloud.entities

注意：

修改服务端口号、数据库连接。
对外暴露的统一的服务实例名。

i、修改子模块 cloud-provider-payment8001、cloud-provider-payment8002，包 com.atguigu.springcloud.controller 中 PaymentController.java
在这里插入图片描述

package com.atguigu.springcloud.controller;
import com.atguigu.springcloud.entities.CommonResult;
import com.atguigu.springcloud.entities.Payment;
import com.atguigu.springcloud.service.PaymentService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;
import java.util.List;
@RestController
@Slf4j
public class PaymentController {
    @Resource
    private PaymentService paymentService;
    @Resource
    private DiscoveryClient discoveryClient;
    @Value("${server.port}")
    private String serverPort;
    @PostMapping(value = "/payment/create")
    public CommonResult create(Payment payment) {
        int result = paymentService.create(payment);
        log.info("*****插入结果：" + result);
        if (result > 0) {  //成功
            return new CommonResult(200, "插入数据库成功,serverPort: " + serverPort, result);
        } else {
            return new CommonResult(444, "插入数据库失败", null);
        }
    }
    @GetMapping(value = "/payment/get/{id}")
    public CommonResult getPaymentById(@PathVariable("id") Long id) {
        Payment payment = paymentService.getPaymentById(id);
        log.info("*****查询结果：" + payment);
        if (payment != null) {  //说明有数据，能查询成功
            return new CommonResult(200, "查询成功,serverPort:  " + serverPort, payment);
        } else {
            return new CommonResult(444, "没有对应记录，查询ID：" + id, null);
        }
    }
    @GetMapping(value = "/payment/discovery")
    public Object discovery() {
        List<String> services = discoveryClient.getServices();
        for (String element : services) {
            log.info("***** element:" + element);
        }
        List<ServiceInstance> instances = discoveryClient.getInstances("CLOUD-PAYMENT-SERVICE");
        for (ServiceInstance instance : instances) {
            log.info(instance.getServiceId() + "\t" + instance.getHost() + "\t"
                    + instance.getPort() + "\t" + instance.getUri());
        }
        return this.discoveryClient;
    }
}

j、修改子模块 cloud-consumer-order80，包 com.atguigu.springcloud.controller 中 OrderController.java
在这里插入图片描述

package com.atguigu.springcloud.controller;
import com.atguigu.springcloud.entities.CommonResult;
import com.atguigu.springcloud.entities.Payment;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;
import javax.annotation.Resource;
@RestController
@Slf4j
public class OrderController {
    //public static final String PAYMENT_URL = "http://localhost:8001";// 单机
    public static final String PAYMENT_URL = "http://CLOUD-PAYMENT-SERVICE";// 集群
    @Resource
    private RestTemplate restTemplate;
    @GetMapping("/consumer/payment/create")
    public CommonResult<Payment> create(Payment payment) {
        return restTemplate.postForObject(PAYMENT_URL + "/payment/create", payment, CommonResult.class);// 写
    }
    @GetMapping("/consumer/payment/get/{id}")
    public CommonResult<Payment> getPayment(@PathVariable("id") Long id) {
        return restTemplate.getForObject(PAYMENT_URL + "/payment/get/" + id, CommonResult.class);
    }
}

k、修改子模块 cloud-consumer-order80，包 com.atguigu.springcloud.config 中 ApplicationContextConfig.java

使用 @LoadBalanced 注解赋予 RestTemplate 负载均衡的能力。

package com.atguigu.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 ApplicationContextConfig {
    @Bean
    @LoadBalanced
    public RestTemplate getRestTemplate() {
        return new RestTemplate();
    }
}

l、测试 Ribbon 负载均衡

启动 Eureka 集群（子模块 cloud-eureka-server7001、cloud-eureka-server7002）
启动微服务集群（子模块 cloud-provider-payment8001、cloud-provider-payment8002）
启动子模块 cloud-consumer-order80
http://eureka7001.com:7001/
http://localhost/consumer/payment/get/31

2.2-配置总结

Ribbon 和 Eureka 整合后微服务消费者可以直接调用服务名称而不用再关心地址和端口号，且该服务还有负载功能了。
在这里插入图片描述

3-Ribbon 负载均衡

3.1-架构说明

在这里插入图片描述
Ribbon 工作时分成两步：

先选择 Eureka Server，它优先选择在同一个区域内负载较少的 Server。
再根据用户指定的策略，再从 Server 取到的服务注册列表中选择一个地址。

其中 Ribbon 提供了多种策略：比如轮询、随机和根据响应时间加权。

3.2-配置示例

上面 Ribbon 集成 Eureka 配置示例中没有引入 spring-cloud-starter-ribbon，也可以使用 Ribbon。

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

因为 spring-cloud-starter-netflix-eureka-client 中自带 spring-cloud-starter-ribbon 引用。

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

在这里插入图片描述

3.3-配置总结

Ribbon 其实就是一个软负载均衡的客户端组件，他可以和其他所需请求的客户端结合使用，和 Eureka 结合只是其中的一个实例。

4-Ribbon 核心组件 IRule

IRule：根据特定算法从服务列表中选取一个要访问的服务。

4.1-负载均衡算法

RoundRobinRule：轮询
RandomRule：随机
RetryRule

先按照 RoundRobinRule 的策略获取服务，如果获取服务失败则在指定时间内会进行重试。
WeightedResponseTimeRule

根据平均响应时间计算所有服务的权重，响应时间越快服务权重越大被选中的概率越高。刚启动时如果统计信息不足，则使用RoundRobinRule 策略，等统计信息足够，会切换到 WeightedResponseTimeRule。
BestAvailableRule

会先过滤掉由于多次访问故障而处于断路器跳闸状态的服务，然后选择一个并发量最小的服务。
ZoneAvoidanceRule

默认规则：复合判断 Server 所在区域的性能和 Server 的可用性选择服务器。
AvailabilityFilteringRule

会先过滤掉由于多次访问故障而处于断路器跳闸状态的服务，还有并发的连接数量超过阈值的服务，然后对剩余的服务列表按照轮询策略进行访问。

4.2-自定义算法示例

a、修改子模块 cloud-consumer-order80，目录 /src/main/java 中新建包 com.atguigu.myrule

官方文档明确给出了警告：这个自定义配置类不能放在 @ComponentScan 所扫描的当前包下以及子包下，否则自定义的配置类就会被所有的 Ribbon 客户端所共享，也就是说达不到特殊化定制的目的了。
在这里插入图片描述
b、修改子模块 cloud-consumer-order80，包 com.atguigu.myrule 中新建 Robbin 自定义规则类 MySelfRule.java

package com.atguigu.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 MySelfRule {
    @Bean
    public IRule myRule() {
        return new RandomRule();// Ribbon 默认是轮询，我自定义为随机
    }
}

c、修改子模块 cloud-consumer-order80，包 com.atguigu.springcloud 中启动类 OrderMain80.java
在这里插入图片描述
子模块 cloud-consumer-order80 启动类 OrderMain80.java 添加 @RibbonClient。在启动该微服务的时候就能去加载自定义 Ribbon 配置类，从而使配置生效。

package com.atguigu.springcloud;
import com.atguigu.myrule.MySelfRule;
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;
@EnableEurekaClient
@SpringBootApplication
@RibbonClient(name = "CLOUD-PAYMENT-SERVICE", configuration = MySelfRule.class)
public class OrderMain80 {
    public static void main(String[] args) {
        SpringApplication.run(OrderMain80.class, args);
    }
}

d、测试 Ribbon 自定义算法示例

启动 Eureka 集群（子模块 cloud-eureka-server7001、cloud-eureka-server7002）
启动微服务集群（子模块 cloud-provider-payment8001、cloud-provider-payment8002）
启动子模块 cloud-consumer-order80
http://localhost/consumer/payment/get/31

4.3-自定义算法定制

算法：Rest 接口第几次请求数 % 服务器集群总数量 = 实际调用服务器位置下标，每次服务重启动后 Rest 接口计数从 1 开始。
在这里插入图片描述
a、修改子模块 cloud-provider-payment8001、cloud-provider-payment8002，包 com.atguigu.springcloud.controller 中 PaymentController.java

package com.atguigu.springcloud.controller;
import com.atguigu.springcloud.entities.CommonResult;
import com.atguigu.springcloud.entities.Payment;
import com.atguigu.springcloud.service.PaymentService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;
import java.util.List;
@RestController
@Slf4j
public class PaymentController {
    @Resource
    private PaymentService paymentService;
    @Resource
    private DiscoveryClient discoveryClient;
    @Value("${server.port}")
    private String serverPort;
    @PostMapping(value = "/payment/create")
    public CommonResult create(Payment payment) {
        int result = paymentService.create(payment);
        log.info("*****插入结果：" + result);
        if (result > 0) {  //成功
            return new CommonResult(200, "插入数据库成功,serverPort: " + serverPort, result);
        } else {
            return new CommonResult(444, "插入数据库失败", null);
        }
    }
    @GetMapping(value = "/payment/get/{id}")
    public CommonResult getPaymentById(@PathVariable("id") Long id) {
        Payment payment = paymentService.getPaymentById(id);
        log.info("*****查询结果：" + payment);
        if (payment != null) {  //说明有数据，能查询成功
            return new CommonResult(200, "查询成功,serverPort:  " + serverPort, payment);
        } else {
            return new CommonResult(444, "没有对应记录，查询ID：" + id, null);
        }
    }
    @GetMapping(value = "/payment/discovery")
    public Object discovery() {
        List<String> services = discoveryClient.getServices();
        for (String element : services) {
            log.info("***** element:" + element);
        }
        List<ServiceInstance> instances = discoveryClient.getInstances("CLOUD-PAYMENT-SERVICE");
        for (ServiceInstance instance : instances) {
            log.info(instance.getServiceId() + "\t" + instance.getHost() + "\t"
                    + instance.getPort() + "\t" + instance.getUri());
        }
        return this.discoveryClient;
    }
    @GetMapping(value = "/payment/lb")
    public String getPaymentLB(){
        return serverPort;
    }
}

b、修改子模块 cloud-consumer-order80，包 com.atguigu.springcloud.config 中 ApplicationContextConfig.java

注释 @LoadBalanced 注解。

package com.atguigu.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 ApplicationContextConfig {
    @Bean
    //@LoadBalanced
    public RestTemplate getRestTemplate() {
        return new RestTemplate();
    }
}

c、修改子模块 cloud-consumer-order80，目录 /src/main/java 中新建包 com.atguigu.springcloud.lb

d、修改子模块 cloud-consumer-order80，包 com.atguigu.springcloud.lb 中新建接口 LoadBalancer.java

package com.atguigu.springcloud.lb;
import org.springframework.cloud.client.ServiceInstance;
import java.util.List;
public interface LoadBalancer {
    // 收集服务器：总共有多少台能够提供服务的机器，并放到 List 里面。
    ServiceInstance instances(List<ServiceInstance> serviceInstances);
}

e、修改子模块 cloud-consumer-order80，包 com.atguigu.springcloud.lb 中新建实现类 MyLB.java

package com.atguigu.springcloud.lb;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.stereotype.Component;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
@Component
public class MyLB implements LoadBalancer {
    private AtomicInteger atomicInteger = new AtomicInteger(0);
    // 坐标
    private final int getAndIncrement() {
        int current;
        int next;
        do {
            current = this.atomicInteger.get();
            next = current >= 2147483647 ? 0 : current + 1;
        } while (!this.atomicInteger.compareAndSet(current, next));// 第一个参数是期望值，第二个参数是修改值
        System.out.println("*******第几次访问，次数next: " + next);
        return next;
    }
    @Override
    public ServiceInstance instances(List<ServiceInstance> serviceInstances) {// 得到机器的列表
        int index = getAndIncrement() % serviceInstances.size();// 得到服务器的下标位置
        return serviceInstances.get(index);
    }
}

f、修改子模块 cloud-consumer-order80，包 com.atguigu.springcloud.controller 中 OrderController.java
在这里插入图片描述

package com.atguigu.springcloud.controller;
import com.atguigu.springcloud.entities.CommonResult;
import com.atguigu.springcloud.entities.Payment;
import com.atguigu.springcloud.lb.LoadBalancer;
import lombok.extern.slf4j.Slf4j;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;
import javax.annotation.Resource;
import java.net.URI;
import java.util.List;
@RestController
@Slf4j
public class OrderController {
    // public static final String PAYMENT_URL = "http://localhost:8001";
    public static final String PAYMENT_URL = "http://CLOUD-PAYMENT-SERVICE";
    @Resource
    private RestTemplate restTemplate;
    @Resource
    private LoadBalancer loadBalancer;
    @Resource
    private DiscoveryClient discoveryClient;
    @GetMapping("/consumer/payment/create")
    public CommonResult<Payment> create(Payment payment) {
        return restTemplate.postForObject(PAYMENT_URL + "/payment/create", payment, CommonResult.class);  //写操作
    }
    @GetMapping("/consumer/payment/get/{id}")
    public CommonResult<Payment> getPayment(@PathVariable("id") Long id) {
        return restTemplate.getForObject(PAYMENT_URL + "/payment/get/" + id, CommonResult.class);
    }
    @GetMapping("/consumer/payment/getForEntity/{id}")
    public CommonResult<Payment> getPayment2(@PathVariable("id") Long id) {
        ResponseEntity<CommonResult> entity = restTemplate.getForEntity(PAYMENT_URL + "/payment/get/" + id, CommonResult.class);
        if (entity.getStatusCode().is2xxSuccessful()) {
            //  log.info(entity.getStatusCode()+"\t"+entity.getHeaders());
            return entity.getBody();
        } else {
            return new CommonResult<>(444, "操作失败");
        }
    }
    @GetMapping(value = "/consumer/payment/lb")
    public String getPaymentLB() {
        List<ServiceInstance> instances = discoveryClient.getInstances("CLOUD-PAYMENT-SERVICE");
        if (instances == null || instances.size() <= 0) {
            return null;
        }
        ServiceInstance serviceInstance = loadBalancer.instances(instances);
        URI uri = serviceInstance.getUri();
        return restTemplate.getForObject(uri + "/payment/lb", String.class);
    }
}