Ribbon源码分析

介绍

先看下spring cloud官方对Ribbon的描述：Ribbon is a client-side load balancer that gives you a lot of control over the behavior of HTTP and TCP clients.
大意就是说，Ribbon是一个客户端负责均衡器，它赋予了应用一些支配HTTP与TCP行为的能力。那么，我们常见的nginx，lvs可以理解为服务端负载均衡。在spring cloud中，Feign和Zuul中已经默认集成了Ribbon。

Ribbon的负载均衡策略

负载均衡策略

开启负载均衡

• 直接在RestTemplate加上LoadBalance注解

@Bean
@LoadBalanced
public RestTemplate restTemplate() {
    return new RestTemplate();
}

• 第二种方式稍微麻烦一些
  在配置文件中加配置，hello-server是用来测试的两个服务，并注册到eureka上

hello-server.ribbon.listOfServers=http://192.168.1.6:8101, http://192.168.1.6:8102

在启动类上加注解

@RibbonClients(
        @RibbonClient(value = "hello-server")
)
@SpringBootApplication
@EnableCircuitBreaker
public class StudyApplication {

    public static void main(String[] args) {
        SpringApplication.run(StudyApplication.class, args);
    }

源码解析

/**
 * Annotation to mark a RestTemplate bean to be configured to use a LoadBalancerClient.
 * @author Spencer Gibb
 */
@Target({ ElementType.FIELD, ElementType.PARAMETER, ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@Qualifier
public @interface LoadBalanced {
}

可以看到这个注解的注释中明确的说道了RestTemplate配置使用LoadBalancerClient，那么问题来了，LoadBalancerClient在哪，老套路，我们还是去RibbonAutoConfiguration自动配置类看一下，在这个类里会看到这样的代码

@Bean
public SpringClientFactory springClientFactory() {
        SpringClientFactory factory = new SpringClientFactory();
        factory.setConfigurations(this.configurations);
        return factory;
}

这段代码中会注入SpringClientFactory，可以猜测一下这个类作用，用来获取一个bean，那么获取什么样的bean，我们往下看。
在RibbonAutoConfiguration还有一个重要的bean，LoadBalancerClient

@Bean
@ConditionalOnMissingBean(LoadBalancerClient.class)
    public LoadBalancerClient loadBalancerClient() {
        return new RibbonLoadBalancerClient(springClientFactory());
}

ok，可以清晰的看到这个SpringClientFactory会注入到LoadBalancerClient的实现类RibbonLoadBalancerClient中。
后面我们断点跟进一下

@GetMapping("/study2")
public Object test2() {
    ServiceInstance serviceInstance = loadBalancerClient.choose("hello-server");
    String host = serviceInstance.getHost();
    int port = serviceInstance.getPort();
    return restTemplate.getForObject("http://" + host + ":" + port, String.class, "");
}

从这里进入choose方法最终会调用到RibbonLoadBalancerClient的如下方法

public ServiceInstance choose(String serviceId, Object hint) {
    Server server = getServer(getLoadBalancer(serviceId), hint);
    if (server == null) {
        return null;
    }
    return new RibbonServer(serviceId, server, isSecure(server, serviceId),
            serverIntrospector(serviceId).getMetadata(server));
}

进入getLoadBalancer()方法

protected ILoadBalancer getLoadBalancer(String serviceId) {
    return this.clientFactory.getLoadBalancer(serviceId);
}

这个clientFactory就是上面的SpringClientFactory，这里就明确了这个factory就是获取ILoadBalancer的，获得ILoadBalancer后，会获取Server，那么继续进入getServer()方法

protected Server getServer(ILoadBalancer loadBalancer, Object hint) {
    if (loadBalancer == null) {
        return null;
    }
    // Use 'default' on a null hint, or just pass it on?
    return loadBalancer.chooseServer(hint != null ? hint : "default");
}

负责均衡的目标就是帮我们选择服务，继续进入chooseServer()方法，会进入到BaseLoadBalancer的chooseServer()方法

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;
        }
    }
}

在这我们会看到会用IRule选择服务，所以IRule的实现类（默认是ZoneAvoidanceRule）会注入到ILoadBalancer中，分析到这里我们基本就明白了ribbon是如何选择服务的。

总结

本文分析了如何选择服务的源码，实际上我们通过RestTemplate发起调用的时候，会通过拦截器拦截请求，选择服务，再返回结果。