Ribbon源码解析

上文，我们讲到RestTemplate模版，其本质就是HttpURLConnection的封装，那么在微服务项目中，如何通过RestTemplate来实现负载均衡的调用的呢？

想必大家都见过这样的代码：

@Bean
@LoadBalanced
public RestTemplate restTemplate() {
    return new RestTemplate();
}
1
2
3
4
5

然后调用的时候，拼接服务名：

result = restTemplate.getForObject("http://service-producer/producer", String.class);
1

也许你也知道它的一些原理：

Ribbon会为被@LoadBalanced注解标注的RestTemplate实例添加一个拦截器LoadBalancerInterceptor，在restTemplate调用时拦截器会拦截请求，根据负载均衡策略，通过服务名选择一个server，将url中的服务名替换为对应的ip:host再调用，达到负载均衡。

那你知道具体是怎么实现的么？

我们先从restTemplate入口开始：

接下来，我们看一下是如何创建请求的：HttpAccessor#createRequest

protected ClientHttpRequest createRequest(URI url, HttpMethod method) throws IOException {
	// 创建请求工厂，然后通过这个工厂去创建请求
	ClientHttpRequest request = getRequestFactory().createRequest(url, method);
	initialize(request);
	return request;
}
1
2
3
4
5
6

这里是：创建请求工厂，然后通过这个工厂去创建请求。看看#getRequestFactory

在看这里，首先加载拦截器，如果没有拦截器就调用父类的getRequestFactory方法，既然有负载均衡，那这里一定有与其相关的拦截器喽。【通过debug，看到有一个叫LoadBalancerInterceptor的拦截器】

InterceptingHttpAccessor#getInterceptors

在set方法处添加了拦截器，来看一下哪里调用了set方法。

原来是一个自动配置类LoadBalancerAutoConfiguration

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

    /**
     * 被@LoadBalanced注解标注的RestTemplate实例会被注入到这里，这就是demo中要在RestTemplate加@LoadBalanced注解的原因
     */
	@LoadBalanced
	@Autowired(required = false)
	private List<RestTemplate> restTemplates = Collections.emptyList();

    /**
     * SmartInitializingSingleton接口的实现类会在Spring容器初始化之后被调用其afterSingletonsInstantiated方法
     */
	@Bean
	public SmartInitializingSingleton loadBalancedRestTemplateInitializerDeprecated(
			final ObjectProvider<List<RestTemplateCustomizer>> restTemplateCustomizers) {
		return () -> restTemplateCustomizers.ifAvailable(customizers -> {
            // 为每个RestTemplate添加拦截器
            for (RestTemplate restTemplate : LoadBalancerAutoConfiguration.this.restTemplates) {
                // RestTemplateCustomizer实例在下面创建
                for (RestTemplateCustomizer customizer : customizers) {
                    customizer.customize(restTemplate);
                }
            }
        });
	}

	@Autowired(required = false)
	private List<LoadBalancerRequestTransformer> transformers = Collections.emptyList();

    /**
     * 创建LoadBalancerRequestFactory实例
     */
	@Bean
	@ConditionalOnMissingBean
	public LoadBalancerRequestFactory loadBalancerRequestFactory(
			LoadBalancerClient loadBalancerClient) {
		return new LoadBalancerRequestFactory(loadBalancerClient, transformers);
	}

	@Configuration
	@ConditionalOnMissingClass("org.springframework.retry.support.RetryTemplate")
	static class LoadBalancerInterceptorConfig {
        /**
         * 创建LoadBalancerInterceptor拦截器实例
         */
		@Bean
		public LoadBalancerInterceptor ribbonInterceptor(
				LoadBalancerClient loadBalancerClient,
				LoadBalancerRequestFactory requestFactory) {
			return new LoadBalancerInterceptor(loadBalancerClient, requestFactory);
		}

        /**
         * 为resttemplate添加拦截器
         */
		@Bean
		@ConditionalOnMissingBean
		public RestTemplateCustomizer restTemplateCustomizer(
				final LoadBalancerInterceptor loadBalancerInterceptor) {
			return restTemplate -> {
                // 该方法就是上面customizer.customize(restTemplate)的调用
                // 在这里将拦截器添加到restTemplate中
                List<ClientHttpRequestInterceptor> list = new ArrayList<>(
                        restTemplate.getInterceptors());
                list.add(loadBalancerInterceptor);
                restTemplate.setInterceptors(list);
            };
		}
	}

	@Configuration
	@ConditionalOnClass(RetryTemplate.class)
	public static class RetryAutoConfiguration {

		@Bean
		@ConditionalOnMissingBean
		public LoadBalancedRetryFactory loadBalancedRetryFactory() {
			return new LoadBalancedRetryFactory() {};
		}
	}

	@Configuration
	@ConditionalOnClass(RetryTemplate.class)
	public static class RetryInterceptorAutoConfiguration {
		@Bean
		@ConditionalOnMissingBean
		public RetryLoadBalancerInterceptor ribbonInterceptor(
				LoadBalancerClient loadBalancerClient, LoadBalancerRetryProperties properties,
				LoadBalancerRequestFactory requestFactory,
				LoadBalancedRetryFactory loadBalancedRetryFactory) {
			return new RetryLoadBalancerInterceptor(loadBalancerClient, properties,
					requestFactory, loadBalancedRetryFactory);
		}

		@Bean
		@ConditionalOnMissingBean
		public RestTemplateCustomizer restTemplateCustomizer(
				final RetryLoadBalancerInterceptor loadBalancerInterceptor) {
			return restTemplate -> {
                List<ClientHttpRequestInterceptor> list = new ArrayList<>(
                        restTemplate.getInterceptors());
                list.add(loadBalancerInterceptor);
                restTemplate.setInterceptors(list);
            };
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

该自动配置类的作用就是为@LoadBalanced注解标注的RestTemplate实例添加LoadBalancerInterceptor拦截器实例，这就解答了上面RestTemplate中的拦截器是哪来的了。

总体来说，创建请求就是创建一个包含拦截器功能的request，用在执行请求时拦截请求，至于拦截了做些啥，看下面的解析。

接下来，到了创建请求的时候了

由于创建的request是InterceptingClientHttpRequestFactory

所以最后执行的是InterceptingClientHttpRequestFactory#createRequest

所以执行execute最终执行到InterceptingClientHttpRequest的executeInternal方法

InterceptingClientHttpRequest类结构

创建拦截链、执行拦截链

执行拦截器

	@Override
	public ClientHttpResponse intercept(final HttpRequest request, final byte[] body,
			final ClientHttpRequestExecution execution) throws IOException {
        // 这个demo里是http://service-producer/producer
		final URI originalUri = request.getURI();
        // service-producer
		String serviceName = originalUri.getHost();
		Assert.state(serviceName != null, "Request URI does not contain a valid hostname: " + originalUri);
        // 通过负载均衡器执行
		return this.loadBalancer.execute(serviceName, requestFactory.createRequest(request, body, execution));
	}
1
2
3
4
5
6
7
8
9
10
11

这里会通过一个LoadBalancerClient执行，应该就是真正负载均衡的地方，那这个LoadBalancerClient接口的实例是谁呢？看上面自动配置类创建拦截器时会注入这个LoadBalancerClient，那这个LoadBalancerClient应该也是在某个自动配置类中创建的。

可以看到是RibbonLoadBalancerClient，通过查看构造方法的调用，发现是在RibbonAutoConfiguration中创建的，看到ribbon，看来是跟ribbon相关的了。


其实我们在引入注册中心的时候，比如Nacos，在cloud2020版本以下的时候，会引入Ribbon作为负载均衡器，引入org/springframework/cloud/spring-cloud-netflix-ribbon，其中会加入自动装配类RibbonAutoConfiguration

好，我们继续流程：【负载均衡核心代码】

@Override
public <T> T execute(String serviceId, LoadBalancerRequest<T> request) throws IOException {
    // 根据服务id从Spring容器中获取负载均衡器，根据debug可知是ZoneAwareLoadBalancer
    ILoadBalancer loadBalancer = getLoadBalancer(serviceId);
    // 通过负载均衡选择一个服务
    Server server = getServer(loadBalancer);
    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);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

可以看到先通过服务名获取一个spring容器，再从spring容器中获取ILoadBalancer，该bean包含该服务名下的服务实例以及负载均衡所需要用到的相关组件。

这个contexts是一个map，发现搞了一个缓存，key是服务名称，value是AnnotationConfigApplicationContext，相当于在Ribbon中每个服务都有一个spring容器，互不影响。

第一次访问时，是没有缓存的，所以需要新建

可以看到是直接创建AnnotationConfigApplicationContext实例，然后注册几个配置类，最后刷新容器，跟初始化spring容器的步骤差不多。

这里会注册NacosRibbonClientConfiguration配置类，这个配置包含了负载均衡所需的所有组件和服务列表。

ZoneAwareLoadBalancer是在RibbonClientConfiguration配置类中创建的，默认使用该负载均衡器。

那么问题来了，在注册中心选择一个服务的时候，首先应该获取服务列表，那么服务列表是在哪里获取的呢？

这还要从我们的自动装配类开始说起：