Spring Cloud 升級之途 – 2020.0.x – 6. 应用 Spring Cloud LoadBalancer (1)

本新项目编码详细地址：https://GitHub.com/HashZhang/spring-cloud-scaffold/tree/master/spring-cloud-iiford

大家应用 Spring Cloud 官方网强烈推荐的 Spring Cloud LoadBalancer 做为大家的手机客户端负载均衡设备。

Spring Cloud LoadBalancer情况

Spring Cloud LoadBalancer是一个手机客户端负载均衡设备，类似Ribbon，可是因为Ribbon早已进到维护保养方式，而且Ribbon 2并不与Ribbon 1互相兼容，因此Spring Cloud套餐在Spring Cloud Commons新项目中，加上了Spring cloud Loadbalancer做为新的负载均衡设备，而且干了往前兼容，即使你的新项目中再次用 Spring Cloud Netflix 套服（包含Ribbon，Eureka，Zuul，Hystrix这些）使你的新项目中有这种依靠，你也能够根据简易的配备，把ribbon换成Spring Cloud LoadBalancer。

负载均衡设备在哪儿应用？

Spring Cloud 中內部微服务架构启用默认设置是 http 要求，关键根据下边三种 API：

• RestTemplate：同歩 http API
• WebClient：多线程响应式网站 http API
• 三方手机客户端封裝，比如 openfeign

假如新项目中添加了 spring-cloud-loadbalancer 的依靠而且配备开启了，那麼会全自动在有关的 Bean 中添加负载均衡设备的特点。

• 针对 RestTemplate，会全自动对全部 @LoadBalanced 注释装饰的 RestTemplate Bean 提升 Interceptor 进而再加上了负载均衡设备的特点。
• 针对 WebClient，会全自动建立 ReactorLoadBalancerExchangeFilterFunction，我们可以根据添加ReactorLoadBalancerExchangeFilterFunction会添加负载均衡设备的特点。
• 针对三方手机客户端，一般不用大家附加配备哪些。

这种应用的实例，会在我们系列升級完最终的检测一部分见到。

Spring Cloud LoadBalancer 构造介绍

上一节大家提及了 NamedContextFactory，Spring Cloud LoadBalancer 这儿也是应用了这一体制完成了不一样微服务架构应用不一样的 Spring Cloud LoadBalancer 配备。有关关键完成是 @LoadBalancerClient 和 @LoadBalancerClients 这两个注释，及其 NamedContextFactory.Specification 的完成 LoadBalancerClientSpecification，NamedContextFactory 的完成 LoadBalancerClientFactory。

历经上一节的深入分析，我们知道能够根据 LoadBalancerClientFactory 了解默认设置配备类为 LoadBalancerClientConfiguration. 而且获得微服务架构名字能够根据 environment.getProperty(LoadBalancerClientFactory.PROPERTY_NAME);

LoadBalancerClientFactory

public static final String NAMESPACE = "loadbalancer";
public static final String PROPERTY_NAME = NAMESPACE   ".client.name";
public LoadBalancerClientFactory() {
	super(LoadBalancerClientConfiguration.class, NAMESPACE, PROPERTY_NAME);
}

查询配备类 LoadBalancerClientConfiguration，我们可以发觉这一类关键界定二种 Bean，分别是 ReactorLoadBalancer<ServiceInstance> 和 ServiceInstanceListSupplier。

ReactorLoadBalancer 是负载均衡设备，关键给予依据服务项目名字获得服务项目案例目录并从从这当中挑选的作用。

ReactorLoadBalancer

Mono<Response<T>> choose(Request request);

在默认设置配备中的完成是：

LoadBalancerClientConfiguration

@Bean
@ConditionalOnMissingBean
public ReactorLoadBalancer<ServiceInstance> reactorServiceInstanceLoadBalancer(
		Environment environment,
		LoadBalancerClientFactory loadBalancerClientFactory) {
	//获得微服务架构名字
	String name = environment.getProperty(LoadBalancerClientFactory.PROPERTY_NAME);
	//建立 RoundRobinLoadBalancer 
	//留意这儿引入的是 LazyProvider，这关键由于在申请注册这一 Bean 的情况下有关的 Bean 很有可能都还没被载入申请注册，运用 LazyProvider 而不是立即引入需要的 Bean 避免 报找不着 Bean 引入的不正确。
	return new RoundRobinLoadBalancer(loadBalancerClientFactory.getLazyProvider(name,
			ServiceInstanceListSupplier.class), name);
}

能够看得出，默认设置配备的 ReactorLoadBalancer 完成是 RoundRobinLoadBalancer。这一负载均衡设备完成非常简单，有一个分子种类的 AtomicInteger position，从 ServiceInstanceListSupplier 中载入全部的服务项目案例目录，随后针对 position 分子加1，对目录尺寸牙模型，返回列表中这一部位的服务项目案例 ServiceInstance。

RoundRobinLoadBalancer

public Mono<Response<ServiceInstance>> choose(Request request) {
    //引入的情况下引入的是 Lazy Provider，这儿取下真真正正的 Bean，也就是 ServiceInstanceListSupplier
	ServiceInstanceListSupplier supplier = serviceInstanceListSupplierProvider
			.getIfAvailable(NoopServiceInstanceListSupplier::new);
			//获得案例目录
	return supplier.get(request)
	        .next()
	        //从目录中挑选一个案例
			.map(serviceInstances -> processInstanceResponse(supplier, serviceInstances));
}

private Response<ServiceInstance> processInstanceResponse(ServiceInstanceListSupplier supplier,
		List<ServiceInstance> serviceInstances) {
	Response<ServiceInstance> serviceInstanceResponse = getInstanceResponse(serviceInstances);
	// 假如 ServiceInstanceListSupplier 也完成了 SelectedInstanceCallback，则实行下边的逻辑性开展回调函数。SelectedInstanceCallback 便是每一次负载均衡设备挑选案例以后开展的回调函数
	if (supplier instanceof SelectedInstanceCallback && serviceInstanceResponse.hasServer()) {
		((SelectedInstanceCallback) supplier).selectedServiceInstance(serviceInstanceResponse.getServer());
	}
	return serviceInstanceResponse;
}

private Response<ServiceInstance> getInstanceResponse(List<ServiceInstance> instances) {
	if (instances.isEmpty()) {
		return new EmptyResponse();
	}
	//postion 分子  1 并取平方根
	int pos = Math.abs(this.position.incrementAndGet());
    //回到相匹配下标底案例
	ServiceInstance instance = instances.get(pos % instances.size());
	return new DefaultResponse(instance);
}

ServiceInstanceListSupplier 是服务项目目录服务提供者插口：

ServiceInstanceListSupplier

public interface ServiceInstanceListSupplier extends Supplier<Flux<List<ServiceInstance>>> {
	String getServiceId();
	default Flux<List<ServiceInstance>> get(Request request) {
		return get();
	}
	static ServiceInstanceListSupplierBuilder builder() {
		return new ServiceInstanceListSupplierBuilder();
	}
}

spring-cloud-loadbalancer 中有很多 ServiceInstanceListSupplier 的完成，在默认设置配备中是根据特性配备特定完成的，这一配备项是spring.cloud.loadbalancer.configurations。比如：

LoadBalancerClientConfiguration

@Bean
@ConditionalOnBean(ReactiveDiscoveryClient.class)
@ConditionalOnMissingBean
//spring.cloud.loadbalancer.configurations 未找到或是为 default
@ConditionalOnProperty(value = "spring.cloud.loadbalancer.configurations", havingValue = "default",
		matchIfMissing = true)
public ServiceInstanceListSupplier discoveryClientServiceInstanceListSupplier(
		ConfigurableApplicationContext context) {
	return ServiceInstanceListSupplier.builder()
	//根据 DiscoveryClient 给予案例
	.withDiscoveryClient()
	//打开缓存文件
	.withCaching()
	.build(context);
}

@Bean
@ConditionalOnBean(ReactiveDiscoveryClient.class)
@ConditionalOnMissingBean
//假如 spring.cloud.loadbalancer.configurations 特定为 zone-preference
@ConditionalOnProperty(value = "spring.cloud.loadbalancer.configurations", havingValue = "zone-preference")
public ServiceInstanceListSupplier zonePreferenceDiscoveryClientServiceInstanceListSupplier(
		ConfigurableApplicationContext context) {
	return ServiceInstanceListSupplier.builder()
	//根据 DiscoveryClient 给予案例
	.withDiscoveryClient()
	//开启更趋向于同一个 zone 下案例的特点
	.withZonePreference()
	//打开缓存文件
	.withCaching()
			.build(context);
}

能够见到，能够根据 ServiceInstanceListSupplier.builder() 转化成官方网封裝好各种各样特点的 ServiceInstanceListSupplier。实际上从最底层完成能够看得出，全部的 ServiceInstanceListSupplier 完成全是分销模式，比如针对默认设置配备，最底层编码近似于：

return  //打开服务项目案例缓存文件
        new CachingServiceInstanceListSupplier(
                        //开启根据 discoveryClient 的服务发现
                        new DiscoveryClientServiceInstanceListSupplier(
                                discoveryClient, env
                        )
                , cacheManagerProvider.getIfAvailable()
        );

除开默认设置配备 LoadBalancerClientConfiguration，客户配备自定配备则是根据 @LoadBalancerClients 和 @LoadBalancerClient.这一基本原理是根据 LoadBalancerClientConfigurationRegistrar 完成的。最先，大家看来一下 LoadBalancerClientFactory 这一 NamedContextFactory 是怎样建立的：

[LoadBalancerAutoConfiguration]

private final ObjectProvider<List<LoadBalancerClientSpecification>> configurations;

public LoadBalancerAutoConfiguration(ObjectProvider<List<LoadBalancerClientSpecification>> configurations) {
    //引入 LoadBalancerClientSpecification List 的 provider
    //在 Bean 建立的情况下，开展加载，而不是申请注册的情况下
	this.configurations = configurations;
}

@ConditionalOnMissingBean
@Bean
public LoadBalancerClientFactory loadBalancerClientFactory() {
    //建立 LoadBalancerClientFactory
	LoadBalancerClientFactory clientFactory = new LoadBalancerClientFactory();
    //载入全部的 LoadBalancerClientSpecification，设定为 LoadBalancerClientFactory 的配备
	clientFactory.setConfigurations(this.configurations.getIfAvailable(Collections::emptyList));
	return clientFactory;
}

那麼，LoadBalancerClientSpecification 这种 Bean 是怎么建立的呢？在 @LoadBalancerClients 和 @LoadBalancerClient 注释中，都包括 @Import(LoadBalancerClientConfigurationRegistrar.class)。这一 @Import 载入一个 ImportBeanDefinitionRegistrar，这儿是 LoadBalancerClientConfigurationRegistrar. ImportBeanDefinitionRegistrar里边的方式 主要参数包括注释数据库，及其申请注册 Bean 的 BeanDefinitionRegistry。一般通过注释数据库，动态性根据 BeanDefinitionRegistry 申请注册 Bean，在这儿的完成是：

[LoadBalancerClients]

@Configuration(proxyBeanMethods = false)
@Retention(RetentionPolicy.RUNTIME)
@Target({ ElementType.TYPE })
@Documented
@Import(LoadBalancerClientConfigurationRegistrar.class)
public @interface LoadBalancerClients {
    //能够特定好几个 LoadBalancerClient
	LoadBalancerClient[] value() default {};
	//特定全部的web服务配备的默认设置配备
	Class<?>[] defaultConfiguration() default {};
}

[LoadBalancerClient]

@Configuration(proxyBeanMethods = false)
@Import(LoadBalancerClientConfigurationRegistrar.class)
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface LoadBalancerClient {
    //name 和 value 全是微服务架构名字
	@AliasFor("name")
	String value() default "";
	@AliasFor("value")
	String name() default "";
	//这一微服务架构的配备
	Class<?>[] configuration() default {};
}

[LoadBalancerClientConfigurationRegistrar]

@Override
public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
    //获得 LoadBalancerClients 注释的数据库
	Map<String, Object> attrs = metadata.getAnnotationAttributes(LoadBalancerClients.class.getName(), true);
	if (attrs != null && attrs.containsKey("value")) {
		AnnotationAttributes[] clients = (AnnotationAttributes[]) attrs.get("value");
		//针对 value 特性，实际上便是一个 LoadBalancerClient 目录，针对每一个转化成一个特殊微服务架构名称的  LoadBalancerClientSpecification
		for (AnnotationAttributes client : clients) {
			registerClientConfiguration(registry, getClientName(client), client.get("configuration"));
		}
	}
	//假如特定了 defaultConfiguration，则申请注册为 default 的配备
	if (attrs != null && attrs.containsKey("defaultConfiguration")) {
		String name;
		if (metadata.hasEnclosingClass()) {
			name = "default."   metadata.getEnclosingClassName();
		}
		else {
			name = "default."   metadata.getClassName();
		}
		registerClientConfiguration(registry, name, attrs.get("defaultConfiguration"));
	}
	//获得 LoadBalancerClient 注释的数据库
	Map<String, Object> client = metadata.getAnnotationAttributes(LoadBalancerClient.class.getName(), true);
	String name = getClientName(client);
	if (name != null) {
		registerClientConfiguration(registry, name, client.get("configuration"));
	}
}

private static void registerClientConfiguration(BeanDefinitionRegistry registry, Object name, Object configuration) {
    //复位 LoadBalancerClientSpecification 的 BeanDefinition，用以申请注册一个 LoadBalancerClientSpecification Bean
	BeanDefinitionBuilder builder = BeanDefinitionBuilder
			.genericBeanDefinition(LoadBalancerClientSpecification.class);
	//构造器主要参数
	builder.addConstructorArgValue(name);
	builder.addConstructorArgValue(configuration);
	//申请注册 Bean
	registry.registerBeanDefinition(name   ".LoadBalancerClientSpecification", builder.getBeanDefinition());
}

从编码中我们可以看得出，根据应用 @LoadBalancerClients 和 @LoadBalancerClient 注释能够自动生成相匹配的 LoadBalancerClientSpecification 从而完成公共性web服务配备或是特殊某一微服务架构的web服务配备。

搜索微信“我的程序编写喵”扫码关注，加创作者手机微信，每日一刷，轻轻松松提高技术性，夺得各种各样offer：