Spring-Cloud-Loadblancer详细分析_1

背景

从SpringCloud 2020 版本之后，组件移除了除 Eureka 以外，所有 Netflix 的相关，包括最常用的 Ribbon Hystrix 等，所以 SpringCloud 在 spring-cloud-commons 提供了Loadbalancer 用来替代 Ribbon。本系列就来介绍Loadbalancer 的执行流程

项目版本:

• Spring-Boot2.6.13
• Spring-Cloud 2021.0.5
• spring-cloud-alibaba 2021.0.5.0
• Loadbalancer 3.1.5

从项目中最常用的Feign来当做入口，不了解Feign的原理也没有关系，直接从Feign和Loadbalancer 的集成部分分析即可

分析

入口处

FeignBlockingLoadBalancerClient

public class FeignBlockingLoadBalancerClient implements Client {private static final Log LOG = LogFactory.getLog(FeignBlockingLoadBalancerClient.class);private final Client delegate;private final LoadBalancerClient loadBalancerClient;private final LoadBalancerClientFactory loadBalancerClientFactory;@Overridepublic Response execute(Request request, Request.Options options) throws IOException {//请求路径final URI originalUri = URI.create(request.url());//获取到要调用的服务idString serviceId = originalUri.getHost();DefaultRequest<RequestDataContext> lbRequest = new DefaultRequest<>(new RequestDataContext(buildRequestData(request), hint));	Set<LoadBalancerLifecycle> supportedLifecycleProcessors = LoadBalancerLifecycleValidator.getSupportedLifecycleProcessors(//在这步创建了每个服务的子容器	loadBalancerClientFactory.getInstances(serviceId, LoadBalancerLifecycle.class),RequestDataContext.class, ResponseData.class, ServiceInstance.class);supportedLifecycleProcessors.forEach(lifecycle -> lifecycle.onStart(lbRequest));		//执行loadBalancer的负载均衡策略，返回将过滤后的服务，非常重要ServiceInstance instance = loadBalancerClient.choose(serviceId, lbRequest);org.springframework.cloud.client.loadbalancer.Response<ServiceInstance> lbResponse = new DefaultResponse(instance);//省略...//将ServiceInstance进行解析后，转换为真正的http方式进行远程调用服务String reconstructedUrl = loadBalancerClient.reconstructURI(instance, originalUri).toString();Request newRequest = buildRequest(request, reconstructedUrl);LoadBalancerProperties loadBalancerProperties = loadBalancerClientFactory.getProperties(serviceId);return executeWithLoadBalancerLifecycleProcessing(delegate, options, newRequest, lbRequest, lbResponse,supportedLifecycleProcessors, loadBalancerProperties.isUseRawStatusCodeInResponseData());}protected Request buildRequest(Request request, String reconstructedUrl) {return Request.create(request.httpMethod(), reconstructedUrl, request.headers(), request.body(),request.charset(), request.requestTemplate());}private String getHint(String serviceId) {LoadBalancerProperties properties = loadBalancerClientFactory.getProperties(serviceId);String defaultHint = properties.getHint().getOrDefault("default", "default");String hintPropertyValue = properties.getHint().get(serviceId);return hintPropertyValue != null ? hintPropertyValue : defaultHint;}}

可以看到，在OpenFeign中调用了loadBalancerClient.choose(serviceId, lbRequest)来实现负载均衡策略，然后返回过滤后的服务ServiceInstance，也就是服务的对象。我们要重点分析此过程

首先分析loadBalancerClient是怎么注入进来的呢，我们先看下其结构

ServiceInstanceChooser

public interface ServiceInstanceChooser {ServiceInstance choose(String serviceId);<T> ServiceInstance choose(String serviceId, Request<T> request);}

LoadBalancerClient

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;URI reconstructURI(ServiceInstance instance, URI original);}

可以看到ServiceInstanceChooser定义了负载均衡的方法， LoadBalancerClient则继承了ServiceInstanceChooser额外定义了execute执行和reconstructURI构建真正http请求的方法

那么LoadBalancerClient的实现是谁呢，刚才的疑问中又是怎么被注入的呢，其实LoadBalancerClient的实现是BlockingLoadBalancerClient，在配置类BlockingLoadBalancerClientAutoConfiguration中被注入

这里既然提到了自动装配配置类，那么我们就需要看下其结构，来了解各个作用

# AutoConfiguration
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.cloud.loadbalancer.config.LoadBalancerAutoConfiguration,\
org.springframework.cloud.loadbalancer.config.BlockingLoadBalancerClientAutoConfiguration,\
org.springframework.cloud.loadbalancer.config.LoadBalancerCacheAutoConfiguration,\
org.springframework.cloud.loadbalancer.security.OAuth2LoadBalancerClientAutoConfiguration,\
org.springframework.cloud.loadbalancer.config.LoadBalancerStatsAutoConfiguration

• LoadBalancerAutoConfiguration 是最核心最重要的配置，随后会详细的分析
• BlockingLoadBalancerClientAutoConfiguration 上文中提高的LoadBalancerClient的实现类BlockingLoadBalancerClient就是在此装配的

BlockingLoadBalancerClientAutoConfiguration

@Configuration(proxyBeanMethods = false)
@LoadBalancerClients
@AutoConfigureAfter(LoadBalancerAutoConfiguration.class)
@AutoConfigureBefore({ org.springframework.cloud.client.loadbalancer.LoadBalancerAutoConfiguration.class,AsyncLoadBalancerAutoConfiguration.class })
@ConditionalOnClass(RestTemplate.class)
public class BlockingLoadBalancerClientAutoConfiguration {@Bean@ConditionalOnBean(LoadBalancerClientFactory.class)@ConditionalOnMissingBeanpublic LoadBalancerClient blockingLoadBalancerClient(LoadBalancerClientFactory loadBalancerClientFactory) {return new BlockingLoadBalancerClient(loadBalancerClientFactory);}//省略}

可以看到注入了LoadBalancerClient的实现类BlockingLoadBalancerClient。但此自动配置类的装配有很多的规则：

1. @LoadBalancerClients 此注解非常重要，实现每个服务间的负载均衡配置隔离就是通过此注解，后面会详细的分析
2. @AutoConfigureAfter(LoadBalancerAutoConfiguration.class)在LoadBalancerAutoConfiguration之后进行装配，LoadBalancerAutoConfiguration也很重要，后面也会详细的分析
3. @AutoConfigureBefore({ org.springframework.cloud.client.loadbalancer.LoadBalancerAutoConfiguration.class, AsyncLoadBalancerAutoConfiguration.class }) 在org.springframework.cloud.client.loadbalancer.LoadBalancerAutoConfiguration和AsyncLoadBalancerAutoConfiguration之前进行装配。注意：2和3中的LoadBalancerAutoConfiguration不是一个对象，2中的是在spring-cloud-loadbalancer模块中，3中的是在spring-cloud-commons模块中，这也是有步骤2的原因，毕竟肯定是要先装配本模块下的
4. @ConditionalOnClass(RestTemplate.class)这个不是重点，可以略过
5. @ConditionalOnBean(LoadBalancerClientFactory.class) 在注入时依赖了LoadBalancerClientFactory，LoadBalancerClientFactory也非常的重要，后面也会进行详细的分析

上面多次提到了LoadBalancerAutoConfiguration，自动装配中也有它，那么现在就来分析下其流程

LoadBalancerAutoConfiguration

@Configuration(proxyBeanMethods = false)
@LoadBalancerClients
@EnableConfigurationProperties(LoadBalancerClientsProperties.class)
@AutoConfigureBefore({ ReactorLoadBalancerClientAutoConfiguration.class,LoadBalancerBeanPostProcessorAutoConfiguration.class })
@ConditionalOnProperty(value = "spring.cloud.loadbalancer.enabled", havingValue = "true", matchIfMissing = true)
public class LoadBalancerAutoConfiguration {//依赖了LoadBalancerClientSpecification类型的对象集合private final ObjectProvider<List<LoadBalancerClientSpecification>> configurations;public LoadBalancerAutoConfiguration(ObjectProvider<List<LoadBalancerClientSpecification>> configurations) {this.configurations = configurations;}@Bean@ConditionalOnMissingBeanpublic LoadBalancerZoneConfig zoneConfig(Environment environment) {return new LoadBalancerZoneConfig(environment.getProperty("spring.cloud.loadbalancer.zone"));}@ConditionalOnMissingBean@Beanpublic LoadBalancerClientFactory loadBalancerClientFactory(LoadBalancerClientsProperties properties) {LoadBalancerClientFactory clientFactory = new LoadBalancerClientFactory(properties);//LoadBalancerClientSpecification类型的配置类集合对象注入到NamedContextFactory，实现个性化配置clientFactory.setConfigurations(this.configurations.getIfAvailable(Collections::emptyList));return clientFactory;}}

可以看到此配置类的装配规则也比较复杂，但大部分都和本系列要分析的内容关联性不大，直接略过即可，我们只关心两个地方

• @LoadBalancerClients 这个注解出现多次，我们会做详细的分析
• 注入了loadBalancerClientFactory，这个也非常的重要，随后会做详细的分析

到这里我们要解决的三个重点：

• @LoadBalancerClients的作用
• ObjectProvider<List<LoadBalancerClientSpecification>> configurations的作用
• LoadBalancerClientFactory的作用，别忘了负载均衡的执行对象BlockingLoadBalancerClient在生成时，将此对象注入了进去

下一篇文章我们进行详细分析