SpringCloud-Ribbon-自定义负载均衡算法

Ribbon核心组件IRule

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

类	Value
RoundRobinRule	轮询
RandomRule	随机
AvailabilityFilterRule	会先过滤掉由于多次访问故障而处于断路器跳闸的服务，还有并发的连接数量超过阈值的服务，然后对剩余的服务列表按照轮询策略进行访问
WeightedResponseTimeRule	根据平均响应时间计算所有服务的权重，响应时间越快服务权重越大，被选中的概率越高，刚启动时如果统计信息不足，则使用RoundRobinRule策略，等待统计信息足够，会切换到WeightedResponseTimeRule
RetryRule	先按照RoundRobinRule的策略获取服务，如果获取服务失败，则在指定时间内会进行重试，获取可用的服务
BestAvailableRule	会先过滤掉由于多次访问故障而处于断路器跳闸状态的服务，然后选择一个并发量最小的服务
ZoneAvoidanceRule	默认规则，复合判断server所在区域的性能和server的可用性选择服务器

---

• 替换默认的轮询算法为随机
  

@Bean
    public IRule myiRule(){
    
    
        return new RandomRule();
    }

自定义负载均衡算法

tips：自定义配置类不能放在@ComponentScan所扫描的当前包以及子包下，否则这个配置类就会被所有的Ribbon客户端所共享，也就是说达不到特殊化定制的目的了

• 选择一个和applicationContext.yml不同级的目录下建立包结构
  

1.自定义算法（仿照随机算法，更改核心代码）：每个服务访问5次后访问下一个服务

public class myRule  extends AbstractLoadBalancerRule {
    
    

    private int total = 0; //总共被调用的次数
    private int currentIndex = 0; //当前提供服务的机器序号！

//    public myRule() {
    
    
//    }

    //@SuppressWarnings({"RCN_REDUNDANT_NULLCHECK_OF_NULL_VALUE"})
    public Server choose(ILoadBalancer lb, Object key) {
    
    
        if (lb == null) {
    
    
            return null;
        } else {
    
    
            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 = this.chooseRandomInt(serverCount);    //生成区间随机数
//                server = (Server)upList.get(index);    //从活着的服务中，随机取出一个

                //===============================================
                if (total<5){
    
    
                    server = upList.get(currentIndex);
                    total++;
                }else {
    
    
                    total = 0;
                    currentIndex++;
                    if (currentIndex>upList.size()-1){
    
    
                        currentIndex = 0;
                    }
                    server = upList.get(currentIndex);
                }

                //===============================================
                if (server == null) {
    
    
                    Thread.yield();
                } else {
    
    
                    if (server.isAlive()) {
    
    
                        return server;
                    }

                    server = null;
                    Thread.yield();
                }
            }

            return server;
        }
    }

    protected int chooseRandomInt(int serverCount) {
    
    
        return ThreadLocalRandom.current().nextInt(serverCount);
    }

    public Server choose(Object key) {
    
    
        return this.choose(this.getLoadBalancer(), key);
    }

    public void initWithNiwsConfig(IClientConfig clientConfig) {
    
    
    }
}

2.自定义配置类，返回自定义算法，并注入到容器中

@Configuration
public class MyLoaderBalanceConfig {
    
    
    @Bean
    public IRule setLB(){
    
    
        return new myRule();
    }
}

3.启动类中为指定服务绑定自定义算法

@SpringBootApplication
@EnableEurekaClient
@RibbonClient(name = "SPRINGCLOUD-PROVIDER-DEPT",configuration = MyLoaderBalanceConfig.class)   //在微服务启动的时候加载自定义的Ribbon
public class DeptConsumer_80 {
    
    
    public static void main(String[] args) {
    
    
        SpringApplication.run(DeptConsumer_80.class,args);
    }
}