ribbon自定义负载均衡

要自定义 Ribbon 的负载均衡策略，需要实现 `IRule` 接口。具体步骤如下：

1. 创建一个类，实现 `IRule` 接口；

2. 在类上添加 `@Configuration` 注解，将其声明为一个配置类；

3. 在类中实现 `choose(Object key)` 方法，根据自定义的负载均衡算法选取一个服务实例；

4. 在 `@Configuration` 注解的类中添加 `@Bean` 注解，将自定义的负载均衡算法实例化为一个 Bean；

5. 在应用程序中使用 `@RibbonClient` 注解指定服务名，使用 `@LoadBalanced` 注解启用负载均衡，然后调用 RestTemplate 发起请求。

下面是一个自定义轮询负载均衡算法的示例代码：

@Configuration
public class MyRule {

    @Bean
    public IRule myRule() {
        return new MyLoadBalancerRule();
    }

    public class MyLoadBalancerRule extends AbstractLoadBalancerRule {

        private AtomicInteger nextServerCyclicCounter;
        private static final boolean AVAILABLE_ONLY_SERVERS = true;
        private static final boolean ALL_SERVERS = false;

        public MyLoadBalancerRule() {
            nextServerCyclicCounter = new AtomicInteger(0);
        }

        @Override
        public void initWithNiwsConfig(IClientConfig clientConfig) {
        }

        @Override
        public Server choose(Object key) {
            ILoadBalancer lb = getLoadBalancer();

            if (lb == null) {
                return null;
            }

            Server server = null;
            int count = 0;

            while (server == null && count++ < 10) {
                List<Server> reachableServers = lb.getReachableServers();
                List<Server> allServers = lb.getAllServers();

                int upCount = reachableServers.size();
                int serverCount = allServers.size();

                if (upCount == 0 || serverCount == 0) {
                    return null;
                }

                int nextServerIndex = incrementAndGetModulo(serverCount);
                server = allServers.get(nextServerIndex);

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

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

                server = null;
                Thread.yield();
            }

            if (count >= 10) {
                System.out.println("No available alive servers after 10 tries from load balancer: "
                        + lb);
            }
            return server;
        }

        private int incrementAndGetModulo(int modulo) {
            for (;;) {
                int current = nextServerCyclicCounter.get();
                int next = (current + 1) % modulo;
                if (nextServerCyclicCounter.compareAndSet(current, next))
                    return next;
            }
        }

        @Override
        public void setLoadBalancer(ILoadBalancer lb) {
            super.setLoadBalancer(lb);
            if (nextServerCyclicCounter != null) {
                nextServerCyclicCounter.set(0);
            }
        }

        @Override
        public ILoadBalancer getLoadBalancer() {
            ILoadBalancer lb = super.getLoadBalancer();
            if (lb == null) {
                return null;
            }

            return lb;
        }
    }
}

使用该自定义负载均衡算法的示例代码：

@RibbonClient(name = "service-provider")
public class MyController {

    @Autowired
    private RestTemplate restTemplate;

    @GetMapping("/hello")
    public String hello() {
        String url = "http://service-provider/hello";
        return restTemplate.getForObject(url, String.class);
    }
}