SpringCloud-Ribbon

Ribbon介绍：https://www.jianshu.com/p/1bd66db5dc46　

　　　　　　Spring Cloud Ribbon是一个基于HTTP和TCP的客户端负载均衡工具，它基于Netflix Ribbon实现。通过Spring Cloud的封装，可以让我们轻松地将面向服务的REST模版请求自动转换成客户端负载均衡的服务调用。Spring Cloud Ribbon虽然只是一个工具类框架，它不像服务注册中心、配置中心、API网关那样需要独立部署，但是它几乎存在于每一个Spring Cloud构建的微服务和基础设施中。因为微服务间的调用，API网关的请求转发等内容，实际上都是通过Ribbon来实现的，包括后续我们将要介绍的Feign，它也是基于Ribbon实现的工具。所以，对Spring Cloud Ribbon的理解和使用，对于我们使用Spring Cloud来构建微服务非常重要。

 

　　•消费者客户端导入依赖

　　

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

　　•编写配置

　　

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/

　　•开启功能 启动类

　　

@EnableEurekaClient

　　•配置负载均衡

　　

　　•controller配置访问地址

　　

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

 注意:这里想使用Application的名字来代替具体地址访问，必须要加注解@LoadBalanced负载均衡

　　•测试

　　

Ribbon:使用Ribbon实现负载均衡

　　•创建多个服务提供者，复制7001的pom 导入依赖

 　　

　　    •复制7001里面的项目

　  　•测试

　　如果项目反复检查没错，但是测试不对，可以尝试重启在测试。

　　

　　•开启消费者访问，第一次访问8001，第二次访问8003，第三次访问8002，根据UP里面的顺序依次访问

　　

　　

Ribbon：自定义负载均衡算法

　　

// IRule
    // RoundRobinRule 轮询
    // RandomRule 随机
    // AvailabilityFilteringRule ： 会先过滤掉，跳闸，访问故障的服务~，对剩下的进行轮询~
    // RetryRule ： 会先按照轮询获取服务~，如果服务获取失败，则会在指定的时间内进行，重试

　　•默认是RoundRobinRule轮询

　　  •修改为随机，前提负载均衡以开启@LoadBalanced

　　 

@Bean
    public IRule myRule(){
        return new RandomRule(); //随机
    }

　　

　　　•自己定义Ruble，开启Ribbon

　　

package com.kuang.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;

/**
 * A loadbalacing strategy that randomly distributes traffic amongst existing
 * servers.
 * 
 * @author stonse
 * 
 */
public class KuangRandomRule extends AbstractLoadBalancerRule {
    //每个机器访问五次，换下一个服务

    private int total=0;//被调用的次数
    private int currentIndex=0;//当前是谁在提供服务
    //@edu.umd.cs.findbugs.annotations.SuppressWarnings(value = "RCN_REDUNDANT_NULLCHECK_OF_NULL_VALUE")
    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
        
    }
}

package com.kuang.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 KuangRule {
    @Bean
    public IRule myRule(){
        return new KuangRandomRule();//默认KuangRandomRule轮询
    }
}