Ribbon源码之ClientConfigEnabledRoundRobinRule和BestAvailableRule解读

一 类图中的位置

二 ClientConfigEnabledRoundRobinRule代码解读

//该策略较为特殊，我们一般不直接使用它。因为它本身并没有实现什么特殊的处理逻辑。
//通过继承该策略，默认的choose就实现了线性轮询机制，在子类中做一些高级策略时通常可能存在
//一些无法实施的情况，就可以用父类的实现作为备选。
public class ClientConfigEnabledRoundRobinRule extends AbstractLoadBalancerRule {
    //内部定义了一个RoundRobinRule策略
    RoundRobinRule roundRobinRule = new RoundRobinRule();

    @Override
    public void initWithNiwsConfig(IClientConfig clientConfig) {
        roundRobinRule = new RoundRobinRule();
    }

    @Override
    public void setLoadBalancer(ILoadBalancer lb) {
        super.setLoadBalancer(lb);
        roundRobinRule.setLoadBalancer(lb);
    }
    //使用RoundRobinRule的线性轮询机制
    @Override
    public Server choose(Object key) {
        if (roundRobinRule != null) {
            return roundRobinRule.choose(key);
        } else {
            throw new IllegalArgumentException(
                    "This class has not been initialized with the RoundRobinRule class");
        }
    }

}

三 BestAvailableRule 代码解读

//继承自ClientConfigEnabledRoundRobinRule
//该策略的特性是可选出最空闲的实例
public class BestAvailableRule extends ClientConfigEnabledRoundRobinRule {

    //注入负载均衡器的统计对象loadBalancerStats
    private LoadBalancerStats loadBalancerStats;
    
    
    @Override
    public Server choose(Object key) {
        //当loadBalancerStats为空，采用父类的线性轮询
        //体现了在ClientConfigEnabledRoundRobinRule的子类无法满足高级策略时，采用
        //ClientConfigEnabledRoundRobinRule的线性轮询特性
        if (loadBalancerStats == null) {
            return super.choose(key);
        }
        List<Server> serverList = getLoadBalancer().getAllServers();
        int minimalConcurrentConnections = Integer.MAX_VALUE;
        long currentTime = System.currentTimeMillis();
        Server chosen = null;
        //利用loadBalancerStats保存的实例统计信息来选择满足要求的实例
        //遍历负载均衡器中维护的所有服务实例
        for (Server server: serverList) {
            ServerStats serverStats = loadBalancerStats.getSingleServerStat(server);
            //过滤掉负载的实例
            if (!serverStats.isCircuitBreakerTripped(currentTime)) {
                int concurrentConnections = serverStats.getActiveRequestsCount(currentTime);
                //找出请求数最小的一个
                if (concurrentConnections < minimalConcurrentConnections) {
                    minimalConcurrentConnections = concurrentConnections;
                    chosen = server;
                }
            }
        }
        if (chosen == null) {
            return super.choose(key);
        } else {
            return chosen;
        }
    }

    @Override
    public void setLoadBalancer(ILoadBalancer lb) {
        super.setLoadBalancer(lb);
        if (lb instanceof AbstractLoadBalancer) {
            loadBalancerStats = ((AbstractLoadBalancer) lb).getLoadBalancerStats();            
        }
    }
}