Ribbon核⼼源码剖析

目录

一. Ribbon⼯作原理

二. @LoadBalanced源码剖析

​ （一）研究LoadBalancerAutoConfifiguration

（二）分析拦截器LoadBalancerInterceptor

1. 关注点1：

2. 关注点2：选择服务 

 3 . 关注点3：

（三）serverList分析

三. RoundRobinRule轮询策略源码剖析

 四. RandomRule随机策略源码剖析

---

一. Ribbon⼯作原理

 重点：Ribbon给restTemplate添加了⼀个拦截器

思考： Ribbon 在做什么：

当我们访问 http://lagou-service-resume/resume/openstate/ 的时候， ribbon 应该

根据服务名 lagou-service-resume 获取到该服务的实例列表并按照⼀定的负载均衡

策略从实例列表中获取⼀个实例 Server ，并最终通过 RestTemplate 进⾏请求访问

Ribbon 细节结构图（涉及到底层的⼀些组件 / 类的描述）

1) 获取服务实例列表 2 ）从列表中选择⼀个 server

图中核⼼是 负载均衡管理器 LoadBalancer （总的协调者，相当于⼤脑，为了做事

情，协调四肢） ，围绕它周围的多有 IRule 、 IPing 等

• IRule：是在选择实例的时候的负载均衡策略对象
• IPing：是⽤来向服务发起⼼跳检测的，通过⼼跳检测来判断该服务是否可⽤
• ServerListFilter：根据⼀些规则过滤传⼊的服务实例列表
• ServerListUpdater：定义了⼀系列的对服务列表的更新操作

二. @LoadBalanced源码剖析

我们在 RestTemplate 实例上添加了⼀个 @LoadBalanced 注解，就可以实现负载均

衡，很神奇，我们接下来分析这个注解背后的操作（负载均衡过程）

• 查看@LoadBalanced注解，那这个注解是在哪⾥被识别到的呢？

• LoadBalancerClient类（实现类RibbonLoadBalancerClient，待⽤）

package org.springframework.cloud.client.loadbalancer;

import org.springframework.cloud.client.ServiceInstance;

import java.io.IOException;
import java.net.URI;

/**
 * Represents a client-side load balancer.
 * @author Spencer Gibb
 */
public interface LoadBalancerClient extends ServiceInstanceChooser {

    // 根据服务执⾏请求内容
	<T> T execute(String serviceId, LoadBalancerRequest<T> request) throws IOException;

    // 根据服务执⾏请求内容
	<T> T execute(String serviceId, ServiceInstance serviceInstance, LoadBalancerRequest<T> request) throws IOException;

    // 拼接请求⽅式 传统中是ip:port 现在是服务名称:port 形式
	URI reconstructURI(ServiceInstance instance, URI original);
}

• ⽼规矩：SpringCloud充分利⽤了SpringBoot的⾃动装配特点，找spring.factories配置⽂件

（一）研究LoadBalancerAutoConfifiguration

 

 =========》》》LoadBalancerAutoConfifiguration⾥⾯的内容剖析

第⼀处：注⼊ resttemplate 对象到集合待⽤

 第⼆处：注⼊resttemplate定制器

 第三处：使⽤定制器给集合中的每⼀个resttemplate对象添加⼀个拦截器

到这⾥，我们明⽩，添加了注解的 RestTemplate 对象会被添加⼀个拦截器

LoadBalancerInterceptor，该拦截器就是后续拦截请求进⾏负载处理的。

所以，下⼀步重点我们该分析拦截器 LoadBalancerInterceptor------>>>intercept()

⽅法。

（二）分析拦截器LoadBalancerInterceptor

 ==========》》》》分析LoadBalancerInterceptor.intercept()⽅法

那么？ RibbonLoadBalancerClient 对象是在哪⾥注⼊的 === 》》回到最初的⾃动配

置类 RibbonAutoConfifiguration 中

负载均衡的事情执⾏原来交给了我们最初看到的LoadBalancerClient 接口的实现类：RibbonLoadBalancerClient 类的对象

⾮常核⼼的⼀个⽅法：RibbonLoadBalancerClient.execute()

1. 关注点1：

 =====》》》回到主配置类RibbonAutoConfifiguration

 

 RibbonClientConfifiguration中装配了⼤脑和肢⼲

 

2. 关注点2：选择服务 

 ZoneAwareLoadBalancer#chooseServer

 ⽗类：com.netflflix.loadbalancer.BaseLoadBalancer#chooseServer

来到区域隔离策略的⽗类 choose ⽅法中

com.netflflix.loadbalancer.PredicateBasedRule#choose

 

 3 . 关注点3：

在下图所示的RibbonLoadBalancerClient类的execute方法的return代码行打上断点，消费端Debug运行后,浏览器请求消费端，进入该方法

 

 

 AbstractClientHttpRequest#execute

此处，就已经到了 RestTemplate 底层执⾏的代码了，由此也将验证最终请求的调⽤

还是靠的 RestTemplate

（三）serverList分析

接下来，在进⾏负载 chooseServer 的时候， LoadBalancer 负载均衡器中已经有了

serverList ，那么这个 serverList 是什么时候被注⼊到 LoadBalancer 中的，它的⼀个

机制⼤概是怎样的？

来到 RibbonClientConfifiguration

 

还是在RibbonClientConfiguration这个类中有一个ServerList<Server>类型的Bean 

 把⽬光聚焦到使⽤这个空对象ServerList的地⽅

 

 

 进⼊enableAndInitLearnNewServersFeature()⽅法

 

进入ServerListUpdater接口的实现类EurekaNotificationServerListUpdater，在该类中找到start(final UpdateAction updateAction)方法：

三. RoundRobinRule轮询策略源码剖析

/*
 *
 * Copyright 2013 Netflix, Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */
package com.netflix.loadbalancer;

import com.netflix.client.config.IClientConfig;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * The most well known and basic load balancing strategy, i.e. Round Robin Rule.
 *
 * @author stonse
 * @author Nikos Michalakis <nikos@netflix.com>
 *
 */
public class RoundRobinRule extends AbstractLoadBalancerRule {

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

    private static Logger log = LoggerFactory.getLogger(RoundRobinRule.class);

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

    public RoundRobinRule(ILoadBalancer lb) {
        this();
        setLoadBalancer(lb);
    }

    // 负载均衡策略类核⼼⽅法
    public Server choose(ILoadBalancer lb, Object key) {
        if (lb == null) {
            log.warn("no load balancer");
            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)) {
                log.warn("No up servers available from load balancer: " + lb);
                return null;
            }
            // 获得⼀个轮询索引
            int nextServerIndex = incrementAndGetModulo(serverCount);
            // 根据索引取出服务实例对象
            server = allServers.get(nextServerIndex);

            if (server == null) {
                /* Transient. */
                Thread.yield();
                continue;
            }
            // 判断服务可⽤后返回

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

            // Next.
            server = null;
        }

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

    /**
     * Inspired by the implementation of {@link AtomicInteger#incrementAndGet()}.
     *
     * @param modulo The modulo to bound the value of the counter.
     * @return The next value.
     */
    private int incrementAndGetModulo(int modulo) {
        for (;;) {
            // 取出上次的计数
            int current = nextServerCyclicCounter.get();
            // 因为是轮询，计数+1之后对总数取模
            int next = (current + 1) % modulo;
            if (nextServerCyclicCounter.compareAndSet(current, next))
                return next;
        }
    }

    @Override
    public Server choose(Object key) {
        return choose(getLoadBalancer(), key);
    }

    @Override
    public void initWithNiwsConfig(IClientConfig clientConfig) {
    }
}

 四. RandomRule随机策略源码剖析