springcloud-Ribbon负载均衡

Ribbon：负载均衡(基于客户端)

1，Ribbon简介

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

2，Ribbon环境搭建

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

<!--Ribbon-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-ribbon</artifactId>
    <version>1.4.6.RELEASE</version>
</dependency>
<!--Eureka: Ribbon需要从Eureka服务中心获取要拿什么-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-eureka</artifactId>
    <version>1.4.6.RELEASE</version>
</dependency>

在application.yml文件中配置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/

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

自定义Spring配置类：ConfigBean.java 配置负载均衡实现RestTemplate,加上 @LoadBalanced注解

注意这个使用的还是默认的轮询的算法，而不是我们自定义的规则

@Configuration
public class ConfigBean {

    @Bean
    @LoadBalanced //配置负载均衡实现RestTemplate
    public RestTemplate getRestTemplate() {
        return new RestTemplate();
    }
}

修改80的controller类：现在已经不是使用具体的端口号了，而是改成服务的名称了

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

ribbon实现负载均衡的原理图：

创建新的服务提供者：

springcloud-provider-dept-8002和springcloud-provider-dept-8003

然后将8001的依赖拷贝到8002和8003上面，同时将其他的java文件以及yaml文件也一并拷贝过去，修改部分数据即可。

下面我们启动7001，8001，8002，8002，来看服务是否注册上去了

这个时候就发现这三个服务提供者的服务已经被注册上去了

下面我们来启动服务消费者，来看是否有轮询算法是否体现

我们不断刷新的时候，数据库的名称就在不断变化，这个就说明了我们在访问不同的服务提供者，轮询有作用了。

当然，我们也可以使用其他的轮询算法

在这里插入代码片@Configuration
public class ConfigBean {
    //@Configuration -- spring  applicationContext.xml
    /**
     * IRule:
     * RoundRobinRule 轮询策略
     * RandomRule 随机策略
     * AvailabilityFilteringRule ： 会先过滤掉，跳闸，访问故障的服务~，对剩下的进行轮询~
     * RetryRule ： 会先按照轮询获取服务~，如果服务获取失败，则会在指定的时间内进行，重试
     */
    @Bean
    public IRule myRule() {
        //return new RandomRule();//使用随机策略
        //return new RoundRobinRule();//使用轮询策略
        //return new AvailabilityFilteringRule();//使用轮询策略
        //return new RetryRule();//使用轮询策略
        return new RandomRule();
    }
}

下面我们来实现自定义的算法：

该包不要和主启动类所在的包同级，要跟启动类所在包同级：

public class RandomRule extends AbstractLoadBalancerRule {

    //每个机器，访问5次，换下一个服务（总共3个）
    //total = 0 默认=0，如果=5，我们指向下一个服务结点
    //index = 0 默认=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) {
                total++;
            } else {
                total = 0;
                currentIndex++;
                if (currentIndex >= serverCount) {
                    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) {

    }
}

在80主启动类配置包的扫描：

//开启负载均衡,并指定自定义的规则
@RibbonClient(name = "SPRINGCLOUD-PROVIDER-DEPT",configuration = MyRule.class)

这个时候就可以看到自己写的算法了，每个服务跑5遍