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

Ribbon核心组件IRule

SpringCloud-Ribbon-自定义负载均衡算法_第1张图片

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

SpringCloud-Ribbon-自定义负载均衡算法_第2张图片
SpringCloud-Ribbon-自定义负载均衡算法_第3张图片

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

  • 替换默认的轮询算法为随机
    SpringCloud-Ribbon-自定义负载均衡算法_第4张图片
@Bean
    public IRule myiRule(){
        return new RandomRule();
    }

SpringCloud-Ribbon-自定义负载均衡算法_第5张图片

自定义负载均衡算法

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

SpringCloud-Ribbon-自定义负载均衡算法_第6张图片

  • 选择一个和applicationContext.yml不同级的目录下建立包结构
    SpringCloud-Ribbon-自定义负载均衡算法_第7张图片

1.自定义算法(仿照随机算法,更改核心代码):每个服务访问5次后访问下一个服务

SpringCloud-Ribbon-自定义负载均衡算法_第8张图片

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);
    }
}

你可能感兴趣的:(SpringCloud)