springcloud-自定义ribbon负载均衡算法

Love The Way You Lie 2022-11-04 11:28 170阅读 0赞

### springcloud-自定义ribbon负载均衡算法 ###

*   *  1、编写配置和算法
     *   *  1. 在与springcloud同级的目录下，新建一个文件夹config
         *  2. 编写自定义负载均衡算法
         *  3. 把自己写的实现注册到spring的Bean
     *  2、修改启动类
     *  3、测试

在一些时候，自带的负载均衡算法不适合我们，因此，我们需要自己自定义自己的负载均衡算法

本篇文章在如下的文章代码的基础上操作  
[springcloud实践-ribbon实现负载均衡][springcloud_-ribbon]

## 1、编写配置和算法 ##

### 1. 在与springcloud同级的目录下，新建一个文件夹config ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzUyMDY3MA_size_16_color_FFFFFF_t_70]

### 2. 编写自定义负载均衡算法 ###

这个算法不用全部自己写，我们可以复制它已经实现的代码，然后再修改关键的算法即可，如下

//
    // Source code recreated from a .class file by IntelliJ IDEA
    // (powered by FernFlower decompiler)
    //
    
    package com.hzxy.config;
    
    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 YeRule extends AbstractLoadBalancerRule { 
        public YeRule() { 
        }
    
        //每个服务访问5次，换下一个服务（3个）
    
        //total=0，默认=0，如果=5，我们指向下一个服务结点
        //index=0，默认=0，如果total=5，index+1
    
        private int total = 0;     //被调用的次数
        private int currentIndex = 0;  //当前是谁在提供服务
    
        @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()){ 
                            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) { 
        }
    }

### 3. 把自己写的实现注册到spring的Bean ###

代码如下：

package com.hzxy.config;
    
    import com.netflix.loadbalancer.IRule;
    
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    @Configuration
    public class YbgRule { 
    
        @Bean
        public IRule myRule(){ 
            return new YeRule();
        }
    }

## 2、修改启动类 ##

加入@RibbonClient注解，第一个参数是服务名称，第二个参数是你的配置算法的YbgRule的class文件

package com.hzxy.springcloud;
    
    import com.hzxy.config.YbgRule;
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
    import org.springframework.cloud.netflix.ribbon.RibbonClient;
    
    
    // ribbon 和 Eureka 整合以后，客户端可以直接调用，不用关心ip地址和端口号
    @SpringBootApplication
    @EnableEurekaClient  //自动配置
    // 在微服务启动的时候就能去加载，我们自定义ribbon类
    @RibbonClient(name = "springcloud-provider-user",configuration = YbgRule.class)
    public class Consumer_80 { 
        public static void main(String[] args) { 
            SpringApplication.run(Consumer_80.class,args);
        }
    }

## 3、测试 ##

一直访问，每5次就换一个数据库，测试成功！  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzUyMDY3MA_size_16_color_FFFFFF_t_70 1]

[springcloud_-ribbon]: https://blog.csdn.net/weixin_43520670/article/details/114271291
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzUyMDY3MA_size_16_color_FFFFFF_t_70]: /images/20221023/0ea8a53a073246a899b3bd847d9de5a3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzUyMDY3MA_size_16_color_FFFFFF_t_70 1]: /images/20221023/894a7416ac534e7cad92eb38936d8f22.png