SpringCloud中Ribbon学习--狂神说

工具：idea
Spring官网：https://spring.io/
详细了解博客连接：https://blog.csdn.net/weixin_43591980/article/details/106255122
视频链接：https://www.bilibili.com/video/BV1jJ411S7xr

Ribbon是什么

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

Ribbon作用（能干什么）

• LB，即负载均衡（Load Balance），在微服务或分布式集群中经常用的一种应用。
• 负载均衡简单的说就是将用户的请求平摊的分配到多个服务上，从而达到系统的HA（高可用）。核心作用
• 常见的负载均衡软件有Nginx、Lvs（Linux虚拟机服务器）等等。Apache+Tomcat也是修改配置来实现负载均衡
• Dubbo、SpringCloud中均给我们提供了负载均衡，SpringCloud的负载均衡算法可以自定义
• 负载均衡简单分类：
  • 集中式LB
    • 即在服务的消费方和提供方之间使用独立的LB设施，入Nginx（反向代理服务器），有该设施负责把访问请求通过某种策略转发至服务的提供方！详细nginx了解：https://blog.csdn.net/weixin_43122090/article/details/105461971
  • 进程式LB
    • 将LB逻辑集成到消费方（即客户端），消费方从服务注册中心获知有哪些地址可用，然后自己再从这些地址中选出一个合适的服务器。
    • Ribbon就属于进程内LB，他只是一个类库，集成于消费方进程，消费方通过它来获取到服务提供方的地址！

因为集成ribbon是以客户端的形式，所以在客户端上写也就是springcloud-consumer-dept-80上集成.从maven仓库里面找，选1.4.6版本。

在pom文件中导入ribbon依赖

<!--ribbon-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-ribbon</artifactId>
    <version>1.4.6.RELEASE</version>
</dependency>
<!--eureka-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-eureka</artifactId>
    <version>1.4.6.RELEASE</version>
</dependency>

编写配置，application.yml文件

server:
  port: 80

#eureka配置
eureka:
  client:
    register-with-eureka: false # 不向eureka注册自己
    service-url:
      defaultZone: http://eureka7001:com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003:com:7003/eureka/

DeptConsumer_80，开启Eureka功能

ConfigBean

DeptConsumerController

也就是通过下图这个服务名称来访问

访问application.yml中那三个地址

运行7001、7002、7003其中的随意两个，以防内存不够加载不够快，然后再运行springcloud-consumer-dept-80的主启动类，输入访问地址：http://localhost/consumer/dept/list

想要每次刷新都能知道ribbon干了什么负载均衡，然后就得增加服务提供者
服务提供者增加，数据库也得增加

打开Navicat导航猫，找到数据库，然后导出

打开新建查询

修改语句

然后首先运行新建数据库，再运行新建表，最后运行在数据表中插入数据
运行新建数据库

运行新建表

运行在数据表中插入数据

刷新，然后看到这个证明已经成功创建一个数据库

然后重复以上操作再创建一个数据库，记住数据库的名字得更改。
在idea上将刚刚新建的数据库全部添加进来

然后将springcloud-provider-dept-8001复制两份，改名字

将springcloud-provider-dept-8001里面该有的东西也给复制到springcloud-provider-dept-8002、springcloud-provider-dept-8003中，并且里面该改的名字也要全部对应改上。特别注意要改的是application.yml文件中的端口号跟连接的数据库还有eureka中的描述信息。接着修改主启动类的名称。
启动7001集群，然后启动消费者8001、8002、8003。然后先不要关闭启动的服务

再启动springcloud-consumer-dept-80，然后输入地址http://localhost/consumer/dept/list访问，第一次是db01

第二次又不一样了，轮询来变换

Ribbon算法
上面是属于轮询的方法变换访问提供者，下面这是用随机变换来访问
在springcloud-consumer-dept-80中ConfigBean里面调用别人写好的封装方法

但是正常情况下不应该在这配。应该在主启动类DeptConsumer_80上配，所以：
在springcloud-consumer-dept-80下建一个包，然后建一个类。

是官网建议不要放到同级上面，想详细了解的可以进springcloud的官网中看。

在springcloud-consumer-dept-80下主启动类DeptConsumer_80上写上配置

然后把那ConfigBean中的那个myRule方法剪切到自己写的路由组件SpringCloudRule中

进到这个里面内容全部复制出来，然后进行改造

复制到myrule的包下面，然后改名为ChangAnRandomRule

复制出来之后，改名字，删掉原来复制出来那个。

ChangAnRandomRule

package com.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;
import java.util.concurrent.ThreadLocalRandom;
public class ChangAnRandomRule extends AbstractLoadBalancerRule {
    //红色警告是镇压警告，可以不管
    //@edu.umd.cs.findbugs.annotations.SuppressWarnings(value = "RCN_REDUNDANT_NULLCHECK_OF_NULL_VALUE")
    //每个服务访问5次，换下一个服务（3）
    //total=0，默认=0，如果=5，我们指向下一个服务节点
    //index=5，默认0，如果total=5，index+1
    private int total = 0;//被调用的次数
    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) {
                return null;
            }
//            //生成区间随机数
//            int index = chooseRandomInt(serverCount);
//            //从活着的服务中随机获取一个
//            server = upList.get(index);
            //自定义的代码---------------
            if(total<5){
                server = upList.get(currentIndex);
                total++;
            }else{
                total=0;
                currentIndex++;
                if (currentIndex>upList.size()){
                    currentIndex=0;
                }
                //从活着的服务中获取指定的服务来进行操作
                server = upList.get(currentIndex);
            }
            //----------------
            if (server == null) {
                Thread.yield();
                continue;
            }
            if (server.isAlive()) {
                return (server);
            }
            server = null;
            Thread.yield();
        }
        return server;
    }
    protected int chooseRandomInt(int serverCount) {
        return ThreadLocalRandom.current().nextInt(serverCount);
    }
   @Override
   public Server choose(Object key) {
      return choose(getLoadBalancer(), key);
   }
   @Override
   public void initWithNiwsConfig(IClientConfig clientConfig) {
      // TODO Auto-generated method stub
      
   }
}

回到SpringCloudRule中

package com.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 SpringCloudRule {
    //调用自己写的方法。默认是轮询
    @Bean
    public IRule myRule(){
        return new ChangAnRandomRule();
    }
}

去浏览器访问，每5次换一个服务器，按轮询的方法来。但是访问速度快的话就会服务中断，这时可以用RetryRule这个方法来解决。