SpringCloud 学习五、Ribbon负载均衡，Rule默认算法 以及 Rule 自定义 负载均衡算法

文章目录

• ​​前言​​
• ​​一、 概述​​

• ​​1. 是什么​​
• ​​2. 能干吗​​

• ​​1) LB（负载均衡）​​

• ​​3. 官网资料​​

• ​​二、 Ribbon配置初步​​

• ​​1. 修改microservicecloud-consumer-dept-80工程​​
• ​​2. 修改pom.xml​​
• ​​3. 修改application.yml 追加eureka的服务注册地址​​
• ​​4. 对ConfigBean进行新注解@LoadBalanced，获得Rest时加入Ribbon的配置​​
• ​​5. 主启动类DeptConsumer80_App添加@EnableEurekaClient​​
• ​​6. 修改DeptController_Consumer客户端访问类​​
• ​​7. 先启动3个eureka集群​​
• ​​8. 再启动microservicecloud-provider-dept-8001并注册进eureka​​
• ​​9. 最后启动microservicecloud-consumer-dept-80​​
• ​​10. 测试​​
• ​​11. 小总结：第二大步骤的重点​​

• ​​三、负载均衡​​

• ​​1. 架构说明​​
• ​​2. 参考microservicecloud-provider-dept-8001，新建两份，分别命名为8002，8003​​

• ​​1). 复制pom文件​​
• ​​2). 新建启动类文件。也可以复制，但最好要修改名称，以防混淆。​​
• ​​3). 复制包文件及子类。​​
• ​​4). 新建yml配置文件，也可以复制，一定要修改里面的内容。​​
• ​​5). 新建8002/8003数据库，各自微服务分别连各自的数据库​​

• ​​3. 修改8002 /8003各自YML​​

• ​​1)只修改几个地方，​​
• ​​2)不修改的地方：​​

• ​​4. 启动3个eureka集群配置区​​
• ​​5. 启动3个Dept微服务并各自测试通过​​
• ​​6. 启动microservicecloud-consumer-dept-80​​
• ​​7. 客户端通过Ribbo完成负载均衡并访问上一步的Dept微服务​​
• ​​8. 总结：Ribbon其实就是一个软负载均衡的客户端组件，​​

• ​​四、 Ribbon核心组件IRule​​

• ​​1. RoundRobinRule​​
• ​​2. RandomRule​​
• ​​3. AvailabilityFilteringRule​​
• ​​4. WeightedResponseTimeRule​​
• ​​5. RetryRule​​
• ​​6. BestAvailableRule​​
• ​​7. ZoneAvoidanceRule​​
• ​​**==8. 测试使用：改变 默认的轮询算法。使用随机的轮询方法==**​​

• ​​五、 Ribbon自定义​​

• ​​1.修改microservicecloud-consumer-dept-80​​
• ​​2.主启动类添加@RibbonClient​​
• ​​3.注意配置细节：新建package com.atguigu.myrule​​
• ​​4. 步骤​​

• ​​1) 新建package com.atguigu.myrule​​
• ​​2) 修改主启动类​​
• ​​3) 测试​​

• ​​六、 自定义规则深度解析：自定义Rule规则，更改需求​​

• ​​1. 问题：​​
• ​​2. 解析源码：​​
• ​​3. 参考源码修改为我们需求要求的RandomRule_ZY.java​​
• ​​4. 调用​​

• ​​1) MySelfRule.java​​
• ​​2) 主启动类​​

• ​​5. 测试​​

前言

案例的都是循序渐进的。案例的顺序：

1. 微服务讲诉->
2. 父工程maven的module建立和rest风格的请求->
3. eureka的学习、三大组件，服务注册与消费->
4. eureka的集群操作 ->
5. ribbon的负载均衡。
6. feign的负载均衡
7. Hystrix断路器
8. Zuul路由网关
9. SpringCloud Config分布式配置中心

一、 概述

1. 是什么

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

客户端技术。。。

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

2. 能干吗

1) LB（负载均衡）

• a) 集中式LB
  即在服务的消费方和提供方之间使用独立的LB设施(可以是硬件，如F5, 也可以是软件，如nginx), 由该设施负责把访问请求通过某种策略转发至服务的提供方；
• b) 进程内LB
  将LB逻辑集成到消费方，消费方从服务注册中心获知有哪些地址可用，然后自己再从这些地址中选择出一个合适的服务器。

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

3. 官网资料

​​https://github.com/Netflix/ribbon/wiki/Getting-Started​​

二、 Ribbon配置初步

1. 修改microservicecloud-consumer-dept-80工程

2. 修改pom.xml

增加ribbon的依赖，有三个：Eureka、ribbon、config。

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <parent>
        <groupId>com.atguigu.springcloud</groupId>
        <artifactId>microservicecloud</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>

    <artifactId>microservicecloud-consumer-dept-80</artifactId>
    <description>部门微服务消费者</description>

    <dependencies>
        <!-- 自己定义的api -->
        <dependency>
            <groupId>com.atguigu.springcloud</groupId>
            <artifactId>microservicecloud-api</artifactId>
            <version>${project.version}</version>
        </dependency>

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

        <!-- Ribbon相关 -->
        <!--首先注册为一个服务-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-eureka</artifactId>
        </dependency>
        <!--然后引入ribbon ，它又依赖 config-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-ribbon</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-config</artifactId>
        </dependency>

        <!-- 修改后立即生效，热部署 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>springloaded</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
        </dependency>
    </dependencies>
</project>

3. 修改application.yml 追加eureka的服务注册地址

原理很干净，仅作为消费者：

注册为微服务后：

server:
  port: 80

eureka:
  client:
    register-with-eureka: false
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/

4. 对ConfigBean进行新注解@LoadBalanced，获得Rest时加入Ribbon的配置

主要使用注解： @LoadBalanced
还要使用 @EnableWebMVC 开启自定义web配置。

package com.atguigu.springcloud.cfgbeans;

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;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;

/**
 * description: ConfigBean
 * author: 冯凡利
 * create:  2019/9/8 16:55
 */
@EnableWebMvc
@Configuration
public class ConfigBean {

    @Bean
    @LoadBalanced  // Spring Cloud Ribbon 是基于 Netflix Ribbon 实现的一套客户端  负载均衡的工具。
    public RestTemplate getRestTemplate()
    {
        return new RestTemplate();
    }

}
复习 类配置的方式
//    public UserService getUserService()
//    {
//        return new UserServiceImpl();
//    }
//    applicationContext.xml == ConfigBean(@Configuration)
//<bean id="userService" class="com.atguigu.tmall.UserServiceImpl" />  == @Bean

5. 主启动类DeptConsumer80_App添加@EnableEurekaClient

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

6. 修改DeptController_Consumer客户端访问类

• 把原来写死的 访问URL地址，写成微服务的名称。
• 这样名称不变，即可访问，还不用关心端口号。
• 而且就算想自定义配置的话，可以通过 yml 里面修改 微服务的名称。

package com.atguigu.springcloud.controller;

import com.atguigu.springcloud.entities.Dept;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import java.util.List;

/**
 * description: DeptController_Consumer
 * author: 冯凡利
 * create:  2019/9/8 16:57
 */
@RestController
public class DeptController_Consumer {

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

    @Autowired
    private RestTemplate restTemplate;

    @RequestMapping("/consumer/dept/add")
    public Boolean add(Dept dept){
        return restTemplate.postForObject(REST_URL_PREFIX,dept,Boolean.class);
    }

    @RequestMapping(value="/consumer/dept/get/{id}")
    public Dept get(@PathVariable("id") Long id)
    {
        return restTemplate.getForObject(REST_URL_PREFIX+"/dept/get/"+id, Dept.class);
    }

    @SuppressWarnings("unchecked")
    @GetMapping(value="/consumer/dept/list")
    public List<Dept> list()
    {
        return restTemplate.getForObject(REST_URL_PREFIX+"/dept/list", List.class);
    }


    /**
     *  测试 @EnableDiscoveryClient ,消费端可以调用服务发现
     * @return
     */
    @RequestMapping(value="/consumer/dept/discovery")
    public Object discovery()
    {
        return restTemplate.getForObject(REST_URL_PREFIX+"/dept/discovery", Object.class);
    }
}

7. 先启动3个eureka集群

8. 再启动microservicecloud-provider-dept-8001并注册进eureka

9. 最后启动microservicecloud-consumer-dept-80

10. 测试

​​http://localhost/consumer/dept/get/1​

​​http://localhost/consumer/dept/list​​

​​http://localhost/consumer/dept/add?dname=大数据部​​

没写对应的方法，就不测试啦！！！

11. 小总结：第二大步骤的重点

Ribbon和Eureka整合后Consumer可以直接调用服务而不用再关心地址和端口号

三、负载均衡

1. 架构说明

Ribbon在工作时分成两步

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

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

2. 参考microservicecloud-provider-dept-8001，新建两份，分别命名为8002，8003

1). 复制pom文件

2). 新建启动类文件。也可以复制，但最好要修改名称，以防混淆。

3). 复制包文件及子类。

4). 新建yml配置文件，也可以复制，一定要修改里面的内容。

5). 新建8002/8003数据库，各自微服务分别连各自的数据库

• 1)8002SQL脚本

DROP DATABASE IF EXISTS cloudDB02;
 
CREATE DATABASE cloudDB02 CHARACTER SET UTF8;
 
USE cloudDB02;
 
CREATE TABLE dept
(
  deptno BIGINT NOT NULL PRIMARY KEY AUTO_INCREMENT,
  dname VARCHAR(60),
  db_source   VARCHAR(60)
);
 
INSERT INTO dept(dname,db_source) VALUES('开发部',DATABASE());
INSERT INTO dept(dname,db_source) VALUES('人事部',DATABASE());
INSERT INTO dept(dname,db_source) VALUES('财务部',DATABASE());
INSERT INTO dept(dname,db_source) VALUES('市场部',DATABASE());
INSERT INTO dept(dname,db_source) VALUES('运维部',DATABASE());
 
SELECT * FROM dept;

• 2)8003SQL脚本

DROP DATABASE IF EXISTS cloudDB03;
 
CREATE DATABASE cloudDB03 CHARACTER SET UTF8;
 
USE cloudDB03;
 
CREATE TABLE dept
(
  deptno BIGINT NOT NULL PRIMARY KEY AUTO_INCREMENT,
  dname VARCHAR(60),
  db_source   VARCHAR(60)
);
 
INSERT INTO dept(dname,db_source) VALUES('开发部',DATABASE());
INSERT INTO dept(dname,db_source) VALUES('人事部',DATABASE());
INSERT INTO dept(dname,db_source) VALUES('财务部',DATABASE());
INSERT INTO dept(dname,db_source) VALUES('市场部',DATABASE());
INSERT INTO dept(dname,db_source) VALUES('运维部',DATABASE());
 
SELECT * FROM dept;

3. 修改8002 /8003各自YML

1)只修改几个地方，

1. 修改端口。
2. 修改数据库名称。为了明显的分别出用的那个微服务。
3. 修改Eureka.instance.instance-id 的值，这样在eureka的客户端即可明显分辨。

2)不修改的地方：

1. Spring.application.name的值不变，三个微服务共用一个名称。

• 1)8002YML

server:
  port: 8002

mybatis:
  config-location: classpath:mybatis/mybatis.cfg.xml        # mybatis配置文件所在路径
  type-aliases-package: com.atguigu.springcloud.entities    # 所有Entity别名类所在包
  mapper-locations:
    - classpath:mybatis/mapper/**/*.xml                       # mapper映射文件

spring:
  application:
    name: microservicecloud-dept                            # 对外暴露的 微服务名字
  datasource:
  type: com.alibaba.druid.pool.DruidDataSource            # 当前数据源操作类型 springboot1.4取消了spring.datasource.type参数。c除非手动声明：datasource bean
    driver-class-name: org.gjt.mm.mysql.Driver              # mysql驱动包
    url: jdbc:mysql://yz1355826760.xyz:3306/cloudDB02            # 数据库名称
    username: root
    password: 123456
    dbcp2:
      min-idle: 5                                           # 数据库连接池的最小维持连接数
      initial-size: 5                                       # 初始化连接数
      max-total: 5                                          # 最大连接数
      max-wait-millis: 200                                  # 等待连接获取的最大超时时间

eureka:
  client:                                     #客户端注册进eureka服务列表内
    service-url:
      #defaultZone: http://localhost:7001/eureka
      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/
  instance:
    instance-id: microservicecloud-dept8002   #自定义修改 服务名称信息， 这个名称会在 eureka 客户端界面上 微服务工程的 右边显示
    prefer-ip-address: true                   # 访问路径(上面的instance-id 的路径，当鼠标放在上面，左下角会显示 访问路径)可以显示IP地址

#以下 都是自己定义的
info:
  app.name: atguigu-microservicecloud
  company.name: www.atguigu.com
  build.artifactId: $project.artifactId$
  build.version: $project.version$

• 2)8003YML

server:
  port: 8003

mybatis:
  config-location: classpath:mybatis/mybatis.cfg.xml        # mybatis配置文件所在路径
  type-aliases-package: com.atguigu.springcloud.entities    # 所有Entity别名类所在包
  mapper-locations:
    - classpath:mybatis/mapper/**/*.xml                       # mapper映射文件

spring:
  application:
    name: microservicecloud-dept                            # 对外暴露的 微服务名字
  datasource:
#type: com.alibaba.druid.pool.DruidDataSource            # 当前数据源操作类型 springboot1.4取消了spring.datasource.type参数。c除非手动声明：datasource bean
    driver-class-name: org.gjt.mm.mysql.Driver              # mysql驱动包
    url: jdbc:mysql://yz1355826760.xyz:3306/cloudDB03            # 数据库名称
    username: root
    password: 123456
    dbcp2:
      min-idle: 5                                           # 数据库连接池的最小维持连接数
      initial-size: 5                                       # 初始化连接数
      max-total: 5                                          # 最大连接数
      max-wait-millis: 200                                  # 等待连接获取的最大超时时间

eureka:
  client:                                     #客户端注册进eureka服务列表内
    service-url:
      #defaultZone: http://localhost:7001/eureka
      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/
  instance:
    instance-id: microservicecloud-dept8003   #自定义修改 服务名称信息， 这个名称会在 eureka 客户端界面上 微服务工程的 右边显示
    prefer-ip-address: true                   # 访问路径(上面的instance-id 的路径，当鼠标放在上面，左下角会显示 访问路径)可以显示IP地址

#以下 都是自己定义的
info:
  app.name: atguigu-microservicecloud
  company.name: www.atguigu.com
  build.artifactId: $project.artifactId$
  build.version: $project.version$

4. 启动3个eureka集群配置区

测试下：
Eureka7001.com:7001
7001的 eureka的服务器上，挂着其他7002、7003 两个服务器集群。
一个微服务下面挂着三个实例。

5. 启动3个Dept微服务并各自测试通过

http://localhost:8001/dept/list

http://localhost:8002/dept/list

http://localhost:8003/dept/list

6. 启动microservicecloud-consumer-dept-80

7. 客户端通过Ribbo完成负载均衡并访问上一步的Dept微服务

http://localhost/consumer/dept/list

注意观察看到返回的数据库名字，各不相同，负载均衡实现，算法是 ：轮询算法：默认

第一次访问

第二次访问

第三次访问

8. 总结：Ribbon其实就是一个软负载均衡的客户端组件，

他可以和其他所需请求的客户端结合使用，和eureka结合只是其中的一个实例。

再来看这个图：

客户端 ：服务消费者：带着负载均衡 算法。
一个注解就可使用 负载均衡。（在消费者中）

四、 Ribbon核心组件IRule

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

1. RoundRobinRule

轮询

2. RandomRule

随机

3. AvailabilityFilteringRule

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

4. WeightedResponseTimeRule

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

5. RetryRule

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

6. BestAvailableRule

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

7. ZoneAvoidanceRule

默认规则,复合判断server所在区域的性能和server的可用性选择服务器

8. 测试使用：改变 默认的轮询算法。使用随机的轮询方法

@EnableWebMvc
@Configuration
public class ConfigBean {

    @Bean
    @LoadBalanced  // Spring Cloud Ribbon 是基于 Netflix Ribbon 实现的一套客户端  负载均衡的工具。
    public RestTemplate getRestTemplate()
    {
        return new RestTemplate();
    }


    /**
     *  没有显式的声明，则用默认的轮询算法，
     *  如果有显式的声明，则按照声明的使用。
     * @return
     */
    @Bean
    public IRule getRandomRule(){

//        return new RoundRobinRule();   // 默认的轮询 算法。
        return new RandomRule();         // 随机算法
    }

}

五、 Ribbon自定义

1.修改microservicecloud-consumer-dept-80

2.主启动类添加@RibbonClient

在启动该微服务的时候就能去加载我们的自定义Ribbon配置类，从而使配置生效，形如：
@RibbonClient(name=“MICROSERVICECLOUD-DEPT”,configuration=MySelfRule.class)

3.注意配置细节：新建package com.atguigu.myrule

官方文档明确给出了警告：
这个自定义配置类不能放在@ComponentScan所扫描的当前包下以及子包下，否则我们自定义的这个配置类就会被所有的Ribbon客户端所共享，也就是说我们达不到特殊化定制的目的了。

4. 步骤

1) 新建package com.atguigu.myrule

新建自定义Robbin规则类，注意包名

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;

/**
 * description: MySelfRule
 * author: 冯凡利
 * create:  2019/9/15 20:06
 */
@Configuration
public class MySelfRule {

    @Bean
    public IRule myRule()
    {
        return new RandomRule();//Ribbon默认是轮询，我自定义为随机
    }
}

这是使用默认的 再自定义包下的 负载均衡算法。
也可以配置类中直接去添加，如下： 下面这个为扩展，自己测试成功。
把 启动类上的 @RibbonClient注解，和上面的类去掉，也可以实现随机负载均衡算法。

package com.atguigu.springcloud.cfgbeans;

import com.netflix.loadbalancer.IRule;
import com.netflix.loadbalancer.RandomRule;
import com.netflix.loadbalancer.RoundRobinRule;
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;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;

/**
 * description: ConfigBean
 * author: 冯凡利
 * create:  2019/9/8 16:55
 */
@EnableWebMvc
@Configuration
public class ConfigBean {
    @Bean
    @LoadBalanced  // Spring Cloud Ribbon 是基于 Netflix Ribbon 实现的一套客户端  负载均衡的工具。
    public RestTemplate getRestTemplate()
    {
        return new RestTemplate();
    }
    /**
     *  没有显式的声明，则用默认的轮询算法，
     *  如果有显式的声明，则按照声明的使用。
     * @return
     */
    @Bean
    public IRule getRandomRule(){
//        return new RoundRobinRule();   // 默认的轮询 算法。
        return new RandomRule();         // 随机算法
    }

}

目录：

2) 修改主启动类

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;

/**
 * description: DeptConsumer80_APP
 * author: 冯凡利
 * create:  2019/9/8 17:04
 */
@SpringBootApplication
@EnableEurekaClient
//在启动该微服务的时候就能去加载我们的自定义Ribbon配置类，从而使配置生效，形如：
//@RibbonClient(name="MICROSERVICECLOUD-DEPT",configuration=MySelfRule.class)
@RibbonClient(name = "MICROSERVICECLOUD-DEPT", configuration = MySelfRule.class)
public class DeptConsumer80_APP {
    public static void main(String[] args) {
        SpringApplication.run(DeptConsumer80_APP.class, args);
    }
}

3) 测试

http://localhost/consumer/dept/list

随机出来的 提供者微服务 次序。

六、 自定义规则深度解析：自定义Rule规则，更改需求

1. 问题：

依旧轮询策略，但是加上新需求，每个服务器要求被调用5次。
也即
以前是每台机器一次，现在是每台机器5次

2. 解析源码：

​​https://github.com/Netflix/ribbon/blob/master/ribbon-loadbalancer/src/main/java/com/netflix/loadbalancer/RandomRule.java​​

3. 参考源码修改为我们需求要求的RandomRule_ZY.java

package com.atguigu.myrule;

import com.netflix.client.config.IClientConfig;
import com.netflix.loadbalancer.AbstractLoadBalancerRule;
import com.netflix.loadbalancer.ILoadBalancer;
import com.netflix.loadbalancer.Server;

import java.util.List;

public class RandomRule_ZY extends AbstractLoadBalancerRule {

    private int total = 0;    //总共被调用的次数，目前要求每台被调用5次
    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<Server> upList = lb.getReachableServers();
            List<Server> 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 = rand.nextInt(serverCount);
//            server = upList.get(index);
            if(total < 5)
            {
                server = upList.get(currentIndex);
                total++;
            }else {
                total = 0;
                currentIndex++;
                if(currentIndex >= upList.size()){
                    currentIndex = 0;
                }
            }
            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;
    }

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

    @Override
    public void initWithNiwsConfig(IClientConfig clientConfig) {

    }
}

4. 调用

1) MySelfRule.java

package com.atguigu.myrule;
 
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
 
import com.netflix.loadbalancer.IRule;
import com.netflix.loadbalancer.RandomRule;
 
@Configuration
public class MySelfRule
{
  @Bean
  public IRule myRule()
  {
   //return new RandomRule();//Ribbon默认是轮询，我自定义为随机
   return new RandomRule_ZY();//我自定义为每个机器被访问5次
  }
}

2) 主启动类

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;

@SpringBootApplication
@EnableEurekaClient
@RibbonClient(name="MICROSERVICECLOUD-DEPT",configuration=MySelfRule.class)
public class DeptConsumer80_App {
    public static void main(String[] args) {
        SpringApplication.run(DeptConsumer80_App.class, args);
    }
}

5. 测试

http://localhost/consumer/dept/list

前五次：

后五次：