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

注明：此项目为本人学习尚硅谷老师的教学视频然后整理核心的配置文件，所有的项目均在以下地址下载。
https://github.com/xwbGithub/microservicecloud下载

本项目请参考microservicecloud-consumer-dept-80项目(负载均衡客户端)，

Ribbon自身的负载均衡算法

RoundRobinRule(轮询算法)

RandomRule(随机算法)

AvailabilityFilteringRule()：会先过滤由于多次访问故障而处于断路器跳闸状态的服务，还有并发的连接数量超过阈值的服务，然后对剩余的服务列表按照轮询策略进行访问

WeightedResponseTimeRule()：根据平均响应的时间计算所有服务的权重，响应时间越快服务权重越大被选中的概率越高，刚启动时如果统计信息不足，则使用RoundRobinRule策略，等统计信息足够会切换到WeightedResponseTimeRule

RetryRule()：先按照RoundRobinRule的策略获取服务，如果获取失败则在制定时间内进行重试，获取可用的服务。

BestAviableRule()：会先过滤掉由于多次访问故障而处于断路器跳闸状态的服务，然后选择一个并发量最小的服务

ZoneAvoidanceRule()：默认规则，符合判断server所在区域的性能和server的可用性选择服务器

自定义负载均衡算法

官方文档指出：

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

为何不能放在此位置：源码解析如下：

 
 

   
   

    
    

   
   
   
   

    
    

     
     @Target({ElementType.TYPE})
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     @Retention(RetentionPolicy.RUNTIME)
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     @Documented
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     @Inherited
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     @SpringBootConfiguration
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     @EnableAutoConfiguration
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     @ComponentScan(
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
         excludeFilters = {
     
     @Filter(
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
         type = FilterType.CUSTOM,
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
         classes = {TypeExcludeFilter.class}
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     ), 
     
     @Filter(
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
         type = FilterType.CUSTOM,
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
         classes = {AutoConfigurationExcludeFilter.class}
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     )}
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     )
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     public 
     
     @interface SpringBootApplication {
    
    
   
   
 
 

因为主启动类已经有ComponentScan，这个注解了，所以说不能放在和主启动类同包下。

自定义算法RandomRule_ZY 必须继承AbstractLoadBalanceRule类

 
 

   
   

    
    

   
   
   
   

    
    

     
     /**自定义的负载均衡算法*/
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     public 
     
     class RandomRule_ZY extends AbstractLoadBalancerRule {
    
    
   
   

   
   

    
    

   
   
   
   

    
    
    
     
     // total = 0 // 当total==5以后，我们指针才能往下走，
    
    
   
   

   
   

    
    

   
   
   
   

    
    
    
     
     // index = 0 // 当前对外提供服务的服务器地址，
    
    
   
   

   
   

    
    

   
   
   
   

    
    
    
     
     // total需要重新置为零，但是已经达到过一个5次，我们的index = 1
    
    
   
   

   
   

    
    

   
   
   
   

    
    
    
     
     // 分析：我们5次，但是微服务只有8001 8002 8003 三台，OK？
    
    
   
   

   
   

    
    

   
   
   
   

    
    
    
     
     private 
     
     int total = 
     
     0;            
     
     // 总共被调用的次数，目前要求每台被调用5次
    
    
   
   

   
   

    
    

   
   
   
   

    
    
    
     
     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;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                 }
    
    
   
   

   
   

    
    

   
   
   
   

    
    
            
     
     //private int total = 0; // 总共被调用的次数，目前要求每台被调用5次
    
    
   
   

   
   

    
    

   
   
   
   

    
    
            
     
     //private int currentIndex = 0; // 当前提供服务的机器号
    
    
   
   

   
   

    
    

   
   
   
   

    
    
            
     
     if (total < 
     
     5) {
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                     server = upList.get(currentIndex);
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                     total++;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                 } 
     
     else {
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                     total = 
     
     0;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                     currentIndex++;
    
    
   
   

   
   

    
    

   
   
   
   

    
    
                
     
     if (currentIndex >= upList.size()) {
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                         currentIndex = 
     
     0;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                     }
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                 }
    
    
   
   

   
   

    
    

   
   
   
   

    
    
            
     
     if (server == 
     
     null) {
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                     Thread.yield();
    
    
   
   

   
   

    
    

   
   
   
   

    
    
                
     
     continue;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                 }
    
    
   
   

   
   

    
    

   
   
   
   

    
    
            
     
     if (server.isAlive()) {
    
    
   
   

   
   

    
    

   
   
   
   

    
    
                
     
     return (server);
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                 }
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                 server = 
     
     null;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                 Thread.yield();
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             }
    
    
   
   

   
   

    
    

   
   
   
   

    
    
        
     
     return server;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
         }
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    
    
     
     @Override
    
    
   
   

   
   

    
    

   
   
   
   

    
    
    
     
     public Server choose(Object key) {
    
    
   
   

   
   

    
    

   
   
   
   

    
    
        
     
     return choose(getLoadBalancer(), key);
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
         }
    
    
   
   

   
   

    
    

   
   
   
   

    
    
    
     
     @Override
    
    
   
   

   
   

    
    

   
   
   
   

    
    
    
     
     public void initWithNiwsConfig(IClientConfig clientConfig) {
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
         }
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     }
    
    
   
   
 
 

如果想使用某个自定义算法则注入到bean中即可。

 
 

   
   

    
    

   
   
   
   

    
    

     
     /**
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
      * 自定义负载均衡算法
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
      */
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     @Configuration
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     public 
     
     class MySelfRule {
    
    
   
   

   
   

    
    

   
   
   
   

    
    
     
     
     @Bean
    
    
   
   

   
   

    
    

   
   
   
   

    
    
    
     
     public IRule myRule() {
    
    
   
   

   
   

    
    

   
   
   
   

    
    
        
     
     //return new RoundRobinRule();//轮询算法
    
    
   
   

   
   

    
    

   
   
   
   

    
    
        
     
     //return new RandomRule();//随机算法
    
    
   
   

   
   

    
    

   
   
   
   

    
    
        
     
     return 
     
     new RandomRule_ZY();
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
         }
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     }
    
    
   
   
 
 

在主启动类中添加ribbon注解

 
 

   
   

    
    

   
   
   
   

    
    

     
     @SpringBootApplication
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     @EnableEurekaClient
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     @RibbonClient(name = 
     
     "MICROSERVICECLOUD-DEPT", configuration = MySelfRule.class)
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     public 
     
     class DeptConsumer80_App {
    
    
   
   

   
   

    
    

   
   
   
   

    
    
    
     
     public static void main(String[] args) {
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             SpringApplication.run(DeptConsumer80_App.class, args);
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
         }
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     }
    
    
   
   
 
 

特别注意的是@RibbonClient(name = "MICROSERVICECLOUD-DEPT", configuration = MySelfRule.class)

name指定针对哪个服务 进行负载均衡，而configuration指定负载均衡的算法具体实现类

测试：启动80负载均衡微服务，然后启动一个7001微服务注册中心，然后启动8001,8002,8003，访问80负载均衡客户端，每次刷新的结果都是按照新写的负载均衡算法去执行，达到效果。

至此：自定义负载均衡算法开发完毕