1、负载均衡以及Ribbon

Ribbon是什么？

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

Ribbon能干嘛？

  • LB，即负载均衡 (LoadBalancer) ，在微服务或分布式集群中经常用的一种应用。
  • 负载均衡简单的说就是将用户的请求平摊的分配到多个服务上，从而达到系统的HA (高用)。
  • 常见的负载均衡软件有 Nginx、Lvs 等等。
  • Dubbo、SpringCloud 中均给我们提供了负载均衡，SpringCloud 的负载均衡算法可以自定义。
  • 负载均衡简单分类：
    • 集中式LB
      • 即在服务的提供方和消费方之间使用独立的LB设施，如Nginx(反向代理服务器)，由该设施负责把访问请求通过某种策略转发至服务的提供方！
    • 进程式 LB
      • 将LB逻辑集成到消费方，消费方从服务注册中心获知有哪些地址可用，然后自己再从这些地址中选出一个合适的服务器。
      • Ribbon 就属于进程内LB，它只是一个类库，集成于消费方进程，消费方通过它来获取到服务提供方的地址！

2、集成Ribbon

springcloud-consumer-dept-80向pom.xml中添加Ribbon和Eureka依赖

  1. <!--Ribbon基于客户端负载均衡-->
  2. <dependency>
  3.     <groupId>org.springframework.cloud</groupId>
  4.     <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
  5. </dependency>
  6. <!--Eureka: Ribbon需要从Eureka服务中心获取要拿什么-->
  7. <dependency>
  8.     <groupId>org.springframework.cloud</groupId>
  9.     <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
  10. </dependency>

在application.yml文件中配置Eureka

  1. # Eureka配置
  2. eureka:
  3.   client:
  4.     register-with-eureka: false # 不向 Eureka注册自己
  5.     service-url: # 从三个注册中心中随机取一个去访问
  6.       defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/

主启动类加上@EnableEurekaClient注解，开启Eureka

  1. @SpringBootApplication
  2. @EnableEurekaClient //开启Eureka 客户端
  3. public class DeptConsumer_80 {
  4.     public static void main(String[] args) {
  5.         SpringApplication.run(DeptConsumer_80.class, args);
  6.     }
  7. }

自定义Spring配置类：ConfigBean.java 配置负载均衡实现RestTemplate

  1. @Configuration
  2. public class ConfigBean {
  4.     @Bean
  5.     @LoadBalanced //配置负载均衡实现RestTemplate
  6.     public RestTemplate getRestTemplate() {
  7.         return new RestTemplate();
  8.     }
  9. }

修改conroller：DeptConsumerController.java

  1. //Ribbon:我们这里的地址，应该是一个变量，通过服务名来访问
  2. //private static final String REST_URL_PREFIX = "http://localhost:8001";
  3. private static final String REST_URL_PREFIX = "http://SPRINGCLOUD-PROVIDER-DEPT";

3、使用Ribbon实现负载均衡

流程图：

SpringCloud06：Ribbon负载均衡（基于客户端） - 图1

测试结果：

SpringCloud06：Ribbon负载均衡（基于客户端） - 图2

测试访问http://localhost/consumer/dept/list 这时候随机访问的是服务提供者8002

SpringCloud06：Ribbon负载均衡（基于客户端） - 图3

再次访问http://localhost/consumer/dept/list这时候随机的是服务提供者8003

SpringCloud06：Ribbon负载均衡（基于客户端） - 图4

以上这种每次访问http://localhost/consumer/dept/list随机访问集群中某个服务提供者，这种情况叫做轮询，轮询算法在SpringCloud中可以自定义。

如何切换或者自定义规则呢？

在springcloud-provider-erueka-80模块下的ConfigBean中进行配置，切换使用不同的规则

  1. @Configuration
  2. public class ConfigBean {
  3.     //配置负载均衡实现RestTemplate
  4.     // IRule
  5.     // RoundRobinRule 轮询
  6.     // RandomRule 随机
  7.     // AvailabilityFilteringRule ： 会先过滤掉，跳闸，访问故障的服务~，对剩下的进行轮询~
  8.     // RetryRule ： 会先按照轮询获取服务~，如果服务获取失败，则会在指定的时间内进行，重试
  9.     @Bean
  10.     public IRule myRule() {
  11.         return new RandomRule();//使用随机策略
  12.         //return new RoundRobinRule();//使用轮询策略
  13.         //return new AvailabilityFilteringRule();//使用轮询策略
  14.         //return new RetryRule();//使用轮询策略
  15.     }
  16. }

也可以自定义规则，在myRule包下自定义一个配置类MyRule.java和自定义负载均衡随机规则MyRandomRule.java

MyRule.java

  1. @Configuration
  2. public class MyRule {
  4.     //配置负载均衡实现RestTemplate
  5.     // IRule
  6.     // RoundRobinRule 轮询
  7.     // RandomRule 随机
  8.     // AvailabilityFilteringRule ： 会先过滤掉，跳闸，访问故障的服务~，对剩下的进行轮询~
  9.     // RetryRule ： 会先按照轮询获取服务~，如果服务获取失败，则会在指定的时间内进行，重试
  10.     @Bean
  11.     public IRule myRule() {
  12.         //return new RandomRule();//使用随机策略
  13.         //return new RoundRobinRule();//使用轮询策略
  14.         //return new AvailabilityFilteringRule();//使用轮询策略
  15.         //return new RetryRule();//使用轮询策略
  16.         return new MyRandomRule();
  17.     }
  18. }

自定义的规则(这里我们参考Ribbon中默认的规则代码自己稍微改动)：MyRandomRule.java

  1. package com.godfrey.myrule;
  3. import com.netflix.client.config.IClientConfig;
  4. import com.netflix.loadbalancer.AbstractLoadBalancerRule;
  5. import com.netflix.loadbalancer.ILoadBalancer;
  6. import com.netflix.loadbalancer.Server;
  8. import java.util.List;
  10. /**
  11.  * 自定义负载均衡随机规则
  12.  *
  13.  * @author godfrey
  14.  * @since 2020-11-27
  15.  */
  16. public class MyRandomRule extends AbstractLoadBalancerRule {
  18.     //每个服务，访问5次~，换下一个服务（3个）
  20.     // total=0, 默认=0，如果=5，我们指向下一个服务节点
  21.     // index=0，默认0，如果total=5，index+1，
  23.     private int total = 0; //被调用的次数
  24.     private int currentIndex = 0; //当前是谁在提供服务~
  26.     public Server choose(ILoadBalancer lb, Object key) {
  27.         if (lb == null) {
  28.             return null;
  29.         }
  30.         Server server = null;
  32.         while (server == null) {
  34.             if (Thread.interrupted()) {
  35.                 return null;
  36.             }
  37.             List<Server> upList = lb.getReachableServers(); //获得活着的服务
  38.             List<Server> allList = lb.getAllServers(); //获得全部的服务
  40.             int serverCount = allList.size();
  41.             if (serverCount == 0) {
  42.                 return null;
  43.             }
  45. //            int index = chooseRandomInt(serverCount); //生成区间随机数
  46. //            server = upList.get(index); //从活着的服务中，随机获取一个~
  49.             //-=========================================================
  51.             if (total < 5) {
  52.                 server = upList.get(currentIndex);
  53.                 total++;
  54.             } else {
  55.                 total = 0;
  56.                 currentIndex++;
  57.                 if (currentIndex > upList.size()) {
  58.                     currentIndex = 0;
  59.                 }
  60.                 server = upList.get(currentIndex); //从活着的服务中，获取指定的服务来进行操作
  61.             }
  63.             //-=========================================================
  64.             if (server == null) {
  65.                 Thread.yield();
  66.                 continue;
  67.             }
  69.             if (server.isAlive()) {
  70.                 return (server);
  71.             }
  73.             server = null;
  74.             Thread.yield();
  75.         }
  77.         return server;
  78.     }
  81.     @Override
  82.     public void initWithNiwsConfig(IClientConfig iClientConfig) {
  83.     }
  85.     @Override
  86.     public Server choose(Object key) {
  87.         return choose(getLoadBalancer(), key);
  88.     }
  89. }

主启动类开启负载均衡并指定自定义的MyRule配置类

  1. @SpringBootApplication
  2. @EnableEurekaClient //开启Eureka 客户端
  3. //在微服务启动的时候就能加载自定义的Ribbon类(自定义的规则会覆盖原有默认的规则)
  4. @RibbonClient(name = "SPRINGCLOUD-PROVIDER-DEPT",configuration = MyRule.class) //开启负载均衡,并指定自定义的规则
  5. public class DeptConsumer_80 {
  6.     public static void main(String[] args) {
  7.         SpringApplication.run(DeptConsumer_80.class, args);
  8.     }
  9. }