Spring Cloud：自定義 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<Server> upList = lb.getReachableServers();
            // 獲取所有服務列表
            List<Server> 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;
    }
}