图解+源码讲解 Ribbon 服务选择原理-CFANZ编程社区

图解+源码讲解 Ribbon 服务选择原理

遇到困难时不要抱怨，既然改变不了过去，那么就努力改变未来

相关文章
图解+源码讲解 Ribbon 如何获取注册中心的实例图解+源码讲解 Ribbon 原理初探图解+源码讲解 Ribbon 服务列表更新

从哪里开始分析

想想什么时候进行服务选择呢，指定是在请求访问的时候，会进行具体的服务选择，那我们就来看看这块执行的代码，看看里面有没有具体的相关代码

public <T> T execute(String serviceId, LoadBalancerRequest<T> request, Object hint)
        throws IOException {
    ILoadBalancer loadBalancer = getLoadBalancer(serviceId);
    Server server = getServer(loadBalancer, hint);
    if (server == null) {
        throw new IllegalStateException("No instances available for " + serviceId);
    }
    RibbonServer ribbonServer = new RibbonServer(serviceId, server,
            isSecure(server, serviceId),
            serverIntrospector(serviceId).getMetadata(server));

    return execute(serviceId, ribbonServer, request);
}

一眼就看到了获取服务的方法 getServer(loadBalancer, hint)，那我们就从这行代码开始分析，下面先看一个1择服务原理流程图

选择服务原理图

图解+源码讲解 Ribbon 服务选择原理_Spring Cloud

源码分析

1. 获取服务 DynamicServerListLoadBalancer

其实他是从负载均衡器中获取的服务列表 getServer(loadBalancer, hint)，这个负载均衡器就是 DynamicServerListLoadBalancer，他就是之前在RibbonClientConfiguration 里面定义好的，其实我们看上面的流程图，里面已经获取到了两个服务节点【192.168.0.107:9100、192.168.0.107:9200】了

2. loadBalancer 选择服务

loadBalancer.chooseServer 这个选择服务的方法其实走的就是 BaseLoadBalancer类里面的 chooseServer 方法

protected Server getServer(ILoadBalancer loadBalancer, Object hint) {
    if (loadBalancer == null) {
        return null;
    }
    return loadBalancer.chooseServer(hint != null ? hint : "default");
}

其实是通过一定的服务选择规则进行服务选择的，rule.choose(key) 这块代码是核心的选择规则

public Server chooseServer(Object key) {
    if (counter == null) {
        counter = createCounter();
    }
    counter.increment();
    if (rule == null) {
        return null;
    } else {
        try {
            // 实例选择算法
            return rule.choose(key);
        } catch (Exception e) {
            logger.warn("LoadBalancer [{}]:  Error choosing server for key {}",
                        name, key, e);
            return null;
        }
    }
}

3. 通过轮询规则选择服务

默认的服务选择规则是轮询算法，就是一个一个的进行访问的，chooseRoundRobinAfterFiltering 这个方法是最重要的，他是将负载均衡器中的服务列表传入进去之后通过循环算法选择一个出来，我们进入这个方法里面看看就明白了

@Override
public Server choose(Object key) {
    ILoadBalancer lb = getLoadBalancer();
    Optional<Server> server = getPredicate()
        .chooseRoundRobinAfterFiltering(lb.getAllServers(), key);
    if (server.isPresent()) {
        return server.get();
    } else {
        return null;
    }
}

4. 轮询算法选择过滤 chooseRoundRobinAfterFiltering

先通过 getEligibleServers 这个方法选择出合适的服务列表,返回一个List 集合，之后通过 incrementAndGetModulo(eligible.size()) 这个取模算法进新服务选择

public Optional<Server> chooseRoundRobinAfterFiltering(List<Server> servers,
                                                           Object loadBalancerKey) {
        List<Server> eligible = getEligibleServers(servers, loadBalancerKey);
        if (eligible.size() == 0) {
            return Optional.absent();
        }
        return Optional.of(eligible.get(incrementAndGetModulo(eligible.size())));
    }

5. 取模算法 incrementAndGetModulo

一个for的死循环，通过一个原子类nextIndex 记录当前的值，之后通过当前值+1与服务列表进行取余，得出来的余数设置给 current 并返回它，其实就是计算出一个索引值，这个索引值一定是小于服务列表的size的，因为它需要从 List 这个集合中通过索引 get 出一个值的

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