【Spring Cloud 源码解读】之 【这也太神奇了，RestTemplate加上一个@LoadBalanced注解就能实现负载均衡！】

前提概要：

前天，有个前端大佬问了我两个问题：为啥不引入Ribbon依赖就能使用Ribbon？为啥RestTemplate加上@LoadBalanced注解就能负载均衡了？我也表示很疑惑，而我本身其实也真的没去了解过，因此趁着工做不太忙，赶忙去研究一波。

第一个问题比较简单，通常都是其余依赖引入了Ribbon，我这里是Nacos，而他那边也是注册中心Eureka。

第二个问题因为有一点深度，因此须要好好的研究一番。

一、准备：启动两个服务提供者实例，而后启动一个服务消费者实例

二、开始搞起来

一、准备两个RestTemplate:

一个启动负载均衡，一个不启动负载均衡

@Configuration
public class MyConfiguration {

    // 启动负载均衡
    @LoadBalanced
    @Bean
    RestTemplate loadBalanced() {
        return new RestTemplate();
    }

    // 不启动负载均衡
    @Bean
    RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

二、负载均衡探索：

@Autowired
private RestTemplate loadBalanced;

@GetMapping("restTemplate-hello")
public String sayHello(){
    return loadBalanced.getForObject("http://cloud-nacos-discovery-server/hello",String.class);
}

注意：使用负载均衡的RestTemplate去请求时url必定得写服务名，由于Ribbon会根据服务名[serviceId]去获取全部实例，而后进行负载均衡。因此记得不能写IP:Port，否则会报错。

java.lang.IllegalStateException: No instances available for 10.172.29.666

(1)、为什么带上@LoadBalanced就能负载均衡？

之因此标记了@LoadBalanced的RestTemplate会带有负载均衡的功能，是由于RestTemplate里面加入LoadBalancerInterceptor拦截器。咱们也能够看到，咱们上面的代码使用的loadBalanced确实有LoadBalancerInterceptor拦截器。

(2)、拦截器是如何进行负载均衡的？

RestTemplate的每次请求都会被此拦截，而后利用Ribbon实现负载均衡逻辑。

public ClientHttpResponse intercept(final HttpRequest request, final byte[] body, final ClientHttpRequestExecution execution) throws IOException {
        URI originalUri = request.getURI();
        String serviceName = originalUri.getHost();
        Assert.state(serviceName != null, "Request URI does not contain a valid hostname: " + originalUri);
      //这里是使用负载均衡，而这里的loadBalancer就是Spring Cloud提供的LoadBalancerClient接口的实现类。
        return (ClientHttpResponse)this.loadBalancer.execute(serviceName, this.requestFactory.createRequest(request, body, execution));
    }

咱们也看到，最后是经过(ClientHttpResponse)this.loadBalancer.execute(serviceName, this.requestFactory.createRequest(request, body, execution))去负载均衡的，而从上图咱们也能够看到，咱们RestTemplate的loadBanalcer是RibbonLoadBalancerClient，因此说，最后是经过Ribbon是负载均衡的。

(3)、那到底是谁帮RestTemplate加上这个拦截器的？并且是何时加的？

① LoadBalancerAutoConfiguration配置类

关于@LoadBalanced自动生效的配置，咱们须要来到这个自动配置类：LoadBalancerAutoConfiguration。

咱们能够看到这个配置类上有俩个注解：@ConditionalOnClass({RestTemplate.class})，@ConditionalOnBean({LoadBalancerClient.class})，意思是说：只要有RestTemplate类存在，而且Spring容器中存在LoadBalancerClient类型的Bean，这个配置类才会生效。首先，Spring的web模块已经提供了RestTemplate类，而Ribbon也提供了实现LoadBalancerClient接口的实现类，因此说上面全部的条件都符合了，该配置类会生效。

@Configuration
@ConditionalOnClass({RestTemplate.class})
@ConditionalOnBean({LoadBalancerClient.class})
@EnableConfigurationProperties({LoadBalancerRetryProperties.class})
public class LoadBalancerAutoConfiguration {

② 一个关键的成员变量

咱们能够看到LoadBalancerAutoConfiguration中有一个成员变量：

//拿到Spring容器内全部的标注有@LoadBalanced注解的RestTemplate们。 注意：是带有@LoadBalanced注解的
@LoadBalanced
@Autowired(required = false)
private List<RestTemplate> restTemplates = Collections.emptyList();

③ RestTemplateCustomizer来加拦截器

咱们会先找拦截器相关的代码，由于此时咱们都知道负载均衡主要靠的是拦截器，因此，上代码：

@Bean
@ConditionalOnMissingBean
public RestTemplateCustomizer restTemplateCustomizer(final LoadBalancerInterceptor loadBalancerInterceptor) {
    return (restTemplate) -> {
        // 咱们能够看到，若是咱们没有本身实现`RestTemplateCustomizer`，就会执行下面的逻辑，而最突兀的就是，它给每个`RestTemplate`添加了`LoadBalancerInterceptor`，也就是实现负载均衡的重点所在。
        List<ClientHttpRequestInterceptor> list = new ArrayList(restTemplate.getInterceptors());
        list.add(loadBalancerInterceptor);
        restTemplate.setInterceptors(list);
    };
}

④ 什么时候利用RestTemplateCustomizer来给RestTemplate加拦截器

还有另一段很重要的代码，须要来解读一下：

首先咱们得先了解SmartInitializingSingleton是干吗的，它的afterSingletonsInstantiated()方法会在全部的单例Bean初始化完成以后，再去一个一个的去处理。

public interface SmartInitializingSingleton {
    void afterSingletonsInstantiated();
}

那么咱们就知道了，接下来要解读的代码就是为了处理一个个带有@LoadBalanced的RestTemplate们，利用RestTemplateCustomizer给RestTemplate们加上拦截器LoadBalancerInterceptor。

@Bean
public SmartInitializingSingleton loadBalancedRestTemplateInitializerDeprecated(final ObjectProvider<List<RestTemplateCustomizer>> restTemplateCustomizers) {
    return () -> {
        restTemplateCustomizers.ifAvailable((customizers) -> {
            // 遍历上面说起的成员变量，带@LoadBalanced的RestTemplate们
            Iterator var2 = this.restTemplates.iterator();

            while(var2.hasNext()) {
                RestTemplate restTemplate = (RestTemplate)var2.next();
                Iterator var4 = customizers.iterator();

                while(var4.hasNext()) {
                    // 利用上面的RestTemplateCustomizer给RestTemplate们加拦截器
                    RestTemplateCustomizer customizer = (RestTemplateCustomizer)var4.next();
                    customizer.customize(restTemplate);
                }
            }

        });
    };
}

因此最后，咱们能够给第三个问题一个答案：在带有@LoadBalanced注解的RestTemplate们完成Bean初始化以后，利用RestTemplateCustomizer给RestTemplate们加上拦截器LoadBalancerInterceptor，来实现负载均衡。

三、非负载均衡探索

@Autowrite
private RestTemplate restTemplate;

@GetMapping("restTemplate-hello")
public String sayHello(){
    return myRestTemplate.getForObject("http://10.172.29.666:8887/hello",String.class);
}

首先能够看到，RestTemplate再也不带有拦截器

并且，咱们能够看到，最后接口走的是SimpleBufferingClientHttpRequest，而不是RibbonLoadBalancerClient：

到此，关于为何添加了@LoadBalanced就能进行负载均衡的分析已经结束。而若是你们对Ribbon如何进行负载均衡的也很感兴趣，有空再你们一块儿研究研究😄。