SpringCloud中如何自定义Ribbon负载均衡策略

@SpringBootApplication
@EnableEurekaClient
@RibbonClient(name = "MICROSERVICE-ORDER", configuration = MyRuleConfig.class)
public class OrderConsumer {

   public static void main(String[] args) {
       SpringApplication.run(OrderConsumer.class, args);
   }
}

/**
* 自定义规则
* @author shengwu ni
*/
@Configuration
public class MyRuleConfig {
   @Bean
   public IRule myselfRule() {
       // 指定策略：我们自定义的策略
       return new CustomRule();
   }
}

/**
* 自定义规则
* @author shengwu ni
*/
public class CustomRule extends AbstractLoadBalancerRule {

   /**
    * 总共被调用的次数，目前要求每台被调用4次
     */
   private int total = 0;
   /**
    * 当前提供服务列表的索引
    */
   private int currentIndex = 0;

   @Override public void initWithNiwsConfig(IClientConfig iClientConfig) {
   }

   /**
    * 在choose方法中，自定义我们自己的规则，返回的Server就是具体选择出来的服务
    * 自己的规则：按照轮询的规则，但是每个被轮询到的服务调用5次。
    * @param o
    * @return
    */
   @Override public Server choose(Object o) {
       // 获取负载均衡器lb
       ILoadBalancer lb = getLoadBalancer();
       if (lb == null) {
           return null;
       }

       Server server = null;
       while (server == null) {
           if (Thread.interrupted()) {
               return null;
           }
           // 获取可用服务列表
           List upList = lb.getReachableServers();
           // 获取所有服务列表
           List allList = lb.getAllServers();
           int serverCount = allList.size();
           if (serverCount == 0) {
               return null;
           }

           // 若调用次数小于4次，一直调用可用服务列表中索引为 currentIndex 的服务
           if(total < 4)
           {
               server = upList.get(currentIndex);
               total++;
           } else {
               // 到了4次之后，服务列表中的索引值++，表示下一个调用下一个服务
               total = 0;
               currentIndex++;
               // 当索引大于可用服务列表的size时，要重新从头开始
               currentIndex = currentIndex % upList.size();

               if (server == null) {
                   Thread.yield();
                   continue;
               }

               if (server.isAlive()) {
                   return (server);
               }

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